Contraintes de clé uniques pour plusieurs colonnes dans Entity Framework

J'utilise d'abord le code Entity Framework 5.0;

public class Entity
 {
   [Key, DatabaseGenerated(DatabaseGeneratedOption.Identity)]
   public string EntityId { get; set;}
   public int FirstColumn  { get; set;}
   public int SecondColumn  { get; set;}
 }

Je veux rendre la combinaison entre FirstColumnet SecondColumnaussi unique.

Exemple:

Id  FirstColumn  SecondColumn 
1       1              1       = OK
2       2              1       = OK
3       3              3       = OK
5       3              1       = THIS OK 
4       3              3       = GRRRRR! HERE ERROR

Y'a-t'il un quelconque moyen d'y arriver?

Avec Entity Framework 6.1, vous pouvez désormais procéder comme suit:

[Index("IX_FirstAndSecond", 1, IsUnique = true)]
public int FirstColumn { get; set; }

[Index("IX_FirstAndSecond", 2, IsUnique = true)]
public int SecondColumn { get; set; }

Le deuxième paramètre de l'attribut est l'endroit où vous pouvez spécifier l'ordre des colonnes dans l'index.
Plus d'informations: MSDN

J'ai trouvé trois façons de résoudre le problème.

Index uniques dans EntityFramework Core:

Première approche:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
   modelBuilder.Entity<Entity>()
   .HasIndex(p => new {p.FirstColumn , p.SecondColumn}).IsUnique();
}

La seconde approche pour créer des contraintes uniques avec EF Core en utilisant des clés alternatives.

Exemples

Une colonne:

modelBuilder.Entity<Blog>().HasAlternateKey(c => c.SecondColumn).HasName("IX_SingeColumn");

Plusieurs colonnes:

modelBuilder.Entity<Entity>().HasAlternateKey(c => new [] {c.FirstColumn, c.SecondColumn}).HasName("IX_MultipleColumns");

EF 6 et inférieurs:

Première approche:

dbContext.Database.ExecuteSqlCommand(string.Format(
                        @"CREATE UNIQUE INDEX LX_{0} ON {0} ({1})", 
                                 "Entitys", "FirstColumn, SecondColumn"));

Cette approche est très rapide et utile mais le principal problème est qu'Entity Framework ne sait rien de ces changements!

Deuxième approche:
je l'ai trouvé dans ce post mais je n'ai pas essayé par moi-même.

CreateIndex("Entitys", new string[2] { "FirstColumn", "SecondColumn" },
              true, "IX_Entitys");

Le problème de cette approche est le suivant: elle a besoin de DbMigration, alors que faites-vous si vous ne l'avez pas?

Troisième approche:
je pense que c'est la meilleure mais cela demande du temps. Je vais juste vous montrer l'idée derrière cela: Dans ce lien http://code.msdn.microsoft.com/CSASPNETUniqueConstraintInE-d357224a, vous pouvez trouver le code d'annotation de données de clé unique:

[UniqueKey] // Unique Key 
public int FirstColumn  { get; set;}
[UniqueKey] // Unique Key 
public int SecondColumn  { get; set;}

// The problem hier
1, 1  = OK 
1 ,2  = NO OK 1 IS UNIQUE

Le problème de cette approche; Comment puis-je les combiner? J'ai une idée d'étendre cette implémentation Microsoft par exemple:

[UniqueKey, 1] // Unique Key 
public int FirstColumn  { get; set;}
[UniqueKey ,1] // Unique Key 
public int SecondColumn  { get; set;}

Plus loin dans IDatabaseInitializer comme décrit dans l'exemple Microsoft, vous pouvez combiner les clés en fonction de l'entier donné. Une chose doit être notée cependant: si la propriété unique est de type chaîne, vous devez définir la longueur maximale.

Si vous utilisez Code-First , vous pouvez implémenter une extension personnalisée HasUniqueIndexAnnotation

using System.ComponentModel.DataAnnotations.Schema;
using System.Data.Entity.Infrastructure.Annotations;
using System.Data.Entity.ModelConfiguration.Configuration;

internal static class TypeConfigurationExtensions
{
    public static PrimitivePropertyConfiguration HasUniqueIndexAnnotation(
        this PrimitivePropertyConfiguration property, 
        string indexName,
        int columnOrder)
    {
        var indexAttribute = new IndexAttribute(indexName, columnOrder) { IsUnique = true };
        var indexAnnotation = new IndexAnnotation(indexAttribute);

        return property.HasColumnAnnotation(IndexAnnotation.AnnotationName, indexAnnotation);
    }
}

Ensuite, utilisez-le comme ceci:

this.Property(t => t.Email)
    .HasColumnName("Email")
    .HasMaxLength(250)
    .IsRequired()
    .HasUniqueIndexAnnotation("UQ_User_EmailPerApplication", 0);

this.Property(t => t.ApplicationId)
    .HasColumnName("ApplicationId")
    .HasUniqueIndexAnnotation("UQ_User_EmailPerApplication", 1);

