CSDL-Spezifikation

Die konzeptionelle Schemadefinitionssprache (CSDL) ist eine XML-basierte Sprache, die die Entitäten, Beziehungen und Funktionen beschreibt, die ein konzeptionelles Modell einer datengesteuerten Anwendung bilden. Dieses konzeptionelle Modell kann vom Entity Framework oder WCF Data Services verwendet werden. Die Metadaten, die in CSDL beschrieben werden, werden von Entity Framework verwendet, um Entitäten und Beziehungen zuzuordnen, die in einem konzeptionellen Modell für eine Datenquelle definiert werden. Weitere Informationen finden Sie unter SSDL-Spezifikation und MSL-Spezifikation.

CSDL ist die Entity Framework-Implementierung des Entity Data Model.

In einer Entity Framework-Anwendung werden konzeptionelle Modellmetadaten aus einer CSDL-Datei (in CSDL geschrieben) in eine Instanz der System.Data.Metadata.Edm.EdmItemCollection geladen und können mithilfe von Methoden in der System.Data.Metadata.Edm.MetadataWorkspace-Klasse verwendet werden. Entity Framework verwendet Metadaten des konzeptionellen Modells, um Abfragen für das konzeptionelle Modell in datenquellenspezifische Befehle zu übersetzen.

Der EF Designer speichert konzeptionelle Modellinformationen zur Entwurfszeit in einer EDMX-Datei. Zur Erstellungszeit verwendet der Entity Designer die in einer EDMX-Datei gespeicherten Informationen, um die SSDL-Datei zu erstellen, die zur Laufzeit vom Entity Framework benötigt wird.

Die verschiedenen Versionen von CSDL werden von XML-Namespaces unterschieden.

CSDL-Version	XML-Namespace
CSDL v1	https://schemas.microsoft.com/ado/2006/04/edm
CSDL v2	https://schemas.microsoft.com/ado/2008/09/edm
CSDL v3	https://schemas.microsoft.com/ado/2009/11/edm

 

Zuordnungselement (CSDL)

Ein Association-Element definiert eine Beziehung zwischen zwei Entitätstypen. Eine Zuordnung muss die Entitätstypen, die in der Beziehung enthalten sind, und die mögliche Anzahl von Entitätstypen an den Enden der Beziehung angeben, die auch als Multiplizität bezeichnet wird. Die Multiplizität eines Zuordnungsendes kann über einen Wert von eins (1), null oder eins (0..1) oder n (*) verfügen. Diese Informationen werden in zwei untergeordneten End-Elementen angegeben.

Auf Entitätstypinstanzen an einem Ende einer Zuordnung kann über Navigationseigenschaften oder Fremdschlüssel zugegriffen werden, sofern sie für einen Entitätstyp verfügbar gemacht werden.

In einer Anwendung stellt eine Instanz einer Zuordnung eine bestimmte Zuordnung zwischen Instanzen von Entitätstypen dar. Zuordnungsinstanzen werden logisch in einem Zuordnungssatz gruppiert.

Das Association-Element kann die folgenden untergeordneten Elemente aufweisen (der vorliegenden Reihenfolge entsprechend):

• Dokumentation (kein oder ein Element)
• Ende (genau 2 Elemente)
• ReferentialConstraint (kein oder ein Element)
• Anmerkungselemente (kein oder mehrere Elemente)

Anwendbare Attribute

In der folgenden Tabelle werden die Attribute beschrieben, die für das Association-Element übernommen werden können.

Attributname	Ist erforderlich	Wert
Name	Ja	Der Name der Zuordnung.

 

 

Beispiel

Das folgende Beispiel zeigt ein Association-Element, das die Zuordnung CustomerOrders definiert, wenn Fremdschlüssel für die Customer- und Order-Entitätstypen nicht verfügbar gemacht wurden. Die Multiplikationswerte für jedes Ende der Zuordnung geben an, dass viele Bestellungen einem Kundenzugeordnet werden können, aber nur ein Kunde kann einer Bestellung zugeordnet werden. Darüber hinaus gibt das OnDelete-Element an, dass alle Bestellungen, die mit einem bestimmten Kunden zusammenhängen und in den ObjectContext geladen wurden, gelöscht werden, wenn der Kunde gelöscht wird.

 <Association Name="CustomerOrders">
   <End Type="ExampleModel.Customer" Role="Customer" Multiplicity="1" >
         <OnDelete Action="Cascade" />
   </End>
   <End Type="ExampleModel.Order" Role="Order" Multiplicity="*" />
 </Association>

 

Das folgende Beispiel zeigt ein Association-Element, das die CustomerOrders-Zuordnung definiert, wenn Fremdschlüssel für die Customer- und Order-Entitätstypen verfügbar gemacht wurden. Bei verfügbar gemachten Fremdschlüsseln wird die Beziehung zwischen den Entitäten mit einem ReferentialConstraint-Element verwaltet. Ein entsprechendes AssociationSetMapping-Element ist zur Zuordnung dieser Zuweisung zur Datenquelle nicht erforderlich.

 <Association Name="CustomerOrders">
   <End Type="ExampleModel.Customer" Role="Customer" Multiplicity="1" >
         <OnDelete Action="Cascade" />
   </End>
   <End Type="ExampleModel.Order" Role="Order" Multiplicity="*" />
   <ReferentialConstraint>
        <Principal Role="Customer">
            <PropertyRef Name="Id" />
        </Principal>
        <Dependent Role="Order">
             <PropertyRef Name="CustomerId" />
         </Dependent>
   </ReferentialConstraint>
 </Association>

 

 

AssociationSet-Element (CSDL)

Das AssociationSet-Element in der konzeptionellen Schemadefinitionssprache (CSDL) ist ein logischer Container für Zuordnungsinstanzen desselben Typs. Ein Zuordnungssatz stellt eine Definition zum Gruppieren von Zuordnungsinstanzen bereit, sodass sie einer Datenquelle zugeordnet werden können.  

Ein AssociationSet-Element kann die folgenden untergeordneten Elemente aufweisen (der vorliegenden Reihenfolge entsprechend):

• Dokumentation (kein oder ein Element zugelassen)
• Ende (genau zwei Elemente erforderlich)
• Anmerkungselemente (kein oder mehrere Elemente zugelassen)

Das Association-Attribut gibt den Zuordnungstyp an, den ein Zuordnungssatz enthält. Die Entitätssätze, welche die Enden eines Zuordnungssatzes bilden, werden genau mit zwei untergeordneten End-Elementen angegeben.

Anwendbare Attribute

In der folgenden Tabelle werden die Attribute beschrieben, die für das AssociationSet-Element übernommen werden können.

Attributname	Ist erforderlich	Wert
Name	Ja	Der Name des Entitätssatzes. Der Wert des Name-Attributs darf nicht mit dem Wert des Association-Attributs übereinstimmen.
Zuordnung	Ja	Der vollqualifizierte Name der Zuordnung, von der der Zuordnungssatz Instanzen enthält. Die Zuordnung muss sich im gleichen Namespace wie der Zuordnungssatz befinden.

 

 

Beispiel

Das folgende Beispiel zeigt ein EntityContainer-Element mit zwei AssociationSet-Elementen:

 <EntityContainer Name="BooksContainer" >
   <EntitySet Name="Books" EntityType="BooksModel.Book" />
   <EntitySet Name="Publishers" EntityType="BooksModel.Publisher" />
   <EntitySet Name="Authors" EntityType="BooksModel.Author" />
   <AssociationSet Name="PublishedBy" Association="BooksModel.PublishedBy">
     <End Role="Book" EntitySet="Books" />
     <End Role="Publisher" EntitySet="Publishers" />
   </AssociationSet>
   <AssociationSet Name="WrittenBy" Association="BooksModel.WrittenBy">
     <End Role="Book" EntitySet="Books" />
     <End Role="Author" EntitySet="Authors" />
   </AssociationSet>
 </EntityContainer>

 

 

CollectionType-Element (CSDL)

Das CollectionType-Element in konzeptioneller Schemadefinitionssprache (CSDL) gibt an, dass ein Funktionsparameter oder ein Funktionsrückgabetyp eine Auflistung ist. Das CollectionType-Element kann ein untergeordnetes Element des Parameter-Elements oder des ReturnType (Function)-Elements sein. Der Typ der Auflistung kann entweder mit dem Type-Attribut oder einem der folgenden untergeordneten Elemente angegeben werden:

• CollectionType
• ReferenceType
• RowType
• TypeRef

 

Anwendbare Attribute

In der folgenden Tabelle werden die Attribute beschrieben, die auf das CollectionType-Element angewendet werden können. Beachten Sie, dass die Attribute DefaultValue, MaxLength, FixedLength, Precision, Scale, Unicode und Collation nur für Auflistungen von EDMSimpleTypes gelten.

Attributname	Ist erforderlich	Wert
Typ	Nein	Der Typ der Auflistung.
NULL zulassen	Nein	True (Standardwert) oder False abhängig davon, ob die Eigenschaft einen NULL-Wert haben kann. [!NOTE]
> In der CSDL v1 muss eine komplexe Typeigenschaft Nullable="False" aufweisen.
DefaultValue	Nein	Der Standardwert der Eigenschaft.
MaxLength	Nein	Maximale Länge des Eigenschaftswerts.
FixedLength	Nein	Wahr oder Falsch, abhängig davon, ob der Eigenschaftswert als Zeichenfolge mit fester Länge gespeichert wird.
Genauigkeit	Nein	Die Genauigkeit des Eigenschaftswerts.
Skalierung	Nein	Die Skalierung des Eigenschaftswerts.
SRID	Nein	Referenzbezeichner des räumlichen Systems. Gilt nur für Eigenschaften räumlicher Typen.   Weitere Informationen finden Sie unter SRID und SRID (SQL Server)
Unicode	Nein	Wahr oder Falsch, abhängig davon, ob der Eigenschaftswert als Unicode-Zeichenfolge gespeichert wird.
Sortierung	Nein	Eine Zeichenfolge, die angibt, welche Sortierreihenfolge in der Datenquelle verwendet wird.

 

 

Beispiel

Das folgende Beispiel zeigt eine modelldefinierte Funktion, die mithilfe eines CollectionType-Elements angibt, dass die Funktion eine Auflistung von Person-Entitätstypen (wie mit dem ElementType-Attribut angegeben) zurückgibt.

 <Function Name="LastNamesAfter">
        <Parameter Name="someString" Type="Edm.String"/>
        <ReturnType>
             <CollectionType  ElementType="SchoolModel.Person"/>
        </ReturnType>
        <DefiningExpression>
             SELECT VALUE p
             FROM SchoolEntities.People AS p
             WHERE p.LastName >= someString
        </DefiningExpression>
 </Function>

 

Das folgende Beispiel zeigt eine modelldefinierte Funktion, die mithilfe eines CollectionType-Elements angibt, dass die Funktion eine Auflistung von Zeilen (wie im RowType-Element angegeben) zurückgeben soll.

 <Function Name="LastNamesAfter">
   <Parameter Name="someString" Type="Edm.String" />
   <ReturnType>
    <CollectionType>
      <RowType>
        <Property Name="FirstName" Type="Edm.String" Nullable="false" />
        <Property Name="LastName" Type="Edm.String" Nullable="false" />
      </RowType>
    </CollectionType>
   </ReturnType>
   <DefiningExpression>
             SELECT VALUE ROW(p.FirstName, p.LastName)
             FROM SchoolEntities.People AS p
             WHERE p.LastName &gt;= somestring
   </DefiningExpression>
 </Function>

 

Das folgende Beispiel zeigt eine modelldefinierte Funktion, die mithilfe des CollectionType-Elements angibt, dass die Funktion eine Auflistung von Department-Entitätstypen als Parameter akzeptiert.

 <Function Name="GetAvgBudget">
      <Parameter Name="Departments">
          <CollectionType>
             <TypeRef Type="SchoolModel.Department"/>
          </CollectionType>
           </Parameter>
       <ReturnType Type="Collection(Edm.Decimal)"/>
       <DefiningExpression>
             SELECT VALUE AVG(d.Budget) FROM Departments AS d
       </DefiningExpression>
 </Function>

 

 

ComplexType-Element (CSDL)

Ein ComplexType-Element definiert eine Datenstruktur, die aus EdmSimpleType-Eigenschaften oder anderen komplexen Typen besteht.  Ein komplexer Typ kann eine Eigenschaft eines Entitätstyps oder eines anderen komplexen Typs sein. Ein komplexer Typ entspricht einem Entitätstyp, in dem von einem komplexen Typ Daten definiert werden. Es gibt jedoch einige Hauptunterschiede zwischen komplexen Typen und Entitätstypen:

• Komplexe Typen weisen keine Identitäten (oder Schlüssel) auf und können daher nicht unabhängig sein. Komplexe Typen können nur Eigenschaften von Entitätstypen oder anderen komplexen Typen sein.
• Komplexe Typen können nicht Teil von Zuordnungen sein. Die Enden einer Zuordnung können kein komplexer Typ sein, daher können Navigationseigenschaften nicht für komplexe Typen definiert werden.
• Einer komplexen Typeigenschaft kann kein NULL-Wert zugewiesen werden, obwohl jede skalare Eigenschaft eines komplexen Typs auf NULL festgelegt werden kann.

