Cómo mapear la entidad hijo a la entidad principal sin introducir el vinculador principal de tipo primitivo en la entidad secundaria?

Question

tengo estas clases:

public class Product 
{ 
    [Key] 
    public virtual int ProductId { get; set; } 
    public virtual string ProductName { get; set; } 
    public virtual string Category { get; set; } 

    public virtual IList<ProductPricing> ProductPriceList { get; set; } 


    [Timestamp] 
    public virtual byte[] Version { get; set; } 
} 

public class ProductPricing 
{   

    // no ProductId here 
    public virtual Product Product { get; set; } 

    [Key] 
    public virtual int ProductPricingId { get; set; } 

    public virtual DateTime EffectiveDate { get; set; } 
    public virtual decimal Price { get; set; } 


} 

Este es mi modelBuilder:

modelBuilder.Entity<Product>(). 
    HasMany(x => x.ProductPriceList) 
    .WithRequired() 
    .HasForeignKey(x => x.Product); 

Este es el error:

The foreign key component 'Product' is not a declared property on type 'ProductPricing'. Verify that it has not been explicitly excluded from the model and that it is a valid primitive property.

ACTUALIZACIÓN

he probado el siguiente, error correspondiente ORS por debajo del código de

modelBuilder.Entity<Product>() 
    .HasMany(x => x.ProductPriceList) 
    .WithRequired(); 

{"Invalid column name 'Product_ProductId1'.\r\nInvalid column name 'Product_ProductId'.\r\nInvalid column name 'Product_ProductId1'."}

modelBuilder.Entity<Product>() 
    .HasMany(x => x.ProductPriceList) 
    .WithRequired() 
    .Map(x => x.MapKey("ProductId")); 

{"Invalid column name 'Product_ProductId'."}

modelBuilder.Entity<Product>() 
    .HasMany(x => x.ProductPriceList) 
    .WithRequired(x => x.Product); 

{"Invalid column name 'Product_ProductId'.\r\nInvalid column name 'Product_ProductId'."}

modelBuilder.Entity<Product>() 
    .HasMany(x => x.ProductPriceList) 
    .WithRequired(x => x.Product) 
    .Map(x => x.MapKey("ProductId")); 

{"Multiplicity constraint violated. The role 'Product_ProductPriceList_Source' of the relationship 'TestEfCrud.Mappers.Product_ProductPriceList' has multiplicity 1 or 0..1."}

Si se pudiera ayudar, aquí está el DDL:

create table Product 
(
ProductId int not null identity(1,1) primary key, 
ProductName varchar(100) not null, 
Category varchar(100) not null, 
Version rowversion not null 
); 

create table ProductPricing 
(
ProductId int not null references Product(ProductId), 
ProductPricingId int identity(1,1) not null primary key, 
EffectiveDate datetime not null, 
Price decimal(18,6) not null 
); 

ACTUALIZACIÓN 2

He tratado de esta respuesta, que parece un poco similar a mi caso, el mapeo se originó a partir entidad secundaria How to map parent column in EF 4.1 code first

Sin embargo, el uso de este:

modelBuilder.Entity<ProductPricing>() 
    .HasOptional(x => x.Product) 
    .WithMany() 
    .Map(x => x.MapKey("ForeignKeyColumn")); 

y esto:

modelBuilder.Entity<ProductPricing>() 
    .HasRequired(x => x.Product) 
    .WithMany() 
    .HasForeignKey(x => x.Product); 

Ambas resultaron de este error:

{"Invalid column name 'Product_ProductId1'.\r\nInvalid column name 'Product_ProductId1'.\r\nInvalid column name 'Product_ProductId1'."}

Answer 1

No entiendo por qué utiliza la asignación de fluidez? Su modelo debe ser mapeado por convenciones predeterminadas. Si usted quiere hacer un mapa con el uso de mapeo fluidez:

modelBuilder.Entity<Product>() 
      .HasMany(x => x.ProductPriceList) // Product has many ProductPricings 
      .WithRequired(y => y.Product)  // ProductPricing has required Product 
      .Map(m => m.MapKey("ProductId")); // Map FK in database to ProductId column 

Answer 2

Esto tiene la respuesta correcta:

http://agilenet.wordpress.com/2011/04/18/entity-framework-code-first-specify-foreign-key-name-in-one-to-many-relationship-with-fluent-api/

casi lo tengo:

modelBuilder.Entity<ProductPricing>() 
    .HasRequired(x => x.Product) 
    .WithMany() 
    .Map(x => x.MapKey("ProductId")); 

simplemente se me olvidó poner el dependiente del principal (es decir, ProductPriceList.Espero que estoy recibiendo la terminología correcta, quería mantenerse alejado de los padres terminología niño^_ ^): Cartografía Fluido

modelBuilder.Entity<ProductPricing>() 
    .HasRequired(x => x.Product) 
    .WithMany(x => x.ProductPriceList) 
    .Map(x => x.MapKey("ProductId")); 

Entidad de Marco no es fluidez, hay algo de tartamudeo se podría comprometer, sin saberlo, si está no muy familiarizado con los matices de cada método :-) Lookie eso, casi lo tengo correcto. Pasar tanto ProductPricing como ProductPriceList parece redundante, apenas intuitivo.

El mapeo fluido de EF es apenas un buen fluido (de lo cual la intuición debería ser una calidad innata) ciudadano de interfaz, ¿no?