XML- och ADO.NET typer i datakontrakt

  • Artikel

WCF-datakontraktsmodellen (Windows Communication Foundation) stöder vissa typer som representerar XML direkt. När dessa typer serialiseras till XML skriver serialiseraren ut XML-innehållet i dessa typer utan ytterligare bearbetning. Typer som stöds är XmlElement, matriser av XmlNode (men inte XmlNode själva typen) samt typer som implementerar IXmlSerializable. Typen DataSet och DataTable samt typ av datauppsättningar används ofta i databasprogrammering. Dessa typer implementerar IXmlSerializable gränssnittet och kan därför serialiseras i datakontraktsmodellen. Några särskilda överväganden för dessa typer visas i slutet av det här avsnittet.

XML-typer

Xml-element

Typen XmlElement serialiseras med dess XML-innehåll. Du kan till exempel använda följande typ.

[DataContract(Namespace=@"http://schemas.contoso.com")]
public class MyDataContract
{
    [DataMember]
    public XmlElement myDataMember;
    public void TestClass()
    {
        XmlDocument xd = new XmlDocument();
        myDataMember = xd.CreateElement("myElement");
        myDataMember.InnerText = "myContents";
        myDataMember.SetAttribute
         ("myAttribute","myValue");
    }
}

<DataContract([Namespace]:="http://schemas.contoso.com")> _
Public Class MyDataContract
    <DataMember()> _
    Public myDataMember As XmlElement

    Public Sub TestClass()
        Dim xd As New XmlDocument()
        myDataMember = xd.CreateElement("myElement")
        myDataMember.InnerText = "myContents"
        myDataMember.SetAttribute("myAttribute", "myValue")

    End Sub
End Class

Detta serialiseras till XML på följande sätt:

<MyDataContract xmlns="http://schemas.contoso.com">  
    <myDataMember>  
        <myElement xmlns="" myAttribute="myValue">  
            myContents  
        </myElement>  
    </myDataMember>  
</MyDataContract>

Observera att ett omslutningsdatamedlemselement <myDataMember> fortfarande finns. Det går inte att ta bort det här elementet i datakontraktsmodellen. Serialiserare som hanterar den här modellen ( DataContractSerializer och NetDataContractSerializer) kan generera särskilda attribut till det här omslutningselementet. Dessa attribut inkluderar standard attributet XML Schema Instance "nil" (tillåter att det XmlElement är null) och attributet "type" (tillåter XmlElement att det används polymorfiskt). Dessutom är följande XML-attribut specifika för WCF: "Id", "Ref", "Type" och "Assembly". Dessa attribut kan genereras för att stödja med objektdiagrammets XmlElement konserveringsläge aktiverat, eller med NetDataContractSerializer. (Mer information om objektdiagrammets konserveringsläge finns i Serialisering och deserialisering.)

Matriser eller samlingar av XmlElement tillåts och hanteras som alla andra matriser eller samlingar. Det vill säga det finns ett omslutningselement för hela samlingen och ett separat omslutningselement (ungefär som <myDataMember> i föregående exempel) för var och XmlElement en i matrisen.

Vid deserialisering skapas en XmlElement av deserialiseraren från inkommande XML. En giltig överordnad XmlDocument tillhandahålls av deserialiseraren.

Kontrollera att XML-fragmentet som deserialiseras till ett XmlElement definierar alla prefix som används och inte förlitar sig på några prefixdefinitioner från överordnade element. Detta är bara ett problem när du använder DataContractSerializer för att komma åt XML från en annan (icke-DataContractSerializer) källa.

När det används med DataContractSerializer, XmlElement kan tilldelas polymorfiskt, men bara till en datamedlem av typen Object. Även om den implementerar IEnumerablekan en XmlElement inte användas som en samlingstyp och kan inte tilldelas till en IEnumerable datamedlem. Precis som med alla polymorfa tilldelningar DataContractSerializer genererar datakontraktets namn i den resulterande XML-koden. I det här fallet är det "XmlElement" i http://schemas.datacontract.org/2004/07/System.Xml namnområdet.

NetDataContractSerializerMed stöds alla giltiga polymorfa tilldelningar av XmlElement (till Object eller IEnumerable).

Försök inte att använda någon av serialiserarna med typer som härletts från XmlElement, oavsett om de tilldelas polymorfiskt eller inte.

Matris med XmlNode

