CSDL-specificatie

De conceptuele schemadefinitietaal (CSDL) is een op XML gebaseerde taal die de entiteiten, relaties en functies beschrijft waaruit een conceptueel model van een gegevensgestuurde toepassing bestaat. Dit conceptuele model kan worden gebruikt door Entity Framework of WCF Data Services. De metagegevens die worden beschreven met CSDL, worden door het Entity Framework gebruikt om entiteiten en relaties die in een conceptueel model zijn gedefinieerd, toe te wijzen aan een gegevensbron. Zie SSDL-specificatie en MSL-specificatie voor meer informatie.

CSDL is de implementatie van het Entity Framework van het Entity Data Model.

In een Entity Framework-toepassing worden conceptuele modelmetagegevens geladen vanuit een CSDL-bestand (geschreven in CSDL) naar een exemplaar van de klasse System.Data.Metadata.Edm.EdmItemCollection en is toegankelijk met behulp van methoden in de klasse System.Data.Metadata.Edm.MetadataWorkspace. Entity Framework maakt gebruik van metagegevens van conceptueel model om query's te vertalen op basis van het conceptuele model naar specifieke opdrachten voor gegevensbronnen.

De EF Designer slaat conceptuele modelinformatie op in een .edmx-bestand tijdens het ontwerp. Tijdens de build gebruikt ef Designer informatie in een .edmx-bestand om het .csdl-bestand te maken dat tijdens runtime nodig is voor Entity Framework.

Versies van CSDL worden onderscheiden door XML-naamruimten.

Associatie-element (CSDL)

Een koppelingselement definieert een relatie tussen twee entiteitstypen. Een koppeling moet de entiteitstypen opgeven die betrokken zijn bij de relatie en het mogelijke aantal entiteitstypen aan elk uiteinde van de relatie, dat bekend staat als de multipliciteit. De multipliciteit van een koppelingseindpunt kan een waarde hebben van één (1), nul of één (0,.1) of veel (*). Deze informatie wordt gespecificeerd in twee kindeindelementen.

Instanties van entiteitstypen aan het ene uiteinde van een koppeling kunnen worden geopend via navigatie-eigenschappen of vreemde sleutels, als deze beschikbaar zijn op een entiteitstype.

In een toepassing vertegenwoordigt een exemplaar van een koppeling een specifieke koppeling tussen instanties van entiteitstypen. Geassocieerde instanties worden logisch gegroepeerd in een associatieset.

Een koppelingselement kan de volgende onderliggende elementen bevatten (in de vermelde volgorde):

• Documentatie (nul of één element)
• Einde (precies 2 elementen)
• ReferentialConstraint (nul of één element)
• Aantekeningselementen (nul of meer elementen)

Toepasselijke kenmerken

In de onderstaande tabel worden de kenmerken beschreven die kunnen worden toegepast op het koppelingselement .

Voorbeeld

In het volgende voorbeeld ziet u een koppelingselement dat de associatie CustomerOrders definieert wanneer buitenlandse sleutels niet zijn blootgesteld op de entiteitstypen Klant en Order. De multipliciteitswaarden voor elk einde van de koppeling geven aan dat veel orders aan een klant kunnen worden gekoppeld, maar slechts één klant kan worden gekoppeld aan een order. Daarnaast geeft het element OnDelete aan dat alle orders die zijn gerelateerd aan een bepaalde klant en in objectcontext zijn geladen, worden verwijderd als de klant wordt verwijderd.

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

In het volgende voorbeeld toont een Association-element de associatie CustomerOrders zoals gedefinieerd wanneer buitenlandse sleutels zichtbaar zijn gemaakt op de Customer- en Order-entiteitstypen. Als er refererende sleutels worden weergegeven, wordt de relatie tussen de entiteiten beheerd met een ReferentialConstraint-element . Een bijbehorend AssociationSetMapping-element is niet nodig om deze koppeling toe te wijzen aan de gegevensbron.

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

Het element AssociationSet (CSDL)

Het element AssociationSet in de conceptuele schemadefinitietaal (CSDL) is een logische container voor koppelingsexemplaren van hetzelfde type. Een koppelingsset biedt een definitie voor het groeperen van koppelingsexemplaren, zodat deze kunnen worden toegewezen aan een gegevensbron.  

Het element AssociationSet kan de volgende onderliggende elementen bevatten (in de vermelde volgorde):

• Documentatie (nul of één elementen toegestaan)
• Einde (precies twee elementen vereist)
• Aantekeningselementen (nul of meer toegestane elementen)

Het kenmerk Koppeling geeft het type koppeling op dat een koppelingsset bevat. De entiteitssets die de uiteinden van een koppelingsset vormen, worden gespecificeerd met exact twee onderliggende End-elementen.

Toepasselijke kenmerken

In de onderstaande tabel worden de kenmerken beschreven die kunnen worden toegepast op het Element AssociationSet .

Voorbeeld

In het volgende voorbeeld ziet u een EntityContainer-element met twee 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>

Het element CollectionType (CSDL)

Het element CollectionType in de conceptuele schemadefinitietaal (CSDL) geeft aan dat een functieparameter of functie retourtype een verzameling is. Het Element CollectionType kan een onderliggend element van het parameterelement of het element ReturnType (functie) zijn. Het type verzameling kan worden opgegeven met behulp van het kenmerk Type of een van de volgende onderliggende elementen:

• CollectionType
• ReferenceType
• RowType
• TypeRef

Toepasselijke kenmerken

In de volgende tabel worden de kenmerken beschreven die kunnen worden toegepast op het CollectionType-element . Houd er rekening mee dat de kenmerken DefaultValue, MaxLength, FixedLength, Precision, Scale, Unicode en Sortation alleen van toepassing zijn op verzamelingen van EDMSimpleTypes.

Voorbeeld

In het volgende voorbeeld ziet u een modelgedefinieerde functie die gebruikmaakt van een CollectionType-element om op te geven dat de functie een verzameling entiteitstypen Person retourneert (zoals opgegeven met het kenmerk ElementType ).

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

In het volgende voorbeeld ziet u een modelgedefinieerde functie die gebruikmaakt van een CollectionType-element om op te geven dat de functie een verzameling rijen retourneert (zoals opgegeven in het element RowType ).

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

In het volgende voorbeeld ziet u een modelgedefinieerde functie die gebruikmaakt van het element CollectionType om op te geven dat de functie accepteert als parameter een verzameling entiteitstypen Afdeling .

 <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)

