Julie Lerman Blog - ADONetOrcas

Sunday, July 08, 2007

Entity Framework, Some Before & After tidbits

I wanted to see some of the new Beta2 (in the June CTP bits) functionality of Entity Framework so I've been poking around. You can see a nice list of what to look for on Danny Simmons' blog.

One thing that was a huge source of frustration was the inability to support database constraints where a column was both a primary key and also a foreign key of another table. When using the EF Wizard to import database schemas, this would be part of a list of errors that were generated during the model creation and would result in a problem like this:

Notice that you can't get back to the ORDER that owns the Order_Detail.

With the new CTP, that problem goes away.

You can't traverse over Order_details because it is a collection property, but you can get at properties like Count, etc...

Dim od = From o In NWEntities.Orders Where o.ShipCountry = "Spain" _
Select o.Customers.CompanyName, o.Order_Details.Count

Another thing, of course was the difficulty of working with existing views and stored procedures.

Here's a before and after of the wizard:

But the sproc and view support goes much deeper.

Unfortunately, I don't see the wizard carrying the views and stored procs all the way through. If you look at the SSDL, you will see that the views are described as any other table. The stored procs are <function> elements.

While I can't figure out how to surface the query function, there are also functions to let you use your own sprocs for insert, updates and deletes and tie them into EF's SaveChanges function. Shyam Pather wrote a post about this a while ago on the ADONET Team blog and now that stuff is in this version along with documentation examples.

Another SPROC goody is the ability to define your own stored procedures in your model without needing it in the database. Check the DefiningQuery element that goes in the SSDL to achieve this.

Poking around in the CSDL, I see a few changes which tie back to the references.

A Key used to be an attribute of an Entity Type. Now it is an element.

Beta1: <EntityType Name="Employees" Key="EmployeeID">

CTP: <EntityType Name="Employees">
    <Key>
      <PropertyRef Name="EmployeeID" />
    </Key>

So that they could do this:

Which then enables us to do this:

Which is describing this from the database:

Speaking of the database, there was mention of the fact that it's now easier to get at the underlying datastore. I haven't figured out how though, yet. I looked to see if you could now cast an EntityConnetion to a SqlConnection but that's not it. I'll keep an eye out for that. While I was looking though I noticed a bunch of new methods in the ObjectContext such as the pieces that go along with attaching and detaching such as "Addto" methods for each of the entities in the objectContext.

The last thing I'll shove into this already long post is that Entity constructors are no longer auto-generated. This will make customization a lot easier (you can read about that in this post from Danny Simmons).

So where we had this in Beta 1:

Partial Public Class Employees
        Inherits Global.System.Data.Objects.DataClasses.Entity
        '''<summary>
        '''Initialize a new Employees object.
        '''</summary>
        Public Sub New()
            MyBase.New
            'Call DoFinalConstruction if this is the most-derived type.
            If (CType(Me,Object).GetType Is GetType(Global.NorthwindModel.Employees)) Then
                Me.DoFinalConstruction
            End If
        End Sub
        '''<summary>
        '''Initialize a new Employees object.
        '''</summary>
        '''<param name="employeeID">Initial value of EmployeeID.</param>
        '''<param name="lastName">Initial value of LastName.</param>
        '''<param name="firstName">Initial value of FirstName.</param>
        Public Sub New(ByVal employeeID As Integer, ByVal lastName As String, ByVal firstName As String)
            MyBase.New
            Me.EmployeeID = employeeID

Me.LastName = lastName

Me.FirstName = firstName

            'Call DoFinalConstruction if this is the most-derived type.
            If (CType(Me,Object).GetType Is GetType(Global.NorthwindModel.Employees)) Then
                Me.DoFinalConstruction
            End If
        End Sub

Although the constructor is gone (along with the acrobatics that would require creating your own constructors) there is a new method for creating each entity:

     Public Shared Function CreateEmployees(ByVal employeeID As Integer, ByVal lastName As String, ByVal firstName As String) As Employees
            Dim employees As Employees = New Employees
            employees.EmployeeID = employeeID
            employees.LastName = lastName
            employees.FirstName = firstName
            Return employees
        End Function

ADONetOrcas | VB

Sunday, July 08, 2007 4:48:59 PM (Eastern Standard Time, UTC-05:00)

| Comments [0] |

Wednesday, July 04, 2007

Using SPAN to query entities in Entity Framework

By default, when querying entities, you need to explicitly use the Load method to get related data. This is often called "lazy loading" and ensure you only get what you ask for rather than having a query return ALL related data automatically. The new SPAN method forces an entity to include specifid children during a query so that you don't have to load after the fact. READ MORE

[A New DevLife Post]