Entity Framework Contrib

New Post: PostSharp4FE is not working with VS2008 SP1 Beta

RBoeke — Sat, 14 Jun 2008 01:12:30 GMT

Hi Kesav,

yes. However, there is a holiday coming up soon, so I do not know when I will get this done.

I'm dedicated to bring EF to Silverlight. So I will start work on it as soon as I'm back.

The error you are showing does not necessarily have anything to do with SP1 beta though. It seems you are not passing the correct parameters. Did it work correctly before?

New Post: PostSharp4FE is not working with VS2008 SP1 Beta

kesav — Thu, 12 Jun 2008 21:17:49 GMT

I just downloaded the latest postsharp4fe and tried to work with VS2008 SP1Beta things are not working. Initally I had compilation errors for PostSharp4FE project I could fix the API that got changed in the recent SP1. Now I could compile all the projects of PostSharp4FE and could generate the dlls.

Now I created my own domain object class library project and setup the csproj and psproj files to use PostSharp4FE: The project build itself was failing. I ran the PostSharp.exe command from command line and got the following exception:

System.NullReferenceException: Object reference not set to an instance of an object.
   at EntityFrameworkContrib.PostSharp4EF.PocoAttribute.GetMetaDataWorkspace(String assemblyLocation) in c:\Software\efcontrib\EFContrib.Pos
tSharp4EF\EntityFrameworkContrib.PostSharp4EF.Public\PocoAttribute.cs:line 246
   at EntityFrameworkContrib.PostSharp4EF.PocoAttribute.ProvideAspects(Object element, LaosReflectionAspectCollection collection) in c:\Soft
ware\efcontrib\EFContrib.PostSharp4EF\EntityFrameworkContrib.PostSharp4EF.Public\PocoAttribute.cs:line 112
   at PostSharp.Laos.CompoundAspect.PostSharp.Laos.ILaosReflectionAspectProvider.ProvideAspects(LaosReflectionAspectCollection collection) i
n p:\branches\1.0\Laos\PostSharp.Laos\CompoundAspect.cs:line 62
   at PostSharp.Laos.Weaver.LaosTask.EnqueueAspects(ILaosReflectionAspectProvider provider) in p:\branches\1.0\Laos\PostSharp.Laos.Weaver\La
osTask.cs:line 196
   at PostSharp.Laos.Weaver.LaosTask.Execute() in p:\branches\1.0\Laos\PostSharp.Laos.Weaver\LaosTask.cs:line 411
   at PostSharp.Extensibility.Project.ExecutePhase(String phase) in p:\branches\1.0\Core\PostSharp.Core\Extensibility\Project.cs:line 1044
   at PostSharp.Extensibility.Project.Execute() in p:\branches\1.0\Core\PostSharp.Core\Extensibility\Project.cs:line 1082
   at PostSharp.Extensibility.PostSharpObject.ExecuteProjects() in p:\branches\1.0\Core\PostSharp.Core\Extensibility\PostSharpObject.cs:line
581
   at PostSharp.Extensibility.PostSharpObject.InvokeProjects(ProjectInvocation[] projectInvocations) in p:\branches\1.0\Core\PostSharp.Core\
Extensibility\PostSharpObject.cs:line 564
   at PostSharp.Console.Program.InternalMain(String[] args) in p:\branches\1.0\Core\PostSharp.Console\Program.cs:line 301

Is there any plan for updating the code to work with SP1 Beta?

Thanks
-kesav

Created Issue: efcontrib is not compatible with VS2008 SP1 Beta

kesav — Thu, 12 Jun 2008 21:15:57 GMT

Hi

I just downloaded the latest postsharp4fe and tried to work with VS2008 SP1Beta things are not working. Initally I had compilation errors for PostSharp4FE project I could fix the API that got changed in the recent SP1. Now I could compile all the projects of PostSharp4FE and could generate the dlls.

Now I created my own domain object class library project and setup the csproj and psproj files to use PostSharp4FE: The project build itself was failing. I ran the PostSharp.exe command from command line and got the following exception:

System.NullReferenceException: Object reference not set to an instance of an object.
at EntityFrameworkContrib.PostSharp4EF.PocoAttribute.GetMetaDataWorkspace(String assemblyLocation) in c:\Software\efcontrib\EFContrib.Pos
tSharp4EF\EntityFrameworkContrib.PostSharp4EF.Public\PocoAttribute.cs:line 246
at EntityFrameworkContrib.PostSharp4EF.PocoAttribute.ProvideAspects(Object element, LaosReflectionAspectCollection collection) in c:\Soft
ware\efcontrib\EFContrib.PostSharp4EF\EntityFrameworkContrib.PostSharp4EF.Public\PocoAttribute.cs:line 112
at PostSharp.Laos.CompoundAspect.PostSharp.Laos.ILaosReflectionAspectProvider.ProvideAspects(LaosReflectionAspectCollection collection) i
n p:\branches\1.0\Laos\PostSharp.Laos\CompoundAspect.cs:line 62
at PostSharp.Laos.Weaver.LaosTask.EnqueueAspects(ILaosReflectionAspectProvider provider) in p:\branches\1.0\Laos\PostSharp.Laos.Weaver\La
osTask.cs:line 196
at PostSharp.Laos.Weaver.LaosTask.Execute() in p:\branches\1.0\Laos\PostSharp.Laos.Weaver\LaosTask.cs:line 411
at PostSharp.Extensibility.Project.ExecutePhase(String phase) in p:\branches\1.0\Core\PostSharp.Core\Extensibility\Project.cs:line 1044
at PostSharp.Extensibility.Project.Execute() in p:\branches\1.0\Core\PostSharp.Core\Extensibility\Project.cs:line 1082
at PostSharp.Extensibility.PostSharpObject.ExecuteProjects() in p:\branches\1.0\Core\PostSharp.Core\Extensibility\PostSharpObject.cs:line
581
at PostSharp.Extensibility.PostSharpObject.InvokeProjects(ProjectInvocation[] projectInvocations) in p:\branches\1.0\Core\PostSharp.Core\
Extensibility\PostSharpObject.cs:line 564
at PostSharp.Console.Program.InternalMain(String[] args) in p:\branches\1.0\Core\PostSharp.Console\Program.cs:line 301

Is there any plan for updating the code to work with SP1 Beta?

Thanks
-kesav

NEW POST: Screencast

RBoeke — Tue, 27 May 2008 10:55:04 GMT

yes, sorry. The screencast was actually created, but because there was a new version of EF coming out which possibly solves the serialization issue, I decided not to publish it

LinqToSql serialization: yes, certainly. However, at this point I use an extensibility point of WCF that is not supported in Silverlight. Again, look at the new version of EF and WCF to see if there are better possibilities.

I'm going to start work on it pretty soon, and hope to enable EF on SL for sure.

NEW POST: Screencast

Synced — Mon, 12 May 2008 23:10:45 GMT

I saw a mention about a screencast. Is there any screencast of how to use this library?

Also could the same problem with LINQ to SQL circular reference serialization be solved via your library? We are having the exact same issues with circular reference serialization when using LINQ to SQL exposed via WCF for Silverlight 2 applications.

CREATED RELEASE: PostSharp4EF drop 18-4-2008 (apr 18, 2008)

Fri, 18 Apr 2008 12:38:07 GMT

*Disclaimer: This is the first public beta. I still expect some major changes to occur and many bugs to be found. Use with caution ;-)*