Een ComplexType-element definieert een gegevensstructuur die bestaat uit EdmSimpleType-eigenschappen of andere complexe typen.  Een complex type kan een eigenschap van een entiteitstype of een ander complex type zijn. Een complex type is vergelijkbaar met een entiteitstype waarin een complex type gegevens definieert. Er zijn echter enkele belangrijke verschillen tussen complexe typen en entiteitstypen:

• Complexe typen hebben geen identiteiten (of sleutels) en kunnen daarom niet onafhankelijk bestaan. Complexe typen kunnen alleen bestaan als eigenschappen van entiteitstypen of andere complexe typen.
• Complexe typen kunnen niet deelnemen aan koppelingen. Geen van beide uiteinden van een koppeling kan een complex type zijn en daarom kunnen navigatie-eigenschappen niet worden gedefinieerd voor complexe typen.
• Een eigenschap van een complex type kan geen null-waarde hebben, maar de scalaire eigenschappen van een complex type kunnen elk worden ingesteld op null.

Een ComplexType-element kan de volgende onderliggende elementen bevatten (in de vermelde volgorde):

• Documentatie (nul of één element)
• Eigenschap (nul of meer elementen)
• Aantekeningselementen (nul of meer elementen)

In de onderstaande tabel worden de kenmerken beschreven die kunnen worden toegepast op het element ComplexType .

Voorbeeld

In het volgende voorbeeld ziet u een complex type Adres, met de eigenschappen EdmSimpleTypeStreetAddress, City, StateOrProvince, Country en 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>

