Entity Framework 4.0 and T4 templates to generate POCO classes

Hi guys, thanks for visiting again.  This post is to have a brief introduction on how to work with T4 templates that generates ObjectContext and POCO classes dynamically.  In this example, we're going customize the context template with a free template editor which is going to make our life easier with it's features.  After we're going to run the test performance.
We are going to proceed as follows:

• Download ADO.NET C# T4 Entity Code Generator, is an existing T4 template that can be used to generate persistence ignorant entity types (POCO classes) from an Entity Data Model.
• Install the Tangible T4 Editor for Visual Studio 2010, which is an editor basically adds IntelliSense and Syntax Coloring to T4 Text Templates.
• Test how this T4 template generates our Context and POCO classes.
• Run the performance test.

Let's add a class libray project named EF4ApplicationWithPOCOTemplate, just to keep the name convention from my previous post. 

Let's create our model (edmx file) as we did in the previous post on POCO performance.

In order to have the template available, we need to install the ADO.NET C# POCO Entity Generator.   

After installation is finished, you might need to restart Visual Studio to see the new template available.  Add it to your project from the Add new item menu.

When adding the template you'll be prompt a Security Warning window to confirm the execution of the template.  In this window we choose OK, no because we ignore the message, but because we know it will generate our POCO Classes :-), besides it's going to run every time we save it.

After adding the templates, we'll have an awfull error message related to System.IO.FileNotFoundException. 

Basically this error message is because it cannot find the Entity Data Model file (edmx file) which provides the source metadata that is used to generate the code for both the POCO classes and the ObjectContext.  To fix this issue, we just need to open both files and replace the @"$edmxInputFile$" with the name of our edmx file.

After modifying and saving both template files (.tt) with the correct edmx filename, they will generate the POCO and ObjectContext classes as expected and add them to the project.

Now, we have our project with auto generated POCO and ObjectContext classes that works fine; however, since we want to modify and customize the templates as needed, let's start comparing both versions we have in the solution.  

One is the manually created ObjectContext from the previous post and the new one generated by the T4 template.

As shown, there are a couple of differences between these two classes. 
Let's open the context EF4ApplicationWithPOCOTemplate.Context.tt file.

The first thing I thought when looking at the content of the file is "NOTEPAD".  So, I decided to search for a friendly interface that helps me modify this file.  You'll notice that there are many T4 template editors out there.  For this example, we're going to use a FREE tool named Tangible T4 Template Editor.  It will change the whole appearance of the file content by adding features such as intellisense and syntax coloring.

I will only select to Install T4 Editor this time.  If you want, you can install the Modeling tools as well. 

After installing this tool and restarting Visual Studio, you can manage the installation with the Extension Manager, which is in the Tools menu.

Now we're ready to open the template file and change it using the features added.

For this example, I have changed the template so it generates the exact same code, for the ObjectContext, as the manually POCO generated class from the previous post.

File modified content: EF4ApplicationWithPOCOTemplate.Context.tt (all content)

<#@ template language="C#" debug="false" hostspecific="true"#>
<#@ include file="EF.Utility.CS.ttinclude"#><#@
 output extension=".cs"#><#

CodeGenerationTools code = new CodeGenerationTools(this);
MetadataTools ef = new MetadataTools(this);
MetadataLoader loader = new MetadataLoader(this);

string inputFile = @"EF4DomainModelForPOCOTemplate.edmx";
EdmItemCollection ItemCollection = loader.CreateEdmItemCollection(inputFile);
string namespaceName = code.VsNamespaceSuggestion();

EntityContainer container = ItemCollection.GetItems<EntityContainer>().FirstOrDefault();
if (container == null)
{
    return "// No EntityContainer exists in the model, so no code was generated";
}
#>
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated from MY ADJUSTED TEMPLATE!!!!!!!.
// </auto-generated>
//------------------------------------------------------------------------------
using System;
using System.Data.Objects;
using System.Data.EntityClient;

