Entity Framework
Kod första dataAnnoteringar

Anmärkningar

[Key] attribut

Nyckel är ett fält i en tabell som unikt identifierar varje rad / post i en databastabell.

Använd detta attribut för att åsidosätta standard Code-First-konventionen . Om den tillämpas på en egenskap, kommer den att användas som den primära nyckelkolumnen för denna klass.

using System.ComponentModel.DataAnnotations;

public class Person
{
    [Key]
    public int PersonKey { get; set; }        // <- will be used as primary key
     
    public string PersonName { get; set; }    
}

Om en sammansatt primärnyckel krävs kan attributet [Nyckel] också läggas till flera egenskaper. Ordningen på kolumnerna i den sammansatta nyckeln måste anges i formen [ Nyckel, kolumn (ordning = x)] .

using System.ComponentModel.DataAnnotations;

public class Person
{
    [Key, Column(Order = 0)]
    public int PersonKey1 { get; set; }    // <- will be used as part of the primary key

    [Key, Column(Order = 1)]
    public int PersonKey2 { get; set; }    // <- will be used as part of the primary key
     
    public string PersonName { get; set; }    
}

Utan att [Key] -attributet kommer EntityFramework att falla tillbaka till standardkonventionen som är att använda egenskapen för klassen som en primär nyckel som heter "Id" eller "{ClassName} Id".

public class Person
{
    public int PersonID { get; set; }        // <- will be used as primary key
     
    public string PersonName { get; set; }    
}

[Obligatoriskt] attribut

När den tillämpas på en egenskap i en domänklass kommer databasen att skapa en INTE NULL-kolumn.

using System.ComponentModel.DataAnnotations;

public class Person
{
    public int PersonID { get; set; }
    
    [Required]
    public string PersonName { get; set; }    
}

Den resulterande kolumnen med INTE NULL-begränsningen:

Obs: Det kan också användas med asp.net-mvc som ett valideringsattribut.

[MaxLength] och [MinLength] attribut

Attributet [MaxLength (int)] kan tillämpas på en sträng- eller array-egenskap i en domänklass. Entity Framework ställer in storleken på en kolumn till det angivna värdet.

using System.ComponentModel.DataAnnotations;

public class Person
{
    public int PersonID { get; set; }
    
    [MinLength(3), MaxLength(100)]
    public string PersonName { get; set; }    
}

Den resulterande kolumnen med den angivna kolumnlängden:

[MinLength (int)] -attribut är ett valideringsattribut, det påverkar inte databasstrukturen. Om vi försöker infoga / uppdatera en person med personnamn med längd mindre än 3 tecken, kommer detta åtagande att misslyckas. Vi får en DbUpdateConcurrencyException som vi måste hantera.

using (var db = new ApplicationDbContext())
{                    
     db.Staff.Add(new Person() { PersonName = "ng" });
     try
     {
          db.SaveChanges();
     }
     catch (DbEntityValidationException ex)
     {
          //ErrorMessage = "The field PersonName must be a string or array type with a minimum length of '3'."
     }
}

Både [MaxLength] och [MinLength] -attribut kan också användas med asp.net-mvc som ett valideringsattribut.

[Range (min, max)] attribut

Anger ett numeriskt minimum- och maxintervall för en egenskap

using System.ComponentModel.DataAnnotations;   

public partial class Enrollment
{
    public int EnrollmentID { get; set; }
   
    [Range(0, 4)]
    public Nullable<decimal> Grade { get; set; }
}

Om vi försöker infoga / uppdatera ett betyg med värde utanför räckvidden, misslyckas detta åtagande. Vi får en DbUpdateConcurrencyException som vi måste hantera.

using (var db = new ApplicationDbContext())
{
    db.Enrollments.Add(new Enrollment() { Grade = 1000 });

    try
    {
        db.SaveChanges();
    }
    catch (DbEntityValidationException ex)
    {
        // Validation failed for one or more entities
    }
}

Det kan också användas med asp.net-mvc som ett valideringsattribut.

Resultat:

[DatabaseGenerated] attribut

Anger hur databasen genererar värden för egenskapen. Det finns tre möjliga värden:

1. None anger att värdena inte genereras av databasen.
2. Identity anger att kolumnen är en identitetskolumn , som vanligtvis används för heltal för primära nycklar.
3. Computed anger att databasen genererar värdet för kolumnen.

Om värdet är något annat än None kommer Entity Framework inte att göra ändringar gjorda på egenskapen tillbaka till databasen.

Som standard (baserat på StoreGeneratedIdentityKeyConvention ) StoreGeneratedIdentityKeyConvention en heltalsknappegenskap som en identitetskolumn. För att åsidosätta denna konvention och tvinga den att behandlas som en icke-identitetskolumn kan du använda attributen DatabaseGenerated med värdet None .

using System.ComponentModel.DataAnnotations.Schema;

