La cartographie des clés composites à l'aide de EF premier code

Table Sql server:

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

Comment dois-je carte ce en EF 6 le premier code?

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

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

J'ai vu quelques exemples de cas où vous devez définir l'ordre de tri de chaque colonne, c'est que requis?

Est-il la documentation officielle sur cela quelque part?

Est SomeId un string ou un int?
C'est une chaîne, je vais corriger ça.

InformationsquelleAutor loyalflow | 2013-11-05

c#entity-framework entity-framework-6 sql-server

156

Vous avez certainement besoin de mettre de l'ordre des colonnes, sinon, comment SQL Server censé savoir où l'on va d'abord? Voici ce que vous devez faire dans votre code:
```
public class MyTable
{
  [Key, Column(Order = 0)]
  public string SomeId { get; set; }

  [Key, Column(Order = 1)]
  public int OtherId { get; set; }
}
```
Vous pouvez également regarder cette SORTE de question. Si vous voulez une documentation officielle, je vous recommande de regarder le officiel EF site web. Espérons que cette aide.

EDIT: je viens de trouver un blog de Julie Lerman avec des liens vers toutes sortes de EF 6 bonté. Vous pouvez trouver ce dont vous avez besoin ici.
- Comment faites-vous cela par un EntityConfiguration? Je n'ai pas vraiment l'entité pour la table de jointure... j'ai juste les deux entités et un EntityConfiguration sur l'un d'eux avec un .Carte() pour configurer le mapping.
- otherwise how is SQL Server supposed to know which one goes first? - pourquoi pas de la même manière qu'il connaisse l'ordre pour tous les autres de la colonne?
- EF ne sais pas l'ordre des colonnes, vous pouvez insérer des colonnes dans un ordre aussi longtemps que les noms sont spécifiés. Si EF nécessite de l'ordre de composites PK elle doit être liée à l'indexation.
- J'imagine que les EF créateurs ont pu s'en servir de la réflexion afin de déduire la clé/ordre des colonnes, mais peut-être il y a des considérations de performance pour ne pas faire cela. Je vais prendre au moment de la conception de la spécificité au ralentissement de la performance de tout les jours, surtout dans ma DAL.
InformationsquelleAutor IronMan84

Pour la Cartographie de la clé primaire Composite à l'aide de Entity framework, nous pouvons utiliser deux approches.

1) En remplaçant la OnModelCreating() la Méthode

Ex: j'ai le modèle de classe nommée VehicleFeature comme indiqué ci-dessous.

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

Le Code dans mon DBContext serait comme ,

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) Par Des Annotations De Données.

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;}
}

Veuillez consulter les liens ci-dessous pour plus d'informations.

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

2) Comment ajouter un composite unique clé à l'aide de EF 6 Api Fluent?

FYI pour EF de Base, l'Option n ° 2 est impossible, "des clés Composites ne peuvent être configurés à l'aide de l'API Fluent - conventions ne sera jamais l'installation d'une clé composite et vous ne pouvez pas utiliser les Annotations de Données pour configurer un."

InformationsquelleAutor Krishna

7

Par le biais de la Configuration, vous pouvez le faire:
```
Model1
{
    int fk_one,
    int fk_two
}

Model2
{
    int pk_one,
    int pk_two,
}
```
ensuite dans le cadre de config
```
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);
    }
}
```
- Si dans le cadre de config?
- Si vous configurez contexte via code à l'aide d'API Fluent... section 7. public class MyContext : DbContext { protected override void OnModelCreating(DbModelBuilder modelBuilder) { modelBuilder.Entité<Model1>() .HasRequired(e => e.Model2) .WithMany(e => e.Model1s) .HasForeignKey(e => new { e.fk_one, e.fk_two }) .WillCascadeOnDelete(false); } }
- J'ai trouvé, j'ai dû utiliser l'outil au lieu de DbModelBuilder sur dotnet de base.
InformationsquelleAutor philn5d

J'ai pensé que je voudrais ajouter à cette question, comme c'est le top résultat de recherche de google.

Comme il a été noté dans les commentaires, en EF de Base il n'y a pas de support pour l'utilisation d'annotations (attribut de Clé) et elle doit être faite avec fluent.

Que je travaillais sur une grande migration de EF6 à EF Base c'était désagréable et j'ai donc essayé de le pirater en utilisant la Réflexion pour chercher l'attribut de Clé et de les appliquer ensuite au cours de 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);
}

Je n'ai pas entièrement testé ce dans toutes les situations, mais il fonctionne dans ma base de tests. Espérons que cela aide quelqu'un

InformationsquelleAutor cmorgan091

Vous devez vous connecter pour publier un commentaire.