var id = ((IEntity) entity).Id; if (id == default(int))
{     //add } else {
    //update }

public static bool IsTransient<T>(DbContext context, T entity)
    where T : class {
    //find the primary key     var objectContext = ((IObjectContextAdapter)context).ObjectContext;
    //this will error if it's not a mapped entity     var objectSet = objectContext.CreateObjectSet<T>();
    var elementType = objectSet.EntitySet.ElementType;
    var pk = elementType.KeyMembers.First();
    //look it up on the entity     var propertyInfo = typeof(T).GetProperty(pk.Name);
    var propertyType = propertyInfo.PropertyType;
    //what's the default value for the type?     var transientValue = propertyType.IsValueType ? Activator.CreateInstance(propertyType) : null;
    //is the pk the same as the default value (int == 0, string == null ...)     return propertyInfo.GetValue(entity, null) == transientValue;
}

var johnCarter = new Movie() { Title = "John Carter" };
johnCarter.DirectorId = andrewStantonId;
context.Movies.Add(johnCarter);
//after it's added, change the status of the reference
context.Entry(johnCarter.Director).State = EntityState.Unchanged;
context.SaveChanges();

var johnCarter = new Movie() { Title = "John Carter" };
johnCarter.DirectorId = andrewStantonId;
context.Movies.Add(johnCarter);
//after it's added, change the status of the reference
MarkNavigationPropertiesUnchanged(johnCarter);
context.SaveChanges();

private static void MarkNavigationPropertiesUnchanged<T>(DbContext context, T entity)
    where T : class {
    var objectContext = ((IObjectContextAdapter)context).ObjectContext;
    var objectSet = objectContext.CreateObjectSet<T>();
    var elementType = objectSet.EntitySet.ElementType;
    var navigationProperties = elementType.NavigationProperties;
    //the references     var references = from navigationProperty in navigationProperties
                        let end = navigationProperty.ToEndMember
                        where end.RelationshipMultiplicity == RelationshipMultiplicity.ZeroOrOne ||
                        end.RelationshipMultiplicity == RelationshipMultiplicity.One
                        select navigationProperty.Name;
    //NB: We don't check Collections. EF wants to handle the object graph.     var parentEntityState = context.Entry(entity).State;
    foreach (var navigationProperty in references)
    {         //if it's modified but not loaded, don't need to touch it         if (parentEntityState == EntityState.Modified &&
            !context.Entry(entity).Reference(navigationProperty).IsLoaded)
            continue;
        var propertyInfo = typeof(T).GetProperty(navigationProperty);
        var value = propertyInfo.GetValue(entity, null);
        context.Entry(value).State = EntityState.Unchanged;
    } }

SaveChanges() will save the new Movie- but it also saves a new Director record (which gets a new Id, even though you set it manually). When you add an entity to a DbSet, the entire object graph is marked as “Added”.

You could do a Find to load the Director record from the database, but it is a pointless database access that you don’t need. It just needs to save the Movie record with a known directorId.

In NHibernate you can use session.Load<Director>(andrewStantonId) which will create an empty proxy object without hitting the database. Only if you use one of the proxy properties (like director.Name) will it hit the database to load the record. EF Code First doesn’t have this feature.

One way round it to add a foreign key Id property to the Movie record:

       public virtual Director Director { get; set; }
       public int? DirectorId { get; set; }

You can then set the DirectorId directly. The two properties are not kept in step automatically, so setting the DirectorId doesn’t cause Director to load from the database. Foreign key Id properties are convenient, but your object model is “denormalized”.

The alternative is to mark the dummy record as unchanged. There are two ways.

One is to set the context.Entry state for the dummy reference AFTER the new record has been added.

var johnCarter = new Movie() { Title = "John Carter" };
johnCarter.DirectorId = andrewStantonId;
context.Movies.Add(johnCarter);
//after it's added, change the status of the reference
context.Entry(johnCarter.Director).State = EntityState.Unchanged;
context.SaveChanges();

The second way is to create the dummy reference by Attaching it.

