CODEWITHSUNDEEP
c#entity-frameworkef-code-firstfluent-interface
Catalin
Catalin

Reputation: 11721

EF Code First prevent property mapping with Fluent API

I have a class Product and a complex type AddressDetails

public class Product
{
    public Guid Id { get; set; }

    public AddressDetails AddressDetails { get; set; }
}

public class AddressDetails
{
    public string City { get; set; }
    public string Country { get; set; }
    // other properties
}

Is it possible to prevent mapping "Country" property from AddressDetails inside Product class? (because i will never need it for Product class)

Something like this

Property(p => p.AddressDetails.Country).Ignore();

Upvotes: 33

Views: 30808

Answers (7)

Salizar Marxx
Salizar Marxx

Reputation: 933

While I realize that this is an old question, the answers didn't resolve my issue with EF 6.

For EF 6 you need to create a ComplexTypeConfiguration Mapping.

example:

public class Workload
{
    public int Id { get; set; }
    public int ContractId { get; set; }
    public WorkloadStatus Status {get; set; }
    public Configruation Configuration { get; set; }
}
public class Configuration
{
    public int Timeout { get; set; }
    public bool SaveResults { get; set; }
    public int UnmappedProperty { get; set; }
}

public class WorkloadMap : System.Data.Entity.ModelConfiguration.EntityTypeConfiguration<Workload>
{
    public WorkloadMap()
    {
         ToTable("Workload");
         HasKey(x => x.Id);
    }
}
// Here This is where we mange the Configuration
public class ConfigurationMap : ComplexTypeConfiguration<Configuration>
{
    ConfigurationMap()
    {
       Property(x => x.TimeOut).HasColumnName("TimeOut");
       Ignore(x => x.UnmappedProperty);
    }
}

If your Context is loading configurations manually you need to add the new ComplexMap, if your using the FromAssembly overload it'll be picked up with the rest of the configuration objects.

Upvotes: 4

Jan
Jan

Reputation: 19

Try this

modelBuilder.ComplexType<AddressDetails>().Ignore(p => p.Country);

It worked for me in similar case.

Upvotes: 1

davidfcruz
davidfcruz

Reputation: 29

On EF6 you can configure the complex type:

 modelBuilder.Types<AddressDetails>()
     .Configure(c => c.Ignore(p => p.Country))

That way the property Country will be always ignored.

Upvotes: 2

Twon-ha
Twon-ha

Reputation: 954

For EF5 and older: In the DbContext.OnModelCreating override for your context:

modelBuilder.Entity<Product>().Ignore(p => p.AddressDetails.Country);

For EF6: You're out of luck. See Mrchief's answer.

Upvotes: 31

JAVizcaino
JAVizcaino

Reputation: 119

If you are using an implementation of EntityTypeConfiguration you can use the Ignore Method:

public class SubscriptionMap: EntityTypeConfiguration<Subscription>
{
    // Primary Key
    HasKey(p => p.Id)

    Property(p => p.Id).HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
    Property(p => p.SubscriptionNumber).IsOptional().HasMaxLength(20);
    ...
    ...

    Ignore(p => p.SubscriberSignature);

    ToTable("Subscriptions");
}

Upvotes: 11

Tommy Ceusters
Tommy Ceusters

Reputation: 22

It can be done in Fluent API as well, just add in the mapping the following code

this.Ignore(t => t.Country), tested in EF6

Upvotes: -2

Mrchief
Mrchief

Reputation: 76218

Unfortunately the accepted answer doesn't work, not at least with EF6 and especially if the child class is not an entity.

I haven't found any way to do this via fluent API. The only way it works is via data annotations:

public class AddressDetails
{
    public string City { get; set; }

    [NotMapped]
    public string Country { get; set; }
    // other properties
}

Note: If you have a situation where Country should be excluded only when it is part of certain other entity, then you're out of luck with this approach.

Upvotes: 15

Related Questions