<#
if (!String.IsNullOrEmpty(namespaceName))
{
#>
namespace <#=code.EscapeNamespace(namespaceName)#>
{
<#
    PushIndent(CodeRegion.GetIndent(1));
}
#>
<#=Accessibility.ForType(container)#> partial class <#=code.Escape(container)#> : ObjectContext
{
    public <#=code.Escape(container)#>() : base("name=<#=container.Name#>", "<#=container.Name#>")
    {
<#
        WriteLazyLoadingEnabled(container);
#>
    }
<#
        foreach (EntitySet entitySet in container.BaseEntitySets.OfType<EntitySet>())
        {
#>

    private ObjectSet<<#=code.Escape(entitySet.ElementType)#>> <#=code.FieldName(entitySet)#>;
    <#=Accessibility.ForReadOnlyProperty(entitySet)#> ObjectSet<<#=code.Escape(entitySet.ElementType)#>> <#=code.Escape(entitySet)#>
    {
        get { 
                if(<#=code.FieldName(entitySet) #>==null) 
                    <#=code.FieldName(entitySet)#> = CreateObjectSet<<#=code.Escape(entitySet.ElementType)#>>("<#=entitySet.Name#>"); 
                return <#=code.FieldName(entitySet) #>;
            }
    }
    
    public void AddTo<#=code.Escape(entitySet)#>(<#=code.Escape(entitySet.ElementType)#> <#=code.Escape(entitySet).ToLower().Trim('s') #>){
        <#=entitySet.Name#>.AddObject(<#=code.Escape(entitySet).ToLower().Trim('s') #>);
    }
<#
        }
#>
}
<#
if (!String.IsNullOrEmpty(namespaceName))
{
    PopIndent();
#>
}
<#
}
#>
<#+
private void WriteLazyLoadingEnabled(EntityContainer container)
{
   string lazyLoadingAttributeValue = null;
   string lazyLoadingAttributeName = MetadataConstants.EDM_ANNOTATION_09_02 + ":LazyLoadingEnabled";
   if(MetadataTools.TryGetStringMetadataPropertySetting(container, lazyLoadingAttributeName, out lazyLoadingAttributeValue))
   {
       bool isLazyLoading = false;
       if(bool.TryParse(lazyLoadingAttributeValue, out isLazyLoading))
       {
#>
        this.ContextOptions.LazyLoadingEnabled = <#=isLazyLoading.ToString().ToLowerInvariant()#>;
<#+
       }
   }
}
#>

To test the generated results, I've just copied and pasted the folder that contains the class with CRUD operations from previous post, then renamed the file and class.  After just add a couple of lines in the console application to run it.

After running the application I have the following results.

Conclusions

• The C# T4 Entity Code Generator for POCO works great and the best thing is that it can be customized as needed. 
• The Tangible T4 Editor is a good tool to modify these files.
• The performance was increased.

What's next?

I'm thinking on writing about extending performance test for EF 4.0, refactoring current solution, repository pattern implementation, MVC 2 pattern, WCF Data Services, etc.  I'm always open to suggestions.    

Entity Framework 4.0 and POCO Performance

In this post we're going to run the same tests we ran in our previous post; however, these tests will be done with POCO (Plain Old CLR Object) classes in place.

We're going to perform the following:

• Rearrange solution project and files.
• Create POCO Classes.
• Create ObjectContext.
• Run CRUD operations and Performance test.
• Compare results of auto generated Entities against POCO classes.

Let's start by changing the file arrangements in our solution.  Let's add two class library projects: one to keep the database scripts and batch file and another named EFApplicationWithPOCO for the POCO Classes and Context.  

Add a new ADO.NET Entity Data Model by using the Update Model From Database wizard to generate the model. 

Empty the Custom Tool property of the Edmx file.  This will remove the EF4DomainModelForPOCO.Designer.cs auto generated file and it won't generated again.

Write your POCO and ObjectContext classes.

Role.cs

using System;
using System.Collections.Generic;

namespace EF4ApplicationWithPOCO
{
    public class Role
    {
        public Int32 RoleId { get; set; }
        public String RoleName { get; set; }
        public virtual List<User> Users { get; set; }
    }
}

User.cs

using System;
namespace EF4ApplicationWithPOCO
{
    public class User
    {
        public Int32 UserId { get; set; }
        public String UserName { get; set; }
        public String FirstName { get; set; }
        public String LastName { get; set; }
        public DateTime? DateOfBirth { get; set; }
        public Int32 RoleId { get; set; }
        public virtual Role Role { get; set; }
    }
}
EF4ApplicationPOCOContext.cs

using System.Data.Objects;