Att använda matriser av XmlNode liknar mycket att använda XmlElement. Om du använder matriser med XmlNode får du större flexibilitet än att använda XmlElement. Du kan skriva flera element i datamedlemshanteringselementet. Du kan också mata in annat innehåll än element i datamedlemshanteringselementet, till exempel XML-kommentarer. Slutligen kan du placera attribut i elementet wrapping data member. Allt detta kan uppnås genom att fylla i matrisen XmlNode med med specifika härledda klasser XmlNode , till exempel XmlAttribute, XmlElement eller XmlComment. Du kan till exempel använda följande typ.

[DataContract(Namespace="http://schemas.contoso.com")]
public class MyDataContract
{
    [DataMember]
    public XmlNode[] myDataMember = new XmlNode[4];
    public void TestClass()
    {
        XmlDocument xd = new XmlDocument();
        XmlElement xe = xd.CreateElement("myElement");
        xe.InnerText = "myContents";
        xe.SetAttribute
         ("myAttribute","myValue");
    
        XmlAttribute atr = xe.Attributes[0];
        XmlComment cmnt = xd.CreateComment("myComment");
        
      myDataMember[0] = atr;
      myDataMember[1] = cmnt;
      myDataMember[2] = xe;
      myDataMember[3] = xe;
    }
}

<DataContract([Namespace]:="http://schemas.contoso.com")> _
Public Class MyDataContract
    <DataMember()> _
    Public myDataMember(3) As XmlNode

    Public Sub TestClass()
        Dim xd As New XmlDocument()
        Dim xe As XmlElement = xd.CreateElement("myElement")
        xe.InnerText = "myContents"
        xe.SetAttribute("myAttribute", "myValue")

        Dim atr As XmlAttribute = xe.Attributes(0)
        Dim cmnt As XmlComment = xd.CreateComment("myComment")

        myDataMember(0) = atr
        myDataMember(1) = cmnt
        myDataMember(2) = xe
        myDataMember(3) = xe

    End Sub

End Class

När xml-koden serialiseras liknar den följande koden.

<MyDataContract xmlns="http://schemas.contoso.com">  
  <myDataMember myAttribute="myValue">  
     <!--myComment-->  
     <myElement xmlns="" myAttribute="myValue">  
 myContents  
     </myElement>  
     <myElement xmlns="" myAttribute="myValue">  
       myContents  
     </myElement>  
  </myDataMember>  
</MyDataContract>

Observera att datamedlemsomslutningselementet <myDataMember> innehåller ett attribut, en kommentar och två element. Det här är de fyra XmlNode instanserna som serialiserades.

En matris med XmlNode som resulterar i ogiltig XML kan inte serialiseras. Till exempel en matris med två XmlNode instanser där den första är en XmlElement och den andra är XmlAttribute ogiltig, eftersom den här sekvensen inte motsvarar någon giltig XML-instans (det finns ingen plats att koppla attributet till).

Vid deserialisering av en matris med XmlNodeskapas och fylls noder med information från inkommande XML. En giltig överordnad XmlDocument tillhandahålls av deserialiseraren. Alla noder deserialiseras, inklusive eventuella attribut i elementet wrapper data member, men exklusive de attribut som placeras där av WCF-serialiserare (till exempel de attribut som används för att indikera polymorfisk tilldelning). Förbehållet om att definiera alla namnområdesprefix i XML-fragmentet gäller för deserialiseringen av matriser på XmlNode samma sätt som det gör för att deserialisera XmlElement.

När du använder serialiserarna med objektdiagrambevarande aktiverat bevaras objektjämlikhet endast på matrisnivå XmlNode , inte enskilda XmlNode instanser.

Försök inte serialisera en matris XmlNode där en eller flera av noderna är inställda på null. Det är tillåtet för hela matrismedlemmen att vara null, men inte för någon individ XmlNode som finns i matrisen. Om hela matrismedlemmen är null innehåller elementet wrapper data member ett särskilt attribut som anger att det är null. Vid deserialisering blir hela matrismedlemmen också null.

Endast vanliga matriser av XmlNode behandlas speciellt av serialiseraren. Datamedlemmar som deklareras som andra samlingstyper som innehåller XmlNode, eller datamedlemmar som deklarerats som matriser av typer som härletts från XmlNode, behandlas inte särskilt. Därför är de normalt inte serialiserbara om de inte också uppfyller något av de andra kriterierna för serialisering.

Matriser eller samlingar med matriser med tillåts XmlNode . Det finns ett wrapper-element för hela samlingen och ett separat omslutningselement (liknar <myDataMember> i föregående exempel) för varje matris XmlNode i den yttre matrisen eller samlingen.