public class Foo
{
    [Key]
    public int Id { get; set; } // identity (auto-increment) column
}

public class Bar
{
    [Key]
    [DatabaseGenerated(DatabaseGeneratedOption.None)]
    public int Id { get; set; } // non-identity column
}

Följande SQL skapar en tabell med en beräknad kolumn:

CREATE TABLE [Person] (
    Name varchar(100) PRIMARY KEY,
    DateOfBirth Date NOT NULL,
    Age AS DATEDIFF(year, DateOfBirth, GETDATE())
)
GO

För att skapa en enhet för att representera posterna i tabellen ovan, måste du använda attributet DatabaseGenerated med ett värde på Computed .

[Table("Person")]
public class Person
{
    [Key, StringLength(100)]
    public string Name { get; set; }
    public DateTime DateOfBirth { get; set; }
    [DatabaseGenerated(DatabaseGeneratedOption.Computed)]
    public int Age { get; set; }
}

[NotMapped] attribut

Genom Code-First-konvention skapar Entity Framework en kolumn för varje offentlig egendom som är av en datatyp som stöds och har både en getter och en setter. Anteckningen [NotMapped] måste tillämpas på alla egenskaper som vi INTE vill ha en kolumn i en databastabell för.

Ett exempel på en egenskap som vi kanske inte vill lagra i databasen är studentens fulla namn baserat på deras för- och efternamn. Det kan beräknas i farten och det finns inget behov av att lagra det i databasen.

public string FullName => string.Format("{0} {1}", FirstName, LastName);

Egenskapen "FullName" har bara en getter och ingen setter, så som standard kommer Entity Framework INTE att skapa en kolumn för den.

Ett annat exempel på en egenskap som vi kanske inte vill lagra i databasen är studentens "AverageGrade". Vi vill inte få genomsnittsgraden på begäran; istället kan vi ha en rutin någon annanstans som beräknar den.

[NotMapped]
public float AverageGrade { set; get; }

"AverageGrade" måste markeras [NotMapped] -anteckningen, annars skapar Entity Framework en kolumn för den.

using System.ComponentModel.DataAnnotations.Schema;

public class Student
{
    public int Id { set; get; }

    public string FirstName { set; get; }

    public string LastName { set; get; }

    public string FullName => string.Format("{0} {1}", FirstName, LastName);

    [NotMapped]
    public float AverageGrade { set; get; }
}

För ovanstående DbMigration.cs kommer vi att se inuti DbMigration.cs

CreateTable(
    "dbo.Students",
     c => new
         {
             Id = c.Int(nullable: false, identity: true),
             FirstName = c.String(),
             LastName = c.String(),
         })
     .PrimaryKey(t => t.Id);

och i SQL Server Management Studio

[Tabell] attribut

[Table("People")]
public class Person
{
    public int PersonID { get; set; }
    public string PersonName { get; set; }    
}

Berättar enhetens ramverk för att använda ett specifikt tabellnamn istället för att generera ett (dvs. Person eller Persons )

Vi kan också ange ett schema för tabellen med attributet [Tabell]

[Table("People", Schema = "domain")]

[Kolumn] attribut

public class Person
{
    public int PersonID { get; set; }
    
    [Column("NameOfPerson")]
    public string PersonName { get; set; }    
}

Berättar enhetsram för att använda ett specifikt kolumnnamn istället med egenskapens namn. Du kan också ange databasdatatypen och kolumnens ordning i tabellen:

[Column("NameOfPerson", TypeName = "varchar", Order = 1)]
public string PersonName { get; set; }    

[Index] attribut

public class Person
{
    public int PersonID { get; set; }
    public string PersonName { get; set; }

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

Skapar ett databasindex för en kolumn eller uppsättning kolumner.

[Index("IX_Person_Age")]
public int Age { get; set; }

Detta skapar ett index med ett specifikt namn.

[Index(IsUnique = true)]
public int Age { get; set; }

Detta skapar ett unikt index.

[Index("IX_Person_NameAndAge", 1)]
public int Age { get; set; }

[Index("IX_Person_NameAndAge", 2)]
public string PersonName { get; set; }

Detta skapar ett sammansatt index med två kolumner. För att göra detta måste du ange samma indexnamn och ange en kolumnordning.

Obs : Indexattributet introducerades i Entity Framework 6.1. Om du använder en tidigare version gäller inte informationen i det här avsnittet.

[ForeignKey (string)] attribut

Anger anpassat utländskt nyckelnamn om en utländsk nyckel som inte följer EFs konvention önskas.

public class Person 
{
    public int IdAddress { get; set; }

    [ForeignKey(nameof(IdAddress))]
    public virtual Address HomeAddress { get; set; }
}

Detta kan också användas när du har flera relationer till samma entitetstyp.

using System.ComponentModel.DataAnnotations.Schema;

public class Customer
{
    ...