namespace EF4ApplicationWithPOCO
{
    public class EF4ApplicationPOCOContext : ObjectContext
    {
        public EF4ApplicationPOCOContext() : base("name=EF4DomainModelContainerForPOCO", "EF4DomainModelContainerForPOCO")
        {
            ContextOptions.LazyLoadingEnabled = true;
        }

        private ObjectSet<User> _users;
        public ObjectSet<User> Users
        {
            get
            {
                if (_users == null)
                    _users = CreateObjectSet<User>("Users");
                return _users;
            }
        }

        private ObjectSet<Role> _roles;
        public ObjectSet<Role> Roles
        {
            get
            {
                if (_roles == null)
                    _roles = CreateObjectSet<Role>("Roles");
                return _roles;
            }
        }

        public void AddToRoles(Role role)
        {
            Roles.AddObject(role);
        }

        public void AddToUsers(User user)
        {
            Users.AddObject(user);
        }
    }
}

Now that we've created our POCO and ObjectContext classes, we can add code to the TestCrudeOperationsWithPOCO.cs class and implement it as follows.

using System;
using System.Linq;
using EF4ApplicationInterfaces;

namespace EF4ApplicationWithPOCO.Temp
{
    public class TestCrudeOperationsWithPOCO : IEF4ApplicationTest
    {
        public void CreateDbTest()
        {
            using (var context = new EF4ApplicationPOCOContext())
            {
                Console.WriteLine("INSERTING ROLES TO DATABASE");
                context.AddToRoles(new Role {RoleName = "Role 1"});
                context.AddToRoles(new Role {RoleName = "Role 2"});
                context.AddToRoles(new Role {RoleName = "Role 3"});
                context.SaveChanges();

                Console.WriteLine("INSERTING USERS TO DATABASE");
                var firstRole = context.Roles.Where(t => t.RoleName == "Role 1").FirstOrDefault();
                context.AddToUsers(
                    new User
                    {
                        UserName = "user1",
                        FirstName = "FirstName1",
                        LastName = "LastName1",
                        DateOfBirth = new DateTime(1980, 12, 10),
                        Role = firstRole
                    });
                var secondRole = context.Roles.Where(t => t.RoleName == "Role 2").FirstOrDefault();
                context.AddToUsers(
                    new User
                    {
                        UserName = "user2",
                        FirstName = "FirstName2",
                        LastName = "LastName2",
                        DateOfBirth = new DateTime(1980, 12, 11),
                        Role = secondRole
                    });
                var thridRole = context.Roles.Where(t => t.RoleName == "Role 3").FirstOrDefault();
                context.AddToUsers(
                    new User
                    {
                        UserName = "user3",
                        FirstName = "FirstName3",
                        LastName = "LastName3",
                        DateOfBirth = null,
                        Role = thridRole
                    });
                context.SaveChanges();
            }
        }

        public void UpdateDbTest()
        {
            using (var context = new EF4ApplicationPOCOContext())
            {
                Console.WriteLine("UPDATING USER INFORMATION");
                var user1 = context.Users.Where(t => t.UserName == "user1").FirstOrDefault();
                user1.FirstName = "Alexandro";
                user1.LastName = "Velarde";
                context.SaveChanges();
            }
        }

        public void ReadFromDbTest()
        {
            using (var context = new EF4ApplicationPOCOContext())
            {
                Console.WriteLine("VIEW INSERTED USERS");
                var users = context.Users;
                foreach (var u in users)
                {
                    Console.WriteLine(string.Format(
                        "UserName = {0}, FirstName = {1}, LastName = {2}, DateOfBirth = {3}",
                        u.UserName, u.FirstName, u.LastName,
                        u.DateOfBirth.HasValue ? u.DateOfBirth.Value.ToString("MM/dd/yyyy")
                        : string.Empty));
                }
            }
        }

        public void PerformanceTest()
        {
            using (var context = new EF4ApplicationPOCOContext())
            {
                var users = context.Users;
                Console.WriteLine("PERFORMANCE TEST STARTED...");
                var user = users.FirstOrDefault();
                string readValueOneMillionTimes = null;
                var timeWhenTestStarted = DateTime.Now;
                for (int i = 0; i < 1000000; i++)
                    readValueOneMillionTimes = user.Role.RoleName;

                var duration = DateTime.Now.Subtract(timeWhenTestStarted);
                Console.WriteLine("VALUE READ: " + readValueOneMillionTimes +
                                  " DURATION: " + duration.TotalMilliseconds + " MILLISECONDS");
                Console.WriteLine("PERFORMANCE TEST END");
            }
        }

