Code First Data AnnotationsCode First Data Annotations

Hinweis

EF 4.1 und höher: die Features, APIs usw., die auf dieser Seite erläutert wurden, wurden in Entity Framework 4,1 eingeführt.EF4.1 Onwards Only - The features, APIs, etc. discussed in this page were introduced in Entity Framework 4.1. Wenn Sie eine frühere Version verwenden, sind einige oder alle dieser Informationen nicht anwendbar.If you are using an earlier version, some or all of this information does not apply.

Der Inhalt auf dieser Seite wird von einem Artikel angepasst, der ursprünglich von Julie Lerman () geschrieben wurde <http://thedatafarm.com> .The content on this page is adapted from an article originally written by Julie Lerman (<http://thedatafarm.com>).

Entity Framework Code First ermöglicht Ihnen die Verwendung ihrer eigenen Domänen Klassen, um das Modell darzustellen, das EF zum Ausführen von Abfragen, Änderungs Nachverfolgung und Aktualisierungs Funktionen verwendet.Entity Framework Code First allows you to use your own domain classes to represent the model that EF relies on to perform querying, change tracking, and updating functions. Code First nutzt ein Programmier Muster, das als "Konvention over Configuration" bezeichnet wird.Code First leverages a programming pattern referred to as 'convention over configuration.' Code First geht davon aus, dass die Klassen den Konventionen Entity Framework entsprechen und in diesem Fall automatisch herausfinden, wie der Auftrag ausgeführt wird.Code First will assume that your classes follow the conventions of Entity Framework, and in that case, will automatically work out how to perform its job. Wenn Ihre Klassen diesen Konventionen jedoch nicht folgen, können Sie Ihren Klassen Konfigurationen hinzufügen, um EF die erforderlichen Informationen bereitzustellen.However, if your classes do not follow those conventions, you have the ability to add configurations to your classes to provide EF with the requisite information.

Code First bietet Ihnen zwei Möglichkeiten, diese Konfigurationen ihren Klassen hinzuzufügen.Code First gives you two ways to add these configurations to your classes. Eine Methode verwendet einfache Attribute namens DataAnnotations, die zweite verwendet die fließende API Code First, die Ihnen eine Möglichkeit bietet, Konfigurationen im Code Imperativ zu beschreiben.One is using simple attributes called DataAnnotations, and the second is using Code First’s Fluent API, which provides you with a way to describe configurations imperatively, in code.

Der Schwerpunkt dieses Artikels liegt auf der Verwendung von DataAnnotations (im Namespace System. ComponentModel. DataAnnotations) zum Konfigurieren der Klassen – Hervorhebung der am häufigsten benötigten Konfigurationen.This article will focus on using DataAnnotations (in the System.ComponentModel.DataAnnotations namespace) to configure your classes – highlighting the most commonly needed configurations. DataAnnotations werden auch von einer Reihe von .NET-Anwendungen, wie z. b. ASP.NET MVC, interpretiert, sodass diese Anwendungen die gleichen Anmerkungen für Client seitige Überprüfungen nutzen können.DataAnnotations are also understood by a number of .NET applications, such as ASP.NET MVC which allows these applications to leverage the same annotations for client-side validations.

Die Model-KomponenteThe model

Ich zeige Ihnen Code First DataAnnotations mit einem einfachen paar von Klassen: Blog und Post.I’ll demonstrate Code First DataAnnotations with a simple pair of classes: Blog and Post.

    public class Blog
    {
        public int Id { get; set; }
        public string Title { get; set; }
        public string BloggerName { get; set;}
        public virtual ICollection<Post> Posts { get; set; }
    }

    public class Post
    {
        public int Id { get; set; }
        public string Title { get; set; }
        public DateTime DateCreated { get; set; }
        public string Content { get; set; }
        public int BlogId { get; set; }
        public ICollection<Comment> Comments { get; set; }
    }

Wie Sie sind, befolgen die Blog-und Post-Klassen die Code First-Konvention und erfordern keine Anpassungen, um die EF-Kompatibilität zu ermöglichen.As they are, the Blog and Post classes conveniently follow code first convention and require no tweaks to enable EF compatability. Allerdings können Sie mit den Anmerkungen auch weitere Informationen zu den Klassen und der Datenbank, denen Sie zugeordnet sind, für EF bereitstellen.However, you can also use the annotations to provide more information to EF about the classes and the database to which they map.

 

SchlüsselKey

Entity Framework stützt sich auf jede Entität, die einen Schlüsselwert aufweist, der für die Entitäts Verfolgung verwendet wird.Entity Framework relies on every entity having a key value that is used for entity tracking. Eine Code First Konvention sind implizite Schlüsseleigenschaften. Code First suchen nach einer Eigenschaft mit dem Namen "ID" oder einer Kombination aus Klassenname und ID, z. b. "BlogId".One convention of Code First is implicit key properties; Code First will look for a property named “Id”, or a combination of class name and “Id”, such as “BlogId”. Diese Eigenschaft wird einer Primärschlüssel Spalte in der Datenbank zugeordnet.This property will map to a primary key column in the database.