//attach the dummy director record
var andrewStanton = new Director { Id = andrewStantonId};
context.Directors.Attach(andrewStanton);
//now we have an "unchanged" director record to attach
var johnCarter = new Movie() { Title = "John Carter" };
johnCarter.Director = andrewStanton;
context.Movies.Add(johnCarter);
context.SaveChanges();

public void UpdateMovie(Movie movie)
{     using (var context = new DomainContext())
    {         //attach it         context.Movies.Attach(movie);
        //mark it as modified         context.Entry(movie).State = EntityState.Modified;
        //save - but saves all properties...         context.SaveChanges();
    } }

public void UpdateMovieBoxOffice(Movie movie)
{     using (var context = new DomainContext())
    {         //get database version         var databaseMovie = context.Movies.Find(movie.Id);
        //manually copy the values         databaseMovie.BoxOffice = movie.BoxOffice;
        //save         context.SaveChanges();
    } }

public void UpdateMovieProperties(Movie movie, IList<string> propertyNames)
{     using (var context = new DomainContext())
    {         //attach it         context.Movies.Attach(movie);
        //use the context entry         DbEntityEntry<Movie> entry = context.Entry(movie);
        foreach (var propertyName in propertyNames)
        {             //modify the specific property states only             entry.Property(propertyName).IsModified = true;
        }         //save         context.SaveChanges();
    } }

public void UpdateMovieChangedProperties(Movie movie)
{     using (var context = new DomainContext())
    {         //attach it         context.Movies.Attach(movie);
        //use the context entry         DbEntityEntry<Movie> entry = context.Entry(movie);
        //do a database call to get the state         var databaseValues = entry.GetDatabaseValues();
        foreach (var propertyName in databaseValues.PropertyNames)
        {             //modify the specific property states only             entry.Property(propertyName).IsModified = true;
        }         //save         context.SaveChanges();
    } }

public class Product {
    [Key]     public int ProductId { get; set; }
    [Required]     [StringLength(40)]
    public string ProductName { get; set; }
    [Required]     public virtual Category Category { get; set; }
}

using (var context = new NorthwindContext())
{     //find a specific product     var product = context.Products.Find(147);
    //set a new name     product.ProductName = Guid.NewGuid().ToString();
    //ERROR!     context.SaveChanges();
}

Solution 1- no auto validation

context.Configuration.ValidateOnSaveEnabled = false;
context.SaveChanges(); 

Solution 2- ensure required references are loaded

//find a specific productvar product = context.Products.Find(147); //make sure it's loaded context.Entry(product).Reference(p => p.Category).Load();

var product = context.Products
    .Include(p => p.Category)     .First(p => p.ProductId == 147);

Solution 3- Add a foreign key Id property

//it's not nullable so it's implicitly requiredpublicint CategoryId { get; set; } public virtual Category Category { get; set; }

HasRequired(x => x.Category)
    .WithMany()
    .HasForeignKey(p => p.CategoryId);

//find a specific productvar product = context.Products.Find(146); //it's category 4 in bothConsole.WriteLine(product.Category.CategoryId); Console.WriteLine(product.CategoryId); //set the categoryId property product.CategoryId = 1; //we've just set it, so it's 1Console.WriteLine(product.CategoryId); //oh no, still says 4!Console.WriteLine(product.Category.CategoryId);

//find a specific productvar product = context.Products.Find(146); //it's category 1 in bothConsole.WriteLine(product.Category.CategoryId); Console.WriteLine(product.CategoryId); //set the category instance product.Category = context.Categories.Find(2); //we've just set it, so it's 2Console.WriteLine(product.Category.CategoryId); //oh no, still says 1!Console.WriteLine(product.CategoryId); 

product.CategoryId = 1;
var returnMessage = "Category updated to " + product.Category.CategoryName; 

Conclusion

//unbounded result set - there could be 1000s!var products = category.Products
    .OrderBy(p => p.ProductName) //you have to order     .Skip((page - 1) * pageSize)
    .Take(pageSize);

