Continue reading »]]> Following up on my recent post about the improvements to the Entity Framework in .Net 4.0 this is the first in a series of posts examining some of the new features and showing you how to put some of them into practice.

In this post I am going to look at one of the most anticipated features, Model First.  In the first version of the Entity Framework, you took a pre-existing database and the tools would generate your entity model for you.  In v2.0, you now have the option of creating your entity model first and then generating your database DDL from your finished model.

To follow this tutorial you will need Visual Studio 2010 Beta 1, .Net Framework 4.0 Beta 1 installed, SQL 2005 or 2008 / SQL Express.

Please bear with me and let me know if there are any parts of this tutorial that are not completely clear.  I am new to writing these! So any comments welcome….

Creating your project and adding your blank entity model

Open Visual Studio 2010 and create a new Dynamic Data Entities Web Application project(you could another project type to host your entity model, such as an ASP.Net Web Application).

Once your project has been created add a new ADO.Net Entity Data Model to the project. 

You will then be asked about what the model should contain.  As with version 1 of the Entity Framework, you have two options, Generate from Database and Empty Model.  To a large extent, the latter was redundant in the first version of the framework, but with version 2 it becomes very useful.  Select Empty Model and click Finish.

Adding an entity and scalar properties to your model

You will now be presented with your empty model designer ready for you to add your entities.  Right click on the designer and select Add –> Entity…  For this example we will name our entity “Customer” and the entity set “Customers”.  This will create your Customer entity in the designer.

You will now need to add some properties to the entity.  You can do this by right clicking the entity and Add –> Scalar Property and then selecting the data type of the property. Do this and create two string scalar properties for Name and Email.

Adding complex types

You should now have a Customer entity with properties for the customer’s name and email address. A complex type is essentially a property that can contain sub properties.  To display this we are going to create one for the customer’s mailing address.

In your model browser, right click on the “Complex Types” folder and select Create Complex Type.  Rename this created type “Address”.  Now right click on the Address object you have created and select Add –> Scalar Property –> String.  Rename the created property “Line 1”.  Repeat this, adding properties for Line 2, Town, County, Post Code (you could use City, State, Zip if you are in the U.S. for example).

Once you have created your complex type, you can add this to your Customer entity by right clicking the entity and selecting Add –> Complex Property. If you name your property Address, then the property type should automatically be set to Address, which is what we have just created.  You can check this and alter the type via the properties of the complex property (that’s a lot of properties )

Create some additional entities

Once I had created my Customer entity, I then went through the same steps to create two additional entities for Order and Product. If you do this, then you should end up with something like below.

Adding entity associations

Now that we have our entities for Customer, Order and Product, we need to tell the model how the entities are associated.  For example, a customer will have related orders and an order will have related products.

To add our first association, right click the Customer entity and select Add –> Association. You will then be presented with the dialog shown below to actually define the association.  As you can see, the primary entity for this association is Customer which is related to Order with a multiplicity of one-to-many.  Here is where we also set the navigation properties which will allow us to access related entities.  So for example, the Customer entity will have a navigation property of “Orders”.  There is also a plain English description of the association you are about to create to ensure that you are creating it correctly.

Once you are happy click ok and the association will be shown on your model connecting the Customer and Order entities.

We now need to also create an association between the Order and Product entities using the same steps as above, but this time the properties of the association are slightly different as the multiplicity is many-to-many as show below.

Generating the database

Ok, so we have our model containing our entities.  Our entities have their properties and their associations, but we still do not have a database for our model to map to.  This is the bit I really like.  Right click on the model designer area and click “Generate Database Script From Model…”.

This will then open the standard database connection dialog we are all used to in Visual Studio. Add a connection, select your server and enter a name for your database (use a name that does not already exist, I called mine “ModelFirstTestDb”…..original I know!), then click OK.  You should then be prompted to create the database as seen below, so click Yes to create the database.

You should now see your new connection selected and the option to store the credentials in the web.config should be checked. Click next and the database schema scripts (DDL) will be generated for you and you will be presented with the generated script as below.  Take a minute to have a look through the DDL and see how it has created the tables and fields.  In the image below you can see the fields that have been generated to map to the complex type for the Customer address we created earlier.