Die Blog-und Post-Klassen befolgen diese Konvention.The Blog and Post classes both follow this convention. Was geschieht, wenn Sie nicht?What if they didn’t? Was passiert, wenn der Blog stattdessen den Namen primarytrackingkey oder sogar fooverwendet hat?What if Blog used the name PrimaryTrackingKey instead, or even foo? Wenn Code First keine Eigenschaft findet, die dieser Konvention entspricht, löst er eine Ausnahme aus, da die Anforderung des Entity Framework eine Schlüsseleigenschaft aufweisen muss.If code first does not find a property that matches this convention it will throw an exception because of Entity Framework’s requirement that you must have a key property. Sie können die Schlüssel Anmerkung verwenden, um anzugeben, welche Eigenschaft als EntityKey verwendet werden soll.You can use the key annotation to specify which property is to be used as the EntityKey.

    public class Blog
    {
        [Key]
        public int PrimaryTrackingKey { get; set; }
        public string Title { get; set; }
        public string BloggerName { get; set;}
        public virtual ICollection<Post> Posts { get; set; }
    }

Wenn Sie das Feature zur Datenbankgenerierung von Code First verwenden, verfügt die Tabelle "Blog" über eine Primärschlüssel Spalte mit dem Namen "primarytrackingkey", die standardmäßig auch als Identität definiert ist.If you are using code first’s database generation feature, the Blog table will have a primary key column named PrimaryTrackingKey, which is also defined as Identity by default.

Blog Tabelle mit Primärschlüssel

Zusammengesetzte SchlüsselComposite keys

Entity Framework unterstützt zusammengesetzte Schlüssel-Primärschlüssel, die aus mehr als einer Eigenschaft bestehen.Entity Framework supports composite keys - primary keys that consist of more than one property. Beispielsweise können Sie über eine Passport-Klasse verfügen, deren Primärschlüssel eine Kombination aus Passport Number und issuingcountry ist.For example, you could have a Passport class whose primary key is a combination of PassportNumber and IssuingCountry.

    public class Passport
    {
        [Key]
        public int PassportNumber { get; set; }
        [Key]
        public string IssuingCountry { get; set; }
        public DateTime Issued { get; set; }
        public DateTime Expires { get; set; }
    }

Wenn Sie versuchen, die oben genannte Klasse in Ihrem EF-Modell zu verwenden, ergibt sich Folgendes InvalidOperationException :Attempting to use the above class in your EF model would result in an InvalidOperationException:

Die zusammengesetzte Primärschlüssel Anordnung für den Typ "Passport" kann nicht bestimmt werden. Verwenden Sie die ColumnAttribute-Methode oder die Haskey-Methode, um eine Reihenfolge für zusammengesetzte Primärschlüssel anzugeben.Unable to determine composite primary key ordering for type 'Passport'. Use the ColumnAttribute or the HasKey method to specify an order for composite primary keys.

Um zusammengesetzte Schlüssel verwenden zu können, müssen Entity Framework eine Reihenfolge für die Schlüsseleigenschaften definieren.In order to use composite keys, Entity Framework requires you to define an order for the key properties. Hierfür können Sie mithilfe der Spalten Anmerkung eine Bestellung angeben.You can do this by using the Column annotation to specify an order.

Hinweis

Der ORDER-Wert ist relativ (nicht Index basiert), sodass alle Werte verwendet werden können.The order value is relative (rather than index based) so any values can be used. Beispielsweise sind 100 und 200 anstelle von 1 und 2 zulässig.For example, 100 and 200 would be acceptable in place of 1 and 2.

    public class Passport
    {
        [Key]
        [Column(Order=1)]
        public int PassportNumber { get; set; }
        [Key]
        [Column(Order = 2)]
        public string IssuingCountry { get; set; }
        public DateTime Issued { get; set; }
        public DateTime Expires { get; set; }
    }

Wenn Sie über Entitäten mit zusammengesetzten Fremdschlüsseln verfügen, müssen Sie die gleiche Spalten Reihenfolge angeben, die Sie für die entsprechenden Primärschlüssel Eigenschaften verwendet haben.If you have entities with composite foreign keys, then you must specify the same column ordering that you used for the corresponding primary key properties.

