This one had me a little stumped, and as usual, there are not enough examples in the Microsoft documentation to be very helpful. I’m using EntityFramework CodeFirst with Visual Studio 2011.  Let’s assume you create a class as follows:

public class CongressNumber
    {
        [Key]
        public int CongressNumberValue { get; set; }
    }

Then, you manually set the value of CongressNumberValue to 112.  I’d certainly think that is a reasonable thing to do. I know that the Microsoft guys often special case Id or id, but hard to believe they would take something like CongressNumberValue and assume I meant that to be an autogenerating Identity column.  Well, it seems they do that and the doc’s don’t even mention it. 

After first, finding the page on annotations, I discovered that what we really need to set is this to have it work as we want (with no identity key generation).

 public class CongressNumber
    {
        [Key]
        [DatabaseGenerated(DatabaseGeneratedOption.None)]
        public int CongressNumberValue { get; set; }
    }

I found this after drilling down some in there doc.  What surprises me is that no where does it mention that if you have a string, that does not get database generated, but if you have an int, that does.  I wonder what happens if you have a Guid? (I’ll leave that up to someone who wants to use a guid).

I would have loved to put in my own comments on the page: http://msdn.microsoft.com/en-us/library/system.componentmodel.dataannotations.databasegeneratedoption(v=vs.103).aspx but there was no user comment section.  Oh well.

To be fair, on the page: http://msdn.microsoft.com/en-us/library/gg197525(v=vs.103).aspx it does explain about identity and integers but when I had my issue, I was already on the detail page.  Seems to me the detail page should have more information on it than the summary page that leads in.  The only reason I found it was because while writing this post, I went back to get the proper links.

HTH’s.

Problem

So, if you have been doing development with Visual Studio 2010, Entity Framework CodeFirst, SqlServer or SqlServerCE for any amount of time, you’ll quickly run into the problem that the database can not be reinitialized because it is open.  Basically, the scenario is this.

1)  Put in your Global.asax.cs file a line that always recreates the database (naturally because you are in a development mode and as you constantly change your model and seed data).  The line is something like this:  Database.SetInitializer(new DropCreateDatabaseAlways<SiteDB>());

2)  Run your application with something like Debug/Run (All is fine)

3)  Go into the database browser (either in Visual Studio or Enterprise Manager)  and look at some data.

4)  Run your application again and you will get this error: “[SqlException (0x80131904): Cannot drop database "NewYorkTimesDb" because it is currently in use.]”.  This is because your database browser has a connection to the database and until it is dropped, you can not drop the catalog.

Solutions

The easiest and guaranteed to work solution is just to restart your SqlServer database server (control panel, services).  This is what I use to do but finally got tired of that because it takes about 20 seconds and, well, I’m very impatient.

The other solution I found in the forums (can’t find the link right now) is to execute the following script from the master database catalog:

use master
ALTER DATABASE NewYorkTimesDb 
   SET SINGLE_USER WITH ROLLBACK IMMEDIATE 
ALTER DATABASE NewYorkTimesDb SET MULTI_USER

Basically, just switching from multi-user to single-user and back clears the connections.

HTH’s!

I’m currently on the honey moon with EF CodeFirst.  I only have about 10 tables (4 deep at most).  Life is good.

So, here is the problem.  I created a CodeFirst implementation of EntityFramework in Visual Studio and created a simple hierarchy in my data model.  That is, without showing all the code, here is what I have:

public class Person
{
    [Key]
    [DatabaseGeneratedAttribute(DatabaseGeneratedOption.Identity)]
    public int Id { get; set; }

    public virtual List<EmailAddressInfo> EmailAddressInfoList { get; set; }
    ..
}

public class EmailAddressInfo
{
    [Key]
    [DatabaseGeneratedAttribute(DatabaseGeneratedOption.Identity)]
    public int Id { get; set; }

    public string EmailAddress { get; set; }

}

public class EmailAccount
{
    [Key]
    [DatabaseGeneratedAttribute(DatabaseGeneratedOption.Identity)]
    public int Id { get; set; }
    ...
}

Now, if you execute a LINQ command like the following:

var recs = (from data in db.Persons
                            select data);
                foreach (var rec in recs)
                {
                    foreach (var email in rec.EmailAddressInfoList)
                    {
                        Console.WriteLine(email);
                    }
                }

You get the error:

Exception Details: System.InvalidOperationException: There is already an open DataReader associated with this Command which must be closed first.

To solve this, you need to tell EntityFramework/CodeFirst to include the EmailAddressInfoList in the query.  All you need to do is change the db.Persons to db.Persons.Include("EmailAddressInfoList") as follows:

var recs = (from data in db.Persons.Include("EmailAddressInfoList")
            select data);

