Mapeo de claves compuestas usando el código EF primero

Tabla de servidor SQL:

SomeId PK varchar(50) not null 
OtherId PK int not null

¿Cómo debo asignar esto en el código EF 6 primero?

public class MyTable
{
    [Key]
    public string SomeId { get; set; }

    [Key]
    public int OtherId { get; set; }
}

He visto algunos ejemplos en los que debe establecer el orden para cada columna, ¿es necesario?

¿Hay documentación oficial sobre esto en alguna parte?

Definitivamente debe poner el orden de las columnas, de lo contrario, ¿cómo se supone que SQL Server sepa cuál va primero? Esto es lo que debe hacer en su código:

public class MyTable
{
  [Key, Column(Order = 0)]
  public string SomeId { get; set; }

  [Key, Column(Order = 1)]
  public int OtherId { get; set; }
}

También puede consultar esta pregunta SO . Si desea documentación oficial, le recomiendo que consulte el sitio web oficial de EF . Espero que esto ayude.

EDITAR: Acabo de encontrar una publicación de blog de Julie Lerman con enlaces a todo tipo de bondades de EF 6. Puedes encontrar lo que necesites aquí .

Para el mapeo de la clave primaria compuesta usando Entity framework, podemos usar dos enfoques.

1) Anulando el método OnModelCreating ()

Por ejemplo: tengo la clase de modelo denominada VehicleFeature como se muestra a continuación.

public class VehicleFeature
{
    public int VehicleId { get; set; }
    public int FeatureId{get;set;}
    public Vehicle Vehicle{get;set;}
    public Feature Feature{get;set;}
}

El código en mi DBContext sería como,

public class VegaDbContext : DbContext
{
    public DbSet<Make> Makes{get;set;}

    public DbSet<Feature> Features{get;set;}
    public VegaDbContext(DbContextOptions<VegaDbContext> options):base(options)        
    {           

    }
    // we override the OnModelCreating method here.
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<VehicleFeature>().HasKey(vf=> new {vf.VehicleId, vf.FeatureId});
    }
}

2) Por anotaciones de datos.

public class VehicleFeature
{
    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]  
    [Key]
    public int VehicleId { get; set; }
    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]   
    [Key]
    public int FeatureId{get;set;}
    public Vehicle Vehicle{get;set;}
    public Feature Feature{get;set;}
}

Consulte los enlaces a continuación para obtener más información.

1) https://msdn.microsoft.com/en-us/library/jj591617(v=vs.113).aspx

2) ¿Cómo agregar una clave única compuesta usando EF 6 Fluent Api?

A través de la configuración, puede hacer esto:

Model1
{
    int fk_one,
    int fk_two
}

Model2
{
    int pk_one,
    int pk_two,
}

luego en la configuración de contexto

public class MyContext : DbContext
{
    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Model1>()
            .HasRequired(e => e.Model2)
            .WithMany(e => e.Model1s)
            .HasForeignKey(e => new { e.fk_one, e.fk_two })
            .WillCascadeOnDelete(false);
    }
}

Pensé que agregaría algo a esta pregunta, ya que es el mejor resultado de búsqueda de Google.

Como se ha señalado en los comentarios, en EF Core no hay soporte para el uso de anotaciones (atributo clave) y debe hacerse con fluidez.

Como estaba trabajando en una gran migración de EF6 a EF Core, esto fue desagradable y traté de piratearlo usando Reflection para buscar el atributo Key y luego aplicarlo durante OnModelCreating

// get all composite keys (entity decorated by more than 1 [Key] attribute
foreach (var entity in modelBuilder.Model.GetEntityTypes()
    .Where(t => 
        t.ClrType.GetProperties()
            .Count(p => p.CustomAttributes.Any(a => a.AttributeType == typeof(KeyAttribute))) > 1))
{
    // get the keys in the appropriate order
    var orderedKeys = entity.ClrType
        .GetProperties()
        .Where(p => p.CustomAttributes.Any(a => a.AttributeType == typeof(KeyAttribute)))
        .OrderBy(p => 
            p.CustomAttributes.Single(x => x.AttributeType == typeof(ColumnAttribute))?
                .NamedArguments?.Single(y => y.MemberName == nameof(ColumnAttribute.Order))
                .TypedValue.Value ?? 0)
        .Select(x => x.Name)
        .ToArray();

    // apply the keys to the model builder
    modelBuilder.Entity(entity.ClrType).HasKey(orderedKeys);
}

No lo he probado completamente en todas las situaciones, pero funciona en mis pruebas básicas. Espero que esto ayude a alguien