I just finished full support for using complex types in EFContrib. I thought I'd quickly share what complex types are and how they are used in Entity Framework.
Julie Lerman blogged about Complex Types here, where she also shows how to use them. Check her post for a great example.
In Daniel Simmons' words:
Complex types “Complex types” is the Entity Framework name for value properties which have more intricate structure than scalars. The canonical example is an Address type which contains several parts (street, city, state, etc.) Complex types are somewhat like entities except that they do not have any identity of their own (they are value types). This means that a complex type instance is always a part of some other enclosing entity—it can’t stand on its own, it doesn’t have relationships, etc. In this release, the mapping scenarios for complex types are significantly limited: inheritance is not supported, complex type properties cannot be null and they can only occur in single instances, not collections.
So, a complex type can be seen as a struct, without identity.
Let's create a complex type. I will have a person table with 3 address related columns. My person object though, should have a property named 'Address' which points to a class of type Address.
The CSDL looks like this:
<EntityType Name="Person">
<Key>
<PropertyRef Name="PersonID" />
</Key>
<Property Name="PersonID" Type="Int32" Nullable="false" />
<Property Name="FirstName" Type="String" Nullable="false" MaxLength="50" Unicode="false" />
<Property Name="LastName" Type="String" Nullable="false" MaxLength="50" Unicode="false" />
<Property Name="Address" Type="Self.Address" Nullable="false" />
</EntityType>
<ComplexType Name="Address">
<Property Name="City" Type="String" Nullable="false" MaxLength="50" Unicode="false" />
<Property Name="Street" Type="String" Nullable="false" MaxLength="50" Unicode="false" />
<Property Name="PostalCode" Type="String" Nullable="false" MaxLength="10" Unicode="false" />
</ComplexType>
Pretty clear: our Person has an address property, with a type of 'Self.Address'. Make sure it is not Nullable. The Address is defined just like you would expect. Please know that the current designer does not allow designing complextypes visually, which is why I did it in xml.
The database looks like this:
<EntityContainer Name="dbo">
<EntitySet Name="Person" EntityType="ComplexTypesTestModel.Store.Person" />
</EntityContainer>
<EntityType Name="Person">
<Key>
<PropertyRef Name="PersonID" />
</Key>
<Property Name="PersonID" Type="int" Nullable="false" StoreGeneratedPattern="Identity" />
<Property Name="FirstName" Type="varchar" Nullable="false" MaxLength="50" />
<Property Name="LastName" Type="varchar" Nullable="false" MaxLength="50" />
<Property Name="Street" Type="varchar" Nullable="false" MaxLength="50" />
<Property Name="City" Type="varchar" Nullable="false" MaxLength="50" />
<Property Name="PostalCode" Type="varchar" Nullable="false" MaxLength="10" />
</EntityType>
Here we see a row with all columns in it. Darned DBA's!!
To map that database description to the classes, we take a look at the C-S mapping:
<EntitySetMapping Name="Person">
<EntityTypeMapping TypeName="IsTypeOf(EntityFrameworkContrib.PostSharp4EF.Testing.ComplexType.Person)">
<MappingFragment StoreEntitySet="Person">
<ScalarProperty Name="PersonID" ColumnName="PersonID" />
<ScalarProperty Name="FirstName" ColumnName="FirstName" />
<ScalarProperty Name="LastName" ColumnName="LastName" />
<ComplexProperty Name="Address">
<ScalarProperty Name="City" ColumnName="City"/>
<ScalarProperty Name="Street" ColumnName="Street"/>
<ScalarProperty Name="PostalCode" ColumnName="PostalCode"/>
</ComplexProperty>
</MappingFragment>
</EntityTypeMapping>
</EntitySetMapping>
As you can see, the complexproperty is defined within the Person mapping. That caught me off-guard for a while.
EFContrib support
I have not checked in the source yet, but I will shortly at http://www.codeplex.com/efcontrib.
As you know, my contribution project to Entity Framework aims to help you use Entity Framework without all the generated code. You can just create your own domain model and add one attribute. The system will actually change the code to facilitate the EDM during compilation. Leaving you with a clean model.
It was actually quite difficult to implement this behind the scenes. To support normal entitytypes, I have to implement the three IPoco interfaces. But complex types are radically different. In the end, I had to alter the code I put into the setters of your properties.
I also had to somehow get hold of a list of properties in your type that are complexTypes (in this case Address). When the system injects your entitytype with a changetracker, it should notify all complex types. I could have done that with reflection, but we all know that's really slow. So I actually generate a method in your entity: 'UpdateComplexTypes(tracker)' and insert that with the correct IL to set the tracker in all the complextype-properties. So the solution is as fast as it can get, completely on par with handwritten c#. I may have to write another post on how I did it.
Our domain objects look like this:
0 [Poco("ComplexTypesTestEntities")]
1 public class Person
2 {
3 public int PersonID { get; set; }
4 public string FirstName
{ get; set; }
5 public string LastName { get; set; }
6 public Address Address
{ get; set; }
7 }
8
9 [Poco("ComplexTypesTestEntities")]
10 public class Address
11 {
12 public string City
{ get; set; }
13 public string Street { get; set; }
14 public string PostalCode
{ get; set; }
15 }
16
Now, this code will work great:
0 using (ComplexTypesTestEntities context
= new ComplexTypesTestEntities())
1 {
2 // clear out database
3 foreach (Person old in context.Person)
4 {
5 context.DeleteObject(old);
6 }
7 context.SaveChanges();
8
9 Person p = new Person { FirstName = "Ruurd", LastName = "Boeke" };
10
11 // this will set the changetracker
12 context
.AddToPerson
(p
);
13
14 Address a
= new Address { City
= "Rotterdam", Street
= "My Street", PostalCode
= "1111 VA" };
15 p.Address = a;
16
17 IGetChangeTracker ctA = PostSharp.Post.Cast<Address, IGetChangeTracker>(a);
18 Debug.Assert
(ctA
.GetChangeTracker
() != null);
19
20 Address b
= new Address { City
= "Seattle", Street
= "redmond street", PostalCode
= "2222 BB" };
21 p.Address = b;
22 Debug.Assert
(ctA
.GetChangeTracker
() == null);
23
24 IGetChangeTracker ctB
= PostSharp
.Post.Cast
<Address, IGetChangeTracker>(b
);
25 Debug.Assert(ctB.GetChangeTracker() != null);
26
27 context.SaveChanges();
28 }
You can see me casting the object to the interface I implemented on lines 17 and 24.