This drop belongs to changeset 16806. You can either download the complete sourcetrunk [url:http://www.codeplex.com/efcontrib/SourceControl/DownloadSourceCode.aspx?changeSetId=16806] or download the zipped version which only includes PostSharp4EF source.

This release supports:
* POCO classes with EF
* inheritance
* complex types
* serialization/deserialization
* client side changetracking (without EF) and serverside attaching

A screencap was created to demonstrate how to use.

Please leave your comments and bug reports: [url:http://www.codeplex.com/efcontrib/Thread/List.aspx]

UPDATED WIKI: full disconnected n-tier usage

RBoeke — Wed, 16 Apr 2008 19:53:53 GMT

Disconnected n-tier usage of Entity Framework objects

To enable the use of Entity Framework objects in a disconnected scenario, we use 3 projects together:

PostSharp4EF: enhances Plain Old Code Objects to be understood by Entity Framework
Circular Serializer: serializes graphs of objects and takes care of original values
Editable Business Objects: enhances Plain Old Code Objects to manage original values

Read more here: http://www.sitechno.com/Blog/DisconnectedNTierObjectsUsingEntityFramework.aspx and here: http://www.sitechno.com/Blog/NewSampleApplicationForDisconnectedNtierEntityFrameworkObjects.aspx.

What we need to achieve is work from one domain layer, but create two versions of it. This is not done in source, but by enhancing the dll.
Client side: use Circular Serializer and Editable Business Objects
Server side: use Circular Serializer and PostSharp4EF

The end result would be two solutions (one for the client, one for the server) that both reference the same Domain project (which holds your business objects). When compiling, the correct enhancements need to be executed.

please note that all these steps are simplified when using TFS or nAnt to manage builds where more control is possible

Step 1: get a conditional compilation symbol
Open the proj file of your domain project. Add the following code to it:

   
<PropertyGroup>
       <DefineConstants>$(DefineConstants);$(SolutionName)</DefineConstants>
</PropertyGroup>

This will set your normal constants, but add the solution name to it. As an alternative, you might want to use a <Choose> group and create more elaborate schemes of determining in what context this project is loaded.

Step 2: use conditional attributes
I like to leave my domain objects completely clean, and so I put my enhancement attributes in the assembly info of my Domain project.
The following example is based on solutionnames 'Server' and 'Client'.

#if Server
[assembly: Poco("InheritanceTypeConnection", AttributeTargetAssemblies = "Domain", AttributeTargetTypes = "Domain.*")]
[assembly: CreateSerializeSurrogate("EntityFrameworkContrib.PostSharp4EF.ISerializationHelp, EntityFrameworkContrib.PostSharp4EF", 
AttributeTargetAssemblies = "Domain", AttributeTargetTypes = "Domain.*")]
#endif
#if Client
[assembly: EditableBusinessObjectAttribute(AttributeTargetAssemblies="Domain", AttributeTargetTypes="Domain.*")]
[assembly: CreateSerializeSurrogate("EditableBusinessObjects.Postsharp.Public.IEditableBusinessObject, 
EditableBusinessObjects.Postsharp.Public", AttributeTargetAssemblies="Domain", AttributeTargetTypes="Domain.*")]
#endif

We instruct PostSharp to enhance all objects starting with namespace Domain, in assembly Domain to either use Poco and CircularSerializer or EditableBusinessObjects and CircularSerializer.

(optional) Step 3: Create different configurations so that Domain does not get overwritten
When compiling your solution, the Domain.dll is placed in either Debug or Release folder. However, you are very likely to compile both the client and server solution at the same time. It might be prudent to create a new configuration so that Domain gets placed in different folders.
In the end, the only thing that is important, is the dll that is copied to either the client project or the server project.

Please take a look at the client/server samples that are included with the source code.

UPDATED WIKI: full disconnected n-tier usage

RBoeke — Wed, 16 Apr 2008 19:52:57 GMT

Disconnected n-tier usage of Entity Framework objects

To enable the use of Entity Framework objects in a disconnected scenario, we use 3 projects together:

PostSharp4EF: enhances Plain Old Code Objects to be understood by Entity Framework
Circular Serializer: serializes graphs of objects and takes care of original values
Editable Business Objects: enhances Plain Old Code Objects to manage original values

   
<PropertyGroup>
       <DefineConstants>$(DefineConstants);$(SolutionName)</DefineConstants>
</PropertyGroup>

#if Server
[assembly: Poco("InheritanceTypeConnection", AttributeTargetAssemblies = "Domain", AttributeTargetTypes = "Domain.*")]
[assembly: CreateSerializeSurrogate("EntityFrameworkContrib.PostSharp4EF.ISerializationHelp, EntityFrameworkContrib.PostSharp4EF", AttributeTargetAssemblies = "Domain", AttributeTargetTypes = "Domain.*")]
#endif
#if Client
[assembly: EditableBusinessObjectAttribute(AttributeTargetAssemblies="Domain", AttributeTargetTypes="Domain.*")]
[assembly: CreateSerializeSurrogate("EditableBusinessObjects.Postsharp.Public.IEditableBusinessObject, EditableBusinessObjects.Postsharp.Public", AttributeTargetAssemblies="Domain", AttributeTargetTypes="Domain.*")]
#endif

UPDATED WIKI: full disconnected n-tier usage

RBoeke — Wed, 16 Apr 2008 19:50:42 GMT

Disconnected n-tier usage of Entity Framework objects

To enable the use of Entity Framework objects in a disconnected scenario, we use 3 projects together:

PostSharp4EF: enhances Plain Old Code Objects to be understood by Entity Framework
Circular Serializer: serializes graphs of objects and takes care of original values
Editable Business Objects: enhances Plain Old Code Objects to manage original values

Read more here: http://www.sitechno.com/Blog/DisconnectedNTierObjectsUsingEntityFramework.aspx and here: http://www.sitechno.com/Blog/NewSampleApplicationForDisconnectedNtierEntityFrameworkObjects.aspx.

What we need to achieve is work from one domain layer, but create two versions of it. This is not done in source, but by enhancing the dll.
Client side: use Circular Serializer and Editable Business Objects
Server side: use Circular Serializer and PostSharp4EF

Cannot resolve link: [image:http://www.sitechno.com/Blog/content/binary/WindowsLiveWriter/DisconnectedNTierobjectsusingEntityFrame_12D68/image_2.png]

The end result would be two solutions (one for the client, one for the server) that both reference the same Domain project (which holds your business objects). When compiling, the correct enhancements need to be executed.

please note that all these steps are simplified when using TFS or nAnt to manage builds where more control is possible

Step 1: get a conditional compilation symbol
Open the proj file of your domain project. Add the following code to it:

   
<PropertyGroup>
       <DefineConstants>$(DefineConstants);$(SolutionName)</DefineConstants>
</PropertyGroup>

#if Server
[assembly: Poco("InheritanceTypeConnection", AttributeTargetAssemblies = "Domain", AttributeTargetTypes = "Domain.*")]
[assembly: CreateSerializeSurrogate("EntityFrameworkContrib.PostSharp4EF.ISerializationHelp, EntityFrameworkContrib.PostSharp4EF", AttributeTargetAssemblies = "Domain", AttributeTargetTypes = "Domain.*")]
#endif
#if Client
[assembly: EditableBusinessObjectAttribute(AttributeTargetAssemblies="Domain", AttributeTargetTypes="Domain.*")]
[assembly: CreateSerializeSurrogate("EditableBusinessObjects.Postsharp.Public.IEditableBusinessObject, EditableBusinessObjects.Postsharp.Public", AttributeTargetAssemblies="Domain", AttributeTargetTypes="Domain.*")]
#endif

UPDATED WIKI: Editable Business Objects

RBoeke — Wed, 16 Apr 2008 19:24:42 GMT

Editable Business Objects

The Editable Business Objects (EBO) enhancements has two objectives:

Implement IEditableObject
Keep originalvalues so that they can be delivered to the Circular Serializer

The project works together with 2 other projects (also included): Circular Serializer and PostSharp4EF. Together they offer effortless n-tier distributed usage of your domain layer, arguably the most important layer of your application. Read more about this here: full disconnected n-tier usage.

EBO is meant as a purely client side enhancement for objects.
More can be read here: http://www.sitechno.com/Blog/AddingEditSupportToBusinessobjects.aspx and here: //http://www.sitechno.com/Blog/SneakPreviewSerializingObjectsWithOriginalValues.aspx

Given a simple Person object:

    [DataContract(Namespace = "myNamespace", Name = "Person")]
    public class Person
    {
        [DataMember]
        public int PersonID { get; set; }
        [DataMember]
        public string Firstname { get; set; }
        [DataMember]
        public string Lastname { get; set; }
    }

We can enhance this object by adding this attribute to it:
[EditableBusinessObjectAttribute()]

This triggers the following actions:

Implement the IEditableObject interface, which gives BeginEdit, CancelEdit and AcceptEdit methods
Rewrite all access to fields to pass through a method that will decide if a backup is necessary (when beginedit was called)
At canceledit, backups will be restored

In addition the following capabilities are added:

A dictionary for 'original values'
Allow straight access to the 'original values' that is used by the Circular Serializer

It is important to understand that this is never visible in Visual Studio. Your code remains untouched. The resulting dll is enhanced with these features

To use it's features, we can cast the object to IEditableObject and call the exposed methods.

UPDATED WIKI: Circular Serializer

RBoeke — Wed, 16 Apr 2008 19:10:05 GMT

Circular Serializer

The circular serializer has two objectives:

Allow for serializing graphs of objects that might have relations to eachother. In other words: solve the circular reference problem
Work together with PostSharp4EF and Editable Business Objects to serialize 'original values'. This way, change tracking is possible on all clients and efficient attaching to EF contexts

Serializing graphs

A more detailed look at this is available here http://www.sitechno.com/Blog/CircularReferencesWithWCFSolvedADifferentWay.aspx and here http://www.sitechno.com/Blog/RevisitingSerializingCircularReferencesKeepingContextDuringDeserialization.aspx.

Given a domain object Employee:

    [DataContract(Namespace = "myNamespace", Name = "Employee")]
    public class Employee : Person
    {
        [DataMember]
        public ICollection<Employee> TeamMembers { get; set; }
 
        [DataMember]
        public Employee TeamLeader { get; set; }
    }

When serializing this object using WCF with anything other than the nettcp binding, you might run into a stackoverflow. This is caused by a circular reference between employees: EmployeeA has a collection of teamMembers that contain EmployeeB, while EmployeeB has point to EmployeeA through it's TeamLeader reference. WCF can not serialize this relationship.
It is possible to set a switch on the DataContractSerializer that will enable a custom serializing scheme which might look like this:

<Person xmlns:i="http://www.w3.org/2001/XMLSchema-instance" z:Id="1" xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/" xmlns="myNamespace">
    <FieldedNumbers xmlns:d2p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays" z:Id="2" z:Size="2">
        <d2p1:int>12</d2p1:int>
        <d2p1:int>24</d2p1:int>
    </FieldedNumbers>
    <FirstName z:Id="3">Ruurd</FirstName>
    <LastName z:Id="4">Boeke</LastName>
    <Numbers xmlns:d2p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays" z:Id="5" z:Size="2">
        <d2p1:int>31</d2p1:int>
        <d2p1:int>29</d2p1:int>
    </Numbers>
    <Orders z:Id="6" z:Size="2">
        <Order z:Id="7">
            <Amount>12</Amount>
            <Customer z:Ref="1" i:nil="true" />
            <OrderID>12</OrderID>
            <ProductID>19</ProductID>
        </Order>
        <Order z:Id="8">
            <Amount>12</Amount>
            <Customer z:Ref="1" i:nil="true" />
            <OrderID>13</OrderID>
            <ProductID>255</ProductID>
        </Order>
    </Orders>
    <PersonID>23</PersonID>
    <Something>666</Something>
</Person>

Here you can see the z:ID and z:Ref attributes placed on the graph. This is not interoperable.

By placing a simple attribute on your class:
[CreateSerializeSurrogate("EditableBusinessObjects.Postsharp.Public.IEditableBusinessObject, EditableBusinessObjects.Postsharp.Public")]
this problem can be fixed.

The attribute triggers the following changes:

Create a surrogate class that has all the same datamembers as the original class
Create a constructor that will check a List<object> to see if the object was already serialized.

If not: all properties are copied
If so: only an ID is set

Create a method inside the original type, that will copy all information from the surrogate to itself (no reflection is used)

It is important to understand that this is never visible in Visual Studio. Your code remains untouched. The resulting dll is enhanced with these features

Example

Using reflector we can take a look at the Person class:

[EdmEntityType(Name="Person", NamespaceName="Domain")]
public class Person : IPocoFacade, IComposed<IPocoFacade>, IUpdateComplexTypesWithTracker, IStorageAccess, IRelationshipLoader, ISerializationHelp
{
 
.... members left out ...
 
    // Methods
    static Person();
    public Person();
    public void CopyDataFromSurrogate(PersonSurrogate surrogate);
 
    // Nested Types
    [DataContract(Name="Person", Namespace="myNamespace")]
    private class PersonSurrogate
    {
        // Fields
        [DataMember(EmitDefaultValue=false)]
        public string Firstname;
        [DataMember(EmitDefaultValue=false)]
        public string Lastname;
        [DataMember(EmitDefaultValue=false, Order=0x63)]
        public string OriginalValue_Firstname;
        [DataMember(EmitDefaultValue=false, Order=0x63)]
        public string OriginalValue_Lastname;
        [DataMember(EmitDefaultValue=false, Order=0x63)]
        public int OriginalValue_PersonID;
        [DataMember(EmitDefaultValue=false)]
        public int PersonID;
        [DataMember]
        public int SerializationID;
 
        // Methods
        public PersonSurrogate();
        public PersonSurrogate(Person source, List<object> graphList);
    }

All this is done invisible to the developer.
Now the datacontract serializer is able to serialize using the surrogates. The xml looks like:

<Person xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="myNamespace">
       <FieldedNumbers xmlns:d2p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">  
           <d2p1:int>12</d2p1:int>  
           <d2p1:int>24</d2p1:int>  
       </FieldedNumbers>  
       <FirstName>Ruurd</FirstName>  
       <LastName>Boeke</LastName>  
       <Numbers xmlns:d2p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">  
          <d2p1:int>31</d2p1:int> 
           <d2p1:int>29</d2p1:int> 
       </Numbers> 
       <Orders> 
           <Order> 
               <Amount>12</Amount> 
               <Customer> 
                   <SerializationID>0</SerializationID> 
               </Customer> 
               <OrderID>12</OrderID> 
               <ProductID>19</ProductID> 
               <SerializationID>1</SerializationID> 
           </Order> 
           <Order> 
               <Amount>12</Amount> 
               <Customer> 
                   <SerializationID>0</SerializationID> 
               </Customer> 
               <OrderID>13</OrderID> 
               <ProductID>255</ProductID> 
               <SerializationID>2</SerializationID> 
           </Order> 
       </Orders> 
       <PersonID>23</PersonID> 
       <SerializationID>0</SerializationID> 
       <Something>666</Something>
  </Person>

A datacontractsurrogate is supplied and should be attached to the service with an attribute

    [CircularReferenceSurrogateAttribute]
    [ServiceContract(Namespace = "Http://sitechno.Employee")]
    [ServiceKnownType("GetKnownTypes", typeof(KnownTypeHelper))]
    public interface IEmployeeService
    {
        [OperationContract]
        List<Employee> GetEmployees(string lastNameBeginsWith);
 
        [OperationContract]
        Person SavePerson(Person person);
 
        [OperationContract]
        Employee GetEmployee(int id);
    }

This will trigger the datacontractserializer to use the surrogate while serializing and call the 'CopyDataFromSurrogate' method when deserializing.

Original Values

The surrogate does not only have properties that match the parentType, but also creates properties that can be used to hold 'original values'.
The surrogate will try to fetch these values according to the supplied interface:
[CreateSerializeSurrogate("EditableBusinessObjects.Postsharp.Public.IEditableBusinessObject, EditableBusinessObjects.Postsharp.Public")]
Here, we are using the EditableBusinessObject interface. The surrogate will cast the parentType to this interface and call the 'GetOriginalValue' on it. This value will be placed in the originalvalue property that was created.

Apart from Editable Business Objects, the PostSharp4EF can also be used as a supplier of original values:
[CreateSerializeSurrogate("EntityFrameworkContrib.PostSharp4EF.ISerializationHelp, EntityFrameworkContrib.PostSharp4EF")]

The editable business objects keeps the original values in a dictionary. The PostSharp4EF (Poco) enhancements actually creates properties on the parenttype and fills them when signalled to.

UPDATED WIKI: PostSharp4EF

RBoeke — Wed, 16 Apr 2008 18:37:17 GMT

PostSharp4EF: Automatically implement IPoco interfaces

This project adds a compilation phase to your project. During that compilation phase, the metadata from your edmx file is used to alter the compiled code to actually implement all the requirements for a domain object to work with Entity Framework. This enables the developer to work with POCO (Plain Old Code Objects) objects that know nothing of the Entity Framework, in other words: they are Persistence Ignorant.

The project works together with 2 other projects (also included): Circular Serializer and Editable Business Objects. Together they offer effortless n-tier distributed usage of your domain layer, arguably the most important layer of your application. Read more about this here: full disconnected n-tier usage.

Reason of existence

In an agile design process, it is important to be able to work on a domain layer that is not weighed down by data access code. Ideally, one would like to be able to reuse the domain objects in other scenario's without having to make changes. Also, it should be simple to replace data-access code (for instance, to use another OR-mapper), without having to worry about how this affects the business layer.
This means that no data-access logic should invade the domain layer at all. Business objects focus solely on implementing business logic and validation.

The Entity Framework does not allow this in version 1. It does however present 3 interfaces (commonly known as the IPoco interfaces) that, when implemented, at least take away the need for a baseclass. The implementation of these interfaces is not easy and still invades the domain layer.

Example

Let's start by creating a Person object:

    [DataContract(Namespace = "myNamespace", Name = "Person")]
    public class Person
    {
        [DataMember]
        public int PersonID { get; set; }
        [DataMember]
        public string Firstname { get; set; }
        [DataMember]
        public string Lastname { get; set; }
 
    }

The next step is to add an attribute that will notify the postcompilation step to alter this object:
[assembly: Poco("InheritanceTypeConnection")]

This will trigger the following actions:

implementing IEntityWithChangeTracker, IEntityWithKey and IEntityWithRelationships. These are the IPoco interfaces that EF needs to work
put the EdmEntityType attribute on top of the class
put the EdmScalarProperty attributes on top of the properties
put EdmRelationShip attributes on the assembly (if needed)
put the EdmSchema attribute on the assembly

Then a few other interfaces are implemented, that are needed for the system to work.

the IUpdateComplexTypesWithTracker interface is used to facilitate complex types
the IGetChangeTracker interface is used to get to the changetracker
the IContextAware interface can be used to attach an object to the context (!) and prepare it for serialization (!)
the IRelationshipLoader interface can be used to load relationships
the IStorageAccess and ISerializationHelp interfaces are used during serialization

Behind the scenes, access to relationships are rewritten to use the Relationshipmanager, and setters of properties are intercepted to raise the proper events.

It is important to understand that this is never visible in Visual Studio. Your code remains untouched. The resulting dll is enhanced with these features

When we open the dll in reflector, we see the following:

[EdmEntityType(Name="Person", NamespaceName="Domain")]
public class Person : IPocoFacade, IComposed<IPocoFacade>, IUpdateComplexTypesWithTracker, IStorageAccess, IRelationshipLoader, ISerializationHelp
{
...... a lot of members left out .....
    // Properties
    [DataMember, EdmScalarProperty(IsNullable=false)]
    public string Firstname { get; set; }
    [DataMember, EdmScalarProperty(IsNullable=false)]
    public string Lastname { get; set; }
    [EdmScalarProperty(IsNullable=false, EntityKeyProperty=true), DataMember]
    public int PersonID { get; set; }
}

End result

The end result is that you are able to work with regular objects, without thinking about Entity Framework. This enables an agile work process.

UPDATED WIKI: Home

RBoeke — Wed, 16 Apr 2008 14:41:34 GMT

Welcome to the Entity Framework Contrib project

This project is a home to contributions for the Entity Framework in order to accomodate different scenario's and programming styles.
It consists of multiple projects aimed at helping you take full advantage of EF.

Projects

PostSharp4EF: Automatically implement IPoco This project uses PostSharp to post-compile your assemblies. When it encounters a simple attribute, it will implement everything needed to use it in EF: Typelevel attributes, EDMscalar attributes, changetracking and default values. This means there are no runtime performance penalties. See Introducing EF Contrib post for more detailed information about this project. The following supporting projects are included as well and will enable the use of full disconnected n-tier usage of your domain objects:

Circular Serializer: enables the serialization of object graphs (including circular references) with knowledge of 'original values'.
Editable Business Objects: does changetracking and provides the serializer with the correct values.

Plug-in Edmx Code Generator: easily add assemblies that will hook into the codegeneration part of Entity Framework. Check this blog post out for more info!

Community feedback

Please contribute to this project by either contributing code or giving feedback. Let me know if you are interested in the project and if you'd like to see it completed.

NEWS FEED

Disconnected N-Tier objects using EntityFramework

Monday, April 07, 2008 | From Ruurd Boeke Enterprise development and technobabble - EF-Contrib

Relation support for n-tier EF

Thursday, March 27, 2008 | From Ruurd Boeke Enterprise development and technobabble - EF-Contrib

Progress on light objects on the client, full blown EF entities on the backend

Friday, March 21, 2008 | From Ruurd Boeke Enterprise development and technobabble - EF-Contrib

Sneak preview: serializing objects with original values

Monday, March 17, 2008 | From Ruurd Boeke Enterprise development and technobabble - EF-Contrib

Complex types in EF, how they work and support in EFContrib

Friday, March 14, 2008 | From Ruurd Boeke Enterprise development and technobabble - EF-Contrib

Relationship support in EFContrib

Monday, March 10, 2008 | From Ruurd Boeke Enterprise development and technobabble - EF-Contrib

Postcompiling for Entity Framework: Part VI

Monday, February 25, 2008 | From Ruurd Boeke Enterprise development and technobabble - EF-Contrib

Postcompiling for Entity Framework: Part V

Friday, February 22, 2008 | From Ruurd Boeke Enterprise development and technobabble - EF-Contrib

Default values for efcontrib

Thursday, February 21, 2008 | From Ruurd Boeke Enterprise development and technobabble - EF-Contrib

Postcompiling for Entity Framework: Part IV

Thursday, February 21, 2008 | From Ruurd Boeke Enterprise development and technobabble - EF-Contrib

NEWS FEED

UPDATED WIKI: Home

RBoeke — Wed, 16 Apr 2008 14:39:55 GMT

Welcome to the Entity Framework Contrib project

Projects

PostSharp4EF: Automatically implement IPoco This project uses PostSharp to post-compile your assemblies. When it encounters a simple attribute, it will implement everything needed to use it in EF: Typelevel attributes, EDMscalar attributes, changetracking and default values. This means there are no runtime performance penalties. See Introducing EF Contrib post for more detailed information about this project. The following supporting projects are included as well and will enable the use of full disconnected n-tier usage of your domain objects:

Circular Weaver: enables the serialization of object graphs with knowledge of 'original values'.
Editable Business Objects: does changetracking and provides the serializer with the correct values.

Plug-in Edmx Code Generator: easily add assemblies that will hook into the codegeneration part of Entity Framework. Check this blog post out for more info!

Community feedback

Please contribute to this project by either contributing code or giving feedback. Let me know if you are interested in the project and if you'd like to see it completed.

NEWS FEED

Disconnected N-Tier objects using EntityFramework

Monday, April 07, 2008 | From Ruurd Boeke Enterprise development and technobabble - EF-Contrib

Relation support for n-tier EF

Thursday, March 27, 2008 | From Ruurd Boeke Enterprise development and technobabble - EF-Contrib

Progress on light objects on the client, full blown EF entities on the backend

Friday, March 21, 2008 | From Ruurd Boeke Enterprise development and technobabble - EF-Contrib

Sneak preview: serializing objects with original values

Monday, March 17, 2008 | From Ruurd Boeke Enterprise development and technobabble - EF-Contrib

Complex types in EF, how they work and support in EFContrib

Friday, March 14, 2008 | From Ruurd Boeke Enterprise development and technobabble - EF-Contrib

Relationship support in EFContrib