Now we just need to click Finish and we will be warned that our existing mappings and store schema will be overwritten, click Yes to continue.

Execute your DDL

Now you need to take the generated script and execute it against your database.  The database itself will have been created, but in this beta version you still need to execute the scripts manually.  The ADO.Net team have indicated that this will not be the case in the final version.

Running your Dynamic Data Entities application

If you now open the Global.asax.cs file in your project and add the following line in the RegisterRoutes method, you should be able to run your application and see your new model and database in action;

DefaultModel.RegisterContext(typeof(Model1Container),new ContextConfiguration() { ScaffoldAllTables = true });

Technorati Tags: .net 4, ADO.NET, Entity Framework, tutorial, visual studio 2010

Continue reading »]]> I have used the entity framework in a few projects using .Net 3.5, but we were promised that there was much more to come in the next version which is shipping with .Net 4.0 and with quite a few announcements recently from the ADO.NET Team, I thought I would summarise and provide some links (at the bottom of the post) for you to get some more detailed info if you are interested.

Model First

This is something that I am really excited about and something that has long been needed IMHO.

In .Net 3.5 you could take a database and generate your entity framework model from it.  In .Net 4.0 , however, it is possible to create your model first and then generate DDL for creating your database from your model. 

This is all fantastic and I can see me using this method alot, but whats even better is the fact that you will also have the ability to customise the DDL generation step yourself to suit your own needs.  For example, the default generation would be to generate a table per entity type, but you may have several entity classes that inherit from a parent class and in this instance you may want to modify the generator to produce a table per hierarchy structure for your database.

Deferred Loading

One of the things that people wish was available in the Entity Framework is deferred loading as it is in Linq to SQL. Well, now thanks to the ADO.Net team listening to the feedback, it is.  Previously, if you had a Customer object that contained Orders for each customer, you needed to explicitly call a Load method on the Customer object to be able to use the Order objects associated with it.

Now though, the following is possible;

using (NorthwindEntities db = new NorthwindEntities())
{
    db.ContextOptions.DeferredLoadingEnabled = true;

    foreach (Customer c in db.Customers)
    {
        if (c.Orders.Count > 10)
        {
            SendLoyaltyRewardToCustomer(c);
        }
    }
}

In the simple example above, you will notice that you do not need to explicitly load any Orders, but simply set the DeferredLoadingEnabled flag to true (this is off by default, but apparently there are ways to change this).

General Entity Framework Improvements

The following is a list from a recent post on the ADO.Net Team Blog of other key improvements coming to the Framework in this version;

1. 1. Development Approaches
      1. Model First development –  We’ve added functionality to the ADO.NET Entity Data Model designer to start from a Model and then have T-SQL and customized code generated.
      2. Testing applications that use the Entity Framework – Along with the patterns above we’ve added an interface, along with guidance, that enables better testability of applications that use the Entity Framework.

      Architectural Concerns

      1. Persistence Ignorance – Enabling developers to use their own classes without needing to introduce interfaces or other elements specific to the Entity Framework.
      2. Applications Patterns – Discussing patterns like the Repository and UnitOfWork patterns with guidance on how to use them with the Entity Framework
      3. Building N-Tier applications with the Entity Framework – Adding API’s and templates that make building N-Tier applications with the Entity Framework much easier.

      Entity Framework Improvements

      1. Customization of Code Generation – Integration with the ADO.NET Entity Framework Designer and T4 Templates in Visual Studio to provide developer controlled code generation.
      2. Small things that make development of applications simpler – Adding things like Pluralization and Singularlization in the model, lazy loading, and more stored procedure mapping make building applications that use the Entity Framework much easier.
      3. Customizing Queries – Adding support for existing LINQ operators, recognizing a larger set of patterns with LINQ, writing model defined functions along with the ability to use these in LINQ, and a number of other ways to create and customize queries.
      4. SQL Generation Readability Improvements – Improving the readability, along with TSQL performance optimizations, of the generated queries to make it much easier to understand what is happening
      5. And much, much more

Useful Links