Nur die relative Reihenfolge in den Fremdschlüssel Eigenschaften muss identisch sein. die genauen Werte, die der Bestellung zugewiesen sind, müssen nicht übereinstimmen.Only the relative ordering within the foreign key properties needs to be the same, the exact values assigned to Order do not need to match. In der folgenden Klasse können z. b. 3 und 4 anstelle von 1 und 2 verwendet werden.For example, in the following class, 3 and 4 could be used in place of 1 and 2.

    public class PassportStamp
    {
        [Key]
        public int StampId { get; set; }
        public DateTime Stamped { get; set; }
        public string StampingCountry { get; set; }

        [ForeignKey("Passport")]
        [Column(Order = 1)]
        public int PassportNumber { get; set; }

        [ForeignKey("Passport")]
        [Column(Order = 2)]
        public string IssuingCountry { get; set; }

        public Passport Passport { get; set; }
    }

ErforderlichRequired

Die- Required Anmerkung weist EF an, dass eine bestimmte Eigenschaft erforderlich ist.The Required annotation tells EF that a particular property is required.

Durch das Hinzufügen von erforderlich für die Title-Eigenschaft wird EF (und MVC) gezwungen, sicherzustellen, dass die Eigenschaft über Daten verfügt.Adding Required to the Title property will force EF (and MVC) to ensure that the property has data in it.

    [Required]
    public string Title { get; set; }

Ohne zusätzlichen Code oder Markup Änderungen in der Anwendung führt eine MVC-Anwendung eine Client seitige Validierung durch, wobei eine Nachricht auch dynamisch mit den Namen der Eigenschaft und der Anmerkung erstellt wird.With no additional code or markup changes in the application, an MVC application will perform client side validation, even dynamically building a message using the property and annotation names.

Fehler beim Erstellen einer Seite mit dem Titel "erforderlich".

Das erforderliche Attribut wirkt sich auch auf die generierte Datenbank aus, indem die zugeordnete Eigenschaft nicht auf NULL festgelegt werden kann.The Required attribute will also affect the generated database by making the mapped property non-nullable. Beachten Sie, dass sich das Feld "Title" in "not NULL" geändert hat.Notice that the Title field has changed to “not null”.

Hinweis

In einigen Fällen ist es möglicherweise nicht möglich, dass die Spalte in der Datenbank keine NULL-Werte zulässt, auch wenn die-Eigenschaft erforderlich ist.In some cases it may not be possible for the column in the database to be non-nullable even though the property is required. Wenn z. b. eine TPH-Vererbungs Strategie verwendet wird, werden Daten für mehrere Typen in einer einzelnen Tabelle gespeichert.For example, when using a TPH inheritance strategy data for multiple types is stored in a single table. Wenn ein abgeleiteter Typ eine erforderliche Eigenschaft enthält, kann die Spalte nicht auf NULL festleg Bare Werte festgelegt werden, da nicht alle Typen in der Hierarchie über diese Eigenschaft verfügen.If a derived type includes a required property the column cannot be made non-nullable since not all types in the hierarchy will have this property.

 

Tabelle "Blogs"

 

MaxLength und minLengthMaxLength and MinLength

MaxLengthMit dem-Attribut und dem- MinLength Attribut können Sie zusätzliche Eigenschaften Überprüfungen angeben, wie Sie dies durchgeführt haben Required .The MaxLength and MinLength attributes allow you to specify additional property validations, just as you did with Required.

Im folgenden finden Sie den Blog Name mit Längen Anforderungen.Here is the BloggerName with length requirements. Das Beispiel veranschaulicht auch das Kombinieren von Attributen.The example also demonstrates how to combine attributes.

    [MaxLength(10),MinLength(5)]
    public string BloggerName { get; set; }

Die MaxLength-Anmerkung wirkt sich auf die Datenbank aus, indem die Länge der Eigenschaft auf 10 festgelegt wird.The MaxLength annotation will impact the database by setting the property’s length to 10.

Tabelle "Blogs" mit der maximalen Länge für die bloggername-Spalte

Bei der Client seitigen MVC-Anmerkung und der serverseitigen EF 4,1-Anmerkung wird diese Validierung berücksichtigt, und es wird erneut dynamisch eine Fehlermeldung erstellt: "das Feld" bloggername "muss eine Zeichenfolge oder ein Arraytyp mit einer maximalen Länge von" 10 "sein. Diese Nachricht ist ein wenig lang.MVC client-side annotation and EF 4.1 server-side annotation will both honor this validation, again dynamically building an error message: “The field BloggerName must be a string or array type with a maximum length of '10'.” That message is a little long. Viele Anmerkungen ermöglichen es Ihnen, eine Fehlermeldung mit dem ErrorMessage-Attribut anzugeben.Many annotations let you specify an error message with the ErrorMessage attribute.

    [MaxLength(10, ErrorMessage="BloggerName must be 10 characters or less"),MinLength(5)]
    public string BloggerName { get; set; }

Sie können auch ErrorMessage in der erforderlichen Anmerkung angeben.You can also specify ErrorMessage in the Required annotation.