var pagedProductsByCategory = context.Products
    //have to specify primary keys here- can't match on "category"     .Where(p => p.Category.CategoryId == category.CategoryId)
    .OrderBy(p => p.ProductName) //you have to order     .Skip((page - 1) * pageSize)
    .Take(pageSize);

var pagedProducts = context.Entry(category)
    //from the DbEntityEntry, get the navigation property     .Collection(x => x.Products)
    //turn it into a query     .Query()
    //page     .OrderBy(p => p.ProductName) //you have to order     .Skip((page - 1) * pageSize)
    .Take(pageSize);

HasOptional(x => x.Category)
    .WithMany() //.WithMany(c => c.Products)     .Map(m => m.MapKey("CategoryID"));

using (var context = new NorthwindContext()))
{     var category = context.Categories.Find(1); //Beverages     Console.WriteLine(category.Products.Count);

}

This loads ALL the products for the category, and then counts them.

Fine for a small result set, not so good if you have 1000s of products per category.

Simple solution: use a filter on products.

Console.WriteLine(context.Products
    .Count(p => p.Category.CategoryId == category.CategoryId));

This generates SQL in the form "SELECT COUNT(*) FROM Products WHERE CategoryID = @p"

Alternative solution: use context.Entry with .Query()

Console.WriteLine(context.Entry(category)
    .Collection(x => x.Products)     .Query()
    .Count());