Then, it all works!

Hope this helps.

I’m currently writing a series of articles on building a Sencha ExtJS application with Microsoft ASP.NET MVC3.  I use codefirst and at the moment I’m building a database of US Presidents and linking them to their Party (republican, democrat, etc.).  So, the important thing is to link from the Presidents table to the Party Table and also from the Party to the President.  Below is the code:

namespace SenchaDesignerExtension.Models
{
    public class Party
    {
        [Key]
        [DatabaseGeneratedAttribute(DatabaseGeneratedOption.Identity)]
        public int Id { get; set; }

        [MaxLengthAttribute(40)]
        public string Name { get; set; }
        public virtual ICollection<President> Presidents { get; set; } 
    }

    public class President
    {
        [Key]
        [DatabaseGeneratedAttribute(DatabaseGeneratedOption.Identity)]
        public int Id { get; set; }

        public virtual Party Party { get; set; }

        public int PresidentNumber { get; set; }

        [MaxLengthAttribute(20)]
        public string FirstName { get; set; }
        [MaxLengthAttribute(20)]
        public string LastName { get; set; }
        public bool Impeached { get; set; }
        public DateTime TookOffice { get; set; }
        public DateTime LeftOffice { get; set; }
        public decimal  Income { get; set; }
    } 
}

And, the repository is defined as follows:

public class USPresidentsDb : DbContext
{
     public USPresidentsDb()
        : base("name=USPresidents")
    {
    }

