Entity Framework

Created Unassigned: DetectChanges() throws "An item with the same key has already been added." exception after setting a complex type property [1278]

iouri — Wed, 19 Jun 2013 00:26:02 GMT

Hi,

In Beta 1 the DbContext.ChangeTracker.DetectChanges() throws "An item with the same key has already been added." exception after setting a complex type property.

See the following code which reproduces the issue. The context.ChangeTracker.DetectChanges() line is the one to look for.

It would be great if it is looked at as soon as possible as it is a blocking issue for me.

Thanks

Regards

Iouri

using System;
using System.Linq;

namespace EF6b1.ComplexProperty.Bug
{
public class ComplexType
{
public virtual int? Value1 { get; set; }
public virtual int? Value2 { get; set; }
}

public class Entity
{
public virtual Guid Id { get; set; }
public virtual ComplexType ComplexProperty { get; set; }
}

public class DbContext : System.Data.Entity.DbContext
{
public DbContext(string connectionString) : base(connectionString) { }
public virtual System.Data.Entity.IDbSet<Entity> Entities { get; set; }
}

class Program
{
static DbContext CreateDbContext()
{
return new DbContext(@"Data Source=(local)\sql2012;Initial Catalog=EF6b1.ChangeTrackingBug;Integrated Security=True;MultipleActiveResultSets=True");
}
static void Main(string[] args)
{
try
{
using (var context = CreateDbContext())
{
var entity = context.Entities.Create();
context.Entities.Add(entity);
entity.Id = Guid.NewGuid();

//(IS) at the moment EF requires the complex type proeprties to be explicitly set to non-null values - I dont think it's right
entity.ComplexProperty = new ComplexType();

context.SaveChanges();
}

using (var context = CreateDbContext())
{
var entity = context.Entities.Take(1).First();

entity.ComplexProperty = new ComplexType();

//(IS) this will fail with "An item with the same key has already been added." exception originating in EntityEntry.ExpandComplexTypeAndAddvalues()
context.ChangeTracker.DetectChanges();
}

Console.WriteLine("Finished with no errors.");
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}

Console.WriteLine("Press any key to exit...");
Console.ReadKey(true);
}
}
}

Closed Task: Revert DbLocalView made public [1059]

maumar — Tue, 18 Jun 2013 23:49:27 GMT

These classes are now public: System.Data.Entity.Infrastructure.DbLocalView<TEntity>, System.Data.Entity.Infrastructure.ObjectReferenceEqualityComparer

This property's signature changed: DbLocalView<TEntity> DbSet<TEntity>.Local
Comments: Verified code against the original change, no extra tests needed, closing

Closed Task: Revert IDbSet.Local breaking change [1205]

maumar — Tue, 18 Jun 2013 23:47:31 GMT

Based on discussion about Reference equality and the changes made to support it we decided to revert the change to the return type of DbSet.Local and IDbSet.Local. The returned type can also be made internal again.

This is being done becauase:
* It's a breaking change to an interface that we have decided not to break for EF6
* It only provides benefit in very limited situations--i.e. when the type is used directly
Comments: Verified code against the original change, no extra tests needed, closing

Created Unassigned: Stored Procs :: NullReferenceException when trying to scaffold migration for entity with Enum Key that is mapped to stored procedures [1277]

maumar — Tue, 18 Jun 2013 23:38:43 GMT

Create the following model:

```
namespace StoredProcsCustomize
{
public enum MilitaryRank
{
Private,
Major,
Colonel,
General,
};

public class EnumKey
{
public MilitaryRank Id { get; set; }
public string Name { get; set; }
}

public class MyContext : DbContext
{
public DbSet<EnumKey> Keys { get; set; }
}
```

Enable-Migrations
Add-Migration Mig1
Update-Database

now, add the following lines to the context:

```
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
modelBuilder.Entity<EnumKey>().MapToStoredProcedures();
}

```

Add-Migration Mig2