Als u het complexe type Adres (hierboven) wilt definiëren als een eigenschap van een entiteitstype, moet u het eigenschapstype declareren in de definitie van het entiteitstype. In het volgende voorbeeld ziet u de eigenschap Adres als een complex type voor een entiteitstype (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>

Het element DefiningExpression (CSDL)

Het element DefiningExpression in de conceptuele schemadefinitietaal (CSDL) bevat een Entity SQL-expressie waarmee een functie in het conceptuele model wordt gedefinieerd.  

Toepasselijke kenmerken

Een willekeurig aantal aantekeningenkenmerken (aangepaste XML-kenmerken) kan worden toegepast op het element DefiningExpression . Aangepaste kenmerken behoren echter mogelijk niet tot een XML-naamruimte die is gereserveerd voor CSDL. De volledig gekwalificeerde namen voor twee aangepaste kenmerken kunnen niet hetzelfde zijn.

Voorbeeld

In het volgende voorbeeld wordt een DefineExpression-element gebruikt om een functie te definiëren die het aantal jaren retourneert sinds een boek is gepubliceerd. De inhoud van het element DefiningExpression is geschreven in Entity SQL.

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

Afhankelijk element (CSDL)

Het afhankelijke element in de conceptuele schemadefinitietaal (CSDL) is een onderliggend element voor het element ReferentialConstraint en definieert het afhankelijke einde van een referentiële beperking. Een ReferentialConstraint-element definieert functionaliteit die vergelijkbaar is met een beperking voor referentiële integriteit in een relationele database. Op dezelfde manier dat een kolom (of kolommen) uit een databasetabel kan verwijzen naar de primaire sleutel van een andere tabel, kan een eigenschap (of eigenschappen) van een entiteitstype verwijzen naar de entiteitssleutel van een ander entiteitstype. Het entiteitstype waarnaar wordt verwezen, wordt het principal-einde van de beperking genoemd. Het entiteitstype dat verwijst naar het principal-einde wordt het afhankelijke einde van de beperking genoemd. PropertyRef-elementen worden gebruikt om op te geven welke sleutels verwijzen naar het principal-einde.

Het afhankelijke element kan de volgende onderliggende elementen bevatten (in de vermelde volgorde):

• PropertyRef (een of meer elementen)
• Aantekeningselementen (nul of meer elementen)

Toepasselijke kenmerken

In de onderstaande tabel worden de kenmerken beschreven die kunnen worden toegepast op het afhankelijke element.

Voorbeeld

In het volgende voorbeeld ziet u een ReferentialConstraint-element dat wordt gebruikt als onderdeel van de definitie van de associatie PublishedBy. De eigenschap PublisherId van het entiteitstype Boek vormt het afhankelijke einde van de referentiële beperking.

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

Documentatie-element (CSDL)

Het Documentatie-element in de conceptuele schemadefinitietaal (CSDL) kan worden gebruikt om informatie te verschaffen over een object dat is gedefinieerd in een ouder element. Wanneer in een .edmx-bestand het element Documentatie een onderliggend element is dat wordt weergegeven als een object op het ontwerpoppervlak van de EF Designer (zoals een entiteit, koppeling of eigenschap), wordt de inhoud van het element Documentatie weergegeven in het venster Eigenschappen van Visual Studio voor het object.

Het element Documentatie kan de volgende onderliggende elementen bevatten (in de vermelde volgorde):

• Samenvatting: Een korte beschrijving van het bovenliggende element. (nul of één element)
• LongDescription: een uitgebreide beschrijving van het bovenliggende element. (nul of één element)
• Aantekeningselementen. (nul of meer elementen)

Toepasselijke kenmerken

Een willekeurig aantal aantekeningenkenmerken (aangepaste XML-kenmerken) kan worden toegepast op het element Documentatie . Aangepaste kenmerken behoren echter mogelijk niet tot een XML-naamruimte die is gereserveerd voor CSDL. De volledig gekwalificeerde namen voor twee aangepaste kenmerken kunnen niet hetzelfde zijn.

Voorbeeld

In het volgende voorbeeld ziet u het element Documentatie als een onderliggend element van een EntityType-element. Als het onderstaande fragment zich in de CSDL-inhoud van een .edmx-bestand bevindt, wordt de inhoud van de elementen Samenvatting en LongDescription weergegeven in het venster Eigenschappen van Visual Studio wanneer u op het Customer entiteitstype klikt.

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

Eindelement (CSDL)

Het End-element in de conceptuele schemadefinitietaal (CSDL) kan een onderliggend element zijn van het Association-element of het AssociationSet-element. In elk geval is de rol van het eindelement anders en zijn de toepasselijke kenmerken verschillend.

End Element als een kind van het koppelingselement

Een eindelement (als onderliggend element van het koppelingselement ) identificeert het entiteitstype aan het ene uiteinde van een koppeling en het aantal exemplaren van het entiteitstype dat aan dat einde van een koppeling kan bestaan. Associatie-einden worden gedefinieerd als onderdeel van een associatie; een associatie moet precies twee associatie-einden hebben. Instanties van entiteitstypen aan het ene uiteinde van een associatie kunnen worden geopend via navigatie-eigenschappen of refererende sleutels als deze op een entiteitstype beschikbaar zijn.  

Een eindelement kan de volgende onderliggende elementen bevatten (in de vermelde volgorde):

• Documentatie (nul of één element)
• OnDelete (nul of één element)
• Aantekeningselementen (nul of meer elementen)

Toepasselijke kenmerken

In de volgende tabel worden de kenmerken beschreven die kunnen worden toegepast op het eindelement wanneer het het onderliggende element van een koppelingselement is.

Voorbeeld

In het volgende voorbeeld ziet u een koppelingselement dat de koppeling CustomerOrders definieert. De multipliciteitswaarden voor elk einde van de koppeling geven aan dat veel orders aan een klant kunnen worden gekoppeld, maar slechts één klant kan worden gekoppeld aan een order. Daarnaast geeft het element OnDelete aan dat alle orders die zijn gerelateerd aan een bepaalde klant en die in ObjectContext zijn geladen, worden verwijderd als de klant wordt verwijderd.

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

Eindelement als onderliggend element van het AssociationSet-element

Het element Einde geeft één einde van een koppelingsset aan. Het element AssociationSet moet twee eindelementen bevatten. De informatie in een End-element wordt gebruikt bij het toewijzen van een associatieset aan een gegevensbron.

Een eindelement kan de volgende onderliggende elementen bevatten (in de vermelde volgorde):

• Documentatie (nul of één element)
• Aantekeningselementen (nul of meer elementen)

Toepasselijke kenmerken

In de volgende tabel worden de kenmerken beschreven die kunnen worden toegepast op het eindelement wanneer dit het onderliggende element van een AssociationSet-element is.

Voorbeeld

In het volgende voorbeeld ziet u een EntityContainer-element met twee AssociationSet-elementen , elk met twee eindelementen :

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

Het element EntityContainer (CSDL)

Het element EntityContainer in de conceptuele schemadefinitietaal (CSDL) is een logische container voor entiteitssets, koppelingssets en functieimport. Een conceptuele modelentiteitscontainer wordt toegewezen aan een container van een opslagmodelentiteit via het element EntityContainerMapping. Een entiteit container voor opslagmodel beschrijft de structuur van de database: entiteitssets beschrijven tabellen, koppelingssets beschrijven beperkingen voor refererende sleutels, en functieimporteurs beschrijven opgeslagen procedures in een database.

Een EntityContainer-element kan nul of één documentatie-elementen bevatten. Als er een documentatieelement aanwezig is, moet dit voorafgaan aan alle elementen EntitySet, AssociationSet en FunctionImport .

Een EntityContainer-element kan nul of meer van de volgende onderliggende elementen bevatten (in de vermelde volgorde):

• EntiteitSet
• AssociationSet
• FunctionImport
• Aantekeningselementen

U kunt een EntityContainer-element uitbreiden om de inhoud van een andere EntityContainer op te nemen die zich in dezelfde naamruimte bevindt. Als u de inhoud van een andere EntityContainer wilt opnemen, stelt u in het element EntityContainer waarnaar wordt verwezen de waarde van het kenmerk Breidt in op de naam van het EntityContainer-element dat u wilt opnemen. Alle onderliggende elementen van het opgenomen EntityContainer-element worden behandeld als onderliggende elementen van het element EntityContainer waarnaar wordt verwezen.

Toepasselijke kenmerken

In de onderstaande tabel worden de kenmerken beschreven die kunnen worden toegepast op het element Using .

Voorbeeld

In het volgende voorbeeld ziet u een EntityContainer-element dat drie entiteitssets en twee koppelingssets definieert.

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

Het element EntitySet (CSDL)

Het element EntitySet in conceptuele schemadefinitietaal is een logische container voor exemplaren van een entiteitstype en exemplaren van elk type dat is afgeleid van dat entiteitstype. De relatie tussen een entiteitstype en een entiteitsset is vergelijkbaar met de relatie tussen een rij en een tabel in een relationele database. Net als een rij definieert een entiteitstype een set gerelateerde gegevens en, zoals een tabel, bevat een entiteitsset exemplaren van die definitie. Een entiteitsset biedt een constructie voor het groeperen van entiteitstype-exemplaren, zodat deze kunnen worden toegewezen aan gerelateerde gegevensstructuren in een gegevensbron.  

Er kunnen meer dan één entiteitsset voor een bepaald entiteitstype worden gedefinieerd.

Het Element EntitySet kan de volgende onderliggende elementen bevatten (in de vermelde volgorde):

• Documentatie-element (nul of één elementen toegestaan)
• Aantekeningselementen (nul of meer toegestane elementen)

Toepasselijke kenmerken

In de onderstaande tabel worden de kenmerken beschreven die kunnen worden toegepast op het Element EntitySet .

Voorbeeld

In het volgende voorbeeld ziet u een EntityContainer-element met drie 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>

Het is mogelijk om meerdere entiteitssets per type (MEST) te definiëren. In het volgende voorbeeld wordt een entiteitscontainer met twee entiteitssets gedefinieerd voor het entiteitstype Book :

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

EntiteitType-element (CSDL)

Het Element EntityType vertegenwoordigt de structuur van een concept op het hoogste niveau, zoals een klant of order, in een conceptueel model. Een entiteitstype is een sjabloon voor exemplaren van entiteitstypen in een toepassing. Elke sjabloon bevat de volgende informatie:

• Een unieke naam. (Vereist.)
• Een entiteitssleutel die wordt gedefinieerd door een of meer eigenschappen. (Vereist.)
• Eigenschappen voor het bevatten van gegevens. (Optioneel.)
• Navigatie-eigenschappen waarmee navigatie vanaf het ene uiteinde van een koppeling naar het andere uiteinde mogelijk is. (Optioneel.)

In een toepassing vertegenwoordigt een exemplaar van een entiteitstype een specifiek object (zoals een specifieke klant of bestelling). Elk exemplaar van een entiteitstype moet een unieke entiteitssleutel hebben binnen een entiteitsset.

Twee entiteitstypeexemplaren worden alleen als gelijk beschouwd als ze van hetzelfde type zijn en de waarden van hun entiteitssleutels hetzelfde zijn.

Een EntityType-element kan de volgende onderliggende elementen bevatten (in de vermelde volgorde):

• Documentatie (nul of één element)
• Sleutel (nul of één element)
• Eigenschap (nul of meer elementen)
• NavigationProperty (nul of meer elementen)
• Aantekeningselementen (nul of meer elementen)

Toepasselijke kenmerken

In de onderstaande tabel worden de kenmerken beschreven die kunnen worden toegepast op het EntityType-element .

Voorbeeld

In het volgende voorbeeld ziet u een EntityType-element met drie eigenschapselementen en twee 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)