Ein ComplexType-Element kann die folgenden untergeordneten Elemente beinhalten (in entsprechender Reihenfolge aufgelistet):

• Dokumentation (kein oder ein Element)
• Eigenschaft (kein oder mehr Elemente)
• Anmerkungselemente (kein oder mehrere Elemente)

In der folgenden Tabelle werden die Attribute beschrieben, die für das ComplexType-Element übernommen werden können.

Attributname	Ist erforderlich	Wert
Name	Ja	Der Name des komplexen Typs. Der Name eines komplexen Typs darf nicht dem Namen anderer komplexer Typen, Entitätstypen oder Zuordnungen entsprechen, die sich innerhalb des Bereichs des Modells befinden.
BaseType	Nein	Der Name eines anderen komplexen Typs, der der Basistyp des zu definierenden komplexen Typs ist. [!NOTE]
> Dieses Attribut ist in CSDL v1 nicht anwendbar. Für komplexe Typen wird Vererbung in dieser Version nicht unterstützt.
Zusammenfassung	Nein	(Der Standardwert) Wahr oder Falsch, ist abhängig davon, ob der komplexe Typ ein abstrakter Typ ist oder nicht. [!NOTE]
> Dieses Attribut ist in CSDL v1 nicht anwendbar. Komplexe Typen in dieser Version können keine abstrakten Typen sein.

 

 

Beispiel

Das folgende Beispiel zeigt einen komplexen Typ, Address, mit den EdmSimpleType-Eigenschaften StreetAddress, City, StateOrProvince, Country und PostalCode.

 <ComplexType Name="Address" >
   <Property Type="String" Name="StreetAddress" Nullable="false" />
   <Property Type="String" Name="City" Nullable="false" />
   <Property Type="String" Name="StateOrProvince" Nullable="false" />
   <Property Type="String" Name="Country" Nullable="false" />
   <Property Type="String" Name="PostalCode" Nullable="false" />
 </ComplexType>

 

Deklarieren Sie den Eigenschaftentyp Address in der Entitätstypdefinition, um den komplexen Typ (oben) als Eigenschaft eines Entitätstyps zu definieren. Das folgende Beispiel zeigt die Address-Eigenschaft als komplexen Typ für einen Entitätstyp (Publisher):

 <EntityType Name="Publisher">
       <Key>
         <PropertyRef Name="Id" />
       </Key>
       <Property Type="Int32" Name="Id" Nullable="false" />
       <Property Type="String" Name="Name" Nullable="false" />
       <Property Type="BooksModel.Address" Name="Address" Nullable="false" />
       <NavigationProperty Name="Books" Relationship="BooksModel.PublishedBy"
                           FromRole="Publisher" ToRole="Book" />
     </EntityType>

 

 

DefiningExpression-Element (CSDL)

Das DefineExpression-Element in der konzeptionellen Schemadefinitionssprache (CSDL) enthält einen Entity SQL-Ausdruck, der eine Funktion im konzeptionellen Modell definiert.  

 

Anwendbare Attribute

Eine beliebige Anzahl von Anmerkungsattributen (benutzerdefinierte XML-Attribute) kann für das DefiningExpression-Element übernommen werden. Benutzerdefinierte Attribute dürfen jedoch zu keinem XML-Namespace gehören, der für CSDL reserviert ist. Die vollqualifizierten Namen für zwei benutzerdefinierte Attribute dürfen nicht übereinstimmen.

Beispiel

Im folgenden Beispiel wird mithilfe eines DefiningExpression-Elements eine Funktion definiert, die den Zeitraum seit der Veröffentlichung eines Buchs in Jahren zurückgibt. Der Inhalt des DefiningExpression-Elements wird in Entity SQL geschrieben.

 <Function Name="GetYearsInPrint" ReturnType="Edm.Int32" >
       <Parameter Name="book" Type="BooksModel.Book" />
       <DefiningExpression>
         Year(CurrentDateTime()) - Year(cast(book.PublishedDate as DateTime))
       </DefiningExpression>
     </Function>

 

 

Dependent-Element (CSDL)

Das Dependent-Element in konzeptioneller Schemadefinitionssprache (CSDL) ist ein dem ReferentialConstraint-Element untergeordnetes Element und definiert das abhängige Ende einer referenziellen Einschränkung. Ein ReferentialConstraint-Element definiert Funktionen, die einer Einschränkung der referenziellen Integrität in einer relationalen Datenbank ähnlich sind. So wie eine Spalte (oder Spalten) einer Datenbanktabelle auf den Primärschlüssel einer anderen Tabelle verweisen kann, kann eine Eigenschaft (oder Eigenschaften) eines Entitätstyps auf den Entitätsschlüssel eines anderen Entitätstyps verweisen. Der Entitätstyp, auf den verwiesen wird, wird als Prinzipalende der Einschränkung bezeichnet. Der Entitätstyp, der auf das Prinzipalende verweist, wird als abhängiges Ende der Einschränkung bezeichnet. PropertyRef-Elemente werden verwendet, um anzugeben, welche Schlüssel auf das Prinzipalende verweisen.

Ein Dependent-Element kann die folgenden untergeordneten Elemente aufweisen (der vorliegenden Reihenfolge entsprechend):

• PropertyRef (ein oder mehrere Element)
• Anmerkungselemente (kein oder mehrere Elemente)

Anwendbare Attribute

In der folgenden Tabelle werden die Attribute beschrieben, die für das Dependent-Element übernommen werden können.

Attributname	Ist erforderlich	Wert
Rolle	Ja	Der Name des Entitätstyps am abhängigen Ende der Zuordnung.

 

 

Beispiel

Das folgende Beispiel zeigt ein ReferentialConstraint-Element, das als Teil der Definition der PublishedBy-Zuordnung verwendet wird. Die PublisherId-Eigenschaft des Entitätstyps Book stellt das abhängige Ende der referenziellen Einschränkung dar.

 <Association Name="PublishedBy">
   <End Type="BooksModel.Book" Role="Book" Multiplicity="*" >
   </End>
   <End Type="BooksModel.Publisher" Role="Publisher" Multiplicity="1" />
   <ReferentialConstraint>
     <Principal Role="Publisher">
       <PropertyRef Name="Id" />
     </Principal>
     <Dependent Role="Book">
       <PropertyRef Name="PublisherId" />
     </Dependent>
   </ReferentialConstraint>
 </Association>

 

 

Documentation-Element (CSDL)

Das Documentation-Element in konzeptioneller Schemadefinitionssprache (CSDL) kann verwendet werden, um Informationen zu einem Objekt bereitzustellen, das in einem übergeordneten Element definiert ist. Ist in einer EDMX-Datei das Documentation-Element ein untergeordnetes Element eines anderen Elements, das als Objekt auf der Entwurfsoberfläche von EF Designer (z. B. als Entität, Zuordnung oder Eigenschaft) angezeigt wird, wird der Inhalt des Documentation-Elements im Properties-Fenster von Visual Studio für das Objekt angezeigt.

Ein Documentation-Element kann die folgenden untergeordneten Elemente aufweisen (der vorliegenden Reihenfolge entsprechend):

• Summary: eine kurze Beschreibung des übergeordneten Elements. (kein (Null) oder ein Element)
• LongDescription: Eine ausführliche Beschreibung des übergeordneten Elements. (kein (Null) oder ein Element)
• Anmerkungselemente. (keine (Null) oder mehrere Elemente)

Anwendbare Attribute

Eine beliebige Anzahl von Anmerkungsattributen (benutzerdefinierte XML-Attribute) kann für das Documentation-Element übernommen werden. Benutzerdefinierte Attribute dürfen jedoch zu keinem XML-Namespace gehören, der für CSDL reserviert ist. Die vollqualifizierten Namen für zwei benutzerdefinierte Attribute dürfen nicht übereinstimmen.

Beispiel

Das folgende Beispiel zeigt das Documentation-Element als untergeordnetes Element eines EntityType-Elements. Wenn sich der folgende Codeausschnitt im CSDL-Inhalt einer EDMX-Datei befindet, werden die Inhalte der Elemente Summary und LongDescription im Fenster Properties von Visual Studio angezeigt, wenn Sie auf den Entitätstyp Customer klicken.

 <EntityType Name="Customer">
    <Documentation>
      <Summary>Summary here.</Summary>
      <LongDescription>Long description here.</LongDescription>
    </Documentation>
    <Key>
      <PropertyRef Name="CustomerId" />
    </Key>
    <Property Type="Int32" Name="CustomerId" Nullable="false" />
    <Property Type="String" Name="Name" Nullable="false" />
 </EntityType>

 

 

End-Element (CSDL)

Das End-Element kann in konzeptioneller Schemadefinitionssprache (CSDL) ein untergeordnetes Element des Association-Elements oder des AssociationSet-Elements sein. In beiden Fällen unterscheiden sich die Rolle und die anwendbaren Attribute des End-Elements.

Das End-Element als untergeordnetes Objekt des Association-Elements

Ein End-Element (als untergeordnetes Element des Association-Elements) identifiziert an einem Ende einer Zuordnung den Entitätstyp und die Anzahl der Entitätstypinstanzen, die an diesem Ende einer Zuordnung existieren können. Zuordnungsenden werden als Teil einer Zuordnung definiert. Eine Zuordnung muss genau zwei Zuordnungsenden aufweisen. Auf Entitätstypinstanzen an einem Ende einer Zuordnung kann über Navigationseigenschaften oder Fremdschlüssel zugegriffen werden, sofern sie für einen Entitätstyp verfügbar gemacht werden.  

Ein End-Element kann die folgenden untergeordneten Elemente aufweisen (der vorliegenden Reihenfolge entsprechend):

• Dokumentation (kein oder ein Element)
• OnDelete (kein oder ein Element)
• Anmerkungselemente (kein oder mehrere Elemente)

Anwendbare Attribute

In der folgenden Tabelle werden die Attribute beschrieben, die für das End-Element übernommen werden können, wenn es sich dabei um das untergeordnete Element eines Association-Elements handelt.

Attributname	Ist erforderlich	Wert
Typ	Ja	Der Name des Entitätstyps an einem Ende der Zuordnung.
Rolle	Nein	Der Name für das Zuordnungsende. Wird kein Name angegeben, wird der Name des Entitätstyps am Zuordnungsende verwendet.
Multiplizität	Ja	1, 0..1 oder *, abhängig von der Anzahl der Entitätstypinstanzen am Ende der Zuordnung. 1 gibt an, dass genau eine Entitätstypinstanz am Zuordnungsende vorhanden ist. 0..1 gibt an, dass keine oder eine Entitätstypinstanz am Zuordnungsende vorhanden ist. * gibt an, dass keine, eine oder mehrere Entitätstypinstanz/en am Zuordnungsende vorhanden ist/sind.

 

 

Beispiel

Das folgende Beispiel zeigt ein Association-Element, das die CustomerOrders-Zuordnung definiert. Die Multiplikationswerte für jedes Ende der Zuordnung geben an, dass viele Bestellungen einem Kundenzugeordnet werden können, aber nur ein Kunde kann einer Bestellung zugeordnet werden. Darüber hinaus gibt das OnDelete-Element an, dass alle Orders, die mit einem bestimmten Customer zusammenhängen und in den ObjectContext geladen wurden, gelöscht werden, wenn der Customer gelöscht wird.

 <Association Name="CustomerOrders">
   <End Type="ExampleModel.Customer" Role="Customer" Multiplicity="1" />
   <End Type="ExampleModel.Order" Role="Order" Multiplicity="*">
         <OnDelete Action="Cascade" />
   </End>
 </Association>

 

Das End-Element als untergeordnetes Objekt des AssociationSet-Elements

Das End-Element gibt ein Ende des Zuordnungssatzes an. Das AssociationSet-Element muss zwei End-Elemente enthalten. Die in einem End-Element enthaltenen Informationen werden beim Zuordnen eines Zuordnungssatzes zu einer Datenquelle verwendet.

Ein End-Element kann die folgenden untergeordneten Elemente aufweisen (der vorliegenden Reihenfolge entsprechend):

• Dokumentation (kein oder ein Element)
• Anmerkungselemente (kein oder mehrere Elemente)

 

Anwendbare Attribute

In der folgenden Tabelle werden die Attribute beschrieben, die für das End-Element übernommen werden können, wenn es sich dabei um das untergeordnete Element eines AssociationSet-Elements handelt.

Attributname	Ist erforderlich	Wert
EntitySet	Ja	Der Name des EntitySet-Elements, das ein Ende des übergeordneten AssociationSet-Elements definiert. Das EntitySet-Element muss im gleichen Entitätscontainer wie das übergeordnete AssociationSet-Element definiert werden.
Rolle	Nein	Der Name des Endes des Zuordnungssatzes. Wird das Role-Attribut nicht verwendet, ist der Name des Zuordnungssatzendes der Name des Entitätssatzes.

 

 

Beispiel