Seite mit benutzerdefinierter Fehlermeldung erstellen

 

Nicht zugeordnetNotMapped

Die Code First-Konvention legt fest, dass jede Eigenschaft mit einem unterstützten Datentyp in der Datenbank dargestellt wird.Code first convention dictates that every property that is of a supported data type is represented in the database. Dies ist jedoch nicht immer der Fall in Ihren Anwendungen.But this isn’t always the case in your applications. Beispielsweise könnten Sie über eine Eigenschaft in der Blog-Klasse verfügen, die einen Code auf Grundlage der Felder Titel und bloggername erstellt.For example you might have a property in the Blog class that creates a code based on the Title and BloggerName fields. Diese Eigenschaft kann dynamisch erstellt werden und muss nicht gespeichert werden.That property can be created dynamically and does not need to be stored. Sie können alle Eigenschaften, die nicht der Datenbank zugeordnet sind, mit der Anmerkung "notmapping" markieren, z. b. diese blogcode-Eigenschaft.You can mark any properties that do not map to the database with the NotMapped annotation such as this BlogCode property.

    [NotMapped]
    public string BlogCode
    {
        get
        {
            return Title.Substring(0, 1) + ":" + BloggerName.Substring(0, 1);
        }
    }

 

ComplexTypeComplexType

Es ist nicht ungewöhnlich, dass Sie Ihre Domänen Entitäten über einen Satz von Klassen hinweg beschreiben und dann diese Klassen auf die Beschreibung einer kompletten Entität umschichten.It’s not uncommon to describe your domain entities across a set of classes and then layer those classes to describe a complete entity. Beispielsweise können Sie dem Modell eine Klasse mit dem Namen blogdetails hinzufügen.For example, you may add a class called BlogDetails to your model.

    public class BlogDetails
    {
        public DateTime? DateCreated { get; set; }

        [MaxLength(250)]
        public string Description { get; set; }
    }

Beachten Sie, dass keinen BlogDetails Typ von Schlüsseleigenschaft hat.Notice that BlogDetails does not have any type of key property. Im Domänen gestützten Design BlogDetails wird als Wertobjekt bezeichnet.In domain driven design, BlogDetails is referred to as a value object. Entity Framework bezieht sich auf Wert Objekte als komplexe Typen.Entity Framework refers to value objects as complex types.Komplexe Typen können nicht selbst nachverfolgt werden.  Complex types cannot be tracked on their own.

Als Eigenschaft in der- Blog Klasse wird jedoch BlogDetails als Teil eines-Objekts nachverfolgt Blog .However as a property in the Blog class, BlogDetails will be tracked as part of a Blog object. Damit Code zuerst dies erkennt, müssen Sie die BlogDetails Klasse als markieren ComplexType .In order for code first to recognize this, you must mark the BlogDetails class as a ComplexType.

    [ComplexType]
    public class BlogDetails
    {
        public DateTime? DateCreated { get; set; }

        [MaxLength(250)]
        public string Description { get; set; }
    }

Nun können Sie in der-Klasse eine Eigenschaft hinzufügen Blog , die BlogDetails für diesen Blog darstellt.Now you can add a property in the Blog class to represent the BlogDetails for that blog.

        public BlogDetails BlogDetail { get; set; }

In der-Datenbank Blog enthält die Tabelle alle Eigenschaften des Blogs einschließlich der Eigenschaften, die in der-Eigenschaft enthalten sind BlogDetail .In the database, the Blog table will contain all of the properties of the blog including the properties contained in its BlogDetail property. Standardmäßig wird jedem der Name des komplexen Typs "blogdetail" vorangestellt.By default, each one is preceded with the name of the complex type, "BlogDetail".

Blog Tabelle mit komplexem Typ

ConcurrencyCheckConcurrencyCheck

Mit der-Anmerkung ConcurrencyCheck können Sie eine oder mehrere Eigenschaften markieren, die für die Parallelitäts Überprüfung in der Datenbank verwendet werden sollen, wenn ein Benutzer eine Entität bearbeitet oder löscht.The ConcurrencyCheck annotation allows you to flag one or more properties to be used for concurrency checking in the database when a user edits or deletes an entity. Wenn Sie mit dem EF-Designer gearbeitet haben, entspricht dies dem Festlegen der Eigenschaft ConcurrencyMode auf Fixed .If you've been working with the EF Designer, this aligns with setting a property's ConcurrencyMode to Fixed.

Sehen wir uns ConcurrencyCheck an, wie funktioniert, indem es der-Eigenschaft hinzugefügt wird BloggerName .Let’s see how ConcurrencyCheck works by adding it to the BloggerName property.

    [ConcurrencyCheck, MaxLength(10, ErrorMessage="BloggerName must be 10 characters or less"),MinLength(5)]
    public string BloggerName { get; set; }