Het enumType-element vertegenwoordigt een geïnventariseerd type.

Een EnumType-element kan de volgende onderliggende elementen bevatten (in de vermelde volgorde):

• Documentatie (nul of één element)
• Lid (nul of meer elementen)
• Aantekeningselementen (nul of meer elementen)

Toepasselijke kenmerken

In de onderstaande tabel worden de kenmerken beschreven die kunnen worden toegepast op het EnumType-element .

Voorbeeld

In het volgende voorbeeld ziet u een EnumType-element met drie lidelementen :

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

Functie-element (CSDL)

Het element Functie in de conceptuele schemadefinitietaal (CSDL) wordt gebruikt om functies in het conceptuele model te definiëren of declareren. Een functie wordt gedefinieerd met behulp van een DefinedExpression-element.  

Een functie-element kan de volgende onderliggende elementen bevatten (in de vermelde volgorde):

• Documentatie (nul of één element)
• Parameter (nul of meer elementen)
• DefiningExpression (nul of één element)
• ReturnType (functie) (nul of één element)
• Aantekeningselementen (nul of meer elementen)

Een retourtype voor een functie moet worden opgegeven met het element ReturnType (Function) of het kenmerk ReturnType (zie hieronder), maar niet beide. De mogelijke retourtypen zijn elk EdmSimpleType, entiteitstype, complex type, rijtype of ref-type (of een verzameling van een van deze typen).

Toepasselijke kenmerken

In de onderstaande tabel worden de kenmerken beschreven die kunnen worden toegepast op het functie-element .

Voorbeeld

In het volgende voorbeeld wordt een functie-element gebruikt om een functie te definiëren die het aantal jaren retourneert sinds een docent is ingehuurd.

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

Het element FunctionImport (CSDL)

Het element FunctionImport in de conceptuele schemadefinitietaal (CSDL) vertegenwoordigt een functie die is gedefinieerd in de gegevensbron, maar beschikbaar is voor objecten via het conceptuele model. Een functie-element in het opslagmodel kan bijvoorbeeld worden gebruikt om een opgeslagen procedure in een database weer te geven. Een FunctionImport-element in het conceptuele model vertegenwoordigt de bijbehorende functie in een Entity Framework-toepassing en wordt toegewezen aan de opslagmodelfunctie met behulp van het element FunctionImportMapping. Wanneer de functie wordt aangeroepen in de toepassing, wordt de bijbehorende opgeslagen procedure uitgevoerd in de database.

Het element FunctionImport kan de volgende onderliggende elementen bevatten (in de vermelde volgorde):

• Documentatie (nul of één elementen toegestaan)
• Parameter (nul of meer elementen toegestaan)
• Aantekeningselementen (nul of meer toegestane elementen)
• ReturnType (FunctionImport) (nul of meer elementen toegestaan)

Er moet één parameterelement worden gedefinieerd voor elke parameter die door de functie wordt geaccepteerd.

Een retourtype voor een functie moet worden opgegeven met het element ReturnType (FunctionImport) of het kenmerk ReturnType (zie hieronder), maar niet beide. De waarde van het retourtype moet een verzameling EdmSimpleType, EntityType of ComplexType zijn.

Toepasselijke kenmerken

In de onderstaande tabel worden de kenmerken beschreven die kunnen worden toegepast op het element FunctionImport .

Voorbeeld

In het volgende voorbeeld ziet u een FunctionImport-element dat één parameter accepteert en een verzameling entiteitstypen retourneert:

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

Belangrijk Element (CSDL)

Het sleutelelement is een onderliggend element van het EntityType-element en definieert een entiteitssleutel (een eigenschap of een set eigenschappen van een entiteitstype die identiteit bepalen). De eigenschappen waaruit een entiteitssleutel bestaat, worden gekozen tijdens het ontwerp. De waarden van entiteitssleuteleigenschappen moeten een exemplaar van het entiteitstype uniek identificeren binnen een entiteitset tijdens runtime. De eigenschappen waaruit een entiteitssleutel bestaat, moeten worden gekozen om de uniekheid van exemplaren in een entiteitsset te garanderen. Het sleutelelement definieert een entiteitssleutel door te verwijzen naar een of meer eigenschappen van een entiteitstype.

Het sleutelelement kan de volgende onderliggende elementen bevatten:

• PropertyRef (een of meer elementen)
• Aantekeningselementen (nul of meer elementen)

Toepasselijke kenmerken

Een willekeurig aantal aantekeningenkenmerken (aangepaste XML-kenmerken) kan worden toegepast op het sleutelelement . Aangepaste kenmerken behoren echter mogelijk niet tot een XML-naamruimte die is gereserveerd voor CSDL. De volledig gekwalificeerde namen voor twee aangepaste kenmerken kunnen niet hetzelfde zijn.

Voorbeeld

In het onderstaande voorbeeld wordt een entiteitstype met de naam Book gedefinieerd. De entiteitssleutel wordt gedefinieerd door te verwijzen naar de eigenschap ISBN van het entiteitstype.

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

De eigenschap ISBN is een goede keuze voor de entiteitssleutel, omdat een INTERNATIONAL Standard Book Number (ISBN) een boek uniek identificeert.

In het volgende voorbeeld ziet u een entiteitstype (Auteur) met een entiteitssleutel die bestaat uit twee eigenschappen, Naam en Adres.

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

Het gebruik van naam en adres voor de entiteitssleutel is een redelijke keuze, omdat twee auteurs van dezelfde naam waarschijnlijk niet op hetzelfde adres wonen. Deze keuze voor een entiteitssleutel garandeert echter niet absoluut unieke entiteitssleutels in een entiteitsset. Het toevoegen van een eigenschap, zoals AuthorId, die kan worden gebruikt om een auteur uniek te identificeren, wordt in dit geval aanbevolen.

Lidelement (CSDL)

Het element Lid is een onderliggend element van het EnumType-element en definieert een lid van het geïnventariseerd type.

Toepasselijke kenmerken

