Vincoli chiave univoci per più colonne in Entity Framework

Sto usando prima Entity Framework 5.0 Code;

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

Voglio rendere la combinazione tra FirstColumne SecondColumnunica.

Esempio:

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

Esiste un modo per farlo?

Con Entity Framework 6.1, ora puoi farlo:

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

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

Il secondo parametro nell'attributo è dove è possibile specificare l'ordine delle colonne nell'indice.
Ulteriori informazioni: MSDN

Ho trovato tre modi per risolvere il problema.

Indici univoci in EntityFramework Core:

Primo approccio:

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

Il secondo approccio per creare vincoli univoci con EF Core utilizzando i tasti alternativi.

Esempi

Una colonna:

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

Colonne multiple:

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

EF 6 e inferiore:

Primo approccio:

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

Questo approccio è molto rapido e utile, ma il problema principale è che Entity Framework non sa nulla di questi cambiamenti!

Secondo approccio: l'
ho trovato in questo post ma non ho provato da solo.

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

Il problema di questo approccio è il seguente: ha bisogno di DbMigration, quindi cosa fai se non ce l'hai?

Terzo approccio:
penso che questo sia il migliore, ma richiede del tempo per farlo. Ti mostrerò solo l'idea alla base: in questo link http://code.msdn.microsoft.com/CSASPNETUniqueConstraintInE-d357224a puoi trovare il codice per l'annotazione dei dati chiave univoci:

[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

Il problema per questo approccio; Come posso combinarli? Ho un'idea per estendere questa implementazione Microsoft ad esempio:

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

Più avanti in IDatabaseInitializer come descritto nell'esempio Microsoft è possibile combinare le chiavi in ​​base al numero intero indicato. È necessario notare una cosa: se la proprietà unica è di tipo stringa, è necessario impostare MaxLength.

Se si utilizza Code-First , è possibile implementare un'estensione personalizzata 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);
    }
}

Quindi usalo così:

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

Ciò comporterà questa migrazione:

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

E alla fine finiscono nel database come:

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

Devi definire una chiave composita.

Con le annotazioni dei dati è simile al seguente:

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

Puoi anche farlo con modelBuilder quando esegui l'override di OnModelCreating specificando:

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

La risposta di Niaher affermando che per usare l'API fluente è necessaria un'estensione personalizzata potrebbe essere stata corretta al momento della scrittura. Ora puoi (EF core 2.1) utilizzare l'API fluente come segue:

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

Completamento della risposta @chuck per l'utilizzo di indici compositi con chiavi esterne .

È necessario definire una proprietà che conterrà il valore della chiave esterna. È quindi possibile utilizzare questa proprietà all'interno della definizione dell'indice.

Ad esempio, abbiamo compagnia con dipendenti e solo noi abbiamo un vincolo univoco su (nome, azienda) per qualsiasi dipendente:

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

Ora la mappatura della 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);
    }
}

Nota che ho anche usato l'estensione @niaher per l'annotazione univoca dell'indice.

Nella risposta accettata da @chuck, c'è un commento che dice che non funzionerà nel caso di FK.

ha funzionato per me, caso di 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; }
}

Presumo che tu voglia sempre EntityIdessere la chiave primaria, quindi sostituirla con una chiave composita non è un'opzione (se non altro perché le chiavi composite sono molto più complicate con cui lavorare e perché non è molto ragionevole avere chiavi primarie che abbiano anche un significato nella logica aziendale).

Il minimo da fare è creare una chiave univoca su entrambi i campi nel database e verificare in modo specifico le eccezioni alla violazione delle chiavi univoche durante il salvataggio delle modifiche.

Inoltre, è possibile (dovrebbe) verificare i valori univoci prima di salvare le modifiche. Il modo migliore per farlo è tramite una Any()query, perché riduce al minimo la quantità di dati trasferiti:

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

Attenzione che questo controllo da solo non è mai abbastanza. C'è sempre un po 'di latenza tra il controllo e il commit effettivo, quindi avrai sempre bisogno del vincolo univoco + gestione delle eccezioni.

Recentemente aggiunto una chiave composita con l'unicità di 2 colonne usando l'approccio consigliato da 'chuck', grazie a @chuck. Solo questo approccio mi è sembrato più pulito:

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