Wenn SaveChanges aufgerufen wird, ConcurrencyCheck BloggerName wird der ursprüngliche Wert dieser Eigenschaft in der Aktualisierung verwendet, aufgrund der-Anmerkung für das Feld.When SaveChanges is called, because of the ConcurrencyCheck annotation on the BloggerName field, the original value of that property will be used in the update. Der Befehl versucht, die richtige Zeile zu suchen, indem nicht nur der Schlüsselwert, sondern auch der ursprüngliche Wert von gefiltert wird BloggerName .The command will attempt to locate the correct row by filtering not only on the key value but also on the original value of BloggerName.Hier sind die wichtigen Teile des Update-Befehls, die an die Datenbank gesendet werden. in diesem Fall können Sie sehen, dass der Befehl die Zeile mit dem PrimaryTrackingKey Wert "1" und BloggerName "Julie" aktualisiert. Dies war der ursprüngliche Wert, als dieser Blog aus der Datenbank abgerufen wurde.  Here are the critical parts of the UPDATE command sent to the database, where you can see the command will update the row that has a PrimaryTrackingKey is 1 and a BloggerName of “Julie” which was the original value when that blog was retrieved from the database.

    where (([PrimaryTrackingKey] = @4) and ([BloggerName] = @5))
    @4=1,@5=N'Julie'

Wenn jemand den Blogger-Namen für diesen Blog in der Zwischenzeit geändert hat, schlägt dieses Update fehl, und Sie erhalten eine dbupdatecon-cyexception , die Sie behandeln müssen.If someone has changed the blogger name for that blog in the meantime, this update will fail and you’ll get a DbUpdateConcurrencyException that you'll need to handle.

 

TimeStampTimeStamp

Es ist häufiger, rowversion-oder Zeitstempel-Felder für die Parallelitäts Überprüfung zu verwenden.It's more common to use rowversion or timestamp fields for concurrency checking. Anstatt die-Anmerkung ConcurrencyCheck zu verwenden, können Sie jedoch die spezifischere Anmerkung verwenden, solange TimeStamp der Typ der Eigenschaft ein Bytearray ist.But rather than using the ConcurrencyCheck annotation, you can use the more specific TimeStamp annotation as long as the type of the property is byte array. Code First behandelt Timestamp Eigenschaften wie ConcurrencyCheck Eigenschaften, aber es wird auch sichergestellt, dass das Datenbankfeld, das von Code First generiert wird, keine NULL-Werte zulässt.Code first will treat Timestamp properties the same as ConcurrencyCheck properties, but it will also ensure that the database field that code first generates is non-nullable. In einer bestimmten Klasse kann nur eine Zeitstempel-Eigenschaft vorhanden sein.You can only have one timestamp property in a given class.

Fügen Sie der Blog-Klasse die folgende Eigenschaft hinzu:Adding the following property to the Blog class:

    [Timestamp]
    public Byte[] TimeStamp { get; set; }

führt dazu, dass Code zuerst in der Datenbanktabelle eine Zeitstempel-Spalte erstellt, die keine NULL-Werte zulässt.results in code first creating a non-nullable timestamp column in the database table.

Tabelle "Blogs" mit Zeitstempel Spalte

 

Tabelle und SpalteTable and Column

Wenn Sie Code First die Datenbank erstellen möchten, können Sie den Namen der zu erstellenden Tabellen und Spalten ändern.If you are letting Code First create the database, you may want to change the name of the tables and columns it is creating. Sie können auch Code First mit einer vorhandenen Datenbank verwenden.You can also use Code First with an existing database. Es ist jedoch nicht immer der Fall, dass die Namen der Klassen und Eigenschaften in der Domäne den Namen der Tabellen und Spalten in der Datenbank entsprechen.But it's not always the case that the names of the classes and properties in your domain match the names of the tables and columns in your database.

Meine Klasse wird benannt Blog , und Code First geht davon aus, dass dies einer Tabelle mit dem Namen zugeordnet wird Blogs .My class is named Blog and by convention, code first presumes this will map to a table named Blogs. Wenn dies nicht der Fall ist, können Sie den Namen der Tabelle mit dem- Table Attribut angeben.If that's not the case you can specify the name of the table with the Table attribute. In diesem Beispiel gibt die-Anmerkung an, dass der Tabellenname internalblogsist.Here for example, the annotation is specifying that the table name is InternalBlogs.

    [Table("InternalBlogs")]
    public class Blog

Die-Anmerkung Column ist eine bessere Angabe der Attribute einer zugeordneten Spalte.The Column annotation is a more adept in specifying the attributes of a mapped column. Sie können einen Namen, einen Datentyp oder sogar die Reihenfolge festlegen, in der eine Spalte in der Tabelle angezeigt wird.You can stipulate a name, data type or even the order in which a column appears in the table. Im folgenden finden Sie ein Beispiel für das- Column Attribut.Here is an example of the Column attribute.

    [Column("BlogDescription", TypeName="ntext")]
    public String Description {get;set;}