In de onderstaande tabel worden de kenmerken beschreven die kunnen worden toegepast op het element FunctionImport .

Voorbeeld

In het volgende voorbeeld ziet u een EnumType-element met drie lidelementen :

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

Het element NavigationProperty (CSDL)

Een NavigationProperty-element definieert een navigatie-eigenschap, die een verwijzing naar het andere einde van een koppeling biedt. In tegenstelling tot eigenschappen die zijn gedefinieerd met het eigenschapselement, definiëren navigatie-eigenschappen niet de vorm en kenmerken van gegevens. Ze bieden een manier om door een koppeling tussen twee entiteitstypen te navigeren.

Houd er rekening mee dat navigatie-eigenschappen optioneel zijn voor beide entiteitstypen aan het einde van een koppeling. Als u een navigatie-eigenschap definieert voor één entiteitstype aan het einde van een koppeling, hoeft u geen navigatie-eigenschap te definiëren voor het entiteitstype aan het andere uiteinde van de koppeling.

Het gegevenstype dat wordt geretourneerd door een navigatie-eigenschap, wordt bepaald door de multipliciteit van het externe koppelingseindeinde. Stel dat een navigatie-eigenschap OrdersNavProp bestaat op een entiteitstype Klant en navigeert naar een één-op-veel-associatie tussen Klant en Order. Omdat het remote associatie-eindpunt voor de navigatie-eigenschap multipliciteit veel (*) heeft, is het gegevenstype een verzameling (van Order). Evenzo, als een navigatie-eigenschap CustomerNavProp bestaat op het entiteitstype Order, is het datatype Customer omdat de multipliciteit van het externe uiteinde één (1) is.

Een NavigationProperty-element kan de volgende onderliggende elementen bevatten (in de vermelde volgorde):

• Documentatie (nul of één element)
• Aantekeningselementen (nul of meer elementen)

Toepasselijke kenmerken

In de onderstaande tabel worden de kenmerken beschreven die kunnen worden toegepast op het element NavigationProperty .

Voorbeeld

In het volgende voorbeeld wordt een entiteitstype (Boek) gedefinieerd met twee navigatie-eigenschappen (PublishedBy en WrittenBy):

 <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)

Het element OnDelete in de conceptuele schemadefinitietaal (CSDL) definieert het gedrag dat is verbonden met een koppeling. Als het kenmerk Actie is ingesteld op Trapsgewijs aan het ene uiteinde van een koppeling, worden gerelateerde entiteitstypen aan het andere uiteinde van de koppeling verwijderd wanneer het entiteitstype aan het eerste uiteinde wordt verwijderd. Als de koppeling tussen twee entiteitstypen een primaire sleutel-naar-primaire-sleutelrelatie is, wordt een geladen afhankelijk object verwijderd wanneer het principal-object aan het andere uiteinde van de koppeling wordt verwijderd, ongeacht de OnDelete-specificatie .  

Een OnDelete-element kan de volgende onderliggende elementen bevatten (in de vermelde volgorde):

• Documentatie (nul of één element)
• Aantekeningselementen (nul of meer elementen)

Toepasselijke kenmerken

In de onderstaande tabel worden de kenmerken beschreven die kunnen worden toegepast op het onDelete-element .

Voorbeeld

In het volgende voorbeeld ziet u een koppelingselement dat de koppeling CustomerOrders definieert. Het element OnDelete geeft aan dat alle orders die zijn gerelateerd aan een bepaalde klant en in objectcontext zijn geladen, worden verwijderd wanneer de klant wordt verwijderd.

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

Parameterelement (CSDL)

Het parameterelement in de conceptuele schemadefinitietaal (CSDL) kan een onderliggend element zijn van het Element FunctionImport of het element Functie.

FunctieImport-element toepassing

Een parameterelement (als onderliggend element van het element FunctionImport ) wordt gebruikt voor het definiëren van invoer- en uitvoerparameters voor functieimporten die zijn gedeclareerd in CSDL.

Het parameterelement kan de volgende onderliggende elementen bevatten (in de vermelde volgorde):

• Documentatie (nul of één elementen toegestaan)
• Aantekeningselementen (nul of meer toegestane elementen)

Toepasselijke kenmerken

In de volgende tabel worden de kenmerken beschreven die kunnen worden toegepast op het parameterelement .

Voorbeeld

In het volgende voorbeeld ziet u een FunctionImport-element met één onderliggend parameterelement . De functie accepteert één invoerparameter en retourneert een verzameling entiteitstypen.

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

Functie-elementtoepassing

Een parameterelement (als onderliggend element van het functieelement ) definieert parameters voor functies die zijn gedefinieerd of gedeclareerd in een conceptueel model.

Het parameterelement kan de volgende onderliggende elementen bevatten (in de vermelde volgorde):

• Documentatie (nul of één elementen)
• CollectionType (nul of één elementen)
• ReferenceType (nul of één elementen)
• RowType (nul of één elementen)

• Aantekeningselementen (nul of meer toegestane elementen)

Toepasselijke kenmerken

In de volgende tabel worden de kenmerken beschreven die kunnen worden toegepast op het parameterelement .

Voorbeeld

In het volgende voorbeeld ziet u een functie-element dat één onderliggend parameterelement gebruikt om een functieparameter te definiëren.

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

Principaalelement (CSDL)

Het principal-element in de conceptuele schemadefinitietaal (CSDL) is een onderliggend element voor het element ReferentialConstraint dat het principal-einde van een referentiële beperking definieert. Een ReferentialConstraint-element definieert functionaliteit die vergelijkbaar is met een beperking voor referentiële integriteit in een relationele database. Op dezelfde manier dat een kolom (of kolommen) uit een databasetabel kan verwijzen naar de primaire sleutel van een andere tabel, kan een eigenschap (of eigenschappen) van een entiteitstype verwijzen naar de entiteitssleutel van een ander entiteitstype. Het entiteitstype waarnaar wordt verwezen, wordt het principal-einde van de beperking genoemd. Het entiteitstype dat verwijst naar het principal-einde wordt het afhankelijke einde van de beperking genoemd. PropertyRef-elementen worden gebruikt om op te geven naar welke sleutels worden verwezen door het afhankelijke einde.

Het principal-element kan de volgende onderliggende elementen bevatten (in de vermelde volgorde):

• PropertyRef (een of meer elementen)
• Aantekeningselementen (nul of meer elementen)

Toepasselijke kenmerken

In de onderstaande tabel worden de kenmerken beschreven die kunnen worden toegepast op het principal-element .