Att fylla i en datamedlem av typen Array av Object eller IEnumerableArray med XmlNode instanser resulterar inte i att datamedlemmen behandlas som en Array av XmlNode instanserna. Varje matrismedlem serialiseras separat.

När de DataContractSerializeranvänds med kan matriser av XmlNode tilldelas polymorfiskt, men bara till en datamedlem av typen Object. Även om den implementerar IEnumerablekan inte en matris XmlNode med användas som en samlingstyp och tilldelas till en IEnumerable datamedlem. Precis som med alla polymorfa tilldelningar DataContractSerializer genererar datakontraktets namn i den resulterande XML:en – i det här fallet är det "ArrayOfXmlNode" i http://schemas.datacontract.org/2004/07/System.Xml namnområdet. När den används med NetDataContractSerializerstöds alla giltiga tilldelningar av en XmlNode matris.

Schemaöverväganden

Mer information om schemamappning av XML-typer finns i Schemareferens för datakontrakt. Det här avsnittet innehåller en sammanfattning av viktiga punkter.

En datamedlem av typen XmlElement mappas till ett element som definierats med hjälp av följande anonyma typ.

<xsd:complexType>  
   <xsd:sequence>  
      <xsd:any minOccurs="0" processContents="lax" />  
   </xsd:sequence>  
</xsd:complexType>

En datamedlem av typen Matris av XmlNode mappas till ett element som definierats med hjälp av följande anonyma typ.

<xsd:complexType mixed="true">  
   <xsd:sequence>  
      <xsd:any minOccurs="0" maxOccurs="unbounded" processContents="lax" />  
   </xsd:sequence>  
   <xsd:anyAttribute/>  
</xsd:complexType>

Typer som implementerar IXmlSerializable-gränssnittet

Typer som implementerar IXmlSerializable gränssnittet stöds fullt ut av DataContractSerializer. Attributet XmlSchemaProviderAttribute bör alltid tillämpas på dessa typer för att styra deras schema.

Det finns tre typer av typer som implementerar IXmlSerializable: typer som representerar godtyckligt innehåll, typer som representerar ett enda element och äldre DataSet typer.

  • Innehållstyper använder en schemaprovidermetod som anges av attributet XmlSchemaProviderAttribute . Metoden returnerar nullinte , och IsAny egenskapen för attributet lämnas vid standardvärdet false. Det här är den vanligaste användningen av IXmlSerializable typer.

  • Elementtyper används när en IXmlSerializable typ måste styra sitt eget rotelementnamn. Om du vill markera en typ som en elementtyp anger du IsAny antingen egenskapen för XmlSchemaProviderAttribute attributet till true eller returnerar null från metoden schemaprovider. Att ha en schemaprovidermetod är valfritt för elementtyper – du kan ange null i stället för metodnamnet i XmlSchemaProviderAttribute. Men om IsAny är true och en schemaprovidermetod har angetts måste metoden returnera null.

  • Äldre DataSet typer är IXmlSerializable typer som inte har markerats med attributet XmlSchemaProviderAttribute . I stället förlitar de sig på GetSchema metoden för schemagenerering. Det här mönstret används för DataSet typen och dess typade datauppsättning härleder en klass i tidigare versioner av .NET Framework, men är nu föråldrad och stöds endast av äldre skäl. Förlita dig inte på det här mönstret och tillämpa alltid på XmlSchemaProviderAttribute dina IXmlSerializable typer.

IXmlSerializable-innehållstyper

När du serialiserar en datamedlem av en typ som implementerar IXmlSerializable och är en innehållstyp som definierats tidigare skriver serialiseraren omslutningselementet för datamedlemmen och skickar kontrollen till WriteXml metoden. Implementeringen WriteXml kan skriva valfri XML, inklusive att lägga till attribut till wrapper-elementet. När WriteXml är klar stänger serialiseraren elementet.

När du deserialiserar en datamedlem av en typ som implementerar IXmlSerializable och är en innehållstyp som definierats tidigare placerar deserialiseraren XML-läsaren på omslutningselementet för datamedlemmen och skickar kontrollen till ReadXml metoden. Metoden måste läsa hela elementet, inklusive start- och sluttaggar. Kontrollera att koden ReadXml hanterar fallet där elementet är tomt. Dessutom bör implementeringen ReadXml inte förlita sig på att wrapper-elementet namnges på ett visst sätt. Namnet som väljs av serialiseraren kan variera.