Verwechseln Sie TypeName das Attribut der Spalte nicht mit dem DataType-DataAnnotation.Don’t confuse Column’s TypeName attribute with the DataType DataAnnotation. DataType ist eine Anmerkung, die für die Benutzeroberfläche verwendet wird, und wird von Code First ignoriert.DataType is an annotation used for the UI and is ignored by Code First.

Dies ist die Tabelle, nachdem Sie neu generiert wurde.Here is the table after it’s been regenerated. Der Tabellenname wurde in internalblogs geändert, und Description die Spalte aus dem komplexen Typ lautet jetzt BlogDescription .The table name has changed to InternalBlogs and Description column from the complex type is now BlogDescription. Da der Name in der-Anmerkung angegeben wurde, verwendet Code First nicht die Konvention zum Starten des Spaltennamens mit dem Namen des komplexen Typs.Because the name was specified in the annotation, code first will not use the convention of starting the column name with the name of the complex type.

Umbenannte Blogs-Tabelle und-Spalte

 

DatabasegeneratedDatabaseGenerated

Wichtige Datenbankfunktionen sind die Möglichkeit, berechnete Eigenschaften zu haben.An important database features is the ability to have computed properties. Wenn Sie die Code First Klassen Tabellen zuordnet, die berechnete Spalten enthalten, möchten Sie Entity Framework nicht versuchen, diese Spalten zu aktualisieren.If you're mapping your Code First classes to tables that contain computed columns, you don't want Entity Framework to try to update those columns. Sie möchten jedoch, dass EF diese Werte aus der Datenbank zurückgibt, nachdem Sie Daten eingefügt oder aktualisiert haben.But you do want EF to return those values from the database after you've inserted or updated data. Mit der-Anmerkung können Sie DatabaseGenerated diese Eigenschaften in der-Klasse zusammen mit der-Enumeration markieren Computed .You can use the DatabaseGenerated annotation to flag those properties in your class along with the Computed enum. Andere Aufstände sind None und Identity .Other enums are None and Identity.

    [DatabaseGenerated(DatabaseGeneratedOption.Computed)]
    public DateTime DateCreated { get; set; }

Sie können eine Datenbank verwenden, die für Byte-oder Zeitstempel-Spalten generiert wird, wenn Code First die Datenbank generiert. andernfalls sollten Sie diese nur verwenden, wenn Sie auf vorhandene Datenbanken verweisen, da Code First die Formel für die berechnete Spalte nicht ermitteln kann.You can use database generated on byte or timestamp columns when code first is generating the database, otherwise you should only use this when pointing to existing databases because code first won't be able to determine the formula for the computed column.

Sie haben darüber hinaus gelesen, dass eine Schlüsseleigenschaft, die eine ganze Zahl ist, standardmäßig ein Identitätsschlüssel in der Datenbank wird.You read above that by default, a key property that is an integer will become an identity key in the database. Das wäre dasselbe wie das Festlegen DatabaseGenerated von auf DatabaseGeneratedOption.Identity .That would be the same as setting DatabaseGenerated to DatabaseGeneratedOption.Identity. Wenn Sie nicht möchten, dass es sich um einen Identitätsschlüssel handelt, können Sie den Wert auf festlegen DatabaseGeneratedOption.None .If you do not want it to be an identity key, you can set the value to DatabaseGeneratedOption.None.

 

IndexIndex

Hinweis

Nur EF 6.1 : das Index Attribut wurde in Entity Framework 6,1 eingeführt.EF6.1 Onwards Only - The Index attribute was introduced in Entity Framework 6.1. Wenn Sie eine frühere Version verwenden, gelten die Informationen in diesem Abschnitt nicht.If you are using an earlier version the information in this section does not apply.

Mithilfe von Indexattributekönnen Sie einen Index für eine oder mehrere Spalten erstellen.You can create an index on one or more columns using the IndexAttribute. Das Hinzufügen des-Attributs zu einer oder mehreren Eigenschaften bewirkt, dass EF den entsprechenden Index in der Datenbank erstellt, wenn die Datenbank erstellt wird, oder ein Gerüst für die entsprechenden Aufrufe von " anateindex " erstellt, wenn Sie Code First-Migrationen verwenden.Adding the attribute to one or more properties will cause EF to create the corresponding index in the database when it creates the database, or scaffold the corresponding CreateIndex calls if you are using Code First Migrations.

Der folgende Code führt z. b. dazu, dass ein Index für die- Rating Spalte der- Posts Tabelle in der-Datenbank erstellt wird.For example, the following code will result in an index being created on the Rating column of the Posts table in the database.

    public class Post
    {
        public int Id { get; set; }
        public string Title { get; set; }
        public string Content { get; set; }
        [Index]
        public int Rating { get; set; }
        public int BlogId { get; set; }
    }