<?xml version="1.0" encoding="utf-8"?><configuration> 
<connectionStrings>    <add name="NorthwindContext"          providerName="System.Data.SqlClient"          connectionString="Data Source=.\SQLEXPRESS;Initial Catalog=Northwind;Integrated Security=True;Pooling=False;MultipleActiveResultSets=True" />  </connectionStrings>  <system.data>    <DbProviderFactories>      <add name="EF Tracing Data Provider"            invariant="EFTracingProvider"            description="Tracing Provider Wrapper"            type="EFTracingProvider.EFTracingProviderFactory, EFTracingProvider, Version=1.0.0.0, Culture=neutral, PublicKeyToken=def642f226e0e59b" />      <add name="EF Generic Provider Wrapper"            invariant="EFProviderWrapper"            description="Generic Provider Wrapper"            type="EFProviderWrapperToolkit.EFProviderWrapperFactory, EFProviderWrapperToolkit, Version=1.0.0.0, Culture=neutral, PublicKeyToken=def642f226e0e59b" />    </DbProviderFactories>  </system.data></configuration>

        public NorthwindContext()
        {             //default ctor, uses app.config connection string named "NorthwindContext"         }
        public NorthwindContext(DbConnection connection)
            :base(connection,true)
        {            //ctor uses for tracing          }

            using (var context = new NorthwindContext(
                CreateConnectionWrapper(@"name=NorthwindContext")))
            {                 //profile this!                 var product = context.ProductCollection.Find(1);
            }

private static DbConnection CreateConnectionWrapper(string nameOrConnectionString)
{     var providerInvariantName = "System.Data.SqlClient";
    var connectionString = nameOrConnectionString;
    //name=connectionName format     var index = nameOrConnectionString.IndexOf('=');
    if (index > 0 &&
nameOrConnectionString.Substring(0, index).Trim()         .Equals("name", StringComparison.OrdinalIgnoreCase))
    {         nameOrConnectionString = nameOrConnectionString
            .Substring(index + 1).Trim();
    }     //look up connection string name     var connectionStringSetting =
        ConfigurationManager.ConnectionStrings[nameOrConnectionString];
    if (connectionStringSetting != null)
    {         providerInvariantName = connectionStringSetting.ProviderName;
        connectionString = connectionStringSetting.ConnectionString;
    }     //create the special connection string with the provider name in it     var wrappedConnectionString = "wrappedProvider=" + 
        providerInvariantName + ";" + 
        connectionString;     //create the tracing wrapper     var connection = new EFTracingConnection                             {
                                ConnectionString = wrappedConnectionString
                            };
    //hook up logging here     connection.CommandFinished +=
        (sender, args) => Console.WriteLine(args.ToTraceString());
    return connection; }

EFTracingProviderConfiguration.LogToConsole = true; 

Or you can hook up to log4net or EntLib logging to those tracing events.

I wanted to use a many-to-many relationship using Entity Framework Code First (v4.1/4.2).

Using pure code first such as this:

          using (var context = new MyContext())
{ var employee = new Employee { FirstName = "Homer",
LastName = "Simpson" }; var territory = new Territory
{ TerritoryDescription = "Springfield" }; employee.Territories.Add(territory);
context.Employees.Add(employee); context.SaveChanges(); }

results in a nice association table

How do you map existing database tables? Like Northwind's customer to customer demographic table relationship:

This is the code I want to write:

          using (var context = new MyContext("name=Northwind"))
{ var demo = new CustomerDemographic(); demo.CustomerTypeID
= "BERLIN"; demo.CustomerDesc = "Berliner";
context.CustomerDemographics.Add(demo); //link it to a customer
by either end var alfki = context.Customers.Find("ALFKI");
alfki.CustomerDemographics.Add(demo); context.SaveChanges(); }

We have to override DbContext's OnModelCreating and add some mapping. For CodeFirst, you map both sides of the relationship, so you can either put the mapping on Customer or CustomerDemographic - or even both if the mappings agree. A normal foreign key relationship is mapped with ".HasMany|HasOptional|HasRequired" followed by a ".WithMany|WithOptional|WithRequired".

So, from the CustomerDemographic entity, a many to many is just .HasMany(x=>x.Customers).WithMany(z=>z.CustomerDemographics).

In addition, we don't have standard names for our association table so we add a .Map element to specify the table and the left and right key columns.

Note the primary key of CustomerDemographics isn't the 'tableName'+"Id" convention that Code First will expect. So I have to define the key for that. As we have that end of the configuration, we'll define the mapping there.

Here's the code.

modelBuilder.Entity<CustomerDemographic>()
    //the
key isn't standard so specify it .HasKey(x => x.CustomerTypeID) //define
both sides of the relationship - HasMany.WithMany .HasMany(x => x.Customers)
.WithMany(z => z.CustomerDemographics) //specify mapping information .Map(map
=> { //the association table name map.ToTable("CustomerCustomerDemo"); //the
left side (fk to CustomerDemographic, the entity we're defining) map.MapLeftKey("CustomerTypeID"); //the
right side (fk to Customers, the other side) map.MapRightKey("CustomerID");
} );

If we mapped from the Customer entity, the HasMany and WithMany properties are different, and the mapped left and right keys swap round.

Here's the full DbContext for my mini-Northwind mapping:

          class MyContext : DbContext { public MyContext(string connectionName)
: base(connectionName) { } public DbSet<Employee>
Employees { get; set; } public DbSet<Territory> Territories
{ get; set; } public DbSet<Customer> Customers { get;
set; } public DbSet<CustomerDemographic> CustomerDemographics
{ get; set; } protectedoverridevoid OnModelCreating(DbModelBuilder
modelBuilder) { //Database.SetInitializer(new DropCreateDatabaseIfModelChanges<MyContext>()); Database.SetInitializer<MyContext>(null);
modelBuilder.Conventions.Remove<System.Data.Entity.Infrastructure.IncludeMetadataConvention>();
modelBuilder.Entity<CustomerDemographic>() //the key isn't
standard so specify it .HasKey(x => x.CustomerTypeID) //define
both sides of the relationship - HasMany.WithMany .HasMany(x => x.Customers)
.WithMany(z => z.CustomerDemographics) //specify mapping information .Map(map
=> { //the association table name map.ToTable("CustomerCustomerDemo"); //the
left side (fk to CustomerDemographic, the entity we're defining) map.MapLeftKey("CustomerTypeID"); //the
right side (fk to Customers, the other side) map.MapRightKey("CustomerID");
} ); } }