Voorbeeld

In het volgende voorbeeld ziet u een ReferentialConstraint-element dat deel uitmaakt van de definitie van de association PublishedBy . De eigenschap Id van het entiteitstype Publisher vormt het principal-einde van de referentiële beperking.

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

Eigenschapselement (CSDL)

Het element Eigenschap in de conceptuele schemadefinitietaal (CSDL) kan een onderliggend element zijn van het Element EntityType, het element ComplexType of het element RowType.

EntityType- en ComplexType-elementtoepassingen

Eigenschapselementen (als onderliggende elementen van EntityType of ComplexType ) definiëren de vorm en kenmerken van gegevens die een entiteitstype-exemplaar of een complex type-exemplaar bevat. Eigenschappen in een conceptueel model zijn vergelijkbaar met eigenschappen die zijn gedefinieerd in een klasse. Op dezelfde manier als de eigenschappen van een klasse de vorm van de klasse definiëren en informatie over objecten bevatten, definiëren eigenschappen in een conceptueel model de vorm van een entiteitstype en bevatten informatie over instanties van entiteitstypen.

Het eigenschapselement kan de volgende onderliggende elementen bevatten (in de vermelde volgorde):

• Documentatie-element (nul of één elementen toegestaan)
• Aantekeningselementen (nul of meer toegestane elementen)

De volgende facetten kunnen worden toegepast op een eigenschapselement: Nullable, DefaultValue, MaxLength, FixedLength, Precision, Scale, Unicode, Collation, ConcurrencyMode. Facetten zijn XML-kenmerken die informatie bieden over hoe eigenschapswaarden worden opgeslagen in het gegevensarchief.

Toepasselijke kenmerken

In de volgende tabel worden de kenmerken beschreven die kunnen worden toegepast op het eigenschapselement .

Voorbeeld

In het volgende voorbeeld ziet u een EntityType-element met drie eigenschapselementen :

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

In het volgende voorbeeld ziet u een ComplexType-element met vijf eigenschapselementen :

 <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-elementtoepassing

Eigenschapselementen (als onderliggende elementen van een RowType-element ) definiëren de vorm en kenmerken van gegevens die kunnen worden doorgegeven aan of geretourneerd vanuit een modelgedefinieerde functie.  

Het eigenschapselement kan precies een van de volgende onderliggende elementen hebben:

• CollectionType
• ReferenceType
• RowType

Het eigenschapselement kan een willekeurig aantal onderliggende aantekeningselementen bevatten.

Toepasselijke kenmerken

In de volgende tabel worden de kenmerken beschreven die kunnen worden toegepast op het eigenschapselement .

Voorbeeld

In het volgende voorbeeld ziet u eigenschapselementen die worden gebruikt om de vorm van het retourtype van een modelgedefinieerde functie te definiëren.

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

Het element PropertyRef (CSDL)

Het element PropertyRef in de conceptuele schemadefinitietaal (CSDL) verwijst naar een eigenschap van een entiteitstype om aan te geven dat de eigenschap een van de volgende rollen uitvoert:

• Onderdeel van de sleutel van de entiteit (een eigenschap of een set eigenschappen van een entiteitstype die de identiteit bepalen). Een of meer PropertyRef-elementen kunnen worden gebruikt om een entiteitssleutel te definiëren.
• Het afhankelijke of hoofd-einde van een referentiële beperking.

Het element PropertyRef kan alleen annotatie-elementen (nul of meer) bevatten als onderliggende elementen.

Toepasselijke kenmerken

In de onderstaande tabel worden de kenmerken beschreven die kunnen worden toegepast op het element PropertyRef .

Voorbeeld

In het onderstaande voorbeeld wordt een entiteitstype (Boek) gedefinieerd. De entiteitssleutel wordt gedefinieerd door te verwijzen naar de eigenschap ISBN van het entiteitstype.

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

In het volgende voorbeeld worden twee PropertyRef-elementen gebruikt om aan te geven dat twee eigenschappen (Id en PublisherId) de principal en afhankelijke uiteinden van een referentiële beperking zijn.

 <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)

Het element ReferenceType in de conceptuele schemadefinitietaal (CSDL) geeft een verwijzing naar een entiteitstype op. Het element ReferenceType kan een onderliggend element van de volgende elementen zijn:

• ReturnType (functie)
• Kenmerk
• CollectionType

Het ReferenceType-element wordt gebruikt bij het definiëren van een parameter of retourtype voor een functie.

Een ReferenceType-element kan de volgende onderliggende elementen bevatten (in de vermelde volgorde):

• Documentatie (nul of één element)
• Aantekeningselementen (nul of meer elementen)

Toepasselijke kenmerken

In de onderstaande tabel worden de kenmerken beschreven die kunnen worden toegepast op het ReferenceType-element .

Voorbeeld

In het volgende voorbeeld ziet u het ReferenceType-element dat wordt gebruikt als een onderliggend element van een parameterelement in een door een model gedefinieerde functie die een verwijzing naar een entiteitstype Person accepteert:

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

In het volgende voorbeeld ziet u het ReferenceType-element dat wordt gebruikt als een onderliggend element van een ReturnType-element (functie) in een modelgedefinieerde functie die een verwijzing naar een entiteitstype Persoon retourneert:

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

ReferentialConstraint-element (CSDL)

Een ReferentialConstraint-element in de conceptuele schemadefinitietaal (CSDL) definieert functionaliteit die vergelijkbaar is met een beperking voor referentiële integriteit in een relationele database. Op dezelfde manier dat een kolom (of kolommen) uit een databasetabel kan verwijzen naar de primaire sleutel van een andere tabel, kan een eigenschap (of eigenschappen) van een entiteitstype verwijzen naar de entiteitssleutel van een ander entiteitstype. Het entiteitstype waarnaar wordt verwezen, wordt het principal-einde van de beperking genoemd. Het entiteitstype dat verwijst naar het principal-einde wordt het afhankelijke einde van de beperking genoemd.

Als een foreign key die op een entiteitstype voorkomt verwijst naar een eigenschap op een ander entiteitstype, definieert het element ReferentialConstraint een koppeling tussen de twee entiteitstypen. Omdat het element ReferentialConstraint informatie biedt over de relatie tussen twee entiteitstypen, is er geen bijbehorende AssociationSetMapping-element nodig in de toewijzingsspecificatietaal (MSL). Een koppeling tussen twee entiteitstypen waarvoor geen refererende sleutels beschikbaar zijn, moet een bijbehorend AssociationSetMapping-element hebben om koppelingsinformatie toe te wijzen aan de gegevensbron.