        public void DeleteFromDbTest()
        {
            using (var context = new EF4ApplicationPOCOContext())
            {
                Console.WriteLine("DELETE USERS FROM DATABASE");
                foreach (var userToDelete in context.Users)
                    context.DeleteObject(userToDelete);

                foreach (var role in context.Roles)
                    context.DeleteObject(role);
                context.SaveChanges();
            }
        }

        public void RunAllTest()
        {
            CreateDbTest();
            Console.WriteLine();

            UpdateDbTest();
            Console.WriteLine();

            ReadFromDbTest();
            Console.WriteLine();

            PerformanceTest();
            Console.WriteLine();

            DeleteFromDbTest();
            Console.ReadKey();
        }
    }
}

Now let's RUN our the performance test for both projects and COMPARE the results.

Program.cs

using System;
using EF4Application.Temp;
using EF4ApplicationWithPOCO.Temp;

namespace EF4ConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("====== RUNNING AUTO GENERATED CLASSES ======");
            new TestCrudeOperationsNoPOCO().RunAllTest();
            
            Console.WriteLine("====== RUNNING POCO CLASSES TEST =======");
            new TestCrudeOperationsWithPOCO().RunAllTest();
        }
    }
}

Here are the results.  Look at the huge difference between POCO and auto generated entities.

Summary
I think there should be more performance test to be done, but thisone gives you a good idea on where to focus. 

What's next?

In the next post, I can enhance the performance test with much more complex cases to measure the POCO performance for tracking.  After we can see how to write templates to auto generate POCO classes or any good idea you can come up with...  Let me know!.

I hope this was useful, thanks for reading..

Entity Framework 4.0 Walk-through

This example is a walk-through the basic characteristics of Entity Framework 4.0.  In this example we'll see how to perform the following:

• Create an Entity Framework 4.0 based application with Visual Studio 2010.
• Model First Development by creating your Entity Model first and then generate DDL to create the database with maching tables and relations.
• Create relations (associations) between entities.
• Create a Mount database batch file that will run our script to create our database and its objects.
• Execute CRUD operations (Create, Read, Update, Delete) over our database.

Let's start by creating a new Class Library project and add an ADO.NET Entity Data Model.

When the Entity Data Model Wizard dialog appears, choose an Empty Model content.

Add the two Entities (Role and User) that will represent our database tables for this example.  If the database had already existed, we can choose Update Model from Database and select the objects from our database such as tables, stores procedures and functions.

Add the Properties needed to define each Entity. In the properties window we can define type, size and nullability for each property.

Create Association between the entities Role and User.  Right click on the Entity Role and select Add -> Association.

After the Association is added, it can be configured in the properties window or open the Referential Constraint window by double clicking on it.

To view the definition of the table that will be created in the database, we can select the Entity, right click on it and select Table Mapping.

The create database DDL can be generated from the Model by right clicking on it and selecting Generate Database from Model.  If the database existed just click on Update Model from Database and select database objects.

When Generate Database Wizard dialog appears, specify a name for the new ConnectionString that will be added to a configuration file in the application.

After clicking the Next button in the Generate Database Wizard it will generate the SQL script to create database objects from the Model.

Create a batch file and added as an external tool in the Visual Studio.  It will run the Create Database script (manually added) and the one generated by Entity Framework.  This can be easily run each time the Model or Database is modified.

After building the application and clicking the button to show all files, there are three files generated.  The Conceptual schema definition language (CSDL), store schema definition language (SSDL), and mapping specification language (MSL) which are XML-based languages that respectively describe the conceptual model, storage model, and the mapping between these models. These files are generated at build time and the EF needs them at run time.

The EF4DomainModel.Designer.cs was created with the EDMX file.  This file contains the Context, Entities and Types generated by the code generator defined by default in the Custom Tool property of the EDMX file.

Now let’s write some code to test the application with CRUD operations.

• Add a Console Application to the solution.
• Copy the App.config and pasted to the Console Application.
• Create a folder name Temp and Add a TestCrudeOperations.cs class.