Standardmäßig erhält der Index den Namen " **IX _ < Property Name > ** " (IX- _ Bewertung im obigen Beispiel).By default, the index will be named IX_<property name> (IX_Rating in the above example). Sie können jedoch auch einen Namen für den Index angeben.You can also specify a name for the index though. Im folgenden Beispiel wird angegeben, dass der Index benannt werden soll PostRatingIndex .The following example specifies that the index should be named PostRatingIndex.

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

Standardmäßig sind Indizes nicht eindeutig, Sie können jedoch den IsUnique benannten Parameter verwenden, um anzugeben, dass ein Index eindeutig sein muss.By default, indexes are non-unique, but you can use the IsUnique named parameter to specify that an index should be unique. Im folgenden Beispiel wird ein eindeutiger Index für User den Anmelde Namen eines s eingeführt.The following example introduces a unique index on a User's login name.

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

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

        public string DisplayName { get; set; }
    }

Multiple-Column IndizesMultiple-Column Indexes

Indizes, die sich über mehrere Spalten erstrecken, werden mit dem gleichen Namen in mehreren Index Anmerkungen für eine bestimmte Tabelle angegeben.Indexes that span multiple columns are specified by using the same name in multiple Index annotations for a given table. Wenn Sie mehrspaltige Indizes erstellen, müssen Sie eine Reihenfolge für die Spalten im Index angeben.When you create multi-column indexes, you need to specify an order for the columns in the index. Der folgende Code erstellt z. b. einen mehrspaltigen Index für Rating und den BlogId Namen " IX _ blogidandrating".For example, the following code creates a multi-column index on Rating and BlogId called IX_BlogIdAndRating. BlogId ist die erste Spalte im Index und Rating ist die zweite.BlogId is the first column in the index and Rating is the second.

    public class Post
    {
        public int Id { get; set; }
        public string Title { get; set; }
        public string Content { get; set; }
        [Index("IX_BlogIdAndRating", 2)]
        public int Rating { get; set; }
        [Index("IX_BlogIdAndRating", 1)]
        public int BlogId { get; set; }
    }

 

Beziehungs Attribute: invergenproperty und FremdschlüsselRelationship Attributes: InverseProperty and ForeignKey

Hinweis

Diese Seite enthält Informationen zum Einrichten von Beziehungen in Ihrem Code First-Modell mithilfe von Daten Anmerkungen.This page provides information about setting up relationships in your Code First model using Data Annotations. Allgemeine Informationen zu Beziehungen in EF und zum Zugreifen auf und Bearbeiten von Daten mithilfe von Beziehungen finden Sie unter Beziehungen & Navigations Eigenschaften. *For general information about relationships in EF and how to access and manipulate data using relationships, see Relationships & Navigation Properties.*

Die Code First-Konvention kümmert sich um die gängigsten Beziehungen in Ihrem Modell. es gibt jedoch einige Fälle, in denen Sie Hilfe benötigen.Code first convention will take care of the most common relationships in your model, but there are some cases where it needs help.

Wenn Sie den Namen der Schlüsseleigenschaft in der Blog Klasse ändern, wurde ein Problem mit der Beziehung zu hergestellt Post .Changing the name of the key property in the Blog class created a problem with its relationship to Post. 

Beim Erstellen der Datenbank wird von Code zuerst die BlogId -Eigenschaft in der Post-Klasse angezeigt, und Sie wird von der Konvention erkannt, dass Sie mit einem Klassennamen Plus IDals Fremdschlüssel für die-Klasse übereinstimmt Blog .When generating the database, code first sees the BlogId property in the Post class and recognizes it, by the convention that it matches a class name plus Id, as a foreign key to the Blog class. In der Blog-Klasse gibt es jedoch keine- BlogId Eigenschaft.But there is no BlogId property in the blog class. Die Lösung hierfür ist das Erstellen einer Navigations Eigenschaft im Post und die Verwendung der ForeignKey DataAnnotation, um Code zuerst zu helfen, zu verstehen, wie die Beziehung zwischen den beiden Klassen erstellt wird (mithilfe der- Post.BlogId Eigenschaft) und wie Einschränkungen in der Datenbank angegeben werden.The solution for this is to create a navigation property in the Post and use the ForeignKey DataAnnotation to help code first understand how to build the relationship between the two classes (using the Post.BlogId property) as well as how to specify constraints in the database.

    public class Post
    {
            public int Id { get; set; }
            public string Title { get; set; }
            public DateTime DateCreated { get; set; }
            public string Content { get; set; }
            public int BlogId { get; set; }
            [ForeignKey("BlogId")]
            public Blog Blog { get; set; }
            public ICollection<Comment> Comments { get; set; }
    }

