¿Estableciendo restricción única con API fluida?

Estoy tratando de construir una entidad EF con Code First y una EntityTypeConfigurationAPI con fluidez. crear claves primarias es fácil, pero no es así con una restricción única. Estaba viendo publicaciones antiguas que sugerían la ejecución de comandos SQL nativos para esto, pero eso parece frustrar el propósito. ¿Es esto posible con EF6?

En EF6.2 , puede usar HasIndex()para agregar índices para la migración a través de una API fluida.

https://github.com/aspnet/EntityFramework6/issues/274

Ejemplo

modelBuilder
    .Entity<User>()
    .HasIndex(u => u.Email)
        .IsUnique();

En EF6.1 en adelante, puede usar IndexAnnotation()para agregar índices para la migración en su API fluida.

http://msdn.microsoft.com/en-us/data/jj591617.aspx#PropertyIndex

Debe agregar referencia a:

using System.Data.Entity.Infrastructure.Annotations;

Ejemplo básico

Aquí hay un uso simple, agregando un índice en la User.FirstNamepropiedad

modelBuilder 
    .Entity<User>() 
    .Property(t => t.FirstName) 
    .HasColumnAnnotation(IndexAnnotation.AnnotationName, new IndexAnnotation(new IndexAttribute()));

Ejemplo práctico

Aquí hay un ejemplo más realista. Agrega un índice único en múltiples propiedades: User.FirstNamey User.LastName, con un nombre de índice "IX_FirstNameLastName"

modelBuilder 
    .Entity<User>() 
    .Property(t => t.FirstName) 
    .IsRequired()
    .HasMaxLength(60)
    .HasColumnAnnotation(
        IndexAnnotation.AnnotationName, 
        new IndexAnnotation(
            new IndexAttribute("IX_FirstNameLastName", 1) { IsUnique = true }));

modelBuilder 
    .Entity<User>() 
    .Property(t => t.LastName) 
    .IsRequired()
    .HasMaxLength(60)
    .HasColumnAnnotation(
        IndexAnnotation.AnnotationName, 
        new IndexAnnotation(
            new IndexAttribute("IX_FirstNameLastName", 2) { IsUnique = true }));

Como una adición a la respuesta de Yorro, también se puede hacer mediante el uso de atributos.

Muestra para el inttipo de combinación de teclas única:

[Index("IX_UniqueKeyInt", IsUnique = true, Order = 1)]
public int UniqueKeyIntPart1 { get; set; }

[Index("IX_UniqueKeyInt", IsUnique = true, Order = 2)]
public int UniqueKeyIntPart2 { get; set; }

Si el tipo de datos es string, entonces se MaxLengthdebe agregar el atributo:

[Index("IX_UniqueKeyString", IsUnique = true, Order = 1)]
[MaxLength(50)]
public string UniqueKeyStringPart1 { get; set; }

[Index("IX_UniqueKeyString", IsUnique = true, Order = 2)]
[MaxLength(50)]
public string UniqueKeyStringPart2 { get; set; }

Si existe un problema de separación de modelo de dominio / almacenamiento, el uso de Metadatatypeatributo / clase puede ser una opción: https://msdn.microsoft.com/en-us/library/ff664465%28v=pandp.50%29.aspx?f= 255 & MSPPError = -2147217396

Un ejemplo rápido de la aplicación de consola:

using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using System.Data.Entity;

namespace EFIndexTest
{
    class Program
    {
        static void Main(string[] args)
        {
            using (var context = new AppDbContext())
            {
                var newUser = new User { UniqueKeyIntPart1 = 1, UniqueKeyIntPart2 = 1, UniqueKeyStringPart1 = "A", UniqueKeyStringPart2 = "A" };
                context.UserSet.Add(newUser);
                context.SaveChanges();
            }
        }
    }

    [MetadataType(typeof(UserMetadata))]
    public class User
    {
        public int Id { get; set; }
        public int UniqueKeyIntPart1 { get; set; }
        public int UniqueKeyIntPart2 { get; set; }
        public string UniqueKeyStringPart1 { get; set; }
        public string UniqueKeyStringPart2 { get; set; }
    }

    public class UserMetadata
    {
        [Index("IX_UniqueKeyInt", IsUnique = true, Order = 1)]
        public int UniqueKeyIntPart1 { get; set; }

        [Index("IX_UniqueKeyInt", IsUnique = true, Order = 2)]
        public int UniqueKeyIntPart2 { get; set; }

        [Index("IX_UniqueKeyString", IsUnique = true, Order = 1)]
        [MaxLength(50)]
        public string UniqueKeyStringPart1 { get; set; }

        [Index("IX_UniqueKeyString", IsUnique = true, Order = 2)]
        [MaxLength(50)]
        public string UniqueKeyStringPart2 { get; set; }
    }

    public class AppDbContext : DbContext
    {
        public virtual DbSet<User> UserSet { get; set; }
    }
}

Aquí hay un método de extensión para establecer índices únicos con mayor fluidez:

public static class MappingExtensions
{
    public static PrimitivePropertyConfiguration IsUnique(this PrimitivePropertyConfiguration configuration)
    {
        return configuration.HasColumnAnnotation("Index", new IndexAnnotation(new IndexAttribute { IsUnique = true }));
    }
}

Uso:

modelBuilder 
    .Entity<Person>() 
    .Property(t => t.Name)
    .IsUnique();

Generará migración como:

public partial class Add_unique_index : DbMigration
{
    public override void Up()
    {
        CreateIndex("dbo.Person", "Name", unique: true);
    }

    public override void Down()
    {
        DropIndex("dbo.Person", new[] { "Name" });
    }
}

Src: Creación de un índice único con API fluida de Entity Framework 6.1

La respuesta de @ coni2k es correcta, sin embargo, debe agregar un [StringLength]atributo para que funcione; de ​​lo contrario, obtendrá una excepción de clave no válida (Ejemplo a continuación).

[StringLength(65)]
[Index("IX_FirstNameLastName", 1, IsUnique = true)]
public string FirstName { get; set; }

[StringLength(65)]
[Index("IX_FirstNameLastName", 2, IsUnique = true)]
public string LastName { get; set; }

Lamentablemente, esto no es compatible con Entity Framework. Estaba en la hoja de ruta para EF 6, pero se retrasó: Workitem 299: Restricciones únicas (índices únicos)

modelBuilder.Property(x => x.FirstName).IsUnicode().IsRequired().HasMaxLength(50);