Das folgende Beispiel zeigt ein EntityContainer-Element mit zwei AssociationSet-Elementen, jeweils mit zwei End-Elementen:

 <EntityContainer Name="BooksContainer" >
   <EntitySet Name="Books" EntityType="BooksModel.Book" />
   <EntitySet Name="Publishers" EntityType="BooksModel.Publisher" />
   <EntitySet Name="Authors" EntityType="BooksModel.Author" />
   <AssociationSet Name="PublishedBy" Association="BooksModel.PublishedBy">
     <End Role="Book" EntitySet="Books" />
     <End Role="Publisher" EntitySet="Publishers" />
   </AssociationSet>
   <AssociationSet Name="WrittenBy" Association="BooksModel.WrittenBy">
     <End Role="Book" EntitySet="Books" />
     <End Role="Author" EntitySet="Authors" />
   </AssociationSet>
 </EntityContainer>

 

 

EntityContainer-Element (CSDL)

Das EntityContainer-Element in konzeptioneller Schemadefinitionssprache (CSDL) ist ein logischer Container für Entitätssätze, Zuordnungssätze und Funktionsimporte. Durch das EntityContainerMapping-Element wird einem Speichermodell-Entitätscontainer ein konzeptioneller Modellentitätscontainer zugeordnet. Ein Speichermodell-Entitätscontainer beschreibt die Struktur der Datenbank: Entitätssätze beschreiben Tabellen, Zuordnungssätze beschreiben Fremdschlüsseleinschränkungen, und Funktionsimporte beschreiben gespeicherte Prozeduren in einer Datenbank.

Ein EntityContainer-Element kann kein oder ein Dokumentationselement aufweisen. Wenn ein Documentation-Element vorhanden ist, muss es allen EntitySet-, AssociationSet- und FunctionImport-Elementen vorangestellt sein.

Ein EntityContainer-Element kann über keines oder mehrere der folgenden untergeordneten Elemente verfügen (der vorliegenden Reihenfolge entsprechend):

• EntitySet
• AssociationSet
• FunctionImport
• Anmerkungselemente

Sie können ein EntityContainer-Element erweitern, um den Inhalt eines anderen EntityContainers einzuschließen, der sich im selben Namespace befindet. Um den Inhalt eines anderen EntityContainers einzuschließen, legen Sie im verweisenden EntityContainer-Element den Wert des Extends-Attributs auf den Namen des EntityContainer-Elements fest, das Sie einbeziehen möchten. Alle untergeordneten Elemente des enthaltenen EntityContainer-Elements werden als untergeordnete Elemente des verweisenden EntityContainer-Elements behandelt.

Anwendbare Attribute

In der folgenden Tabelle werden die Attribute beschrieben, die für das Using-Element übernommen werden können.

Attributname	Ist erforderlich	Wert
Name	Ja	Der Name des Entitätscontainers.
Extends	Nein	Der Name eines anderen Entitätscontainers innerhalb des gleichen Namespaces.

 

 

Beispiel

Im folgenden Beispiel wird ein EntityContainer-Element dargestellt, das drei Entitätenmengen und zwei Zuordnungssätze definiert.

 <EntityContainer Name="BooksContainer" >
   <EntitySet Name="Books" EntityType="BooksModel.Book" />
   <EntitySet Name="Publishers" EntityType="BooksModel.Publisher" />
   <EntitySet Name="Authors" EntityType="BooksModel.Author" />
   <AssociationSet Name="PublishedBy" Association="BooksModel.PublishedBy">
     <End Role="Book" EntitySet="Books" />
     <End Role="Publisher" EntitySet="Publishers" />
   </AssociationSet>
   <AssociationSet Name="WrittenBy" Association="BooksModel.WrittenBy">
     <End Role="Book" EntitySet="Books" />
     <End Role="Author" EntitySet="Authors" />
   </AssociationSet>
 </EntityContainer>

 

 

EntitySet-Element (CSDL)

Das EntitySet-Element in konzeptioneller Schemadefinitionssprache ist ein logischer Container für Instanzen eines Entitätstyps und Instanzen beliebiger von diesem Entitätstyp abgeleiteter Typen. Die Beziehung zwischen einem Entitätstyp und einem Entitätssatz ist zur Beziehung zwischen einer Zeile und einer Tabelle in einer relationalen Datenbank analog. Wie eine Zeile definiert ein Entitätstyp einen Satz verknüpfter Daten, und ebenso wie eine Tabelle enthält ein Entitätssatz Instanzen dieser Definition. Ein Entitätssatz stellt ein Konstrukt zum Gruppieren von Entitätstypinstanzen bereit, damit diese verwandten Datenstrukturen in einer Datenquelle zugeordnet werden können.  

Für einen bestimmten Entitätstyp kann mindestens ein Entitätssatz definiert werden.

 

Ein EntitySet-Element kann die folgenden untergeordneten Elemente beinhalten (in entsprechender Reihenfolge aufgelistet):

• Dokumentation (kein oder ein Element zugelassen)
• Anmerkungselemente (kein oder mehrere Elemente zugelassen)

Anwendbare Attribute

In der folgenden Tabelle werden die Attribute beschrieben, die für das EntitySet-Element übernommen werden können.

Attributname	Ist erforderlich	Wert
Name	Ja	Der Name des Entitätssatzes.
EntityType	Ja	Der vollqualifizierte Name des Entitätstyps, für den der Entitätssatz Instanzen enthält.

 

 

Beispiel

Das folgende Beispiel zeigt ein EntityContainer-Element mit drei EntitySet-Elementen:

 <EntityContainer Name="BooksContainer" >
   <EntitySet Name="Books" EntityType="BooksModel.Book" />
   <EntitySet Name="Publishers" EntityType="BooksModel.Publisher" />
   <EntitySet Name="Authors" EntityType="BooksModel.Author" />
   <AssociationSet Name="PublishedBy" Association="BooksModel.PublishedBy">
     <End Role="Book" EntitySet="Books" />
     <End Role="Publisher" EntitySet="Publishers" />
   </AssociationSet>
   <AssociationSet Name="WrittenBy" Association="BooksModel.WrittenBy">
     <End Role="Book" EntitySet="Books" />
     <End Role="Author" EntitySet="Authors" />
   </AssociationSet>
 </EntityContainer>

 

Pro Typ (MEST) können mehrere Entitätssätze definiert werden. Im folgenden Beispiel wird ein Entitätscontainer mit zwei Entitätssätzen für den Entitätstyp Book definiert:

 <EntityContainer Name="BooksContainer" >
   <EntitySet Name="Books" EntityType="BooksModel.Book" />
   <EntitySet Name="FictionBooks" EntityType="BooksModel.Book" />
   <EntitySet Name="Publishers" EntityType="BooksModel.Publisher" />
   <EntitySet Name="Authors" EntityType="BooksModel.Author" />
   <AssociationSet Name="PublishedBy" Association="BooksModel.PublishedBy">
     <End Role="Book" EntitySet="Books" />
     <End Role="Publisher" EntitySet="Publishers" />
   </AssociationSet>
   <AssociationSet Name="BookAuthor" Association="BooksModel.BookAuthor">
     <End Role="Book" EntitySet="Books" />
     <End Role="Author" EntitySet="Authors" />
   </AssociationSet>
 </EntityContainer>

 

 

EntityType-Element (CSDL)

Das EntityType-Element stellt in einem konzeptionellen Modell die Struktur eines Konzepts auf der obersten Ebene dar. Ein Entitätstyp ist eine Vorlage für Instanzen von Entitätstypen in einer Anwendung. Jede Vorlage enthält die folgenden Informationen:

• Eine eindeutige Bezeichnung. (Erforderlich.)
• Ein Entitätsschlüssel, der von einem oder mehreren Eigenschaften definiert wird. (Erforderlich.)
• Eigenschaften für enthaltene Daten. (Optional.)
• Navigationseigenschaften, die eine Navigation von einem Ende einer Zuordnung zum anderen Ende ermöglichen. (Optional.)

In einer Anwendung stellt eine Instanz eines Entitätstyps ein spezielles Objekt dar, wie etwa einen bestimmten Kunden oder eine Bestellung. Jede Instanz eines Entitätstyps muss über einen eindeutigen Entitätsschlüssel innerhalb einer Entitätsmenge verfügen.

Zwei Instanzen eines Entitätstyps werden nur dann als gleich betrachtet, wenn sie vom selben Typ sind und die Werte ihrer Entitätsschlüssel übereinstimmen.

Ein EntityType-Element kann die folgenden untergeordneten Elemente beinhalten (in entsprechender Reihenfolge aufgelistet):

• Dokumentation (kein oder ein Element)
• Key (kein oder ein Element)
• Eigenschaft (kein oder mehr Elemente)
• NavigationProperty (kein oder mehrere Elemente)
• Anmerkungselemente (kein oder mehrere Elemente)

Anwendbare Attribute

In der folgenden Tabelle werden die Attribute beschrieben, die für das EntityType-Element übernommen werden können.

Attributname	Ist erforderlich	Wert
Name	Ja	Der Name des Entitätstyps.
BaseType	Nein	Der Name eines anderen Entitätstyps, der der Basistyp des Entitätstyps ist, der definiert wird.
Abstract	Nein	Wahr oder Falsch, abhängig davon, ob der Entitätstyp ein abstrakter Typ ist.
OpenType	Nein	Wahr oder Falsch, abhängig davon, ob der Entitätstyp ein offener Entitätstyp ist. [!NOTE]
> Das OpenType-Attribut gilt nur für Entitätstypen, die in konzeptionellen Modellen definiert sind, die mit ADO.NET Data Services verwendet werden.

 

 

Beispiel

Das folgende Beispiel zeigt ein EntityType-Element mit drei Property- und zwei NavigationProperty-Elementen:

 <EntityType Name="Book">
   <Key>
     <PropertyRef Name="ISBN" />
   </Key>
   <Property Type="String" Name="ISBN" Nullable="false" />
   <Property Type="String" Name="Title" Nullable="false" />
   <Property Type="Decimal" Name="Revision" Nullable="false" Precision="29" Scale="29" />
   <NavigationProperty Name="Publisher" Relationship="BooksModel.PublishedBy"
                       FromRole="Book" ToRole="Publisher" />
   <NavigationProperty Name="Authors" Relationship="BooksModel.WrittenBy"
                       FromRole="Book" ToRole="Author" />
 </EntityType>

 

 

EnumType-Element (CSDL)

Das EnumType-Element stellt einen Aufzählungstyp dar.

Ein EnumType-Element kann die folgenden untergeordneten Elemente beinhalten (in entsprechender Reihenfolge aufgelistet):

• Dokumentation (kein oder ein Element)
• Member (kein oder mehrere Elemente)
• Anmerkungselemente (kein oder mehrere Elemente)

Anwendbare Attribute

In der folgenden Tabelle werden die Attribute beschrieben, die für das EnumType-Element übernommen werden können.

Attributname	Ist erforderlich	Wert
Name	Ja	Der Name des Entitätstyps.
IsFlags	Nein	Wahr oder Falsch, je nachdem, ob der Enumerationstyp als Satz von Flags verwendet werden kann. Der Standardwert ist Falsch.
UnderlyingType	Nein	Edm.Byte, Edm.Int16, Edm.Int32, Edm.Int64 oder Edm.SByte, der den Wertebereich des Typs definiert.   Der zugrunde liegende Standardtyp von Enumerationselementen ist Edm.Int32..

 

 

Beispiel

Das folgende Beispiel zeigt ein EnumType-Element mit drei Member-Elementen:

 <EnumType Name="Color" IsFlags=”false” UnderlyingTyp=”Edm.Byte”>
   <Member Name="Red" />
   <Member Name="Green" />
   <Member Name="Blue" />
 </EntityType>

 

 

Function-Element (CSDL)

Das Function-Element in konzeptioneller Schemadefinitionssprache (CSDL) wird verwendet, um Funktionen im konzeptionellen Modell zu definieren oder zu deklarieren. Eine Funktion wird mit einem DefiningExpression-Element definiert.  

Ein Function-Element kann die folgenden untergeordneten Elemente aufweisen (der vorliegenden Reihenfolge entsprechend):

• Dokumentation (kein oder ein Element)
• Parameter (kein oder mehrere Elemente)
• DefiningExpression (kein oder ein Element)
• ReturnType (Function) (kein oder ein Element)
• Anmerkungselemente (kein oder mehrere Elemente)

Ein Rückgabetyp für eine Funktion muss entweder mit dem ReturnType (Function)-Element oder dem ReturnType-Attribut (siehe unten) angegeben werden, aber nicht mit beiden. Die möglichen Rückgabetypen sind alle EdmSimpleType-Typen, Entitätstypen, komplexe Typen, Zeilentypen (oder eine Auflistung eines dieser Typen) oder Ref-Typen.

Anwendbare Attribute

In der folgenden Tabelle werden die Attribute beschrieben, die für das Function-Element übernommen werden können.

Attributname	Ist erforderlich	Wert
Name	Ja	Der Name der Funktion.
ReturnType	Nein	Der von der Funktion zurückgegebene Typ.

 

 

Beispiel

Im folgenden Beispiel wird mithilfe eines Function-Elements eine Funktion definiert, die den Zeitraum seit der Einstellung eines Kursleiters in Jahren zurückgibt.

 <Function Name="YearsSince" ReturnType="Edm.Int32">
   <Parameter Name="date" Type="Edm.DateTime" />
   <DefiningExpression>
     Year(CurrentDateTime()) - Year(date)
   </DefiningExpression>
 </Function>

 

 