Die-Einschränkung in der-Datenbank zeigt eine Beziehung zwischen InternalBlogs.PrimaryTrackingKey und Posts.BlogId .The constraint in the database shows a relationship between InternalBlogs.PrimaryTrackingKey and Posts.BlogId. 

Beziehung zwischen internalblogs. primarytrackingkey und Posts. BlogId

InversePropertyWird verwendet, wenn mehrere Beziehungen zwischen Klassen vorhanden sind.The InverseProperty is used when you have multiple relationships between classes.

In der- Post Klasse sollten Sie nachverfolgen können, wer einen Blogbeitrag geschrieben hat und wer ihn bearbeitet hat.In the Post class, you may want to keep track of who wrote a blog post as well as who edited it. Hier sind zwei neue Navigations Eigenschaften für die Post-Klasse.Here are two new navigation properties for the Post class.

    public Person CreatedBy { get; set; }
    public Person UpdatedBy { get; set; }

Sie müssen auch in der-Klasse hinzufügen, auf die Person von diesen Eigenschaften verwiesen wird.You’ll also need to add in the Person class referenced by these properties. Die Person -Klasse verfügt über Navigations Eigenschaften zurück zum Post , eine für alle von der Person geschriebenen Beiträge und eine für alle von dieser Person aktualisierten Beiträge.The Person class has navigation properties back to the Post, one for all of the posts written by the person and one for all of the posts updated by that person.

    public class Person
    {
            public int Id { get; set; }
            public string Name { get; set; }
            public List<Post> PostsWritten { get; set; }
            public List<Post> PostsUpdated { get; set; }
    }

Code First kann die Eigenschaften in den beiden Klassen nicht alleine zuordnen.Code first is not able to match up the properties in the two classes on its own. Die Datenbanktabelle für Posts sollte über einen Fremdschlüssel für die CreatedBy Person und einen für die UpdatedBy Person verfügen, aber Code First erstellt vier Fremdschlüssel Eigenschaften: Person _ ID, Person _ Id1, kreatedby _ ID und updatedby _ ID.The database table for Posts should have one foreign key for the CreatedBy person and one for the UpdatedBy person but code first will create four foreign key properties: Person_Id, Person_Id1, CreatedBy_Id and UpdatedBy_Id.

Postet eine Tabelle mit zusätzlichen Fremdschlüsseln.

Um diese Probleme zu beheben, können Sie die-Anmerkung verwenden, InverseProperty um die Ausrichtung der Eigenschaften anzugeben.To fix these problems, you can use the InverseProperty annotation to specify the alignment of the properties.

    [InverseProperty("CreatedBy")]
    public List<Post> PostsWritten { get; set; }

    [InverseProperty("UpdatedBy")]
    public List<Post> PostsUpdated { get; set; }

Da die- PostsWritten Eigenschaft in Person weiß, dass dies auf den- Post Typ verweist, wird die Beziehung zu erstellt Post.CreatedBy .Because the PostsWritten property in Person knows that this refers to the Post type, it will build the relationship to Post.CreatedBy. Ebenso PostsUpdated wird eine Verbindung mit hergestellt Post.UpdatedBy .Similarly, PostsUpdated will be connected to Post.UpdatedBy. Und Code First erstellt nicht die zusätzlichen Fremdschlüssel.And code first will not create the extra foreign keys.

Postet Tabelle ohne zusätzliche Fremdschlüssel

 

ZusammenfassungSummary

Mit DataAnnotations können Sie nicht nur die Client-und serverseitige Validierung in Ihren Code First-Klassen beschreiben, sondern Sie können auch die Annahmen, die Code First über Ihre Klassen auf der Grundlage seiner Konventionen treffen wird, verbessern und sogar korrigieren.DataAnnotations not only let you describe client and server side validation in your code first classes, but they also allow you to enhance and even correct the assumptions that code first will make about your classes based on its conventions. Mit DataAnnotations können Sie nicht nur die Generierung von Datenbankschemas steuern, sondern auch die Code First-Klassen einer bereits vorhandenen Datenbank zuordnen.With DataAnnotations you can not only drive database schema generation, but you can also map your code first classes to a pre-existing database.

Obwohl Sie sehr flexibel sind, beachten Sie, dass DataAnnotations nur die am häufigsten benötigten Konfigurationsänderungen bereitstellen, die Sie an Ihren Code First-Klassen vornehmen können.While they are very flexible, keep in mind that DataAnnotations provide only the most commonly needed configuration changes you can make on your code first classes. Um die Klassen für einige der edgefälle zu konfigurieren, sollten Sie sich den alternativen Konfigurations Mechanismus Code First der fließend-API ansehen.To configure your classes for some of the edge cases, you should look to the alternate configuration mechanism, Code First’s Fluent API .