Do you remember the
SubSonic
project? The Entity Framework is kind of like that. You can create an extensible
and customizable data model from any type of source. It takes the boiler plate coding
away from developing Data Access Layers.
Entity is designed to seperate how data is stored and how data is used. It's called
an Object-Relational Mapping framework. You point the framework at the source, tell
it what kind of business objects you want, and poof: you have an object model. Entity
is also designed to play nicely with LINQ. You can use it as a data source when querying
with LINQ. In my
previous post,
the query used NorthwindModEntities as a data source. It is an Entity object.
|
|
Courtesy of Wikipedia |
The Architecture, as defined in the picture:
-
Data source specific providers, which abstracts the ADO.NET interfaces to connect
to the database when programming against the conceptual schema.
-
Map provider, a database-specific provider that translates the Entity SQL command
tree into a query in the native SQL flavor of the database. It includes the Store
specific bridge, which is the component that is responsible for translating the
generic command tree into a store-specific command tree.
-
EDM parser and view mapping, which takes the SDL specification of the data
model and how it maps onto the underlying relational model and enables programming
against the conceptual model. From the relational schema, it creates views of the
data corresponding to the conceptual model. It aggregates information from multiple
tables in order to aggregate them into an entity, and splits an update to an entity
into multiple updates to whichever table contributed to that entity.
-
Query and update pipeline, processes queries, filters and update-requests to
convert them into canonical command trees which are then converted into store-specific
queries by the map provider.
-
Metadata services, which handle all metadata related to entities, relationships
and mappings.
-
Transactions, to integrate with transactional capabilities of the underlying
store. If the underlying store does not support transactions, support for it needs
to be implemented at this layer.
-
Conceptual layer API, the runtime that exposes the programming model for coding
against the conceptual schema. It follows the ADO.NET pattern of using Connection
objects to refer to the map provider, using Command objects to send the query, and
returning EntityResultSets or EntitySets containing the result.
-
Disconnected components, which locally caches datasets and entity sets for
using the ADO.NET Entity Framework in an occasionally connected environment.
-
Embedded database: ADO.NET Entity Framework includes a lightweight embedded
database for client-side caching and querying of relational data.
-
Design tools, such as Mapping Designer are also included with ADO.NET Entity
Framework which simplifies the job on mapping a conceptual schema to the relational
schema and specifying which properties of an entity type correspond to which table
in the database.
-
Programming layers, which exposes the EDM as programming constructs which can
be consumed by programming languages.
-
Object services, automatically generate code for CLR classes that expose the
same properties as an entity, thus enabling instantiation of entities as .NET objects.
-
Web services, which expose entities as web services.
-
High level services, such as reporting services which work on entities rather
than relational data.
What is Techdays?
The Canadian IT Pro Team would love to call it a Tech-Ed of the north, except on tour.
Check out the site:
www.techdays.ca to get the
info, but the dates are:
|
Date |
City |
Venue |
|
October 29/30 |
Toronto |
Toronto Congress Centre |
|
November 6/7 |
Montreal |
The Palais des Congrès |
|
November 27 |
Ottawa |
Mariott Hotel |
|
December 4 |
Winnipeg |
Delta Hotel |
|
December 10/11 |
Calgary |
Calgary Stampede Roundup Centre |
|
December 17 |
Halifax |
Halifax World Trade Centre |
|
January 21/22 |
Vancouver |
Vancouver Convention Centre |
I will be doing a presentation in Montreal and Ottawa entitled
Microsoft SQL Server:
Essential Database Maintenance for New and Seasoned DBAs. The synopsis is:
Every DBA knows that managing a database using SQL Server
requires dealing with a key set of components of SQL Server in an optimal in order
to make their lives easier. But what are the elements of SQL Server that you need
to really focus on to get the best bang for the DBA buck, and what best practices
should be followed to ensure an optimally-running an instance in SQL Server? In this
session we will walk through the Top 10 List of DBA techniques and best practices
to ensure a smooth running database and instance. You’ll learn: how to optimize data
files and transaction logs; why TempDB is special and how to treat it properly; indexing
strategies dealing with corruption; and much, much more.
I'm also doing a session entitled
Beyond Relational SQL Server 2008: Managing Unstructured
and Semi-Structured Data:
The amount of data that does not fit into the tabular format
of relational tables is increasing tremendously, be it images, sounds, text documents,
XML documents, or semi-structured data. Integrating this data with the robust, efficient
processing capabilities of SQL Server and providing integrated querying and management
of that data together with the standard relational data becomes increasingly more
important. This presentation will present new and existing functionality on how SQL
Server 2008 supports these non-relational kinds of data. The presentation will provide
insights into FILESTREAM, Remote Blob storage, new XML functionality, integrated Full-Text
Search, sparse columns, filtered indexes and the new hierarchyID type.
Should be fun. See you there!
If Google can do it, so can Microsoft. Volta is the GWT of .NET. Enough said. Here's a description of what it is.
The Volta technology preview is a developer toolset that enables you to build multi-tier web applications by applying familiar techniques and patterns. First, design and build your application as a .NET client application, then assign the portions of the application to run on the server and the client tiers late in the development process. The compiler creates cross-browser JavaScript for the client tier, web services for the server tier, and communication, serialization, synchronization, security, and other boilerplate code to tie the tiers together.
Developers can target either web browsers or the CLR as clients and Volta handles the complexities of tier-splitting for you. Volta comprises tools such as end-to-end profiling to make architectural refactoring and optimization simple and quick. In effect, Volta offers a best-effort experience in multiple environments without any changes to the application.
Download it here.
You need Visual Studio 2008 and .NET Framework 3.5.
Click on the issues for the direct download link.
For anyone trying to get started with AJAX and the new AJAX control toolkit here are a couple of short videos that you could watch while sipping on your coffee :)
ASP.NET AJAX Extensions: Installation and Setup
ASP.NET AJAX Control Toolkit: Installation and getting started
You may also want to bookmark http://ajax.asp.net.
SmartNavigation can be set to true on your ASP.NET webform so that when postbacks occur , the page when rendered back to the browser, will navigate back to the control that caused the postback.
But SmartNavigation can be problematic especially when dynamically loading controls onto your webform.
Therefore if you have SmartNavigation turned off = false, below is a piece of code that you can call from your webform that will add javascript to your page, to automatically navigate back to the control that originally caused the postback.
I tested the code against IE6 and Netscape 7.1.
///
/// This method will take passed webPage, and find the control that caused the postback. If it finds
/// one it will set javascript on the page to set focus to that control
///
/// The web page
public void SetFocusPostBackControl(System.Web.UI.Page webPage)
{
string[] ctlPostBack;
ctlPostBack = webPage.Page.Request.Form.GetValues("__EVENTTARGET");
if (ctlPostBack != null && ctlPostBack.Length > 0)
{
string ctlUniqueId;
ctlUniqueId = ctlPostBack[0];
System.Web.UI.Control findControl = webPage.Page.FindControl(ctlUniqueId);
if ((findControl != null) &&
(findControl is DropDownList ||
findControl is TextBox ||
findControl is RadioButton ||
findControl is RadioButtonList))
{
string ctlClientId;
ctlClientId = findControl.ClientID;
string jScript;
jScript = "<SCRIPT language=\"javascript\"> document.getElementById('" + ctlClientId + "').focus(); document.getElementById('"
+ ctlClientId + "').scrollIntoView(true) </SCRIPT>";;
webPage.Page.RegisterStartupScript("focus",jScript );
}
}
}
A couple of months ago, I had to quickly develop an ASP.NET framework.
I incorporated parts of a Windows .NET framework that I had previously worked on. The basic
premise being that a Windows .NET Form and an ASP.NET WebForm are both event driven
and have controls such as buttons and dropdowns.
There were two basic steps in developing this ASP.NET framework.
1) Creating Ancestor code behind pages for all the code behind pages used in the project:
a) public class WebFormBase : System.Web.UI.Page -> For the Web Forms
b) public class WebUserControlBase : System.Web.UI.UserControl -> For the Web User Controls
When a Webform or Web UserControl needs to be created, their code behinds inherit from the custom base class:
public class OrderWebForm : WebFormBase
public class ProductWebuserControl : WebUserControlBase
I think the above is a pretty standard thing to do.
The only thing I really did a little bit differently was to raise more events up to the descendent pages such as:
Loading
Load
Init
Initing
PreRendering
PreRender
etc.
In this way the descendent code has a chance to do some work before and after the code in ancestor.
2) All server side controls used on a WebForm or Web UserControl are inherited from the standard Microsoft Web Controls, or a third party control:
public class MyWebButton : System.Web.UI.WebControls.Button
public class MyWebMenu : Infragistics.Web.UI.UltraWebMenu
etc. etc. As you know there are many more. Hyperlink, Label, DataList etc.
For this framework thats pretty well it, in a nutshell.
This has really paid off for the future development work, because server Side controls can now implement custom interfaces,
such as :
ITranslation
IDisable
Then in the base classes for the code behind for the WebFormBase or the WebUserControlBase, all the code is there to handle translation of pages to French or English or to disable or enable or disable controls automatically depending on a custom property put on the Web page called Enabled. Other things that have been built into the framework are resource file management, session management, navigation management and a custom help button that launches another browser with some help.