FunctionImport-Element (CSDL)

Das FunctionImport-Element in konzeptioneller Schemadefinitionssprache (CSDL) stellt eine Funktion dar, die in der Datenquelle definiert wird, aber durch das konzeptionelle Modell für andere Objekte verfügbar ist. Ein Function-Element im Speichermodell kann z. B. verwendet werden, um eine gespeicherte Prozedur in einer Datenbank darzustellen. Ein FunctionImport-Element im konzeptionellen Modell stellt die entsprechende Funktion in einer Entity Framework-Anwendung dar und wird der Speichermodellfunktion mithilfe des FunctionImportMapping-Elements zugeordnet. Wird die Funktion in der Anwendung aufgerufen, wird die entsprechende gespeicherte Prozedur in der Datenbank ausgeführt.

Ein FunctionImport-Element kann die folgenden untergeordneten Elemente aufweisen (der vorliegenden Reihenfolge entsprechend):

• Dokumentation (kein oder ein Element zugelassen)
• Parameter (kein oder mehrere Elemente zugelassen)
• Anmerkungselemente (kein oder mehrere Elemente zugelassen)
• ReturnType (FunctionImport) (kein oder mehr zulässige Elemente)

Für jeden von der Funktion akzeptierten Parameter sollte ein Parameter-Element definiert werden.

Ein Rückgabetyp für eine Funktion muss entweder mit dem ReturnType-(FunctionImport)-Element oder dem ReturnType-Attribut (siehe unten) angegeben werden, aber nicht mit beiden. Der Rückgabetypwert muss eine Auflistung vom EdmSimpleType, EntityType oder ComplexType sein.

Anwendbare Attribute

In der folgenden Tabelle werden die Attribute beschrieben, die für das FunctionImport-Element übernommen werden können.

Attributname	Ist erforderlich	Wert
Name	Ja	Der Name der importierten Funktion.
ReturnType	Nein	Der Typ, den die Funktion zurückgibt. Verwenden Sie dieses Attribut nicht, wenn die Funktion keinen Wert zurückgibt. Andernfalls muss der Wert eine Auflistung von ComplexType, EntityType oder EDMSimpleType sein.
EntitySet	Nein	Wenn die Funktion eine Auflistung von Entitätstypen zurückgibt, muss der Wert für EntitySet der Entitätssatz sein, zu dem die Auflistung gehört. Andernfalls darf das Attribut EntitySet nicht verwendet werden.
IsComposable	Nein	Wenn der Wert auf wahr festgelegt ist, ist die Funktion schreibbar (Table-valued Function) und kann in einer LINQ-Abfrage verwendet werden.  Der Standardwert ist FALSE.

 

 

Beispiel

Das folgende Beispiel zeigt ein FunctionImport-Element, das einen Parameter akzeptiert und eine Auflistung von Entitätstypen zurückgibt:

 <FunctionImport Name="GetStudentGrades"
                 EntitySet="StudentGrade"
                 ReturnType="Collection(SchoolModel.StudentGrade)">
        <Parameter Name="StudentID" Mode="In" Type="Int32" />
 </FunctionImport>

 

 

Key-Element (CSDL)

Das Key-Element ist ein untergeordnetes Element des EntityType-Elements und definiert einen Entitätsschlüssel (eine Eigenschaft oder eine Gruppe von Eigenschaften eines Entitätstyps, der die Identität bestimmt). Die Eigenschaften, die einen Entitätsschlüssel bilden, werden zur Entwurfszeit ausgewählt. Die Werte von Entitätsschlüsseleigenschaften müssen zur Laufzeit eine Entitätstypinstanz innerhalb einer Entitätenmenge eindeutig identifizieren. Die Eigenschaften, die einen Entitätsschlüssel bilden, sollten so ausgewählt werden, dass die Eindeutigkeit von Instanzen in einem Entitätssatz gewährleistet ist. Das Key-Element definiert einen Entitätsschlüssel, indem es auf mindestens eine der Eigenschaften eines Entitätstyps verweist.

Das Key-Element kann die folgenden untergeordneten Elemente aufweisen:

• PropertyRef (ein oder mehrere Element)
• Anmerkungselemente (kein oder mehrere Elemente)

Anwendbare Attribute

Eine beliebige Anzahl von Anmerkungsattributen (benutzerdefinierte XML-Attribute) kann für das Key-Element übernommen werden. Benutzerdefinierte Attribute dürfen jedoch zu keinem XML-Namespace gehören, der für CSDL reserviert ist. Die vollqualifizierten Namen für zwei benutzerdefinierte Attribute dürfen nicht übereinstimmen.

Beispiel

Im folgenden Beispiel wird ein Entitätstyp mit dem Namen Book definiert. Der Entitätsschlüssel wird definiert, indem auf die ISBN-Eigenschaft des Entitätstyps verwiesen wird.

 <EntityType Name="Book">
   <Key>
     <PropertyRef Name="ISBN" />
   </Key>
   <Property Type="String" Name="ISBN" Nullable="false" />
   <Property Type="String" Name="Title" Nullable="false" />
   <Property Type="Decimal" Name="Revision" Nullable="false" Precision="29" Scale="29" />
   <NavigationProperty Name="Publisher" Relationship="BooksModel.PublishedBy"
                       FromRole="Book" ToRole="Publisher" />
   <NavigationProperty Name="Authors" Relationship="BooksModel.WrittenBy"
                       FromRole="Book" ToRole="Author" />
 </EntityType>

 

Die ISBN-Eigenschaft ist für den Entitätsschlüssel gut geeignet, da ein Buch durch die ISBN eindeutig identifiziert wird.

Das folgende Beispiel zeigt einen Entitätstyp (Author), dessen Entitätstyp aus zwei Eigenschaften, nämlich Name und Address besteht.

 <EntityType Name="Author">
   <Key>
     <PropertyRef Name="Name" />
     <PropertyRef Name="Address" />
   </Key>
   <Property Type="String" Name="Name" Nullable="false" />
   <Property Type="String" Name="Address" Nullable="false" />
   <NavigationProperty Name="Books" Relationship="BooksModel.WrittenBy"
                       FromRole="Author" ToRole="Book" />
 </EntityType>

 

Die Verwendung von Name und Address für den Entitätsschlüssel ist empfehlenswert, da zwei Autoren mit demselben Namen sehr wahrscheinlich nicht die gleiche Adresse besitzen. Dieser Entitätsschlüssel garantiert jedoch nicht absolut eindeutige Entitätsschlüssel in einem Entitätssatz. In diesem Fall wäre das Hinzufügen einer Eigenschaft wie AuthorId zur eindeutigen Identifikation eines Autors empfehlenswert.

 

Member-Element (CSDL)

Das Member-Element ist ein untergeordnetes Element des EnumType-Elements und definiert ein Element des Enumerationstyps.

Anwendbare Attribute

In der folgenden Tabelle werden die Attribute beschrieben, die für das FunctionImport-Element übernommen werden können.

Attributname	Ist erforderlich	Wert
Name	Ja	Der Name des Members.
Wert	Nein	Der Wert des Members. Der erste Enumerator hat standardmäßig den Wert 0. Der Wert jedes nachfolgenden Enumerators wird um 1 erhöht. Es können mehrere Member mit denselben Werten vorhanden sein.

 

 

Beispiel

Das folgende Beispiel zeigt ein EnumType-Element mit drei Member-Elementen:

 <EnumType Name="Color">
   <Member Name="Red" Value=”1”/>
   <Member Name="Green" Value=”3” />
   <Member Name="Blue" Value=”5”/>
 </EntityType>

 

 

NavigationProperty-Element (CSDL)

Ein NavigationProperty-Element definiert eine Navigationseigenschaft, die einen Verweis auf das andere Ende einer Zuordnung bereitstellt. Im Gegensatz zu mit dem Property-Element definierten Eigenschaften werden von Navigationseigenschaften Form und Eigenschaften von Daten nicht definiert. Sie bieten eine Möglichkeit, eine Zuordnung zwischen zwei Entitätstypen zu navigieren.

Beachten Sie, dass Navigationseigenschaften für beide Entitätstypen an den Enden einer Zuordnung optional sind. Wenn Sie für einen Entitätstyp am Ende einer Zuordnung eine Navigationseigenschaft definieren, muss keine Navigationseigenschaft für den Entitätstyp am anderen Ende der Zuordnung definiert werden.

Der von einer Navigationseigenschaft zurückgegebene Datentyp wird von der Multiplizität des Remotezuordnungsendes bestimmt. Angenommen, eine Navigationseigenschaft, OrdersNavProp, ist für den Entitätstyp Kunde vorhanden und navigiert in einer 1:n-Zuordnung zwischen Kunde und Bestellung. Da das Remotezuordnungsende für die Navigationseigenschaft eine Multiplizität von n (*) aufweist, ist sein Datentyp eine Auflistung (Order). Wenn eine Navigationseigenschaft CustomerNavProp für den Entitätstyp Order vorhanden ist, wäre der Datentyp Kunde, da die Multiplikation des Remote-Endes eins (1) ist.

Das NavigationProperty-Element kann die folgenden untergeordneten Elemente beinhalten (in entsprechender Reihenfolge aufgelistet):

• Dokumentation (kein oder ein Element)
• Anmerkungselemente (kein oder mehrere Elemente)

Anwendbare Attribute

In der folgenden Tabelle werden die Attribute beschrieben, die auf das NavigationProperty-Element angewendet werden können.

Attributname	Ist erforderlich	Wert
Name	Ja	Der Name der Navigationseigenschaft.
Beziehung	Ja	Der Name einer Zuordnung, die sich innerhalb des Bereichs des Modells befindet.
ToRole	Ja	Das Ende der Zuordnung, an dem die Navigation endet. Der Wert des ToRole-Attributs muss mit dem Wert eines der Role-Attributen übereinstimmen, die für eines der Zuordnungsenden definiert wurden (definiert im AssociationEnd-Element).
FromRole	Ja	Das Ende der Zuordnung, an dem die Navigation beginnt. Der Wert des FromRole-Attributs muss mit dem Wert eines der Role-Attribute übereinstimmen, das für eines der Zuordnungsenden definiert wurden (definiert im AssociationEnd-Element).

 

 

Beispiel

Im folgenden Beispiel wird ein Entitätstyp (Book) mit zwei Navigationseigenschaften (PublishedBy und WrittenBy) definiert:

 <EntityType Name="Book">
   <Key>
     <PropertyRef Name="ISBN" />
   </Key>
   <Property Type="String" Name="ISBN" Nullable="false" />
   <Property Type="String" Name="Title" Nullable="false" />
   <Property Type="Decimal" Name="Revision" Nullable="false" Precision="29" Scale="29" />
   <NavigationProperty Name="Publisher" Relationship="BooksModel.PublishedBy"
                       FromRole="Book" ToRole="Publisher" />
   <NavigationProperty Name="Authors" Relationship="BooksModel.WrittenBy"
                       FromRole="Book" ToRole="Author" />
 </EntityType>

 

 

OnDelete-Element (CSDL)

Das OnDelete-Element in konzeptioneller Schemadefinitionssprache (CSDL) definiert mit einer Zuordnung verbundenes Verhalten. Wenn das Action-Attribut an einem Ende einer Zuordnung auf Cascade festgelegt wird, werden verwandte Entitätstypen am anderen Ende der Zuordnung gelöscht, sobald der Entitätstyp am ersten Ende gelöscht wird. Ist die Zuordnung zwei Entitätstypen eine Primärschlüssel-zu-Primärschlüssel-Beziehung, wird ein geladenes abhängiges Objekt gelöscht, sobald das Prinzipalobjekt am anderen Ende der Zuordnung gelöscht wird. Dies ist unabhängig von der OnDelete-Spezifikation.  

 

Das OnDelete-Element kann die folgenden untergeordneten Elemente aufweisen (der vorliegenden Reihenfolge entsprechend):

• Dokumentation (kein oder ein Element)
• Anmerkungselemente (kein oder mehrere Elemente)

Anwendbare Attribute

In der folgenden Tabelle werden die Attribute beschrieben, die für das OnDelete-Element übernommen werden können.

Attributname	Ist erforderlich	Wert
Aktion	Ja	Cascade oder None. Bei Cascade werden abhängige Entitätstypen gelöscht, sobald der Prinzipalentitätstyp gelöscht wird. Bei None werden beim Löschen des Prinzipalentitätstyps abhängige Entitätstypen nicht gelöscht.

 

 

Beispiel

Das folgende Beispiel zeigt ein Association-Element, das die CustomerOrders-Zuordnung definiert. Das OnDelete-Element gibt an, dass alle Orders, die mit einem bestimmten Customer zusammenhängen und in den ObjectContext geladen wurden, gelöscht werden, wenn der Customer gelöscht wird.

 <Association Name="CustomerOrders">
   <End Type="ExampleModel.Customer" Role="Customer" Multiplicity="1">
         <OnDelete Action="Cascade" />
   </End>
   <End Type="ExampleModel.Order" Role="Order" Multiplicity="*" />
 </Association>

 

 

Parameter-Element (CSDL)

Das Parameter-Element in konzeptioneller Schemadefinitionssprache (CSDL) kann ein untergeordnetes Element des FunctionImport-Elements oder des Function-Elements sein.