Det är tillåtet att tilldela IXmlSerializable innehållstyper polymorfiskt, till exempel till datamedlemmar av typen Object. Det är också tillåtet för typinstanserna att vara null. Slutligen är det möjligt att använda IXmlSerializable typer med objektdiagrambevarande aktiverat och med NetDataContractSerializer. Alla dessa funktioner kräver att WCF-serialiseraren kopplar vissa attribut till wrapper-elementet ("nil" och "type" i XML-schemainstansens namnområde och "ID", "Ref", "Type" och "Assembly" i ett WCF-specifikt namnområde).

Attribut som ska ignoreras vid implementering av ReadXml

Innan kontrollen skickas till koden ReadXml undersöker deserialiseraren XML-elementet, identifierar dessa speciella XML-attribut och agerar på dem. Om till exempel "nil" är true, deserialiseras ett null-värde och ReadXml anropas inte. Om polymorfism identifieras deserialiseras innehållet i elementet som om det var en annan typ. Den polymorfiskt tilldelade typens implementering av ReadXml anropas. I vilket fall som helst bör en ReadXml implementering ignorera dessa särskilda attribut eftersom de hanteras av deserialiseraren.

Schemaöverväganden för IXmlSerializable-innehållstyper

När du exporterar schema en IXmlSerializable innehållstyp anropas metoden schemaprovider. En XmlSchemaSet skickas till metoden schemaprovider. Metoden kan lägga till valfritt giltigt schema i schemauppsättningen. Schemauppsättningen innehåller det schema som redan är känt när schemaexport sker. När metoden schemaprovider måste lägga till ett objekt i schemauppsättningen måste den avgöra om en XmlSchema med rätt namnområde redan finns i uppsättningen. Om det gör det måste metoden schemaprovider lägga till det nya objektet i den befintliga XmlSchema. Annars måste den skapa en ny XmlSchema instans. Detta är viktigt om matriser av IXmlSerializable typer används. Om du till exempel har en IXmlSerializable typ som exporteras som typen "A" i namnområdet "B" är det möjligt att schemaprovidermetoden redan innehåller schemat för "B" för att lagra typen "ArrayOfA".

Förutom att lägga till typer i XmlSchemaSetmåste schemaprovidermetoden för innehållstyper returnera ett värde som inte är null. Den kan returnera ett XmlQualifiedName som anger namnet på den schematyp som ska användas för den angivna IXmlSerializable typen. Det här kvalificerade namnet fungerar också som datakontraktets namn och namnområde för typen. Det är tillåtet att returnera en typ som inte finns i schemauppsättningen omedelbart när schemaprovidermetoden returneras. Det förväntas dock att när alla relaterade typer exporteras ( Export metoden anropas för alla relevanta typer på XsdDataContractExporter och Schemas egenskapen används) finns typen i schemauppsättningen. Åtkomst till Schemas egenskapen innan alla relevanta Export anrop har gjorts kan resultera i en XmlSchemaException. Mer information om exportprocessen finns i Exportera scheman från klasser.

Metoden schemaprovider kan också returnera för XmlSchemaType användning. Typen kan vara anonym eller inte. Om den är anonym exporteras schemat för IXmlSerializable typen som en anonym typ varje gång IXmlSerializable typen används som datamedlem. Typen IXmlSerializable har fortfarande ett namn och namnområde för datakontraktet. (Detta fastställs enligt beskrivningen i Namn på datakontrakt förutom att DataContractAttribute attributet inte kan användas för att anpassa namnet.) Om den inte är anonym måste den vara en av typerna XmlSchemaSeti . Det här fallet motsvarar att XmlQualifiedName returnera typen.