throws the following exception:

System.NullReferenceException: Object reference not set to an instance of an object.
at System.Data.Entity.Migrations.Infrastructure.ModificationCommandTreeGenerator.SetFakeReferenceKeyValues(Object entity, EntityType entityType)
at System.Data.Entity.Migrations.Infrastructure.ModificationCommandTreeGenerator.<Generate>d__12`1.MoveNext()
at System.Linq.Enumerable.WhereSelectEnumerableIterator`2.MoveNext()
at System.Linq.Enumerable.<CastIterator>d__b1`1.MoveNext()
at System.Linq.Buffer`1..ctor(IEnumerable`1 source)
at System.Linq.Enumerable.ToArray[TSource](IEnumerable`1 source)
at System.Data.Entity.Migrations.Infrastructure.EdmModelDiffer.GenerateFunctionBody[TCommandTree](StorageEntityTypeModificationFunctionMapping modificationFunctionMapping, Func`3 treeGenerator, Lazy`1 modificationCommandTreeGenerator, MigrationSqlGenerator migrationSqlGenerator, String functionName, String rowsAffectedParameterName)
at System.Data.Entity.Migrations.Infrastructure.EdmModelDiffer.GenerateInsertFunctionBody(StorageEntityTypeModificationFunctionMapping modificationFunctionMapping, Lazy`1 modificationCommandTreeGenerator, MigrationSqlGenerator migrationSqlGenerator)
at System.Data.Entity.Migrations.Infrastructure.EdmModelDiffer.<BuildCreateProcedureOperations>d__cd.MoveNext()
at System.Linq.Enumerable.<SelectManyIterator>d__31`3.MoveNext()
at System.Linq.Enumerable.<ConcatIterator>d__71`1.MoveNext()
at System.Collections.Generic.List`1..ctor(IEnumerable`1 collection)
at System.Linq.Enumerable.ToList[TSource](IEnumerable`1 source)
at System.Data.Entity.Migrations.Infrastructure.EdmModelDiffer.Diff(ModelMetadata source, ModelMetadata target, Lazy`1 modificationCommandTreeGenerator, MigrationSqlGenerator migrationSqlGenerator)
at System.Data.Entity.Migrations.Infrastructure.EdmModelDiffer.Diff(XDocument sourceModel, XDocument targetModel, Lazy`1 modificationCommandTreeGenerator, MigrationSqlGenerator migrationSqlGenerator)
at System.Data.Entity.Migrations.DbMigrator.Scaffold(String migrationName, String namespace, Boolean ignoreChanges)
at System.Data.Entity.Migrations.Design.MigrationScaffolder.Scaffold(String migrationName, Boolean ignoreChanges)
at System.Data.Entity.Migrations.Design.ToolingFacade.ScaffoldRunner.Scaffold(MigrationScaffolder scaffolder)
at System.Data.Entity.Migrations.Design.ToolingFacade.ScaffoldRunner.Run()
at System.AppDomain.DoCallBack(CrossAppDomainDelegate callBackDelegate)
at System.AppDomain.DoCallBack(CrossAppDomainDelegate callBackDelegate)
at System.Data.Entity.Migrations.Design.ToolingFacade.Run(BaseRunner runner)
at System.Data.Entity.Migrations.Design.ToolingFacade.Scaffold(String migrationName, String language, String rootNamespace, Boolean ignoreChanges)
at System.Data.Entity.Migrations.AddMigrationCommand.Execute(String name, Boolean force, Boolean ignoreChanges)
at System.Data.Entity.Migrations.AddMigrationCommand.<>c__DisplayClass2.<.ctor>b__0()
at System.Data.Entity.Migrations.MigrationsDomainCommand.Execute(Action command)

Commented Unassigned: One to one issue in TPC hierarchy with mapped abstract base class [1229]

BriceLambson — Tue, 18 Jun 2013 23:24:37 GMT

Hi,
I have a TPC hierarchy like this:
```
public abstract class Base
{
public Guid BaseId { get; set; }
public string BaseName { get; set; }
}
public class Sub1 : Base
{
public Sub2 Vender { get; set; }
}
public class Sub2 : Base
{
public Sub1 Customer { get; set; }
}
public class MyDbContext : DbContext
{
public MyDbContext()
: base("name=db")
{ }

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
modelBuilder.Entity<Sub1>().HasRequired(x => x.Vender).WithOptional(x => x.Customer);
modelBuilder.Entity<Sub1>().Map(x =>
{
x.ToTable("Sub1s");
x.MapInheritedProperties();
});
modelBuilder.Entity<Sub2>().Map(x =>
{
x.ToTable("Sub2s");
x.MapInheritedProperties();
});
}

public DbSet<Base> People { get; set; }
public DbSet<Sub2> Venders { get; set; }
public DbSet<Sub1> Customers { get; set; }
}
```
Then I run the code and EF create tables (Sub1s and Sub2s).
But EF create an aditional Foreign Key for table Sub1, it do not use the Key of Sub1 as the Foreign Key..
Comments: This type of mapping is supported in EDM; however, when the abstract base class in included in the model (via the `DbSet<Base>` property), for some reason, Code First splits the primary key and foreign key into two columns. One workaround is to exclude `Base` from the model using `modelBuilder.Ignore<Base>()`

Edited Unassigned: One to one issue in TPC hierarchy with mapped abstract base class [1229]

BriceLambson — Tue, 18 Jun 2013 23:24:37 GMT

Commented Unassigned: ef migrations creates invalid default value for nullable string FK column [1275]

spongman — Tue, 18 Jun 2013 22:30:22 GMT

say you have the following (in my case this is coming from edmx):

```
public partial class Currency
{
[Key]
[Required]
[StringLength(3, MinimumLength = 3)]
[Column(TypeName = "char")]
public string Code { get; set; }

[InverseProperty("Currency")]
public virtual ICollection<Country> Countries { get; set; }
}

public partial class Country
{
[Key]
public int Id { get; set; }

[Required]
public string Name { get; set; }

public virtual Currency Currency { get; set; }
}
```

notice that Country.Currency is nullable. however, EF migrations creates the column like this:
```
[Currency_Code] CHAR (3) DEFAULT ('') NULL,
```

so if you try to add the following:

```
new Country {
Name = "Antarctica",
Currency = null
};
```
you get a foreign key contraint exception because there's no country with the Code '' - it should be inserting NULL by default.

in fact, as far as i can tell, theres no way to insert NULL into such a column, because EF doesn't specify null values in the insert, even if NULL isn't the DEFAULT. The only time when it's valid to omit the value from the INSERT is when the value in the entity is the same as the DEFAULT value - comparing to null is invalid in general.
Comments: additionally, attempting to add the correct DEFAULT value with a custom migration fails: ``` AlterColumn ("dbo.Countries", "Currency_Code", c => c.String (maxLength: 3, fixedLength: true, unicode: false, defaultValue: null, defaultValueSql: "NULL")); ``` fails with: ``` ALTER TABLE [dbo].[Countries] ADD CONSTRAINT DF_Currency_Code DEFAULT NULL FOR [Currency_Code] ... System.Data.SqlClient.SqlException (0x80131904): Column already has a DEFAULT bound to it. Could not create constraint. ```

Edited Unassigned: Migrations: Migrating from PK/FK to seperated out FK as an IA scaffold invalid migration [1244]

RoMiller — Tue, 18 Jun 2013 21:43:27 GMT

Create the following model

```
public class ArubaTask
{
public int Id { get; set; }
public string Name { get; set; }
}

public class ArubaRun
{
public int Id { get; set; }
public ICollection<ArubaTask> Tasks { get; set; }
}

public class ArubaContext : DbContext
{
public DbSet<ArubaTask> Tasks { get; set; }
public DbSet<ArubaRun> Runs { get; set; }

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
modelBuilder.Entity<ArubaTask>().HasKey(k => new { k.Id, k.Name });
}
}
```

Enable-Migrations
Add-Migration Mig1
Update-Database

ArubaTask.Id gets picked up as the FK (we've discussed this in the past and decided not to change the behavior - https://entityframework.codeplex.com/workitem/892). But folks may want to add some config to add a separate FK column in the database.

```
modelBuilder.Entity<ArubaRun>().HasMany(r => r.Tasks).WithRequired().Map(m => { });
```

If one does this before doing a first migration, everything works fine. However a migration from the first state to the new state generates this code:

```
RenameColumn(table: "dbo.ArubaTasks", name: "Id", newName: "ArubaRun_Id");
DropPrimaryKey("dbo.ArubaTasks", new[] { "Id", "Name" });
AddPrimaryKey("dbo.ArubaTasks", new[] { "Id", "Name" });
```

The PK column gets renamed and then the following calls refer to a column that no longer exists.

The code is probably wrong too - it should really leave the PK column alone and create a new FK column.

Created Issue: Query: Multiple deep includes not processed correctly [1276]

RoMiller — Tue, 18 Jun 2013 21:26:48 GMT

This issue was originally reported via Connect - http://connect.microsoft.com/VisualStudio/feedback/details/789804/ef-not-loading-collection-when-using-include

The query in question has a number of includes that specify multi-level paths, the relationships in question are also quite cyclical.

Here is a simplified repro - the second assert fails.

```
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations.Schema;
using System.Data.Entity;
using System.Diagnostics;
using System.Linq;

namespace ConsoleApplication3
{
class Program
{
static void Main(string[] args)
{
Database.SetInitializer(new TestContextInitializer());

using (TestContext context = new TestContext())
{
context.Configuration.LazyLoadingEnabled = false;

Master master = context.Masters
.Where(m => m.Name == "Master1")
.Include("Query.ChildrenA")
.Include("Query.ChildrenB.SpecialQuery.ChildrenA")
.Include("Query.ChildrenB.SpecialQuery.ChildrenB")
.First();
ChildB c = master.Query.GetChildByName("ChildB3");

// Second Assert Fails
Debug.Assert(c.SpecialQuery.ChildrenA.Count == 1);
Debug.Assert(c.SpecialQuery.ChildrenB.Count == 4);
}
}
}

public class Master
{
public int Id { get; set; }
public string Name { get; set; }
public virtual Query Query { get; set; }
}

public class Query
{
public Query()
{
ChildrenA = new HashSet<ChildA>();
ChildrenB = new HashSet<ChildB>();
}
public int Id { get; set; }
public string Name { get; set; }
public Master Master { get; set; }
public ChildB SpecialChild { get; set; }
public virtual ICollection<ChildA> ChildrenA { get; private set; }
public virtual ICollection<ChildB> ChildrenB { get; private set; }

public ChildB GetChildByName(string name)
{
return ChildrenB.Where(c => c.Name == name).FirstOrDefault();
}
}

public class ChildA
{
public int Id { get; set; }
public string Name { get; set; }
public int Query_Id { get; set; }
public virtual Query Query { get; set; }
}

public class ChildB
{
public int Id { get; set; }
public string Name { get; set; }
public virtual Query SpecialQuery { get; set; }
public int Query_Id { get; set; }
public Query Query { get; set; }
}

public class TestContext : DbContext
{
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
modelBuilder.Entity<Master>()
.Property(m => m.Id)
.HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
modelBuilder.Entity<Master>()
.HasKey(m => m.Id);

modelBuilder.Entity<Query>()
.Property(q => q.Id)
.HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
modelBuilder.Entity<Query>()
.HasKey(q => q.Id);
modelBuilder.Entity<Query>()
.HasOptional(q => q.Master)
.WithOptionalPrincipal(m => m.Query);
modelBuilder.Entity<Query>()
.HasOptional(q => q.SpecialChild)
.WithOptionalPrincipal(c => c.SpecialQuery);

modelBuilder.Entity<ChildA>()
.Property(c => c.Id)
.HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
modelBuilder.Entity<ChildA>()
.HasKey(c => new { c.Query_Id, c.Id });
modelBuilder.Entity<ChildA>()
.HasRequired(c => c.Query)
.WithMany(q => q.ChildrenA)
.HasForeignKey(c => c.Query_Id);

modelBuilder.Entity<ChildB>()
.Property(c => c.Id)
.HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
modelBuilder.Entity<ChildB>()
.HasKey(c => new { c.Query_Id, c.Id });
modelBuilder.Entity<ChildB>()
.HasRequired(c => c.Query)
.WithMany(m => m.ChildrenB)
.HasForeignKey(c => c.Query_Id);
}

public DbSet<Master> Masters { get; set; }
public DbSet<ChildA> ChildrenA { get; set; }
public DbSet<ChildB> ChildrenB { get; set; }
}

public class TestContextInitializer : DropCreateDatabaseAlways<TestContext>
{
protected override void Seed(TestContext context)
{
Master master = new Master() { Name = "Master1", Query = new Query() { Name = "Query1" } };
master.Query.ChildrenA.Add(new ChildA() { Name = "ChildA1" });
master.Query.ChildrenB.Add(new ChildB() { Name = "ChildB1" });
master.Query.ChildrenB.Add(new ChildB() { Name = "ChildB2" });
master.Query.ChildrenB.Add(new ChildB() { Name = "ChildB3" });
master.Query.ChildrenB.Add(new ChildB() { Name = "ChildB4" });
context.Masters.Add(master);

Query special = new Query() { Name = "Special" };
ChildB c3 = master.Query.GetChildByName("ChildB3");
c3.SpecialQuery = special;
special.ChildrenA.Add(new ChildA() { Name = "SpecialChildA1" });
special.ChildrenB.Add(new ChildB() { Name = "SpecialChildB1" });
special.ChildrenB.Add(new ChildB() { Name = "SpecialChildB2" });
special.ChildrenB.Add(new ChildB() { Name = "SpecialChildB3" });
special.ChildrenB.Add(new ChildB() { Name = "SpecialChildB4" });
context.SaveChanges();
}
}
}
```

Edited Unassigned: Bad error message for .HasInverseEndMultiplicity() on out of range enum [1213]

RoMiller — Tue, 18 Jun 2013 21:15:14 GMT

1. New console application
2. PM> Install-package entityframework -pre -version 6.0.0-beta1-20531
3. replace Program.cs with attached file
4. Debug the application (F5)
NOTE: Exception is thrown
Also note, that this exception is thrown with a correctly formatted values for .HasRelationshipMultiplicity()

Error:
Schema specified is not valid. Errors:
(0,0) : error 0005: The 'Multiplicity' attribute is invalid - The value '' is invalid according to its datatype 'http://schemas.microsoft.com/ado/2009/11/edm:TMultiplicity' - The Enumeration constraint failed.
(0,0) : error 0092: Relationship Comment_Parent is not valid. Multiplicity () is not valid. Multiplicity must be: '*', '0..1', or '1'.

Convention:
modelBuilder.Types<Comment>()
.Configure(c => c
.NavigationProperty(t => t.Parent)
.HasInverseEndMultiplicity((RelationshipMultiplicity) 7)
);

Closed Unassigned: Bad error message for .HasInverseEndMultiplicity() on out of range enum [1213]

RoMiller — Tue, 18 Jun 2013 21:15:14 GMT

Edited Unassigned: DbSet.Remove(entity) sets navigation properties to null even if SaveChanges failed [1228]

RoMiller — Tue, 18 Jun 2013 21:14:00 GMT

The deletion of entities can fail because of foreign key constraints, connection failures or trigger interaction. In this case navigation properties are set to null by DbSet<T>.Remove(entity) leaving the object graph in a DbContext in an unrecoverable state.
This behaviour leads to problems in applications which use a longer living DbContext like WPF applications. Here a DbContext can live throughout the live time of a window displaying an entity or entity graph.
E.g. an invoice with its line items is displayed in a wpf window bound to entity properties. If the deletion of the invoice failed all navigation properties of the entity are still set to null.
Thus, I would like to propose the following features to solve this situation:

1. Association OnDelete action
In EF 5 & 6 the action of associations can be set to "None" or "Cascade" (WillCascadeOnDelete) for both ends in the model designer. The current behaviour of "None" resembles more the "Set Null" behaviour of the SQL Server.
Thus, it would be great if the action could be set to “None” and “Set Null” controlling the association more precisely.

2. Foreign key constraints
In the case of a "None" OnDelete action the DbSet<T>.Remove(entity) should throw an exception if an entity can’t be deleted leaving the navigation properties untouched. With this approach the object graph would still be valid. As the graph could be loaded only partially, the decision if an entity can be deleted is not final but can be calculated for the partial graph.

3. Setting navigation properties to null
With 1. & 2. Foreign key constraints are covered. However, there can be still the case that a delete operation fail because of a lost connection, foreign key constraints beyond the loaded entity graph or other database constraints like triggers which are invisible to the EF.
In this case all navigation properties are lost and the entity can’t be used anymore for displaying data, like in the case of WPF bindings. There are a couple of possible solutions for this situation: The simplest one would be to set navigation properties to "null” only after a successful SaveChanges call. This is somehow inconsistent with property changes to entities which are applied instantaneously.
Another approach would be an implementation of IEditableObject in an entity base class leaving the restoring of entities after a failed deletion up to the developer and not the EF framework. In this case the entity has to be notified before removing it from the DbSet. A virtual "RemoveEntity" method in the DbContext like the "SaveChanges" could enable this approach.

If there are other solutions of this problem let me know.

Closed Unassigned: DbSet.Remove(entity) sets navigation properties to null even if SaveChanges failed [1228]

RoMiller — Tue, 18 Jun 2013 21:14:00 GMT

Edited Unassigned: No XML documentation generated for the mergeOption parameter [1230]

RoMiller — Tue, 18 Jun 2013 21:06:54 GMT

In EF 5, when generating the XML documentation for the function imports, the description of the mergeOption parameter is always left empty.

Closed Unassigned: No XML documentation generated for the mergeOption parameter [1230]

RoMiller — Tue, 18 Jun 2013 21:06:54 GMT

In EF 5, when generating the XML documentation for the function imports, the description of the mergeOption parameter is always left empty.
Comments: __EF Team Triage:__ We discussed but aren't planning to fix this given the relatively low benefit it provides. We would consider accepting a pull request that adds it in.

Edited Issue: IAs configured in Code First between entities in same TPC hierarchy cause MappingExceptions [1232]

RoMiller — Tue, 18 Jun 2013 21:05:02 GMT

See CodePlex discussion here: https://entityframework.codeplex.com/discussions/445686

We throw a MappingException as part of view generation when there is an IA configured between two types in a TPC hierarchy--between Media and MediaDocument in this case. It is not clear if this is a limitation in EF mapping or a Code First issue so we should investigate to find out. The workaround is to use an FK relationship.

Full code to repro. (Note that just building the model doesn't throw--you have to get view generation to happen as well.)

```
class Program
{
static void Main(string[] args)
{
using (var context = new MediaContext())
{
context.Database.Delete();

var doc = context.MediaDocuments.Add(new MediaDocument { MediaId = 2 });
doc.MediaDocument = doc;
context.Media.Add(new Media { MediaId = 1, MediaDocument = doc });

context.SaveChanges();
}

using (var context = new MediaContext())
{
foreach (var media in context.Media.Include(m => m.MediaDocument))
{
Console.WriteLine("{0} with {1}", media.MediaId, media.MediaDocument.MediaId);
}
}
}
}

public class MediaContext : DbContext
{
public DbSet<MediaDocument> MediaDocuments { get; set; }
public DbSet<Media> Media { get; set; }

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
modelBuilder.Entity<MediaDocument>()
.Map(m =>
{
m.MapInheritedProperties();
m.ToTable("MediaDocument");
});
}
}

public class MediaDocument : Media
{
}

public partial class Media
{
public int MediaId { get; set; }

// Uncomment this line to workaround the issue
// public int? MediaDocumentMediaId { get; set; }
public virtual MediaDocument MediaDocument { get; set; }
}
```

Edited Issue: An exception when I handle inheritance with EF code first [1206]

RoMiller — Tue, 18 Jun 2013 21:04:26 GMT

When I handle inheritance with EF code first, I hit an exception. My code like this:
```
public abstract class ProjectOwner
{
[key]
public string Id { get; set; }
...
}

[Table("Organizations")]
public class Organization : ProjectOwner
{
...
}

[Table("Users")]
public class User : ProjectOwner
{
...
}

public class Context : DbContext
{
public DbSet<User> Users { get; set; }
public DbSet<Organization> Organizations { get; set; }
}

public User FindUserById(userId)
{
var context = new Context();
return context.Users.Find(userId);
}
```
I found that, when I find an user with userId, it will find the userId in ProjectOwners table. So, it may find a ProjectOwner object whose id is the same as the userId. Then, it will try to convert the ProjectOwner object to UserObject to return. Due to the actual ProjectOwner object may be an Organization not an User, it will raise an exception:
>The specified cast from a materialized 'System.Data.Entity.DynamicProxies.Organization_0D12134520D0F1937F8CB863E385A76833296BFEB7AD53A881C510B5B2C68008' type to the 'User' type is not valid.

That's very strange, my code is context.Users.Find() not context.ProjectOwners.Find(), why not find in Users table only?

Commented Issue: An exception when I handle inheritance with EF code first [1206]

RoMiller — Tue, 18 Jun 2013 21:04:19 GMT

Commented Unassigned: Convention support for naming foreign key columns [1226]

RoMiller — Tue, 18 Jun 2013 21:02:08 GMT

I've spent some time going through the EF 6 source code, and looking for examples, and I've concluded that it's not currently possible to configure foreign key columns using a custom convention.

I can do this for each association without a foreign key property (which I think is named an independent association):
http://msdn.microsoft.com/en-us/data/jj591620.aspx#IndependentAssociation
``` C#
modelBuilder.Entity<Course>()
.HasRequired(c => c.Department)
.WithMany(t => t.Courses)
.Map(m => m.MapKey("ChangedDepartmentID"));
```

where the `MapKey(params string[] columnNames)` is the call that I'm really missing in conventions.

Here's the best that I can figure out:
``` C#
public class AbsentForeignKeyNamingConvention : IConfigurationConvention<PropertyInfo, NavigationPropertyConfiguration>
{

public void Apply(PropertyInfo memberInfo, Func<NavigationPropertyConfiguration> configuration, ModelConfiguration modelConfiguration)
{
ForeignKeyConstraintConfiguration fkConfig = new ForeignKeyConstraintConfiguration();
fkConfig.AddColumn(propertyInfo); // << Requires a PropertyInfo, I can't pass in a column name...
configuration().Constraint = fkConfig;
}

}
```

It's possible this can be completed with other types of conventions, but I haven't been able to figure it out yet.
Comments: __EF Team Triage:__ There should be a way to do this currently (possibly from the lighter weight conventions). Luke can you take a look and post some code that shows how to do this.

Edited Unassigned: Convention support for naming foreign key columns [1226]

RoMiller — Tue, 18 Jun 2013 21:02:08 GMT