In the class TestCrudeOperations.cs add the code bellow. This is what we're doing:

• Insert all the Roles and Users to the database.
• Update User information.
• Read and List the three inserted Users.
• Read a property a Million times to measure performance in milliseconds.
• Delete all the Roles and Users from the database.

We have to call the method SaveChanges() from our context to commit our changes to our database.

using System;
using System.Linq;
namespace EF4Application.Temp
{
    public class TestCrudeOperations
    {
        public void RuntTest()
        {
            using (var context = new EF4DomainModelContainer())
            {
                Console.WriteLine("INSERTING ROLES TO DATABASE");
                context.AddToRoles(new Role { RoleName = "Role 1" });
                context.AddToRoles(new Role { RoleName = "Role 2" });
                context.AddToRoles(new Role { RoleName = "Role 3" });
                context.SaveChanges();

                Console.WriteLine("INSERTING USERS TO DATABASE");
                var firstRole = context.Roles.Where(t =>t.RoleName=="Role 1").FirstOrDefault();
                context.AddToUsers(
                    new User
                    {
                        UserName = "user1",
                        FirstName = "FirstName1",
                        LastName = "LastName1",
                        DateOfBirth = new DateTime(1980, 12, 10),
                        Role = firstRole
                    });
                var secondRole = context.Roles.Where(t =>t.RoleName=="Role 2").FirstOrDefault();
                context.AddToUsers(
                    new User
                        {
                            UserName = "user2", 
                            FirstName = "FirstName2", 
                            LastName = "LastName2", 
                            DateOfBirth = new DateTime(1980, 12, 11), 
                            Role = secondRole
                        });
                var thridRole = context.Roles.Where(t =>t.RoleName=="Role 3").FirstOrDefault();
                context.AddToUsers(
                    new User
                        {
                            UserName = "user3", 
                            FirstName = "FirstName3", 
                            LastName = "LastName3", 
                            DateOfBirth = null, 
                            Role = thridRole
                        });
                context.SaveChanges();

                Console.WriteLine("UPDATING USER INFORMATION");
                var user1 = context.Users.Where(t => t.UserName == "user1").FirstOrDefault();
                user1.FirstName = "Alexandro";
                user1.LastName = "Velarde";
                context.SaveChanges();

                Console.WriteLine("VIEW INSERTED USERS");
                var users = context.Users;
                foreach (var u in users)
                {
                    Console.WriteLine(string.Format(
                        "UserName = {0}, FirstName = {1}, LastName = {2}, DateOfBirth = {3}",
                        u.UserName, u.FirstName, u.LastName, 
                        u.DateOfBirth.HasValue ? u.DateOfBirth.Value.ToString("MM/dd/yyyy") 
                        : string.Empty));
                }

                Console.WriteLine("PERFORMANCE TEST STARTED...");
                var user = users.FirstOrDefault();
                string readValueOneMillionTimes = null;
                var timeWhenTestStarted = DateTime.Now;
                for (int i = 0; i < 1000000; i++)
                {
                    readValueOneMillionTimes = user.Role.RoleName;
                }
                var duration = DateTime.Now.Subtract(timeWhenTestStarted);
                Console.WriteLine("VALUE READ: " + readValueOneMillionTimes + 
                                  " DURATION: " + duration.TotalMilliseconds + " MILLISECONDS");
                Console.WriteLine("PERFORMANCE TEST END");

                Console.WriteLine("DELETE USERS FROM DATABASE");
                foreach (var userToDelete in context.Users)
                    context.DeleteObject(userToDelete);

                foreach (var role in context.Roles)
                    context.DeleteObject(role);
                context.SaveChanges();
                Console.ReadKey();
            }
        }
    }
}

In the Console Application, let’s write the following code in the Main method.

This are the test results in the Console Application.

From the SQL Management Studio, if we do a select to both tables Roles and Users, we’ll see the following results.

Conclusion

With this post we were able to execute and persist data in our database.  The performance test is intented to be compared after, when we see POCO classes.

What's next?

As always, I'm opened to suggestions...for now, this is what I have in mind for next posts: POCO classes and templates for code generation, Change Tracking with POCO (Snapshot and Notification based), Implementing Repository and Unit of Work pattern with Entity Framework 4.0., etc..