Als een vreemde sleutel niet zichtbaar is op een entiteitstype, kan het element ReferentialConstraint alleen een primaire sleutel-naar-primaire sleutelbeperking definiëren tussen het entiteitstype en een ander entiteitstype.

Een ReferentialConstraint-element kan de volgende onderliggende elementen bevatten (in de vermelde volgorde):

• Documentatie (nul of één element)
• Principal (precies één element)
• Afhankelijk (precies één element)
• Aantekeningselementen (nul of meer elementen)

Toepasselijke kenmerken

Het element ReferentialConstraint kan een willekeurig aantal annotatiekenmerken (aangepaste XML-kenmerken) hebben. Aangepaste kenmerken behoren echter mogelijk niet tot een XML-naamruimte die is gereserveerd voor CSDL. De volledig gekwalificeerde namen voor twee aangepaste kenmerken kunnen niet hetzelfde zijn.

Voorbeeld

In het volgende voorbeeld ziet u een ReferentialConstraint-element dat wordt gebruikt als onderdeel van de definitie van de associatie PublishedBy.

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

Het element ReturnType (Function) (CSDL)

Het element ReturnType (Function) in de conceptuele schemadefinitietaal (CSDL) geeft het retourtype op voor een functie die is gedefinieerd in een functie-element. Een retourtype voor een functie kan ook worden opgegeven met een ReturnType-kenmerk .

Retourtypen kunnen elk EdmSimpleType, entiteitstype, complex type, rijtype, reftype of een verzameling van een van deze typen zijn.

Het retourtype van een functie kan worden opgegeven met het kenmerk Type van het element ReturnType (Functie) of met een van de volgende onderliggende elementen:

• CollectionType
• ReferenceType
• RowType

Toepasselijke kenmerken

In de volgende tabel worden de kenmerken beschreven die kunnen worden toegepast op het element ReturnType (Functie).

Voorbeeld

In het volgende voorbeeld wordt een functie-element gebruikt om een functie te definiëren die het aantal jaren retourneert dat een boek is afgedrukt. Houd er rekening mee dat het retourtype wordt opgegeven door het kenmerk Type van een ReturnType-element (functie).

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

Het ReturnType (FunctionImport) element (CSDL)

Het element ReturnType (FunctionImport) in de conceptuele schemadefinitietaal (CSDL) geeft het retourtype op voor een functie die is gedefinieerd in een FunctionImport-element. Een retourtype voor een functie kan ook worden opgegeven met een ReturnType-kenmerk .

Retourtypen kunnen verzamelingen van entiteitstypen, complexe typen of EdmSimpleType zijn,

Het retourtype van een functie wordt opgegeven met het kenmerk Type van het element ReturnType (FunctionImport).

Toepasselijke kenmerken

In de volgende tabel worden de kenmerken beschreven die kunnen worden toegepast op het element ReturnType (FunctionImport).

Voorbeeld

In het volgende voorbeeld wordt een FunctionImport gebruikt waarmee boeken en uitgevers worden geretourneerd. De functie retourneert twee resultatensets en daarom worden er twee ReturnType-elementen (FunctionImport) opgegeven.

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

RowType-element (CSDL)

Een RowType-element in de conceptuele schemadefinitietaal (CSDL) definieert een niet-benoemde structuur als parameter of retourtype voor een functie die is gedefinieerd in het conceptuele model.

Een RowType-element kan het onderliggende element van de volgende elementen zijn:

• CollectionType
• Kenmerk
• ReturnType (functie)

Een RowType-element kan de volgende onderliggende elementen bevatten (in de vermelde volgorde):

• De eigenschap(pen) (een of meer)
• Aantekeningselementen (nul of meer)

Toepasselijke kenmerken

Een willekeurig aantal annotatiekenmerken (aangepaste XML-kenmerken) kan worden toegepast op het element RowType . Aangepaste kenmerken behoren echter mogelijk niet tot een XML-naamruimte die is gereserveerd voor CSDL. De volledig gekwalificeerde namen voor twee aangepaste kenmerken kunnen niet hetzelfde zijn.

Voorbeeld

In het volgende voorbeeld ziet u een modelgedefinieerde functie die gebruikmaakt van een CollectionType-element om op te geven dat de functie een verzameling rijen retourneert (zoals opgegeven in het element RowType ).

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

Schemaelement (CSDL)

Het schema-element is het hoofdelement van een conceptuele modeldefinitie. Het bevat definities voor de objecten, functies en containers waaruit een conceptueel model bestaat.

Het schema-element kan nul of meer van de volgende onderliggende elementen bevatten:

• Gebruiken
• EntiteitContainer
• Entiteitstype
• EnumType
• Vereniging
• ComplexType
• Function

Een schema-element kan nul of één aantekeningselementen bevatten.

Het schema-element maakt gebruik van het kenmerk Naamruimte om de naamruimte voor het entiteitstype, het complexe type en de koppelingsobjecten in een conceptueel model te definiëren. Binnen een naamruimte kunnen geen twee objecten dezelfde naam hebben. Naamruimten kunnen meerdere schema-elementen en meerdere .csdl-bestanden omvatten.

Een conceptuele modelnaamruimte verschilt van de XML-naamruimte van het schema-element . Een conceptuele modelnaamruimte (zoals gedefinieerd door het kenmerk Naamruimte ) is een logische container voor entiteitstypen, complexe typen en koppelingstypen. De XML-naamruimte (aangegeven door het kenmerk XMLNS ) van een schema-element is de standaardnaamruimte voor onderliggende elementen en kenmerken van het schema-element . XML-naamruimten van het formulier https://schemas.microsoft.com/ado/YYYY/MM/edm (waarbij JJJJ en MM respectievelijk een jaar en maand vertegenwoordigen) zijn gereserveerd voor CSDL. Aangepaste elementen en kenmerken kunnen zich niet in naamruimten bevinden die dit formulier hebben.

Toepasselijke kenmerken

In de onderstaande tabel worden de kenmerken beschreven die kunnen worden toegepast op het schema-element .

Voorbeeld

In het volgende voorbeeld ziet u een Schema-element dat een EntityContainer-element , twee EntityType-elementen en één koppelingselement bevat.

 <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)

