Restricciones clave únicas para múltiples columnas en Entity Framework

Estoy usando Entity Framework 5.0 Code First;

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

Quiero hacer la combinación entre FirstColumny SecondColumncomo única.

Ejemplo:

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

¿Hay alguna manera de hacerlo?

Con Entity Framework 6.1, ahora puede hacer esto:

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

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

El segundo parámetro en el atributo es donde puede especificar el orden de las columnas en el índice.
Más información: MSDN

Encontré tres formas de resolver el problema.

Índices únicos en EntityFramework Core:

Primer enfoque:

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

El segundo enfoque para crear restricciones únicas con EF Core mediante el uso de claves alternativas.

Ejemplos

Una columna:

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

Múltiples columnas:

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

EF 6 y abajo:

Primer enfoque:

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

¡Este enfoque es muy rápido y útil, pero el problema principal es que Entity Framework no sabe nada sobre esos cambios!

Segundo enfoque:
lo encontré en esta publicación pero no lo intenté solo.

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

El problema de este enfoque es el siguiente: necesita DbMigration, ¿qué debe hacer si no lo tiene?

Tercer enfoque:
creo que este es el mejor, pero requiere algo de tiempo para hacerlo. Simplemente le mostraré la idea detrás de esto: en este enlace http://code.msdn.microsoft.com/CSASPNETUniqueConstraintInE-d357224a puede encontrar el código para una anotación de datos clave única:

[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

El problema para este enfoque; ¿Cómo puedo combinarlos? Tengo una idea para extender esta implementación de Microsoft, por ejemplo:

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

Más adelante en el IDatabaseInitializer como se describe en el ejemplo de Microsoft, puede combinar las claves de acuerdo con el entero dado. Sin embargo, hay que tener en cuenta una cosa: si la propiedad única es de tipo cadena, debe establecer MaxLength.

Si usa Code-First , puede implementar una extensión personalizada 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);
    }
}

Luego úsalo así:

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

Lo que dará como resultado esta migración:

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

Y finalmente terminan en la base de datos como:

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

Necesita definir una clave compuesta.

Con anotaciones de datos se ve así:

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

También puede hacer esto con modelBuilder al anular OnModelCreating especificando:

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

La respuesta de niaher que indica que para usar la API fluida que necesita una extensión personalizada puede haber sido correcta al momento de la escritura. Ahora puede (EF core 2.1) usar la API fluida de la siguiente manera:

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

Completar la respuesta @chuck para usar índices compuestos con claves foráneas .

Debe definir una propiedad que contendrá el valor de la clave externa. Luego puede usar esta propiedad dentro de la definición del índice.

Por ejemplo, tenemos compañía con empleados y solo tenemos una restricción única en (nombre, compañía) para cualquier empleado:

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

Ahora el mapeo de la clase Empleado:

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

Tenga en cuenta que también usé la extensión @niaher para anotaciones de índice únicas.

En la respuesta aceptada por @chuck, hay un comentario que dice que no funcionará en el caso de FK.

funcionó para mí, caso 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; }
}

Supongo que siempre quiere EntityIdser la clave principal, por lo que reemplazarla por una clave compuesta no es una opción (solo porque las claves compuestas son mucho más complicadas de trabajar y porque no es muy sensato tener claves primarias que también tengan significado en la lógica de negocios).

Lo menos que debe hacer es crear una clave única en ambos campos en la base de datos y verificar específicamente las excepciones de violación de clave única al guardar los cambios.

Además, podría (debería) verificar valores únicos antes de guardar los cambios. La mejor manera de hacerlo es mediante una Any()consulta, ya que minimiza la cantidad de datos transferidos:

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

Tenga en cuenta que este control solo nunca es suficiente. Siempre hay algo de latencia entre la verificación y la confirmación real, por lo que siempre necesitará la restricción única + manejo de excepciones.

Recientemente se agregó una clave compuesta con la singularidad de 2 columnas utilizando el enfoque que recomienda 'chuck', gracias @chuck. Solo este enfoque me pareció más limpio:

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