实体框架中多列的唯一键约束

使用 Entity Framework 6.1，您现在可以执行以下操作：

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

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

属性中的第二个参数是您可以指定索引中列的顺序的位置。
更多信息：MSDN

---

我找到了解决问题的三种方法。

EntityFramework Core 中的唯一索引：

第一种方法：

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

第二种通过使用备用键使用 EF Core 创建唯一约束的方法。

例子

一栏：

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

多列：

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

EF 6 及以下：

第一种方法：

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

这种方法非常快速且有用，但主要问题是 Entity Framework 对这些更改一无所知！

第二种方法：我在这篇文章中找到了它，但我自己没有尝试过。

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

这种方法的问题如下：它需要 DbMigration 那么如果你没有它怎么办？

第三种方法：
我认为这是最好的方法，但需要一些时间来完成。我将向您展示其背后的想法：在此链接 http://code.msdn.microsoft.com/CSASPNETUniqueConstraintInE-d357224a 中，您可以找到唯一关键数据注释的代码：

[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

这种方法的问题；我怎样才能将它们结合起来？我有一个想法来扩展这个 Microsoft 实现，例如：

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

稍后在 Microsoft 示例中描述的 IDatabaseInitializer 中，您可以根据给定的整数组合键。但是必须注意一件事：如果唯一属性是字符串类型，那么您必须设置 MaxLength。

---

如果您使用 Code-First，则可以实现自定义扩展 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);
    }
}

然后像这样使用它：

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

这将导致此迁移：

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

最终在数据库中为：

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

---

niaher 的回答指出，要使用 fluent API，您需要自定义扩展，在撰写本文时可能是正确的。您现在可以（EF 核心 2.1）使用 fluent API，如下所示：

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

---

您需要定义一个复合键。

使用数据注释它看起来像这样：

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

您也可以在通过指定覆盖 OnModelCreating 时使用 modelBuilder 执行此操作：

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

---

完成@chuck 使用带有外键的复合索引的答案。

您需要定义一个保存外键值的属性。然后，您可以在索引定义中使用此属性。

例如，我们有员工的公司，只有我们对任何员工的（姓名，公司）有唯一的约束：

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

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

请注意，我还使用 @niaher 扩展来进行唯一索引注释。

---

对于那些寻找 2021 年解决方案的人来说，已接受答案的工作版本现在应该如下所示：

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

这样注释应该存在于模型上，而不是单独的列上。另请注意 nameof() 语法。

此答案来自官方文档：https://docs.microsoft.com/en-us/ef/core/modeling/indexes?tabs=data-annotations

---

在@chuck 接受的答案中，有一条评论说它在 FK 的情况下不起作用。

它对我有用，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; }
}

---

我假设您总是希望 EntityId 成为主键，因此用复合键替换它不是一种选择（如果只是因为复合键与 和 一起使用要复杂得多，因为它不是拥有在业务逻辑中也有意义的主键是非常明智的）。

您至少应该在数据库中的两个字段上创建一个唯一键，并在保存更改时专门检查唯一键违规异常。

此外，您可以（应该）在保存更改之前检查唯一值。最好的方法是使用 Any() 查询，因为它可以最大限度地减少传输的数据量：

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

请注意，仅此检查是不够的。检查和实际提交之间总是有一些延迟，所以你总是需要唯一约束+异常处理。

---

最近使用“chuck”推荐的方法添加了一个具有 2 列唯一性的复合键，谢谢@chuck。只有这种方法对我来说看起来更干净：

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

---

我想添加我的答案，因为提供的解决方案对我没有帮助。在我的例子中，其中一列是外键引用。

旧型号：

public class Matrix
{
    public int ID { get; set; }

    public MachineData MachineData { get; set; }

    public MachineVariant MachineVariant { get; set; }
}

请注意，MachineVariant 是一个枚举，而 MachineData 是一个引用。

尝试使用@Bassam Alugili 提供的解决方案：

modelBuilder.Entity<Matrix>()
   .HasIndex(sm => new { sm.MachineData, sm.DoughVariant }).IsUnique(true);

没用。所以我为 machineData 外键添加了一个 ID 列，如下所示：

public class Matrix
{
    public int ID { get; set; }

    public MachineData MachineData { get; set; }

    [ForeignKey("MachineData")]
    public int MachineDataID { get; set; }

    public MachineVariant MachineVariant { get; set; }
}

并将模型构建器代码更改为：

modelBuilder.Entity<Matrix>()
   .HasIndex(sm => new { sm.MachineDataID, sm.DoughVariant }).IsUnique(true);

这导致了所需的解决方案

---

您应该将 Index 属性放在实体类的顶部，并在 string[] 中定义多个键

[Index("FirstColumn", "SecondColumn", IsUnique = true, Name = "My_Unique_Index")]
public class Entity    

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

---