Jak utworzyć indeks w Entity Framework 6,2 z najpierw kodem

Czy istnieje sposób na utworzenie indeksu we właściwości / kolumnie przy użyciu najpierw kodu, zamiast używania nowego IndexAttribute?

Otóż ​​26.10.2017 Entity Framework 6.2 został oficjalnie wydany . Obejmuje możliwość łatwego definiowania indeksów poprzez Fluent API. To, że ma być używany, zostało już ogłoszone w wersji beta 6.2.

Teraz możesz użyć HasIndex()metody, a po IsUnique()niej, jeśli powinien to być unikalny indeks.

Tylko małe porównanie (przed / po) przykład:

// before 
modelBuilder.Entity<Person>()
        .Property(e => e.Name)
        .HasColumnAnnotation(
            IndexAnnotation.AnnotationName, 
            new IndexAnnotation(new IndexAttribute { IsUnique = true }));

// after
modelBuilder.Entity<Person>()
    .HasIndex(p => p.Name)
    .IsUnique();

// multi column index
modelBuilder.Entity<Person>()
    .HasIndex(p => new { p.Name, p.Firstname })
    .IsUnique();

Możliwe jest również oznaczenie indeksu jako skupionego z .IsClustered().

EDYCJA # 1

Dodano przykład dla indeksu wielokolumnowego i dodatkowe informacje, jak oznaczyć indeks jako klastrowy.

EDYCJA # 2

Jako dodatkowe informacje w EF Core 2,1 jest teraz dokładnie taki sam jak w EF 6,2.
Oto artykuł MS Doc jako odniesienie.

Obecnie nie ma „pierwszej klasy obsługi” tworzenia indeksu za pośrednictwem interfejsu API Fluent, ale za pomocą interfejsu Fluent API można oznaczyć właściwości jako mające atrybuty z interfejsu API adnotacji. Umożliwi to dodanie Indexatrybutu za pośrednictwem płynnego interfejsu.

Oto kilka przykładów z elementu roboczego z witryny problemy dla EF.

Utwórz indeks w jednej kolumnie:

modelBuilder.Entity<MyEntity>()
    .Property(e => e.MyProperty)
    .HasColumnAnnotation(
        IndexAnnotation.AnnotationName, 
        new IndexAnnotation(new IndexAttribute()));

Wiele indeksów w jednej kolumnie:

modelBuilder.Entity<MyEntity>()
    .Property(e => e.MyProperty)
    .HasColumnAnnotation(
        IndexAnnotation.AnnotationName, 
        new IndexAnnotation(new[]
            {
                new IndexAttribute("Index1"),
                new IndexAttribute("Index2") { IsUnique = true }
            }));

Indeksy wielokolumnowe:

modelBuilder.Entity<MyEntity>()
    .Property(e => e.MyProperty1)
    .HasColumnAnnotation(
        IndexAnnotation.AnnotationName,
        new IndexAnnotation(new IndexAttribute("MyIndex", 1)));

modelBuilder.Entity<MyEntity>()
    .Property(e => e.MyProperty2)
    .HasColumnAnnotation(
        IndexAnnotation.AnnotationName, 
        new IndexAnnotation(new IndexAttribute("MyIndex", 2)));

Użycie powyższych technik spowoduje, że .CreateIndex()wywołania będą automatycznie tworzone dla Ciebie w Twojej Up()funkcji podczas tworzenia szkieletu następnej migracji (lub zostaną automatycznie utworzone w bazie danych, jeśli nie używasz migracji).

Utworzyłem kilka metod rozszerzających i opakowałem je w pakiet nuget, aby to znacznie ułatwić.

Zainstaluj EntityFramework.IndexingExtensionspakiet NuGet.

Następnie możesz wykonać następujące czynności:

public class MyDataContext : DbContext
{
  protected override void OnModelCreating(DbModelBuilder modelBuilder)
  {
    modelBuilder.Entity<Customer>()
        .HasIndex("IX_Customers_Name",          // Provide the index name.
            e => e.Property(x => x.LastName),   // Specify at least one column.
            e => e.Property(x => x.FirstName))  // Multiple columns as desired.

        .HasIndex("IX_Customers_EmailAddress",  // Supports fluent chaining for more indexes.
            IndexOptions.Unique,                // Supports flags for unique and clustered.
            e => e.Property(x => x.EmailAddress)); 
  }
}

Projekt i kod źródłowy są tutaj . Cieszyć się!

Bez wyraźnej nazwy:

[Index]
public int Rating { get; set; } 

O określonej nazwie:

[Index("PostRatingIndex")] 
public int Rating { get; set; }

Od wersji EF 6.1 atrybut [Index]jest obsługiwany.
Użyj [Index(IsUnique = true)]dla unikalnego indeksu.
Oto link od firmy Microsoft

public class User 
{ 
    public int UserId { get; set; } 

    [Index(IsUnique = true)] 
    [StringLength(200)] 
    public string Username { get; set; } 

    public string DisplayName { get; set; } 
}

Entity Framework 6

Property(c => c.MyColumn)
        .HasColumnAnnotation("Index", new IndexAnnotation(new IndexAttribute("IX_MyIndex")));

I dodaj używając:

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

Możesz użyć adnotacji danych INDEX Code First Adnotacje danych

Jeśli nie chcesz używać atrybutów na swoich POCO, zawsze możesz to zrobić w następujący sposób:

context.Database.ExecuteSqlCommand("CREATE INDEX IX_NAME ON ..."); 

Tę instrukcję można wykonać w niestandardowej DbInitializerklasie pochodnej. Nie znam jednak żadnego sposobu na zrobienie tego przez Fluent API.

Piszę metodę rozszerzenia do użycia w płynnym EF, aby uniknąć dodatkowego kodu:

public static PrimitivePropertyConfiguration HasIndexAnnotation(
    this PrimitivePropertyConfiguration primitivePropertyConfiguration, 
    IndexAttribute indexAttribute = null
    )
{
    indexAttribute = indexAttribute ?? new IndexAttribute();

    return primitivePropertyConfiguration
        .HasColumnAnnotation(
            IndexAnnotation.AnnotationName, 
            new IndexAnnotation(indexAttribute)
        );
}

następnie użyj tego w ten sposób:

Property(t => t.CardNo)
    .HasIndexAnnotation();

lub w ten sposób, jeśli indeks wymaga pewnych konfiguracji:

Property(t => t.CardNo)
    .HasIndexAnnotation(new IndexAttribute("IX_Account") { IsUnique = true });

Możesz użyć jednego z tych

// Indeksy

 this.HasIndex(e => e.IsActive)
            .HasName("IX_IsActive");

lub

  this.Property(e => e.IsActive).HasColumnAnnotation(
            "Index",
            new IndexAnnotation(new IndexAttribute("IX_IsActive")));