    public DbSet<UserInfo> Users { get; set; }
    public DbSet<President> Presidents { get; set; }
    public DbSet<Party> Parties { get; set; }
    ...

Notice that in the party class, there is a virtual ICollection of Presidents, and notice in the President class, there is a virtual reference to the Party.  These combined make the relationship work and the foreign key created.

If I look in my SQL Database, you’ll see a new foreign key is automatically created for me as Party_id.

I’m not exactly sure how SqlExpressCE shows foreign keys, but I know it is there because when I try to delete a Party record that is associated with a President I get the following error:

which tells me there is a constraint called Party_Presidents (my foreign key).

So, it worked!  If you want to see the full source for this, keep an eye on the series of articles I’m now writing (only the first one is done, but probably, by the time you find this, I’ll have others done that include this Presidents example.  You can find the first one at the URL:  http://peterkellner.net/2011/11/04/building-an-senchas-extjs-4-0-mvc-application-with-microsofts-asp-net-mvc3-series-basics/

In May of 2009 I discovered some significant performance problems that I blogged about.  In summary, I had tracked it down to the issue of LINQ2SQ having to create a full expression tree on every instantiation of a LINQ2SQL query.  I’m not a compiler write kind of guy but do respect the complexity of that and doing things like building expression trees, but still this really sucked.  Using the compile syntax in LINQ2SQL is very awkward, and IMHO takes all the fun out of using LINQ2SQL.  If you don’t remember my post, here is the graph showing the evil happening.

So, what is a Microsoft MVP to do?  I complained to everyone at Microsoft I knew.  I made this my mission for about a year.  I was told time after time that the problem was hugely complicated and no one was working on making it any faster.  I just could not believe it because I felt this was such a barrier to success to LINQ2SQL type technology (now Entity Framework really) that Microsoft just could not ignore my findings.  I was actually surprised that I was the only one screaming about this.

Well, quietly, Microsoft has announced that in .Net Framework 4.5, Entity Framework will include “Auto-Compiled LINQ Queries”.  This is awesome!   When it comes out, I’ll be testing and it giving feedback.

For now, I’m a very happy camper.

The technology pairing I’ve chosen is Microsoft’s .Net platform with MVC on the server, and ExtJS on the client.  Though it’s possible to still use ExtJS with standard html/aspx pages, I’ve found the best combination is to use 100% JavaScript on the client (ExtJS) and have all the server side technology be 100% service based.  I’ve used LINQ2SQL extensively as well as Entity Framework in the latest Visual Studio 2010 release.

The learning curve was quite steep to actually be able to efficiently build highly flexible, highly scalable applications using these technologies, but now that I know it, I wouldn’t have it any other way.

I’m considering putting together a series of 4 Day Classes around the country (or even world) that would basically teach people the methods and patterns I’ve learned and essentially leap frog a development team into being able to quickly do what it has taken me years to figure out.  I’ve been fortunate enough to know the top 1% instructors and I’m sure with the right incentive, can get them to join me in both putting together these classes as well as teaching them.

So, my question is:

I really appreciate your feedback.  If I go down this path, it will be a lot of work and it would be nice to know if people are really interested.  I know for myself, I’ would have gone to something like this 2 years ago and it would have saved me a lot of time.

Thanks for your feedback.

This article is very short.  In the actual presentation, there was not much time to talk about this so a brief overview was done.  Basically, it’s all standard WCF stuff.  The idea is that the Silverlight Business Template adds logging in and supports Authentication just like an asp.net application does.  It uses the DomainDataSource to do the bridging between the silverlight clientside app, and the web application.  Authorization is built into the login module also so that you can assign attributes to your domainservice classes to restrict access.

That is, if you only want people who are logged in able to access one of your methods, you simply tag it as follows with the [RequiresAuthentication] attribute.

If you only want a certain logged in user role to be able to access a certain method, you tag it as follows

This of course solve the server side only.  On the client side, you need to call methods that are exposed through the domain data.  http://www.silverlightshow.net/items/Silverlight-3-with-Ria-Authentication-service.aspx discusses much of this on the client side.

In this section, we will talk about what happens when the users presses the “Sessions” hyperlink from the speakers page.  If you remember from the last article, we used a special converter on the Speakers.xaml page and bound that to the hyperlink titled sessions as shown below.

When this link is clicked, the navigation created is as follows:

http://localhost:9951/Presentation1TestPage.aspx#/Sessions?SpeakerId=903

// Executes when the user navigates to this page.

protected override void OnNavigatedTo(NavigationEventArgs e)

{

    //Handle SpeakerId

    var qs = NavigationContext.QueryString;

    if (qs.ContainsKey("SpeakerId"))

    {

        this.sessionsOverviewDomainDataSource.FilterDescriptors =

            new FilterDescriptorCollection();

        this.sessionsOverviewDomainDataSource.FilterDescriptors.Add(

              new FilterDescriptor("AttendeeId",

                  FilterOperator.IsEqualTo, qs["SpeakerId"]));

    }

}

This simply adds a filter to the current DomainDataSource that filters the column AttendeeId with the passed in query parameter SpeakerId.

The resulting page looks as follows assuming Peter Kellner’s Session link was clicked.

The video referenced in this article goes into building this page in more details, but fundamentally, the major point is just the query parameter.

In this article, we will  build from scratch, using Visual Studio 2010 Beta 2 a simple application that lets us view Silicon Valley Code Camp Attendees that have authorized us to share their data.  We will be using no special RIA Services Visual Studio 2010 design tools to do this.  We will:

• Create the Entity Framework Repository
• Create the Domain Service
• Wire up an Appropriate Get Method that Returns in IQueryable
• Call From the Client Code the Domain Service
• Show The Results
• Observations

First, we need to create a new Visual Studio Project.  We do that by using the File/New Project and chose “Silverlight Business Application”.

Create The Entity Framework

Then, we need to create an Entity Framework Repository that will be the target of our Domain Service.  We do that by adding to the web project (not the top, Silverlight project), we just created and “ADO.NET Entity Data Model”.  We’ll call it ModelSVCC for Model Silicon Valley Code Camp.

We use the option “Generate From Database” as follows:

Choose the appropriate connection (in our case svcodecamp on our local Sql Server 2008 database).

For simplicity, choose all tables and views as follows.

Do a Rebuild/All to make sure all the template code get’s generated and we are done with our first step.

Create the Domain Service

Next, create the Domain Service.  This is done by adding again to the web project the Domain Service as follows.

Name it DomainServiceSVCC.cs again for Silicon Valley Code Camp.

Next check all tables and views, make sure “Enable Client Access” is checked and also “Generate associated classes for meta data”.  Enable Client Access adds an attribute to the generated domain class which tell Visual Studio (on building) to generate the same domain classes on the client (Silverlight) side.  This means that you are writing both your client and server code at the same time!  Very convenient.

Now, to the method generated in the Domain Service class add an OrderBy Linq command so that the method GetAttendeesWithShare has an implicit order and Skip and Take LINQ will work and the total number of records can be easily obtained (notice the yellow highlighing is the code we added, the rest was there before).

Finally, Rebuild/All again and we are done creating the domain service class for this example.

Wire up an Appropriate Get Method that Returns in IQueryable

Now that we have our Domain Service built on the Server side (and of course it get’s exposed on the client side with Visual Studio 2010 template generating magic), we can go to one of the pages built in the default template, add a Silverlight DataGrid and assign our Domain Context to that. Let’s add the list of attendees to our Home Page.  We do that by going to the View\Home.xaml file and simply add a DataGrid tag to the page (see below highlighted in yellow, we simply typed that in or could have dragged it from the toolbar if we are so included).

Then, we go to the code behind of this page and add the following code to the “OnNavigateTo” enent of the Home.xaml page.

 var context = new DomainServiceSVCC();
 dataGrid1.ItemsSource = context.AttendeesWithShares;
 context.Load(context.GetAttendeesWithSharesQuery());

Now, when we rebuild all and run, we get:

When we click on the Id’s column header, we get the data sorted in reverse Id order, even though we never code an event for that!

Observations

So, what have we done?  Well, we’ve done a lot. first, we’ve create a Domain Service that uses WCF on the server side.  We created code on the Silverlight client that called this domain service.  We got databinding right through to our output.  Be very clear that in our code we added to the OnNavigate Event (repeated here)

we made a clear step across the network boundary.  We created the DataService context and when we loaded it, all the async magic just happened for us.  No wsdl’s, proxies to code, keep updated, etc.  All that actually happens for us, but we don’t have to worry about it.  I think I’m in love.

The actual presentation was done at the Microsoft office in San Francisco.

I’ve heavily borrowed from Brad Abrams PDC09 presentation here and am very thankful for the help.  I’m personally very excited about the opportunities RIA Services gives us as developers to efficiently build powerful multi tier applications without compromise.

I’d recommend going to Brad Abrams PDC09 presentation mentioned above to get a better understanding of what Microsoft was thinking and its plans for RIA Services. The way I see it is RIA Services is built on the WCF Stack.  It basically is a technology that let’s the developer create both client and server code at the same time.  It essentially removes the middle layer form a development perspective, but keeps it there in a very physical way using all the power of WCF.  For example, you create you logic on the server side and that code automatically gets migrated to the client for simplicity of calling.

For those interested where the motivation came from to to this, it’s an interesting story.  Last week, Mathias Brandewinder, the organizer of our local Bay.Net San Francisco user group emailed and asked if I could fill in last minute for the upcoming (actually today’s) bay.net meeting and, could I talk about RIA Services.  Well, 2 years or so ago, I did a quite extensive Silverlight 1.1 project for Leverage Software using the first beta of the .CLR release of Silverlight (C#).  I have to say, it was an awful experience.  So, now at Silverlight 4.0, RIA Services, I’m back and very excited.

By way of people that have helped me in the last week to get this far, just to name a few:  Bruno Terkaly, offering to do whatever he could and giving me tech tips, Michael Scherotter in “going to town” as he says to make the Speaker’s page look really nice in a live meeting, Victor Gaudioso in taking time on his busy weekend to call me  and offer help, Brad Abrams putting up with my list of naive questions and patiently responding, a slew of ASPInsiders who pointed me at an excellent place to host the videos, and David Kelly for giving me a nicely styled Silverlight player to show the videos on this blog.

I’m sitting in the mall below the Microsoft Office in San Francisco where the presentation will be in about 2 hours.  Hopefully, I’ll finish all seven articles and get them posted to the internet very soon.  I did the videos as just practice for my presentation.  They are not polished or edited.  I’m taking the chance of posting them in the hopes that they help someone struggling with all the new features like I have been during the last week.

Finally, this demo is built on live Silicon Valley Code Camp Data that has been collected over the past 4 years.  I can’t really publish that database along with the completed solution before I clean and randomize the attendee data.  Meanwhile, I will post the project code but it will not work until I’ve had a chance to clean up the database.  My thinking is that it’s all positive and better to release the code now rather than wait until I have the database cleaned up.

Below is what the end result of what we are building will look like (if you make it through all the articles and videos).

Attached here is source that you can build with Visual Studio 2010 Beta 2 and it will work with No Database.  The Domain Class is heavily modified from what is presented, but it will allow you to actually run and play with real data.

You all know that I’ve blogged quite a bit about LINQ2SQL.  That technology has saved me a huge amount of programming effort verses using ado.net directly.  We all know that LINQ2SQL is really just a stepping stone to Entity Framework (EF), though Microsoft doesn’t quite say that.  I’m sure, based on how many people are using LINQ2SQL, it will live on and be supported for quite sometime.  Personally, I’ve been waiting for EF to become more mature and then, I assume I’ll start all my new projects with it (EF) and slowly migrate my old ones from LINQ2SQL to EF.  So, time for me to start taking EF more seriously.  It’s baked into the upcoming .net 4.0 and Visual Studio 2010 beta 2.  It’s obviously not done, but from what I’ve seen, when .net 4.0 releases, EF will be ready for prime time.

Now, for the review:

Julie does a great job of introducing Entity Framework and explaining where it fits in, and why you should consider using it.  I was already sold, but now I understand better why.  She then does an excellent job of going through the basics of EF, telling you how to use it, describing the model and all the details necessary to begin using it.  One of the nice features of this book, is it goes beyond the theoretical, and talks about specific implementations.  That is, WCF, WPF, etc.

We all need to get more comfortable with EF and this book is a great starting place.  Julie Lerman is clearly the person to learn this from.  I strongly recommend it.

Programming Entity Framework