FunctionImport-Element-Anwendung

Ein Parameter-Element (als untergeordnetes Element des FunctionImport-Elements) wird verwendet, um Eingabe- und Ausgabeparameter für Funktionsimporte zu definieren, die in CSDL deklariert werden.

Ein Parameter-Element kann die folgenden untergeordneten Elemente aufweisen (der vorliegenden Reihenfolge entsprechend):

• Dokumentation (kein oder ein Element zugelassen)
• Anmerkungselemente (kein oder mehrere Elemente zugelassen)

Anwendbare Attribute

In der folgenden Tabelle werden die Attribute beschrieben, die auf das Parameter-Element angewendet werden können.

Attributname	Ist erforderlich	Wert
Name	Ja	Der Name des Parameters.
Typ	Ja	Der Parametertyp. Der Wert muss ein EDMSimpleType oder komplexer Typ sein, der im Gültigkeitsbereich des Modells liegt.
Mode	Nein	Die Verwendung von In, Out oder InOut ist abhängig davon, ob der Parameter ein Eingabe-, Ausgabe- oder Eingabe/Ausgabeparameter ist.
MaxLength	Nein	Die maximal zulässige Länge des Parameters.
Genauigkeit	Nein	Die Genauigkeit des Parameters.
Skalierung	Nein	Der Maßstab des Parameters.
SRID	Nein	Referenzbezeichner des räumlichen Systems. Gilt nur für Parameter räumlicher Typen. Weitere Informationen finden Sie unter SRID und SRID (SQL Server).

 

 

Beispiel

Das folgende Beispiel zeigt ein FunctionImport-Element mit einem untergeordneten Parameter-Element. Die Funktion akzeptiert einen Eingabeparameter und gibt eine Auflistung von Entitätstypen zurück.

 <FunctionImport Name="GetStudentGrades"
                 EntitySet="StudentGrade"
                 ReturnType="Collection(SchoolModel.StudentGrade)">
        <Parameter Name="StudentID" Mode="In" Type="Int32" />
 </FunctionImport>

 

Function-Element-Anwendung

Ein Parameter-Element (als untergeordnetes Element des Function-Elements) definiert Parameter für Funktionen, die definiert oder in einem konzeptionellen Modell deklariert sind.

Ein Parameter-Element kann die folgenden untergeordneten Elemente aufweisen (der vorliegenden Reihenfolge entsprechend):

• Documentation (kein oder ein Element)
• CollectionType (kein oder ein Element)
• ReferenceType (kein oder ein Element)
• RowType (kein oder ein Element)

 

• Anmerkungselemente (kein oder mehrere Elemente zugelassen)

 

Anwendbare Attribute

In der folgenden Tabelle werden die Attribute beschrieben, die auf das Parameter-Element angewendet werden können.

Attributname	Ist erforderlich	Wert
Name	Ja	Der Name des Parameters.
Typ	Nein	Der Parametertyp. Ein Parameter kann einer der folgenden Typen (oder Auflistungen dieser Typen) sein: EdmSimpleType Entitätstyp Komplexer Typ Zeilentyp Verweistyp
NULL zulassen	Nein	Wahr (Standardwert) oder Falsch je nachdem, ob die Eigenschaft einen Null-Wert aufweisen kann.
DefaultValue	Nein	Der Standardwert der Eigenschaft.
MaxLength	Nein	Maximale Länge des Eigenschaftswerts.
FixedLength	Nein	Wahr oder Falsch, abhängig davon, ob der Eigenschaftswert als Zeichenfolge mit fester Länge gespeichert wird.
Genauigkeit	Nein	Die Genauigkeit des Eigenschaftswerts.
Skalierung	Nein	Die Skalierung des Eigenschaftswerts.
SRID	Nein	Referenzbezeichner des räumlichen Systems. Gilt nur für Eigenschaften räumlicher Typen. Weitere Informationen finden Sie unter SRID und SRID (SQL Server).
Unicode	Nein	Wahr oder Falsch, abhängig davon, ob der Eigenschaftswert als Unicode-Zeichenfolge gespeichert wird.
Sortierung	Nein	Eine Zeichenfolge, die angibt, welche Sortierreihenfolge in der Datenquelle verwendet wird.

 

 

Beispiel

Das folgende Beispiel zeigt ein Function-Element, das ein untergeordnetes Parameter-Element verwendet, um einen Funktionsparameter zu definieren.

 <Function Name="GetYearsEmployed" ReturnType="Edm.Int32">
 <Parameter Name="Instructor" Type="SchoolModel.Person" />
   <DefiningExpression>
   Year(CurrentDateTime()) - Year(cast(Instructor.HireDate as DateTime))
   </DefiningExpression>
 </Function>

 

Principal-Element (CSDL)

Das Principal-Element in konzeptioneller Schemadefinitionssprache (CSDL) ist ein dem ReferentialConstraint-Element untergeordnetes Element, welches das Prinzipalende einer referenziellen Einschränkung definiert. Ein ReferentialConstraint-Element definiert Funktionen, die einer Einschränkung der referenziellen Integrität in einer relationalen Datenbank ähnlich sind. So wie eine Spalte (oder Spalten) einer Datenbanktabelle auf den Primärschlüssel einer anderen Tabelle verweisen kann, kann eine Eigenschaft (oder Eigenschaften) eines Entitätstyps auf den Entitätsschlüssel eines anderen Entitätstyps verweisen. Der Entitätstyp, auf den verwiesen wird, wird als Prinzipalende der Einschränkung bezeichnet. Der Entitätstyp, der auf das Prinzipalende verweist, wird als abhängiges Ende der Einschränkung bezeichnet. PropertyRef-Elemente werden zur Angabe der Schlüssel verwendet, auf die vom abhängigen Ende verwiesen wird.

Das Principal-Element kann die folgenden untergeordneten Elemente (in entsprechender Reihenfolge aufgelistet) umfassen:

• PropertyRef (ein oder mehrere Element)
• Anmerkungselemente (kein oder mehrere Elemente)

Anwendbare Attribute

In der folgenden Tabelle werden die Attribute beschrieben, die für das Principal-Element übernommen werden können.

Attributname	Ist erforderlich	Wert
Rolle	Ja	Der Name des Entitätstyps am Prinzipalende der Zuordnung.

 

 

Beispiel

Das folgende Beispiel zeigt ein ReferentialConstraint-Element, das Teil der Definition der PublishedBy-Zuordnung ist. Die Id-Eigenschaft des Publisher-Entitätstyps bildet das Prinzipalende der referenziellen Einschränkung.

 <Association Name="PublishedBy">
   <End Type="BooksModel.Book" Role="Book" Multiplicity="*" >
   </End>
   <End Type="BooksModel.Publisher" Role="Publisher" Multiplicity="1" />
   <ReferentialConstraint>
     <Principal Role="Publisher">
       <PropertyRef Name="Id" />
     </Principal>
     <Dependent Role="Book">
       <PropertyRef Name="PublisherId" />
     </Dependent>
   </ReferentialConstraint>
 </Association>

 

 

Property-Element (CSDL)

Das Property-Element in konzeptioneller Schemadefinitionssprache (CSDL) kann ein untergeordnetes Element des EntityType-Elements, des ComplexType-Elements oder des RowType-Elements sein.

EntityType- und ComplexType-Element-Anwendungen

Property-Elemente (als untergeordnete Elemente des EntityType- oder ComplexType-Elements) definieren die Form und die Eigenschaften der Daten, die eine Entitätstypinstanz oder eine komplexe Typinstanz enthält. Eigenschaften in einem konzeptionellen Modell sind analog zu den Eigenschaften, die für eine Klasse definiert werden. So wie Eigenschaften die Form einer Klasse definieren und Informationen zu Objekten enthalten definieren Eigenschaften in einem konzeptionellen Modell die Form eines Entitätstyps und enthalten Informationen zu Entitätstypinstanzen.

Das Property-Element kann die folgenden untergeordneten Elemente beinhalten (in entsprechender Reihenfolge aufgelistet):

• Dokumentation (kein oder ein Element zugelassen)
• Anmerkungselemente (kein oder mehrere Elemente zugelassen)

Die folgenden Facets können auf ein Property-Element angewendet werden: Nullable, DefaultValue, MaxLength, FixedLength, Precision, Scale, Unicode, Collation, ConcurrencyMode. Facets sind XML-Attribute, die Informationen über die Speicherung von Eigenschaftswerten im Datenspeicher bereitstellen.

 

Anwendbare Attribute

In der folgenden Tabelle werden die Attribute beschrieben, die auf das Property-Element angewendet werden können.

Attributname	Ist erforderlich	Wert
Name	Ja	Der Name der Eigenschaft.
Typ	Ja	Der Typ des Eigenschaftswerts. Der Typ des Eigenschaftswerts muss ein EDMSimpleType oder ein komplexer Typ sein (erkennbar am vollqualifizierten Namen), der im Gültigkeitsbereich des Modells liegt.
NULL zulassen	Nein	True (Standardwert) oder False abhängig davon, ob die Eigenschaft einen NULL-Wert haben kann. [!NOTE]
> In der CSDL v1 muss eine komplexe Typeigenschaft aufweisen Nullable="False".
DefaultValue	Nein	Der Standardwert der Eigenschaft.
MaxLength	Nein	Maximale Länge des Eigenschaftswerts.
FixedLength	Nein	Wahr oder Falsch, abhängig davon, ob der Eigenschaftswert als Zeichenfolge mit fester Länge gespeichert wird.
Genauigkeit	Nein	Die Genauigkeit des Eigenschaftswerts.
Skalierung	Nein	Die Skalierung des Eigenschaftswerts.
SRID	Nein	Referenzbezeichner des räumlichen Systems. Gilt nur für Eigenschaften räumlicher Typen. Weitere Informationen finden Sie unter SRID und SRID (SQL Server).
Unicode	Nein	Wahr oder Falsch, abhängig davon, ob der Eigenschaftswert als Unicode-Zeichenfolge gespeichert wird.
Sortierung	Nein	Eine Zeichenfolge, die angibt, welche Sortierreihenfolge in der Datenquelle verwendet wird.
ConcurrencyMode	Nein	None (Standardwert) oder Fixed. Wenn der Wert auf Fixedfestgelegt ist, wird der Wert der Eigenschaft zu Überprüfungen auf vollständige Parallelität verwendet.

 

 

Beispiel

Das folgende Beispiel zeigt ein EntityType-Element mit drei Property-Elementen:

 <EntityType Name="Book">
   <Key>
     <PropertyRef Name="ISBN" />
   </Key>
   <Property Type="String" Name="ISBN" Nullable="false" />
   <Property Type="String" Name="Title" Nullable="false" />
   <Property Type="Decimal" Name="Revision" Nullable="false" Precision="29" Scale="29" />
   <NavigationProperty Name="Publisher" Relationship="BooksModel.PublishedBy"
                       FromRole="Book" ToRole="Publisher" />
   <NavigationProperty Name="Authors" Relationship="BooksModel.WrittenBy"
                       FromRole="Book" ToRole="Author" />
 </EntityType>

 

Das folgende Beispiel zeigt ein ComplexType-Element mit fünf Property-Elementen:

 <ComplexType Name="Address" >
   <Property Type="String" Name="StreetAddress" Nullable="false" />
   <Property Type="String" Name="City" Nullable="false" />
   <Property Type="String" Name="StateOrProvince" Nullable="false" />
   <Property Type="String" Name="Country" Nullable="false" />
   <Property Type="String" Name="PostalCode" Nullable="false" />
 </ComplexType>

 

RowType-Element-Anwendung

Property-Elemente (als untergeordnete Elemente eines RowType-Elements) definieren die Form und die Eigenschaften der Daten, die an eine modelldefinierte Funktion übergeben oder von einer modelldefinierten Funktion zurückgegeben werden können.  

Das Property-Element kann über genau eines der folgenden untergeordneten Elemente verfügen:

• CollectionType
• ReferenceType
• RowType

Das Property-Element kann über eine beliebige Anzahl untergeordneter Anmerkungselemente verfügen.

 

Anwendbare Attribute

In der folgenden Tabelle werden die Attribute beschrieben, die auf das Property-Element angewendet werden können.

Attributname	Ist erforderlich	Wert
Name	Ja	Der Name der Eigenschaft.
Typ	Ja	Der Typ des Eigenschaftswerts.
NULL zulassen	Nein	True (Standardwert) oder False abhängig davon, ob die Eigenschaft einen NULL-Wert haben kann. [!NOTE]
> In CSDL v1 muss eine komplexe Typeigenschaft Nullable="False" aufweisen.
DefaultValue	Nein	Der Standardwert der Eigenschaft.
MaxLength	Nein	Maximale Länge des Eigenschaftswerts.
FixedLength	Nein	Wahr oder Falsch, abhängig davon, ob der Eigenschaftswert als Zeichenfolge mit fester Länge gespeichert wird.
Genauigkeit	Nein	Die Genauigkeit des Eigenschaftswerts.
Skalierung	Nein	Die Skalierung des Eigenschaftswerts.
SRID	Nein	Referenzbezeichner des räumlichen Systems. Gilt nur für Eigenschaften räumlicher Typen. Weitere Informationen finden Sie unter SRID und SRID (SQL Server).
Unicode	Nein	Wahr oder Falsch, abhängig davon, ob der Eigenschaftswert als Unicode-Zeichenfolge gespeichert wird.
Sortierung	Nein	Eine Zeichenfolge, die angibt, welche Sortierreihenfolge in der Datenquelle verwendet wird.

 

 