    public int MailingAddressID { get; set; }
    public int BillingAddressID { get; set; }

    [ForeignKey("MailingAddressID")]
    public virtual Address MailingAddress { get; set; }
    [ForeignKey("BillingAddressID")]
    public virtual Address BillingAddress { get; set; }
}

Utan ForeignKey attributen kan EF få dem blandade och använda värdet på BillingAddressID när man hämtar MailingAddress , eller så kan det bara komma med ett annat namn på kolumnen baserat på sina egna namnkonventioner (som Address_MailingAddress_Id ) och försöka använda det istället (vilket skulle resultera i ett fel om du använder detta med en befintlig databas).

[StringLength (int)] attribut

using System.ComponentModel.DataAnnotations;

public class Post
{
    public int Id { get; set; }
    
    [StringLength(100)]
    public string Title { get; set;}

    [StringLength(300)]
    public string Abstract { get; set; }
    
    public string Description { get; set; }
}

Definierar en maximal längd för ett strängfält.

Obs : Det kan också användas med asp.net-mvc som ett valideringsattribut.

[Tidsstämpel] attribut

[TimeStamp] -attributet kan endast tillämpas på en byte-array-egenskap i en viss entitetsklass. Entity Framework skapar en icke-nullable tidsstämpelkolumn i databastabellen för den egenskapen. Entity Framework kommer automatiskt att använda denna TimeStamp-kolumn i samtidighetskontroll.

using System.ComponentModel.DataAnnotations.Schema;

public class Student
{
    public int Id { set; get; }

    public string FirstName { set; get; }

    public string LastName { set; get; }    

    [Timestamp]
    public byte[] RowVersion { get; set; }
}

[ConcurrencyCheck] Attribut

Detta attribut tillämpas på klassegenskapen. Du kan använda attributet ConcurrencyCheck när du vill använda befintliga kolumner för samtidighetskontroll och inte en separat kolumn för tidsstämpel för samtidighet.

using System.ComponentModel.DataAnnotations;

public class Author
{
    public int AuthorId { get; set; }
     
    [ConcurrencyCheck]
    public string AuthorName { get; set; }
}

Från exemplet ovan tillämpas attributet ConcurrencyCheck på egenskapen AuthorName i författarklassen. Så Code-First kommer att inkludera författarnamn-kolumnen i uppdateringskommandot (där klausul) för att kontrollera för optimistisk samtidighet.

[InverseProperty (string)] attribut

using System.ComponentModel.DataAnnotations.Schema;

public class Department  
{  
    ...

    public virtual ICollection<Employee> PrimaryEmployees { get; set; }  
    public virtual ICollection<Employee> SecondaryEmployees { get; set; }  
}  
  
public class Employee  
{  
    ...

    [InverseProperty("PrimaryEmployees")]  
    public virtual Department PrimaryDepartment { get; set; }  
  
    [InverseProperty("SecondaryEmployees")]  
    public virtual Department SecondaryDepartment { get; set; }  
}  

InverseProperty kan användas för att identifiera två sätt relationer när flera tvåvägs relationer existerar mellan två enheter.

Den berättar för Entity Framework vilka navigationsegenskaper den ska matcha med egenskaper på andra sidan.

Entity Framework vet inte vilken navigationsegenskapskarta med vilka egenskaper på andra sidan när flera dubbelriktade relationer finns mellan två enheter.

Den behöver namnet på motsvarande navigationsegenskap i den relaterade klassen som dess parameter.

Detta kan också användas för enheter som har en relation till andra enheter av samma typ och bildar en rekursiv relation.

using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;

public class TreeNode
{
    [Key]
    public int ID { get; set; }
    public int ParentID { get; set; }

    ...

    [ForeignKey("ParentID")]
    public TreeNode ParentNode { get; set; }
    [InverseProperty("ParentNode")]
    public virtual ICollection<TreeNode> ChildNodes { get; set; }
}

Notera också användningen av ForeignKey attributet för att ange kolumnen som används för den utländska nyckeln i tabellen. I det första exemplet kunde de två egenskaperna i klassen Employee ha haft attributet ForeignKey tillämpat för att definiera kolumnnamnen.

[ComplexType] -attribut

using System.ComponentModel.DataAnnotations.Schema;

[ComplexType] 
public class BlogDetails 
{ 
    public DateTime? DateCreated { get; set; } 
 
    [MaxLength(250)] 
    public string Description { get; set; } 
}

public class Blog
{
    ...

    public BlogDetails BlogDetail { get; set; }
}

Markera klassen som komplex typ i Entity Framework.

Komplexa typer (eller värdeföremål i domändriven design) kan inte spåras på egen hand men de spåras som en del av en enhet. Det är därför BlogDetails i exemplet inte har en nyckelegenskap.

De kan vara användbara när du beskriver domänenheter mellan flera klasser och lägger dessa klasser till en komplett enhet.