Унікальні ключові обмеження для кількох стовпців в Entity Framework

Я спочатку використовую код 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;}
 }

Я хочу зробити комбінацію між FirstColumn і SecondColumnтаким же унікальним.

Приклад:

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

Чи все-таки це потрібно зробити?

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

Пізніше в IDatabaseInitializer, як описано в прикладі Microsoft, ви можете комбінувати ключі відповідно до заданого цілого числа. Однак слід зазначити одне: якщо унікальна властивість має рядковий тип, то вам доведеться встановити 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
)

Потрібно визначити складений ключ.

З примітками про дані це виглядає приблизно так:

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

Ви також можете це зробити з modelBuilder, коли заміняєте OnModelCreating, вказавши:

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

Відповідь від niaher про те, що для використання вільного API вам потрібне спеціальне розширення під час написання. Тепер ви можете (ядро EF 2.1) використовувати вільний API таким чином:

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

Завершення @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; }
}

Тепер відображення карти класу Співробітник:

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 для унікальної анотації індексу.

У прийнятій відповіді від @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.
}

Слідкуйте за тим, щоб цього перевірки ніколи не вистачало. Завжди існує деяка затримка між чеком і фактичною комісією, тому вам завжди знадобиться унікальне обмеження + обробка виключень.

Нещодавно додали складений ключ з унікальністю 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; }