Beispiel

Das folgende Beispiel zeigt Property-Elemente, die zur Definition der Form des Rückgabetyps einer modelldefinierten Funktion verwendet wurden.

 <Function Name="LastNamesAfter">
   <Parameter Name="someString" Type="Edm.String" />
   <ReturnType>
    <CollectionType>
      <RowType>
        <Property Name="FirstName" Type="Edm.String" Nullable="false" />
        <Property Name="LastName" Type="Edm.String" Nullable="false" />
      </RowType>
    </CollectionType>
   </ReturnType>
   <DefiningExpression>
             SELECT VALUE ROW(p.FirstName, p.LastName)
             FROM SchoolEntities.People AS p
             WHERE p.LastName &gt;= somestring
   </DefiningExpression>
 </Function>

 

 

PropertyRef-Element (CSDL)

Das PropertyRef-Element in konzeptioneller Schemadefinitionssprache (CSDL) verweist auf eine Eigenschaft eines Entitätstyps. So wird angegeben, dass die Eigenschaft eine der folgenden Rollen ausführt:

• Ein Teil des Entitätsschlüssels (eine Eigenschaft oder ein Satz von Eigenschaften eines Entitätstyps, der die Identität bestimmt). Ein oder mehrere PropertyRef-Elemente können zum Definieren eines Entitätsschlüssels verwendet werden.
• Das abhängige Ende oder Prinzipalende einer referenziellen Einschränkung.

Das PropertyRef-Element kann nur über Anmerkungselemente (keins oder mehrere) als untergeordnete Elemente verfügen.

 

Anwendbare Attribute

In der folgenden Tabelle werden die Attribute beschrieben, die für das PropertyRef-Element übernommen werden können.

Attributname	Ist erforderlich	Wert
Name	Ja	Der Name der referenzierten Eigenschaft.

 

 

Beispiel

Im folgenden Beispiel wird ein Entitätstyp mit dem Namen (Book) definiert. Der Entitätsschlüssel wird definiert, indem auf die ISBN-Eigenschaft des Entitätstyps verwiesen wird.

 <EntityType Name="Book">
   <Key>
     <PropertyRef Name="ISBN" />
   </Key>
   <Property Type="String" Name="ISBN" Nullable="false" />
   <Property Type="String" Name="Title" Nullable="false" />
   <Property Type="Decimal" Name="Revision" Nullable="false" Precision="29" Scale="29" />
   <NavigationProperty Name="Publisher" Relationship="BooksModel.PublishedBy"
                       FromRole="Book" ToRole="Publisher" />
   <NavigationProperty Name="Authors" Relationship="BooksModel.WrittenBy"
                       FromRole="Book" ToRole="Author" />
 </EntityType>

 

Im nächsten Beispiel werden zwei PropertyRef-Elemente zur Angabe verwendet, dass zwei Eigenschaften (Id und PublisherId) das Prinzipalende und das abhängige Ende einer referenziellen Einschränkung bilden.

 <Association Name="PublishedBy">
   <End Type="BooksModel.Book" Role="Book" Multiplicity="*" >
   </End>
   <End Type="BooksModel.Publisher" Role="Publisher" Multiplicity="1" />
   <ReferentialConstraint>
     <Principal Role="Publisher">
       <PropertyRef Name="Id" />
     </Principal>
     <Dependent Role="Book">
       <PropertyRef Name="PublisherId" />
     </Dependent>
   </ReferentialConstraint>
 </Association>

 

 

ReferenceType-Element (CSDL)

Mit dem ReferenceType-Element in konzeptioneller Schemadefinitionssprache (CSDL) wird ein Verweis auf einen Entitätstyp angegeben. Das ReferenceType-Element kann ein untergeordnetes Element der folgenden Elemente sein:

• ReturnType (Funktion)
• Parameter
• CollectionType

Das ReferenceType-Element wird beim Definieren eines Parameters oder eines Rückgabetyps für eine Funktion verwendet.

Ein ReferenceType-Element kann die folgenden untergeordneten Elemente beinhalten (in entsprechender Reihenfolge aufgelistet):

• Dokumentation (kein oder ein Element)
• Anmerkungselemente (kein oder mehrere Elemente)

Anwendbare Attribute

In der folgenden Tabelle werden die Attribute beschrieben, die für das ReferenceType-Element übernommen werden können.

Attributname	Ist erforderlich	Wert
Typ	Ja	Der Name des Entitätstyps, auf den verwiesen wird.

 

 

Beispiel

Das folgende Beispiel zeigt das ReferenceType-Element, das als untergeordnetes Element eines Parameter-Elements in einer modelldefinierten Funktion verwendet wird, die einen Verweis auf den Entitätstyp Person akzeptiert:

 <Function Name="GetYearsEmployed" ReturnType="Edm.Int32">
   <Parameter Name="instructor">
     <ReferenceType Type="SchoolModel.Person" />
   </Parameter>
   <DefiningExpression>
   Year(CurrentDateTime()) - Year(cast(instructor.HireDate as DateTime))
   </DefiningExpression>
 </Function>

 

Das folgende Beispiel zeigt das ReferenceType-Element, das als untergeordnetes Element eines ReturnType (Function)-Elements in einer modelldefinierten Funktion verwendet wird, die einen Verweis auf den Entitätstyp Person zurückgibt:

 <Function Name="GetPersonReference">
     <Parameter Name="p" Type="SchoolModel.Person" />
     <ReturnType>
         <ReferenceType Type="SchoolModel.Person" />
     </ReturnType>
     <DefiningExpression>
           REF(p)
     </DefiningExpression>
 </Function>

 

 

ReferentialConstraint-Element (CSDL)

Ein ReferentialConstraint-Element in konzeptioneller Schemadefinitionssprache (CSDL) definiert die Funktionalität, die einer Einschränkung der referenziellen Integrität in einer relationalen Datenbank ähnlich ist. So wie eine Spalte (oder Spalten) einer Datenbanktabelle auf den Primärschlüssel einer anderen Tabelle verweisen kann, kann eine Eigenschaft (oder Eigenschaften) eines Entitätstyps auf den Entitätsschlüssel eines anderen Entitätstyps verweisen. Der Entitätstyp, auf den verwiesen wird, wird als Prinzipalende der Einschränkung bezeichnet. Der Entitätstyp, der auf das Prinzipalende verweist, wird als abhängiges Ende der Einschränkung bezeichnet.

Wenn ein Fremdschlüssel, der für einen Entitätstyp verfügbar gemacht wird, auf eine Eigenschaft eines anderen Entitätstyps verweist, definiert das ReferentialConstraint-Element eine Zuordnung zwischen den zwei Entitätstypen. Da das ReferentialConstraint-Element Informationen darüber bereitstellt, wie zwei Entitätstypen zueinander in Beziehung stehen, ist kein entsprechendes AssociationSetMapping-Element in der Mapping Specification Language (MSL) erforderlich. Eine Zuordnung zwischen zwei Entitätstypen, für die keine Fremdschlüssel verfügbar ist, muss ein entsprechendes AssociationSetMapping-Element aufweisen, um der Datenquelle Zuordnungsinformationen zuzuordnen.

Wenn ein Fremdschlüssel für einen Entitätstyp nicht verfügbar ist, kann das ReferentialConstraint-Element zwischen dem Entitätstyp und einem anderen Entitätstyp nur eine Primärschlüssel-zu-Primärschlüssel-Einschränkung definieren.

Ein ReferentialConstraint-Element kann die folgenden untergeordneten Elemente aufweisen (in der aufgeführten Reihenfolge):

• Dokumentation (kein oder ein Element)
• Prinzipal (genau ein Element)
• Abhängig (genau ein Element)
• Anmerkungselemente (kein oder mehrere Elemente)

Anwendbare Attribute

Das ReferentialConstraint-Element kann eine beliebige Anzahl von Anmerkungsattributen (benutzerdefinierte XML-Attribute) aufweisen. Benutzerdefinierte Attribute dürfen jedoch zu keinem XML-Namespace gehören, der für CSDL reserviert ist. Die vollqualifizierten Namen für zwei benutzerdefinierte Attribute dürfen nicht übereinstimmen.

Beispiel

Das folgende Beispiel zeigt ein ReferentialConstraint-Element, das als Teil der Definition der PublishedBy-Zuordnung verwendet wird.

 <Association Name="PublishedBy">
   <End Type="BooksModel.Book" Role="Book" Multiplicity="*" >
   </End>
   <End Type="BooksModel.Publisher" Role="Publisher" Multiplicity="1" />
   <ReferentialConstraint>
     <Principal Role="Publisher">
       <PropertyRef Name="Id" />
     </Principal>
     <Dependent Role="Book">
       <PropertyRef Name="PublisherId" />
     </Dependent>
   </ReferentialConstraint>
 </Association>

 

 

ReturnType (Function)-Element (CSDL)

Das ReturnType-Element in konzeptioneller Schemadefinitionssprache (CSDL) gibt den Rückgabetyp für eine Funktion an, die in einem Function-Element definiert ist. Ein Funktionsrückgabetyp kann auch mit einem ReturnType-Attribut angegeben werden.

Rückgabetypen können alle EdmSimpleType, Entitätstypen, komplexe Typen, Zeilentypen, Ref-Typen oder eine Auflistung einer dieser Typen sein.

Der Rückgabetyp einer Funktion kann entweder mit dem Type-Attribut des ReturnType (Function)-Elements oder mit einem der folgenden untergeordneten Elemente angegeben werden:

• CollectionType
• ReferenceType
• RowType

 

Anwendbare Attribute

In der folgenden Tabelle werden die Attribute beschrieben, die auf das ReturnType (Function)-Element angewendet werden können.

Attributname	Ist erforderlich	Wert
ReturnType	Nein	Der von der Funktion zurückgegebene Typ.

 

 

Beispiel

Im folgenden Beispiel wird mithilfe eines Function-Elements eine Funktion definiert, welche die Anzahl der Jahre zurückgibt, die sich ein Buch im Druck befand. Beachten Sie, dass der Rückgabetyp durch das Type-Attribut eines ReturnType (Function)-Elements angegeben wird.

 <Function Name="GetYearsInPrint">
   <ReturnType Type=="Edm.Int32">
   <Parameter Name="book" Type="BooksModel.Book" />
   <DefiningExpression>
    Year(CurrentDateTime()) - Year(cast(book.PublishedDate as DateTime))
   </DefiningExpression>
 </Function>

 

 

ReturnType (FunctionImport)-Element (CSDL)

Das ReturnType (FunctionImport)-Element in der konzeptionellen Schemadefinitionssprache (CSDL) gibt den Rückgabetyp für eine Funktion an, die in einem FunctionImport-Element definiert ist. Ein Funktionsrückgabetyp kann auch mit einem ReturnType-Attribut angegeben werden.

Rückgabetypen können eine beliebige Auflistung von Entitätstypen, komplexem Typ oder EdmSimpleType sein.

Der Rückgabetyp einer Funktion wird mit dem Type-Attribut des ReturnType (FunctionImport)-Elements angegeben.

Anwendbare Attribute

In der folgenden Tabelle werden die Attribute beschrieben, die auf das ReturnType (FunctionImport)-Element angewendet werden können.

Attributname	Ist erforderlich	Wert
Typ	Nein	Der Typ, den die Funktion zurückgibt. Der Wert muss eine Auflistung von ComplexType, EntityType oder EDMSimpleType sein.
EntitySet	Nein	Wenn die Funktion eine Auflistung von Entitätstypen zurückgibt, muss der Wert für EntitySet der Entitätssatz sein, zu dem die Auflistung gehört. Andernfalls darf das Attribut EntitySet nicht verwendet werden.

 

 

Beispiel

Im folgenden Beispiel wird ein FunctionImport-Objekt verwendet, das Bücher und Herausgeber zurückgibt. Beachten Sie, dass die Funktion zwei Ergebnissätze zurückgibt und daher zwei ReturnType (FunctionImport)-Elemente angegeben werden.

 <FunctionImport Name="GetBooksAndPublishers">
   <ReturnType Type=="Collection(BooksModel.Book )" EntitySet=”Books”>
   <ReturnType Type=="Collection(BooksModel.Publisher)" EntitySet=”Publishers”>
 </FunctionImport>

 

 

RowType-Element (CSDL)

Ein RowType-Element in konzeptioneller Schemadefinitionssprache (CSDL) definiert eine unbenannte Struktur als Parameter oder Rückgabetyp für eine im konzeptionellen Modell definierte Funktion.

Ein RowType-Element kann ein untergeordnetes Element der folgenden Elemente sein:

• CollectionType
• Parameter
• ReturnType (Funktion)

Ein RowType-Element kann die folgenden untergeordneten Elemente (in entsprechender Reihenfolge aufgelistet) umfassen:

• Eigenschaft (eins oder mehrere)
• Anmerkungselemente (keins oder mehrere)

Anwendbare Attribute