Ce qui entraînera cette migration:

public override void Up()
{
    CreateIndex("dbo.User", new[] { "Email", "ApplicationId" }, unique: true, name: "UQ_User_EmailPerApplication");
}

public override void Down()
{
    DropIndex("dbo.User", "UQ_User_EmailPerApplication");
}

Et finalement finir dans la base de données comme:

CREATE UNIQUE NONCLUSTERED INDEX [UQ_User_EmailPerApplication] ON [dbo].[User]
(
    [Email] ASC,
    [ApplicationId] ASC
)

Vous devez définir une clé composite.

Avec les annotations de données, cela ressemble à ceci:

public class Entity
 {
   public string EntityId { get; set;}
   [Key]
   [Column(Order=0)]
   public int FirstColumn  { get; set;}
   [Key]
   [Column(Order=1)]
   public int SecondColumn  { get; set;}
 }

Vous pouvez également le faire avec modelBuilder lors de la substitution de OnModelCreating en spécifiant:

modelBuilder.Entity<Entity>().HasKey(x => new { x.FirstColumn, x.SecondColumn });

La réponse de niaher indiquant que pour utiliser l'API fluide, vous avez besoin d'une extension personnalisée peut-être correcte au moment de la rédaction. Vous pouvez maintenant (EF core 2.1) utiliser l'API couramment comme suit:

modelBuilder.Entity<ClassName>()
            .HasIndex(a => new { a.Column1, a.Column2}).IsUnique();

Compléter la réponse @chuck pour utiliser des indices composites avec des clés étrangères .

Vous devez définir une propriété qui contiendra la valeur de la clé étrangère. Vous pouvez ensuite utiliser cette propriété dans la définition d'index.

Par exemple, nous avons une entreprise avec des employés et seulement nous avons une contrainte unique sur (nom, entreprise) pour tout employé:

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

class Employee
{
    public Guid Id { get; set; }
    [Required]
    public String Name { get; set; }
    public Company Company  { get; set; }
    [Required]
    public Guid CompanyId { get; set; }
}

Maintenant, le mappage de la classe Employee:

class EmployeeMap : EntityTypeConfiguration<Employee>
{
    public EmployeeMap ()
    {
        ToTable("Employee");

        Property(p => p.Id)
            .HasDatabaseGeneratedOption(DatabaseGeneratedOption.None);

        Property(p => p.Name)
            .HasUniqueIndexAnnotation("UK_Employee_Name_Company", 0);
        Property(p => p.CompanyId )
            .HasUniqueIndexAnnotation("UK_Employee_Name_Company", 1);
        HasRequired(p => p.Company)
            .WithMany()
            .HasForeignKey(p => p.CompanyId)
            .WillCascadeOnDelete(false);
    }
}

Notez que j'ai également utilisé l'extension @niaher pour l'annotation d'index unique.

Dans la réponse acceptée par @chuck, il y a un commentaire disant que cela ne fonctionnera pas dans le cas de FK.

cela a fonctionné pour moi, cas de EF6 .Net4.7.2

public class OnCallDay
{
     public int Id { get; set; }
    //[Key]
    [Index("IX_OnCallDateEmployee", 1, IsUnique = true)]
    public DateTime Date { get; set; }
    [ForeignKey("Employee")]
    [Index("IX_OnCallDateEmployee", 2, IsUnique = true)]
    public string EmployeeId { get; set; }
    public virtual ApplicationUser Employee{ get; set; }
}

Je suppose que vous voulez toujours EntityIdêtre la clé primaire, donc la remplacer par une clé composite n'est pas une option (ne serait-ce que parce que les clés composites sont beaucoup plus compliquées à utiliser et à utiliser parce qu'il n'est pas très judicieux d'avoir des clés primaires qui ont également un sens dans la logique métier).

Le moins que vous puissiez faire est de créer une clé unique sur les deux champs de la base de données et de vérifier spécifiquement les exceptions de violation de clé unique lors de l'enregistrement des modifications.

De plus, vous pouvez (devriez) vérifier les valeurs uniques avant d'enregistrer les modifications. La meilleure façon de le faire est par une Any()requête, car elle minimise la quantité de données transférées:

if (context.Entities.Any(e => e.FirstColumn == value1 
                           && e.SecondColumn == value2))
{
    // deal with duplicate values here.
}

Attention, ce chèque à lui seul n'est jamais suffisant. Il y a toujours une certaine latence entre la vérification et la validation réelle, vous aurez donc toujours besoin de la gestion unique des contraintes et des exceptions.

Récemment ajouté une clé composite avec l'unicité de 2 colonnes en utilisant l'approche recommandée par 'chuck', merci @chuck. Seule cette approche m'a paru plus propre:

public int groupId {get; set;}

[Index("IX_ClientGrouping", 1, IsUnique = true)]
public int ClientId { get; set; }

[Index("IX_ClientGrouping", 2, IsUnique = true)]
public int GroupName { get; set; }