Dessutom exporteras en global elementdeklaration för typen. Om typen inte har XmlRootAttribute attributet tillämpat på det, har elementet samma namn och namnområde som datakontraktet och dess egenskap "nillable" är true. Det enda undantaget är schemanamnområdet (http://www.w3.org/2001/XMLSchema); om typens datakontrakt finns i det här namnområdet finns motsvarande globala element i det tomma namnområdet eftersom det är förbjudet att lägga till nya element i schemanamnområdet. Om typen har det XmlRootAttribute attribut som tillämpas på den exporteras den globala elementdeklarationen med hjälp av följande egenskaper: ElementName, Namespaceoch IsNullable. Standardvärdena med XmlRootAttribute tillämpad är datakontraktets namn, ett tomt namnområde och "nillable" som är sant.

Samma regler för global elementdeklaration gäller för äldre datauppsättningstyper. Observera att det inte går att åsidosätta globala elementdeklarationer som XmlRootAttribute lagts till via anpassad kod, antingen läggs till XmlSchemaSet med hjälp av metoden schemaprovider eller via GetSchema för äldre datamängdstyper.

IXmlSerializable-elementtyper

IXmlSerializable elementtyper har antingen egenskapen inställd på IsAnytrue eller så returneras nullderas schemaprovidermetod .

Serialisering och deserialisering av en elementtyp liknar serialisering och deserialisering av en innehållstyp. Det finns dock några viktiga skillnader:

  • Implementeringen WriteXml förväntas skriva exakt ett element (som naturligtvis kan innehålla flera underordnade element). Det bör inte skriva attribut utanför det här enskilda elementet, flera syskonelement eller blandat innehåll. Elementet kan vara tomt.

  • Implementeringen ReadXml bör inte läsa omslutningselementet. Det förväntas läsa det enda element som WriteXml producerar.

  • När du serialiserar en elementtyp regelbundet (till exempel som en datamedlem i ett datakontrakt) matar serialiseraren ut ett wrapper-element innan den anropar WriteXml, som med innehållstyper. Men när du serialiserar en elementtyp på den översta nivån matar serialiseraren normalt inte ut ett omslutningselement alls runt elementet som WriteXml skriver, såvida inte ett rotnamn och namnområde uttryckligen angavs när serialiseraren konstruerades i DataContractSerializer konstruktorerna eller NetDataContractSerializer . Mer information finns i Serialisering och deserialisering.

  • När du serialiserar en elementtyp på den översta nivån utan att ange rotnamnet och namnområdet vid byggtiden, WriteStartObject och WriteEndObject i princip inte gör någonting och WriteObjectContent anropar WriteXml. I det här läget kan objektet som serialiseras inte vara null och kan inte tilldelas polymorfiskt. Det går inte heller att aktivera konservering av objektdiagram och kan NetDataContractSerializer inte användas.

  • När du deserialiserar en elementtyp på den översta nivån utan att ange rotnamnet och namnområdet vid byggtiden returneras IsStartObjecttrue om det kan hitta början på något element. ReadObject med parametern verifyObjectName inställd true på fungerar på samma sätt som IsStartObject innan objektet faktiskt läss. ReadObject skickar sedan kontrollen till ReadXml metoden.

Schemat som exporteras för elementtyper är detsamma som för typen XmlElement som beskrivs i ett tidigare avsnitt, förutom att metoden schemaprovider kan lägga till ytterligare scheman XmlSchemaSet som med innehållstyper. XmlRootAttribute Det går inte att använda attributet med elementtyper och globala elementdeklarationer genereras aldrig för dessa typer.

Skillnader från XmlSerializer

Gränssnittet IXmlSerializable och attributen XmlSchemaProviderAttribute och XmlRootAttribute förstås också av XmlSerializer . Det finns dock vissa skillnader i hur dessa behandlas i datakontraktsmodellen. De viktiga skillnaderna sammanfattas i följande:

  • Schemaprovidermetoden måste vara offentlig för att kunna användas i XmlSerializer, men behöver inte vara offentlig för att kunna användas i datakontraktsmodellen.

  • Metoden schemaprovider anropas när IsAny är sant i datakontraktsmodellen men inte med XmlSerializer.

  • XmlRootAttribute När attributet inte finns för innehålls- eller äldre datamängdstyper XmlSerializer exporteras en global elementdeklaration i det tomma namnområdet. I datakontraktsmodellen är det namnområde som används normalt datakontraktets namnområde enligt beskrivningen tidigare.

Tänk på dessa skillnader när du skapar typer som används med båda serialiseringsteknikerna.

ImporteraR IXmlSerializable-schema

När du importerar ett schema som genererats från IXmlSerializable typer finns det några möjligheter:

  • Det genererade schemat kan vara ett giltigt datakontraktsschema enligt beskrivningen i Schemareferens för datakontrakt. I det här fallet kan schemat importeras som vanligt och vanliga datakontraktstyper genereras.

  • Det genererade schemat kanske inte är ett giltigt datakontraktsschema. Till exempel kan din schemaprovidermetod generera ett schema som omfattar XML-attribut som inte stöds i datakontraktsmodellen. I det här fallet kan du importera schemat som IXmlSerializable typer. Det här importläget är inte aktiverat som standard, men kan enkelt aktiveras – till exempel med kommandoradsväxlingen /importXmlTypestill Verktyget för ServiceModel-metadata (Svcutil.exe). Detta beskrivs i detalj i importschemat för att generera klasser. Observera att du måste arbeta direkt med XML för dina typinstanser. Du kan också överväga att använda en annan serialiseringsteknik som stöder ett bredare schemaintervall – se avsnittet om hur du använder XmlSerializer.

  • Du kanske vill återanvända dina befintliga IXmlSerializable typer i proxyn i stället för att generera nya. I det här fallet kan funktionen för refererade typer som beskrivs i avsnittet Importera schema för att generera typer användas för att ange vilken typ som ska återanvändas. Detta motsvarar att använda växeln /reference på svcutil.exe, som anger den sammansättning som innehåller de typer som ska återanvändas.

Representerar godtycklig XML i datakontrakt

Med matrisen XmlElementXmlNodeIXmlSerializable och typerna kan du mata in godtycklig XML i datakontraktsmodellen. Och DataContractSerializerNetDataContractSerializer skicka det här XML-innehållet till XML-skrivaren som används, utan att störa processen. XML-skrivarna kan dock framtvinga vissa begränsningar för DEN XML som de skriver. Här är några viktiga exempel:

  • XML-skrivarna tillåter vanligtvis inte en XML-dokumentdeklaration (till exempel <?xml-version='1.0' ?>) mitt i att skriva ett annat dokument. Du kan inte ta ett fullständigt XML-dokument och serialisera det som en Array datamedlem XmlNode . För att göra detta måste du antingen ta bort dokumentdeklarationen eller använda ditt eget kodningsschema för att representera den.

  • Alla XML-skrivare som medföljer WCF avvisar XML-bearbetningsinstruktioner (<? ... ?>) och dokumenttypsdefinitioner (<! ... >), eftersom de inte tillåts i SOAP-meddelanden. Återigen kan du använda din egen kodningsmekanism för att kringgå den här begränsningen. Om du måste inkludera dessa i din resulterande XML kan du skriva en anpassad kodare som använder XML-skrivare som stöder dem.

  • När du implementerar WriteXmlbör du undvika att anropa WriteRaw metoden på XML-skrivaren. WCF använder en mängd olika XML-kodningar (inklusive binär), det är mycket svårt eller omöjligt att använda WriteRaw så att resultatet kan användas i någon kodning.

  • När du implementerar WriteXmlbör du undvika att använda metoderna WriteEntityRef och WriteNmToken som inte stöds på XML-skrivarna som medföljer WCF.

Använda DataSet, Typed DataSet och DataTable

Användning av dessa typer stöds fullt ut i datakontraktsmodellen. Tänk på följande när du använder de här typerna:

  • Schemat för dessa typer (särskilt DataSet och dess typbaserade härledda klasser) kanske inte kan samverka med vissa icke-WCF-plattformar, eller så kan det leda till dålig användbarhet när det används med dessa plattformar. Dessutom kan användning av DataSet typen få prestandakonsekvenser. Slutligen kan det göra det svårare för dig att versionshantera ditt program i framtiden. Överväg att använda explicit definierade datakontraktstyper i stället för DataSet typer i dina kontrakt.

  • När du importerar DataSet eller DataTable scheman är det viktigt att referera till dessa typer. Med kommandoradsverktyget Svcutil.exe kan du göra detta genom att skicka System.Data.dll sammansättningsnamn till växeln /reference . Om du importerar schema för typ av datauppsättning måste du referera till typ av typ av typ av datauppsättning. Med Svcutil.exe skickar du platsen för den typerade datauppsättningens sammansättning till växeln /reference . Mer information om referenstyper finns i Importera schema för att generera klasser.

Stöd för typade datauppsättningar i datakontraktsmodellen är begränsat. Inskrivna datauppsättningar kan serialiseras och deserialiseras och kan exportera sitt schema. Schemaimporten för datakontrakt kan dock inte generera nya typerade datauppsättningstyper från schemat, eftersom det bara kan återanvända befintliga. Du kan peka på en befintlig typ av DataSet med hjälp av växeln /r på Svcutil.exe. Om du försöker använda en Svcutil.exe utan växeln /r på en tjänst som använder en typinskriven datauppsättning, väljs automatiskt en alternativ serialiserare (XmlSerializer). Om du måste använda DataContractSerializer och måste generera DataSets från schemat kan du använda följande procedur: generera typtypen DataSet (med hjälp av verktyget Xsd.exe med växeln /d på tjänsten), kompilera typerna och peka sedan på dem med hjälp av växeln /r på Svcutil.exe.

Se även