Het Element TypeRef in de conceptuele schemadefinitietaal (CSDL) bevat een verwijzing naar een bestaand benoemd type. Het Element TypeRef kan een onderliggend element van het CollectionType-element zijn, dat wordt gebruikt om op te geven dat een functie een verzameling heeft als parameter of retourtype.

Een TypeRef-element kan de volgende onderliggende elementen bevatten (in de vermelde volgorde):

• Documentatie (nul of één element)
• Aantekeningselementen (nul of meer elementen)

Toepasselijke kenmerken

In de volgende tabel worden de kenmerken beschreven die kunnen worden toegepast op het Element TypeRef . Houd er rekening mee dat de kenmerken DefaultValue, MaxLength, FixedLength, Precision, Scale, Unicode en Sortation alleen van toepassing zijn op EDMSimpleTypes.

Voorbeeld

In het volgende voorbeeld ziet u een modelgedefinieerde functie die gebruikmaakt van het Element TypeRef (als onderliggend element van een CollectionType-element ) om op te geven dat de functie een verzameling entiteitstypen afdeling accepteert.

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

Element gebruiken (CSDL)

Het element Using in conceptual schema definition language (CSDL) importeert de inhoud van een conceptueel model dat bestaat in een andere naamruimte. Door de waarde van het kenmerk Naamruimte in te stellen, kunt u verwijzen naar entiteitstypen, complexe typen en koppelingstypen die zijn gedefinieerd in een ander conceptueel model. Meer dan één using-element kan een onderliggend element van een schema-element zijn.

Het element Using kan de volgende onderliggende elementen hebben:

• Documentatie (nul of één elementen toegestaan)
• Aantekeningselementen (nul of meer toegestane elementen)

Toepasselijke kenmerken

In de onderstaande tabel worden de kenmerken beschreven die kunnen worden toegepast op het element Using .

Voorbeeld

In het volgende voorbeeld ziet u het element Using dat wordt gebruikt om een naamruimte te importeren die ergens anders is gedefinieerd. Houd er rekening mee dat de naamruimte voor het weergegeven schema-element is BooksModel. De Address eigenschap op het PublisherEntityType is een complex type dat is gedefinieerd in de ExtendedBooksModel naamruimte (geïmporteerd met het element Using ).

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

Annotatiekenmerken (CSDL)

Aantekeningenkenmerken in de conceptuele schemadefinitietaal (CSDL) zijn aangepaste XML-kenmerken in het conceptuele model. Naast een geldige XML-structuur moet het volgende waar zijn voor aantekeningenkenmerken:

• Annotatiekenmerken mogen zich niet in een XML-naamruimte bevinden die is gereserveerd voor CSDL.
• Er kunnen meer dan één aantekeningskenmerk worden toegepast op een bepaald CSDL-element.
• De volledig gekwalificeerde namen van welke twee dan ook kenmerken van annotaties mogen niet hetzelfde zijn.

Aantekeningenkenmerken kunnen worden gebruikt om extra metagegevens over de elementen in een conceptueel model te bieden. Metagegevens in annotatie-elementen kunnen tijdens runtime worden geopend met behulp van klassen in de naamruimte System.Data.Metadata.Edm.

Voorbeeld

In het volgende voorbeeld ziet u een EntityType-element met een annotatiekenmerk (CustomAttribute). In het voorbeeld ziet u ook een aantekeningselement dat is toegepast op het element van het entiteitstype.

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

Met de volgende code worden de metagegevens in het aantekeningskenmerk opgehaald en naar de console geschreven:

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

In de bovenstaande code wordt ervan uitgegaan dat het School.csdl bestand zich bevindt in de uitvoermap van het project en dat u de volgende instructies Imports en Using aan uw project hebt toegevoegd:

 using System.Data.Metadata.Edm;

Aantekeningenelementen (CSDL)

Aantekeningenelementen in de conceptuele schemadefinitietaal (CSDL) zijn aangepaste XML-elementen in het conceptuele model. Naast een geldige XML-structuur moet het volgende waar zijn voor aantekeningen:

• Aantekeningselementen mogen zich niet in een XML-naamruimte bevinden die is gereserveerd voor CSDL.
• Meer dan één aantekeningselement kan een onderliggend element van een bepaald CSDL-element zijn.
• De volledig gekwalificeerde namen van twee aantekeningselementen mogen niet hetzelfde zijn.
• Aantekeningselementen moeten worden weergegeven na alle andere onderliggende elementen van een bepaald CSDL-element.

Aantekeningselementen kunnen worden gebruikt om extra metagegevens over de elementen in een conceptueel model te bieden. Vanaf .NET Framework versie 4 kunnen metagegevens in aantekeningen tijdens runtime worden geopend met behulp van klassen in de naamruimte System.Data.Metadata.Edm.

Voorbeeld

In het volgende voorbeeld ziet u een EntityType-element met een aantekeningselement (CustomElement). In het voorbeeld ziet u ook een aantekeningskenmerk dat is toegepast op het element van het entiteitstype.

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

Met de volgende code worden de metagegevens in het aantekeningselement opgehaald en naar de console geschreven:

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

In de bovenstaande code wordt ervan uitgegaan dat het bestand School.csdl zich in de uitvoermap van het project bevindt en dat u de volgende Imports en Using instructies aan uw project hebt toegevoegd.

 using System.Data.Metadata.Edm;

Conceptuele modeltypen (CSDL)

De conceptuele schemadefinitietaal (CSDL) ondersteunt een set abstracte primitieve gegevenstypen, EDMSimpleTypes genoemd, die eigenschappen definiëren in een conceptueel model. EDMSimpleTypes zijn proxy's voor primitieve gegevenstypen die worden ondersteund in de opslag- of hostingomgeving.

De onderstaande tabel bevat de primitieve gegevenstypen die worden ondersteund door CSDL. De tabel bevat ook de facetten die op elk EDMSimpleType kunnen worden toegepast.

Facetten (CSDL)

Facetten in de conceptuele schemadefinitietaal (CSDL) vertegenwoordigen beperkingen voor eigenschappen van entiteitstypen en complexe typen. Facetten worden weergegeven als XML-kenmerken op de volgende CSDL-elementen:

• Vastgoed
• TypeRef
• Kenmerk

In de volgende tabel worden de facetten beschreven die worden ondersteund in CSDL. Alle facetten zijn optioneel. Sommige facetten die hieronder worden vermeld, worden door entity framework gebruikt bij het genereren van een database op basis van een conceptueel model.

Voorbeeld

In het volgende voorbeeld ziet u facetten die zijn toegepast op de eigenschappen van een entiteitstype:

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