The ADO.Net team have said that they have many mroe detailed posts on the way in the next couple of weeks so it’s well worth keeping an eye on their blog.  Plus, we should soon see a beta of Visual Studio 2010 and .Net 4.0 which should contain some of the aforementioned features.  I will be posting here when that’s released so keep an eye out for that.

ADO.Net Team Blog Post regarding Deferred Loading

ADO.Net Team Blog Post reagrding Model First in EF

ADO.Net Team Blog

Technorati Tags: .NET 4.0, ADO.NET, eneity framework

Continue reading »]]> Ok, so a few weeks ago I posted about my plans to attend the MSDN Roadshow 2008 in Manchester and I said that I would post about the event once I had attended.  So as promised here is that very post along with some useful links;

Firstly, the venue for this years event was excellent.  The Odeon in Manchester City Centre in the Printworks is quite simply huge.  Luckily there were escalators for those of use who were to lazy to climb all of the stairs.

Once you reached the third floor, we were greeted by poster boxes with MSDN posters inside with some nice quotes, such as "There’s No Place Like 127.0.0.1" and "I’ll make him a program he can’t refuse", which was a nice touch I thought. Made the whole thing feel like more of an event rather than just a meeting.

In the corridor outside of the actual conference room were the usual stands familiar to those who have attended a Roadshow before, such as the registration table, a stand with discount books from the guys over at Computer Manuals selling discounted books on a variety of subjects from Expression to LINQ and of course, every developers favourite stand, the SWAG stand, with free goodies like the updated Developers Highway Code (which is available for download and I have included a link in the useful links later in this post).  We did all get a free software pack when we left, but more on that shortly.

In addition to the usual stands this year though, we were treated to a couple of really interesting tables showing off the XNA Framework on a dev Xbox 360 and the new Microsoft Robotics studio.  I have to say, some of the games produced with the XNA framework for the 360 were pretty impressive and most of them are available as starter kits from Microsoft if you’re interested.  I will include some links for both of these areas at the end of this post.

The conference room itself was actually a cinema room (surprisingly being at the Odeon ), which was fantastic.  This meant most people got comfortable seats to enjoy the show and those all important cup holders! I arrived slightly late, and so didn’t manage to get a seat, however, the nice Roadshow staff got me a seat and put me right at the side of the stage and I got a ringside seat which was great.  As you can see from the picture to the right (apologies for the quality, somehow I managed to set my camera phones’ resolution unusually low by mistake) of MSDNs Mike Ormond presenting, the slide being on a cinema screen really helped, as they were always clear and nobody was struggling to see anything.

The presentations themselves were, as always, of an excellent quality, with the speakers conveying their expert knowledge in their respective topics clearly and concisely.  I particularly enjoyed Mike Ormonds’ talk on the ASP.NET 3.5 Extensions, especially the new Dynamic Data capabilities (which I am hopefully going to be posting a small tutorial series about shortly. If you’re interested, add this blog to you’re favourites or subscribe to my RSS Feed).

The refreshments this year were good, a choice between ham, cheese and chicken sandwiches, along with crisps and soft drinks for lunch.  Very nice Coffee during the breaks and even popcorn or Ben and Jerrys ice cream in the afternoon!

As I have already mentioned, if you handed in your feedback form and your pass before you left you were treated to a nice software pack, which didn’t disappoint.  Contained within the set were promotional copies of Windows Server 2008 32bit and 64bit editions, SQL Server 2008 Preview along with a voucher to get a development copy when it is released, and my personal favourite, a full copy of Visual Studio 2008.

All in all, an excellent day, well put together and very well received!

One last note, the MSDN Roadshow’s are an invaluable free event from Microsoft giving excellent technical and hands-on insight into the latest techniques and strategies for developers.  Every year they seem to sell out really fast, so my one message to you for next year is….REGISTER EARLY!

Now as promised, some useful links regarding the days speakers, events and topics;

Presentation Slides

Definitely worth a look through…..

Xbox 360 XNA Game Framework and Microsoft Robotics Studio and the Developer Highway Code

As promised, a couple of links to the areas that were the subject of two impressive stands this years event.

Technorati Tags: .net 3.5, ADO.NET, ASP.NET MVC, Dynamic Data, Microsoft Robotics, MSDN, Silverlight, XNA Framework