Eine beliebige Anzahl von Anmerkungsattributen (benutzerdefinierte XML-Attribute) kann für das RowType-Element übernommen werden. Benutzerdefinierte Attribute dürfen jedoch zu keinem XML-Namespace gehören, der für CSDL reserviert ist. Die vollqualifizierten Namen für zwei benutzerdefinierte Attribute dürfen nicht übereinstimmen.

Beispiel

Das folgende Beispiel zeigt eine modelldefinierte Funktion, die mithilfe eines CollectionType-Elements angibt, dass die Funktion eine Auflistung von Zeilen (wie im RowType-Element angegeben) zurückgeben soll.

 <Function Name="LastNamesAfter">
   <Parameter Name="someString" Type="Edm.String" />
   <ReturnType>
    <CollectionType>
      <RowType>
        <Property Name="FirstName" Type="Edm.String" Nullable="false" />
        <Property Name="LastName" Type="Edm.String" Nullable="false" />
      </RowType>
    </CollectionType>
   </ReturnType>
   <DefiningExpression>
             SELECT VALUE ROW(p.FirstName, p.LastName)
             FROM SchoolEntities.People AS p
             WHERE p.LastName &gt;= somestring
   </DefiningExpression>
 </Function>

Schema-Element (CSDL)

Das Schema-Element ist das Stammelement einer konzeptionellen Modelldefinition. Es enthält Definitionen für die Objekte, Funktionen und Container, die ein konzeptionelles Modell bilden.

Das Schema-Element kann keine oder mehrere der folgenden untergeordneten Elemente enthalten:

• Using
• EntityContainer
• EntityType
• EnumType
• Zuordnung
• ComplexType
• Funktion

Ein Schema-Element kann kein oder ein Anmerkungselement enthalten.

 

Das Schema-Element definiert mithilfe des Namespace-Attributs den Namespace für den Entitätstyp, den komplexen Typ und die Zuordnungsobjekte in einem konzeptionellen Modell. Innerhalb eines Namespace müssen alle Objekte eine eindeutige Bezeichnung aufweisen. Namespaces können mehrere Schema-Elemente und mehrere CSDL-Dateien umfassen.

Ein Namespace in einem konzeptionellen Modell unterscheidet sich vom XML-Namespace des Schema-Elements. Ein Namespace in einem konzeptionellen Modell (wie vom Namespace-Attribut definiert) ist ein logischer Container für Entitätstypen, komplexe Typen und Zuordnungstypen. Der XML-Namespace (vom xmlns-Attribut angegeben) eines Schema-Elements ist der Standardnamespace für untergeordnete Elemente und Attribute des Schema-Elements. XML-Namespaces des Formulars https://schemas.microsoft.com/ado/YYYY/MM/edm (wobei JJJJ und MM ein Jahr bzw. Monat darstellen) sind für CSDL reserviert. Benutzerdefinierte Elemente und Attribute können nicht in Namespaces mit diesem Format vorhanden sein.

Anwendbare Attribute

In der folgenden Tabelle werden die Attribute beschrieben, die für das Schema-Element übernommen werden können.

Attributname	Ist erforderlich	Wert
Namespace	Ja	Der Namespace für das konzeptionelle Modell. Der Wert des Namespace-Attributs wird verwendet, um den vollqualifizierten Namen eines Typs zu bilden. Befindet sich z. B. ein EntityType-Element mit dem Namen Customer im Simple.Example.Model-Namespace, dann lautet der voll qualifizierte Name des EntityType-Elements SimpleExampleModel.Customer. Die folgenden Zeichenfolgen können nicht als Wert für das Namespace-Attribut verwendet werden: System, Transient oder Edm. Der Wert für das Namespace-Attribut darf nicht mit dem Wert für das Namespace-Attribut im SSDL Schema-Element übereinstimmen.
Alias	Nein	Ein anstelle der Namespacebezeichnung verwendeter Bezeichner. Wenn sich beispielsweise ein EntityType-Element namens Customer im Simple.Example.Model-Namespace befindet und der Wert des Alias-Attributs Model ist, können Sie Model.Customer als vollqualifizierten Namen des EntityType verwenden.

 

 

Beispiel

Das folgende Beispiel zeigt ein Schema-Element, das ein EntityContainer-Element, zwei EntityType-Elemente und ein Association-Element enthält.

 <Schema xmlns="https://schemas.microsoft.com/ado/2009/11/edm"
      xmlns:cg="https://schemas.microsoft.com/ado/2009/11/codegeneration"
      xmlns:store="https://schemas.microsoft.com/ado/2009/11/edm/EntityStoreSchemaGenerator"
       Namespace="ExampleModel" Alias="Self">
         <EntityContainer Name="ExampleModelContainer">
           <EntitySet Name="Customers"
                      EntityType="ExampleModel.Customer" />
           <EntitySet Name="Orders" EntityType="ExampleModel.Order" />
           <AssociationSet
                       Name="CustomerOrder"
                       Association="ExampleModel.CustomerOrders">
             <End Role="Customer" EntitySet="Customers" />
             <End Role="Order" EntitySet="Orders" />
           </AssociationSet>
         </EntityContainer>
         <EntityType Name="Customer">
           <Key>
             <PropertyRef Name="CustomerId" />
           </Key>
           <Property Type="Int32" Name="CustomerId" Nullable="false" />
           <Property Type="String" Name="Name" Nullable="false" />
           <NavigationProperty
                    Name="Orders"
                    Relationship="ExampleModel.CustomerOrders"
                    FromRole="Customer" ToRole="Order" />
         </EntityType>
         <EntityType Name="Order">
           <Key>
             <PropertyRef Name="OrderId" />
           </Key>
           <Property Type="Int32" Name="OrderId" Nullable="false" />
           <Property Type="Int32" Name="ProductId" Nullable="false" />
           <Property Type="Int32" Name="Quantity" Nullable="false" />
           <NavigationProperty
                    Name="Customer"
                    Relationship="ExampleModel.CustomerOrders"
                    FromRole="Order" ToRole="Customer" />
           <Property Type="Int32" Name="CustomerId" Nullable="false" />
         </EntityType>
         <Association Name="CustomerOrders">
           <End Type="ExampleModel.Customer"
                Role="Customer" Multiplicity="1" />
           <End Type="ExampleModel.Order"
                Role="Order" Multiplicity="*" />
           <ReferentialConstraint>
             <Principal Role="Customer">
               <PropertyRef Name="CustomerId" />
             </Principal>
             <Dependent Role="Order">
               <PropertyRef Name="CustomerId" />
             </Dependent>
           </ReferentialConstraint>
         </Association>
       </Schema>

 

 

TypeRef-Element (CSDL)

Das TypeRef-Element in konzeptioneller Schemadefinitionssprache (CSDL) stellt einen Verweis auf einen vorhandenen benannten Typen bereit. Das TypeRef-Element kann ein untergeordnetes Element des CollectionType-Elements sein, mit dem angegeben wird, dass eine Funktion über eine Auflistung als Parameter oder Rückgabetyp verfügt.

Ein TypeRef-Element kann die folgenden untergeordneten Elemente aufweisen (der vorliegenden Reihenfolge entsprechend):

• Dokumentation (kein oder ein Element)
• Anmerkungselemente (kein oder mehrere Elemente)

Anwendbare Attribute

In der folgenden Tabelle werden die Attribute beschrieben, die auf das TypeRef-Element angewendet werden können. Beachten Sie, dass die Attribute DefaultValue, MaxLength, FixedLength, Precision, Scale, Unicode und Collation nur für EDMSimpleTypes gelten.

Attributname	Ist erforderlich	Wert
Typ	Nein	Der Name der Typbibliothek, auf die verwiesen wird.
NULL zulassen	Nein	True (Standardwert) oder False abhängig davon, ob die Eigenschaft einen NULL-Wert haben kann. [!NOTE]
> In CSDL v1 muss eine komplexe Typeigenschaft Nullable="False" aufweisen.
DefaultValue	Nein	Der Standardwert der Eigenschaft.
MaxLength	Nein	Maximale Länge des Eigenschaftswerts.
FixedLength	Nein	Wahr oder Falsch, abhängig davon, ob der Eigenschaftswert als Zeichenfolge mit fester Länge gespeichert wird.
Genauigkeit	Nein	Die Genauigkeit des Eigenschaftswerts.
Skalierung	Nein	Die Skalierung des Eigenschaftswerts.
SRID	Nein	Referenzbezeichner des räumlichen Systems. Gilt nur für Eigenschaften räumlicher Typen. Weitere Informationen finden Sie unter SRID und SRID (SQL Server).
Unicode	Nein	Wahr oder Falsch, abhängig davon, ob der Eigenschaftswert als Unicode-Zeichenfolge gespeichert wird.
Sortierung	Nein	Eine Zeichenfolge, die angibt, welche Sortierreihenfolge in der Datenquelle verwendet wird.

 

 

Beispiel

Das folgende Beispiel zeigt eine modelldefinierte Funktion, die das TypeRef-Element (als untergeordnetes Element eines CollectionType-Elements) verwendet, um anzugeben, dass die Funktion eine Auflistung von Department-Entitätstypen akzeptiert.

 <Function Name="GetAvgBudget">
      <Parameter Name="Departments">
          <CollectionType>
             <TypeRef Type="SchoolModel.Department"/>
          </CollectionType>
           </Parameter>
       <ReturnType Type="Collection(Edm.Decimal)"/>
       <DefiningExpression>
             SELECT VALUE AVG(d.Budget) FROM Departments AS d
       </DefiningExpression>
 </Function>

 

 

Using-Element (CSDL)

Das Using-Element in konzeptioneller Schemadefinitionssprache (CSDL) importiert den Inhalt eines konzeptionellen Modells aus einem anderen Namespace. Sie können auf Entitätstypen, komplexe Typen und Zuordnungstypen verweisen, die in einem anderen konzeptionellen Modell definiert sind, indem Sie den Wert des Namespace-Attributs festlegen. Mehr als ein Using-Elemente kann untergeordnetes Element eines Schema-Elements sein.

 

Das Using-Element kann die folgenden untergeordneten Elemente aufweisen:

• Dokumentation (kein oder ein Element zugelassen)
• Anmerkungselemente (kein oder mehrere Elemente zugelassen)

Anwendbare Attribute

In der folgenden Tabelle werden die Attribute beschrieben, die für das Using-Element übernommen werden können.

Attributname	Ist erforderlich	Wert
Namespace	Ja	Der Name des importierten Namespaces.
Alias	Ja	Ein anstelle der Namespacebezeichnung verwendeter Bezeichner. Obwohl dieses Attribut erforderlich ist, muss es nicht anstelle des Namespacenamens verwendet wird, um Objektnamen zu qualifizieren.

 

 

Beispiel

Im folgenden Beispiel wird veranschaulicht, wie das Using-Element zum Import eines Namespace verwendet wird, der an einer anderen Stelle definiert ist. Der Namespace für das angezeigte Schema-Element ist BooksModel. Die Address-Eigenschaft für den PublisherEntityType ist ein komplexer Typ, der im ExtendedBooksModel-Namespace (mit dem Using-Element importiert) definiert wird.

 <Schema xmlns="https://schemas.microsoft.com/ado/2009/11/edm"
           xmlns:cg="https://schemas.microsoft.com/ado/2009/11/codegeneration"
           xmlns:store="https://schemas.microsoft.com/ado/2009/11/edm/EntityStoreSchemaGenerator"
           Namespace="BooksModel" Alias="Self">

     <Using Namespace="BooksModel.Extended" Alias="BMExt" />

 <EntityContainer Name="BooksContainer" >
       <EntitySet Name="Publishers" EntityType="BooksModel.Publisher" />
     </EntityContainer>

 <EntityType Name="Publisher">
       <Key>
         <PropertyRef Name="Id" />
       </Key>
       <Property Type="Int32" Name="Id" Nullable="false" />
       <Property Type="String" Name="Name" Nullable="false" />
       <Property Type="BMExt.Address" Name="Address" Nullable="false" />
     </EntityType>

 </Schema>

 

 

Anmerkungsattribute (CSDL)

Anmerkungsattribute in konzeptioneller Schemadefinitionssprache (CSDL) sind benutzerdefinierte XML-Attribute im konzeptionellen Modell. Neben dem Vorhandensein einer gültigen XML-Struktur muss für Anmerkungsattribute folgendes zutreffen:

• Anmerkungsattribute dürfen sich in keinem XML-Namespace befinden, der für CSDL reserviert ist.
• Für ein angegebenes CSDL-Element kann mehr als ein Anmerkungsattribut übernommen werden.
• Die vollqualifizierten Namen zweier Anmerkungsattribute dürfen nicht übereinstimmen.

Anmerkungsattribute können verwendet werden, um zusätzliche Metadaten für die Elemente in einem konzeptionellen Modell bereitzustellen. Auf Metadaten in Anmerkungselementen kann zur Laufzeit mithilfe von Klassen im Namespace System.Data.Metadata.Edm zugegriffen werden.

Beispiel

Das folgende Beispiel zeigt ein EntityType-Element mit einem Anmerkungsattribut (CustomAttribute). Das Beispiel zeigt außerdem ein Anmerkungselement, das auf das Entitätstypelement angewendet wird.

 <Schema Namespace="SchoolModel" Alias="Self"
         xmlns:annotation="https://schemas.microsoft.com/ado/2009/02/edm/annotation"
         xmlns="https://schemas.microsoft.com/ado/2009/11/edm">
   <EntityContainer Name="SchoolEntities" annotation:LazyLoadingEnabled="true">
     <EntitySet Name="People" EntityType="SchoolModel.Person" />
   </EntityContainer>
   <EntityType Name="Person" xmlns:p="http://CustomNamespace.com"
               p:CustomAttribute="Data here.">
     <Key>
       <PropertyRef Name="PersonID" />
     </Key>
     <Property Name="PersonID" Type="Int32" Nullable="false"
               annotation:StoreGeneratedPattern="Identity" />
     <Property Name="LastName" Type="String" Nullable="false"
               MaxLength="50" Unicode="true" FixedLength="false" />
     <Property Name="FirstName" Type="String" Nullable="false"
               MaxLength="50" Unicode="true" FixedLength="false" />
     <Property Name="HireDate" Type="DateTime" />
     <Property Name="EnrollmentDate" Type="DateTime" />
     <p:CustomElement>
       Custom metadata.
     </p:CustomElement>
   </EntityType>
 </Schema>

 

Im folgenden Code werden die Metadaten im Anmerkungsattribut abgerufen und in die Konsole geschrieben:

 EdmItemCollection collection = new EdmItemCollection("School.csdl");
 MetadataWorkspace workspace = new MetadataWorkspace();
 workspace.RegisterItemCollection(collection);
 EdmType contentType;
 workspace.TryGetType("Person", "SchoolModel", DataSpace.CSpace, out contentType);
 if (contentType.MetadataProperties.Contains("http://CustomNamespace.com:CustomAttribute"))
 {
     MetadataProperty annotationProperty =
         contentType.MetadataProperties["http://CustomNamespace.com:CustomAttribute"];
     object annotationValue = annotationProperty.Value;
     Console.WriteLine(annotationValue.ToString());
 }

 

Im Code oben wird davon ausgegangen, dass sich die Datei School.csdl im Ausgabeverzeichnis des Projekts befindet und dass Sie dem Projekt die folgenden Imports- und Using-Anweisungen hinzugefügt haben:

 using System.Data.Metadata.Edm;

 

 

Anmerkungselemente (CSDL)

Anmerkungselemente in konzeptioneller Schemadefinitionssprache (CSDL) sind benutzerdefinierte XML-Elemente im konzeptionellen Modell. Neben dem Vorhandensein einer gültigen XML-Struktur muss für Anmerkungselemente Folgendes zutreffen:

• Anmerkungselemente dürfen sich in keinem XML-Namespace befinden, der für CSDL reserviert ist.
• Mehrere Anmerkungselemente können untergeordnete Elemente eines angegebenen CSDL-Elements sein.
• Die vollqualifizierten Namen zweier Anmerkungselemente dürfen nicht übereinstimmen.
• Anmerkungselemente müssen nach allen anderen untergeordneten Elementen eines angegebenen CSDL-Elements angezeigt werden.

Anmerkungselemente können verwendet werden, um zusätzliche Metadaten für die Elemente in einem konzeptionellen Modell bereitzustellen. Ab .NET Framework Version 4 können Metadaten, die in Anmerkungselementen enthalten sind, zur Laufzeit mithilfe von Klassen im System.Data.Metadata.Edm-Namespace aufgerufen werden.

Beispiel

Das folgende Beispiel zeigt ein EntityType-Element mit einem Anmerkungselement (CustomElement). Das Beispiel zeigt außerdem ein Anmerkungsattribut, das auf das Entitätstypelement angewendet wird.

 <Schema Namespace="SchoolModel" Alias="Self"
         xmlns:annotation="https://schemas.microsoft.com/ado/2009/02/edm/annotation"
         xmlns="https://schemas.microsoft.com/ado/2009/11/edm">
   <EntityContainer Name="SchoolEntities" annotation:LazyLoadingEnabled="true">
     <EntitySet Name="People" EntityType="SchoolModel.Person" />
   </EntityContainer>
   <EntityType Name="Person" xmlns:p="http://CustomNamespace.com"
               p:CustomAttribute="Data here.">
     <Key>
       <PropertyRef Name="PersonID" />
     </Key>
     <Property Name="PersonID" Type="Int32" Nullable="false"
               annotation:StoreGeneratedPattern="Identity" />
     <Property Name="LastName" Type="String" Nullable="false"
               MaxLength="50" Unicode="true" FixedLength="false" />
     <Property Name="FirstName" Type="String" Nullable="false"
               MaxLength="50" Unicode="true" FixedLength="false" />
     <Property Name="HireDate" Type="DateTime" />
     <Property Name="EnrollmentDate" Type="DateTime" />
     <p:CustomElement>
       Custom metadata.
     </p:CustomElement>
   </EntityType>
 </Schema>

 

Im folgenden Code werden die Metadaten im Anmerkungselement abgerufen und in die Konsole geschrieben:

 EdmItemCollection collection = new EdmItemCollection("School.csdl");
 MetadataWorkspace workspace = new MetadataWorkspace();
 workspace.RegisterItemCollection(collection);
 EdmType contentType;
 workspace.TryGetType("Person", "SchoolModel", DataSpace.CSpace, out contentType);
 if (contentType.MetadataProperties.Contains("http://CustomNamespace.com:CustomElement"))
 {
     MetadataProperty annotationProperty =
         contentType.MetadataProperties["http://CustomNamespace.com:CustomElement"];
     object annotationValue = annotationProperty.Value;
     Console.WriteLine(annotationValue.ToString());
 }

 

Im Code oben wird davon ausgegangen, dass sich die Datei School.csdl im Ausgabeverzeichnis des Projekts befindet, und dass Sie dem Projekt die folgenden Imports- und Using-Anweisungen hinzugefügt haben:

 using System.Data.Metadata.Edm;

 

 

Konzeptionelle Modelltypen (CSDL)

Die konzeptionelle Schemadefinitionssprache (CSDL) unterstützt einen Satz von abstrakten primitiven Datentypen mit dem Namen EDMSimpleTypes, die Eigenschaften in einem konzeptionellen Modell definieren. EDMSimpleTypes sind Proxys für primitive Datentypen, die im Speicher oder der Hostumgebung unterstützt werden.

In der nachfolgenden Tabelle werden die von CSDL unterstützten primitiven Datentypen aufgeführt. In der Tabelle werden auch die Facets aufgeführt, die auf jeden EDMSimpleType angewendet werden können.

EDMSimpleType	Beschreibung	Anwendbare Facets
Edm.Binary	Enthält Binärdaten.	MaxLength, FixedLength, Nullable, Default
Edm.Boolean	Enthält den Wert wahr oder falsch.	Nullable, Default
Edm.Byte	Enthält einen 8-Bit-Ganzzahlwert ohne Vorzeichen.	Precision, Nullable, Default
Edm.DateTime	Stellt ein Datum und eine Uhrzeit dar.	Precision, Nullable, Default
Edm.DateTimeOffset	Enthält ein Datum und eine Uhrzeit als Offset in Minuten von GMT.	Precision, Nullable, Default
Edm.Decimal	Enthält einen numerischen Wert mit fester Genauigkeit und festen Dezimalstellen.	Precision, Nullable, Default
Edm.Double	Enthält eine Gleitkommazahl mit einer Genauigkeit von 15 Stellen	Precision, Nullable, Default
Edm.Float	Enthält eine Gleitkommazahl mit einer Genauigkeit von 7 Stellen.	Precision, Nullable, Default
Edm.Guid	Enthält einen eindeutigen 16-Byte-Bezeichner.	Precision, Nullable, Default
Edm.Int16	Enthält einen 16-Bit-Ganzzahlwert mit Vorzeichen.	Precision, Nullable, Default
Edm.Int32	Enthält einen 32-Bit-Ganzzahlwert mit Vorzeichen.	Precision, Nullable, Default
Edm.Int64	Enthält einen 64-Bit-Ganzzahlwert mit Vorzeichen.	Precision, Nullable, Default
Edm.SByte	Enthält einen 8-Bit-Ganzzahlwert mit Vorzeichen.	Precision, Nullable, Default
Edm.String	Enthält Zeichendaten.	Unicode, FixedLength, MaxLength, Collation, Precision, Nullable, Default
Edm.Time	Enthält eine Uhrzeit.	Precision, Nullable, Default
Edm.Geography		Nullfähig, Default, SRID
Edm.GeographyPoint		Nullfähig, Default, SRID
Edm.GeographyLineString		Nullfähig, Default, SRID
Edm.GeographyPolygon		Nullfähig, Default, SRID
Edm.GeographyMultiPoint		Nullfähig, Default, SRID
Edm.GeographyMultiLineString		Nullfähig, Default, SRID
Edm.GeographyMultiPolygon		Nullfähig, Default, SRID
Edm.GeographyCollection		Nullfähig, Default, SRID
Edm.Geometry		Nullfähig, Default, SRID
Edm.GeometryPoint		Nullfähig, Default, SRID
Edm.GeometryLineString		Nullfähig, Default, SRID
Edm.GeometryPolygon		Nullfähig, Default, SRID
Edm.GeometryMultiPoint		Nullfähig, Default, SRID
Edm.GeometryMultiLineString		Nullfähig, Default, SRID
Edm.GeometryMultiPolygon		Nullfähig, Default, SRID
Edm.GeometryCollection		Nullfähig, Default, SRID

Facets (CSDL)

Facets in konzeptioneller Schemadefinitionssprache (CSDL) stellen Einschränkungen für Eigenschaften von Entitätstypen und komplexen Typen dar. Facets werden in den folgenden CSDL-Elementen als XML-Attribute angezeigt:

• Eigenschaft
• TypeRef
• Parameter

In der folgenden Tabelle werden die in CSDL unterstützten Facets beschrieben. Alle Facets sind optional. Beim Generieren einer Datenbank aus einem konzeptionellen Modell werden einige der unten aufgeführten Facets vom Entity Framework verwendet.

Facet	Beschreibung	Gilt für:	Wird für die Datenbankgenerierung verwendet	Wird von der Laufzeit verwendet
Sortierung	Gibt die bei Vergleich- und Sortiervorgängen zu verwendende Sortierreihenfolge für die Werte der Eigenschaft an.	Edm.String	Ja	Nein
ConcurrencyMode	Gibt an, dass der Eigenschaftswert für Prüfungen der vollständigen Parallelität verwendet werden soll.	Alle EDMSimpleType-Eigenschaften	Nein	Ja
Standard	Gibt den Standardwert der Eigenschaft an, wenn bei der Instanziierung kein Wert angegeben wird.	Alle EDMSimpleType-Eigenschaften	Ja	Ja
FixedLength	Gibt an, ob sich die Länge des Eigenschaftswerts ändern kann.	Edm.Binary, Edm.String	Ja	Nein
MaxLength	Gibt die maximale Länge des Eigenschaftswerts an.	Edm.Binary, Edm.String	Ja	Nein
NULL zulassen	Gibt an, ob die Eigenschaft über einen NULL-Wert verfügen kann.	Alle EDMSimpleType-Eigenschaften	Ja	Ja
Genauigkeit	Bei Eigenschaften des Typs Decimal wird die Anzahl der Ziffern angegeben, über die ein Eigenschaftswert verfügen kann. Gibt für Eigenschaften vom Typ Time, DateTime und DateTimeOffset die Anzahl der Ziffern für den Bruchteil der Sekunden des Eigenschaftswerts an.	Edm.DateTime, Edm.DateTimeOffset, Edm.Decimal, Edm.Time	Ja	Nein
Skalierung	Gibt die Anzahl der Dezimalstellen für den Eigenschaftswert an.	Edm.Decimal	Ja	Nein
SRID	Gibt die System-ID des räumlichen Referenzsystems an. Weitere Informationen finden Sie unter SRID und SRID (SQL Server).	Edm.Geography, Edm.GeographyPoint, Edm.GeographyLineString, Edm.GeographyPolygon, Edm.GeographyMultiPoint, Edm.GeographyMultiLineString, Edm.GeographyMultiPolygon, Edm.GeographyCollection, Edm.Geometry, Edm.GeometryPoint, Edm.GeometryLineString, Edm.GeometryPolygon, Edm.GeometryMultiPoint, Edm.GeometryMultiLineString, Edm.GeometryMultiPolygon, Edm.GeometryCollection	Nein	Ja
Unicode	Gibt an, ob der Eigenschaftswert als Unicode gespeichert wird.	Edm.String	Ja	Ja

Beispiel

Das folgende Beispiel zeigt für die Eigenschaften eines Entitätstyps übernommene Facets:

 <EntityType Name="Product">
   <Key>
     <PropertyRef Name="ProductId" />
   </Key>
   <Property Type="Int32"
             Name="ProductId" Nullable="false"
             a:StoreGeneratedPattern="Identity"
    xmlns:a="https://schemas.microsoft.com/ado/2009/02/edm/annotation" />
   <Property Type="String"
             Name="ProductName"
             Nullable="false"
             MaxLength="50" />
   <Property Type="String"
             Name="Location"
             Nullable="true"
             MaxLength="25" />
 </EntityType>