Adatszerződés -helyettesek

Az adatszerződés-helyettesítő egy speciális funkció, amely az Adatszerződés-modellre épül. Ez a funkció a típus testreszabására és helyettesítésére szolgál olyan helyzetekben, amikor a felhasználók módosítani szeretnék a típus szerializálásának, deszerializálásának vagy metaadatokká való kivetítésének módját. Bizonyos helyzetekben a helyettesítők akkor használhatók, ha nincs megadva adatszerződés a típushoz, a mezők és tulajdonságok nincsenek megjelölve az DataMemberAttribute attribútummal, vagy a felhasználók dinamikusan szeretnének sémavariációkat létrehozni.

A szerializálás és a deszerializálás az adatszerződés helyettesítő használatával történik, amikor a .NET-keretrendszer-ból megfelelő formátumra, például XML-formátumra való konvertálásra szolgálDataContractSerializer. Az adatszerződés helyettesítője a típusokhoz exportált metaadatok módosítására is használható, ha metaadat-reprezentációkat, például XML-sémadokumentumokat (XSD) hoz létre. Importáláskor a kód metaadatokból jön létre, és ebben az esetben a helyettesítő is használható a generált kód testreszabásához.

Hogyan működik a helyettes

A helyettesek úgy működnek, hogy egy típust (az "eredeti" típust) egy másik típusra (a "helyettesítő" típusra) leképeznek. Az alábbi példa az eredeti típust Inventory és egy új helyettesítő típust InventorySurrogated mutatja be. A Inventory típus nem szerializálható, de a típus a InventorySurrogated következő:

public class Inventory
{
    public int pencils;
    public int pens;
    public int paper;
}

Mivel ehhez az osztályhoz nincs adatszerződés definiálva, konvertálja az osztályt helyettesítő osztálysá adatszerződéssel. A helyettesítő osztály az alábbi példában látható:

[DataContract(Name = "Inventory")]
public class InventorySurrogated
{
    [DataMember]
    public int numpencils;
    [DataMember]
    public int numpaper;
    [DataMember]
    private int numpens;

    public int pens
    {
        get { return numpens; }
        set { numpens = value; }
    }
}

Az IDataContractSurrogate implementálása

Az adatszerződés helyettesítő használatához implementálja az interfészt IDataContractSurrogate .

Az alábbiakban áttekintheti az egyes módszereket IDataContractSurrogate egy lehetséges implementációval.

GetDataContractType

A GetDataContractType metódus megfelelteti az egyik típust a másiknak. Ez a módszer szerializáláshoz, deszerializáláshoz, importáláshoz és exportáláshoz szükséges.

Az első feladat annak meghatározása, hogy milyen típusok lesznek más típusokra leképezve. Példa:

public Type GetDataContractType(Type type)
{
    Console.WriteLine("GetDataContractType");
    if (typeof(Inventory).IsAssignableFrom(type))
    {
        return typeof(InventorySurrogated);
    }
    return type;
}

• Szerializáláskor a metódus által visszaadott leképezést a rendszer a metódus meghívásával GetObjectToSerialize az eredeti példány helyettesítő példánysá alakításához használja.

• Deszerializáláskor az e módszer által visszaadott leképezést a szerializáló használja a helyettesítő típus egy példányára való deszerializáláshoz. Ezt követően kéri GetDeserializedObject , hogy alakítsa át a helyettesítő példányt az eredeti típusú példánysá.

• Exportálás esetén a metódus által visszaadott helyettesítő típus tükröződik, hogy lekérje az adatszerződést a metaadatok létrehozásához.

• Importáláskor a kezdeti típus helyettesítő típusra változik, amely tükröződik az adatszerződés olyan célokra való felhasználásához, mint a hivatkozási támogatás.

A Type paraméter a szerializált, deszerializált, importált vagy exportált objektum típusa. A GetDataContractType metódusnak vissza kell adnia a bemeneti típust, ha a helyettesítő nem kezeli a típust. Ellenkező esetben adja vissza a megfelelő helyettesítő típust. Ha több helyettesítő típus létezik, ebben a metódusban számos leképezés definiálható.

A GetDataContractType metódus nem hívható meg beépített adatszerződési primitívekhez, például Int32 vagy String. Más típusok, például tömbök, felhasználó által definiált típusok és egyéb adatstruktúrák esetén a rendszer minden típushoz meghívja ezt a metódust.

Az előző példában a metódus ellenőrzi, hogy a type paraméter Inventory összehasonlítható-e. Ha igen, a metódus leképezi a következőre InventorySurrogated: . Amikor szerializálást, deszerializálást, importálási sémát vagy exportálási sémát hív meg, a rendszer ezt a függvényt hívja meg először a típusok közötti leképezés meghatározásához.

GetObjectToSerialize metódus

A GetObjectToSerialize metódus az eredeti típuspéldányt helyettesítő típuspéldánysá alakítja. A szerializáláshoz ez a módszer szükséges.

A következő lépés a fizikai adatok leképezésének módja az eredeti példánytól a helyettesítő példányig a GetObjectToSerialize metódus implementálásával. Példa:

public object GetObjectToSerialize(object obj, Type targetType)
{
    Console.WriteLine("GetObjectToSerialize");
    if (obj is Inventory)
    {
        InventorySurrogated isur = new InventorySurrogated();
        isur.numpaper = ((Inventory)obj).paper;
        isur.numpencils = ((Inventory)obj).pencils;
        isur.pens = ((Inventory)obj).pens;
        return isur;
    }
    return obj;
}

A GetObjectToSerialize metódust akkor hívják meg, ha egy objektum szerializálva van. Ez a módszer adatokat továbbít az eredeti típusról a helyettesítő típus mezőire. A mezők közvetlenül leképezhetők helyettesítő mezőkre, vagy az eredeti adatok manipulálása tárolható a helyettesben. Néhány lehetséges felhasználási lehetőség: a mezők közvetlen leképezése, műveletek végrehajtása a helyettesítő mezőkben tárolandó adatokon, vagy az eredeti típusú XML tárolása a helyettesítő mezőben.

A targetType paraméter a tag deklarált típusára hivatkozik. Ez a paraméter a metódus által GetDataContractType visszaadott helyettesítő típus. A szerializáló nem kényszeríti ki, hogy a visszaadott objektum hozzárendelhető legyen ehhez a típushoz. A obj paraméter a szerializálni kívánt objektum, és szükség esetén helyettessé lesz konvertálva. Ennek a metódusnak vissza kell adnia a bemeneti objektumot, ha a helyettesítő nem kezeli az objektumot. Ellenkező esetben a rendszer visszaadja az új helyettesítő objektumot. A helyettesítő nem lesz meghívva, ha az objektum null értékű. Ebben a metódusban számos helyettesítő leképezés definiálható a különböző példányokhoz.

Amikor létrehoz egy objektumot DataContractSerializer, utasíthatja, hogy őrizze meg az objektumhivatkozásokat. (További információ: Szerializálás és deszerializálás.) Ez úgy történik, hogy a paramétert a preserveObjectReferences konstruktorban a következőre trueállítja. Ebben az esetben a helyettesítő csak egyszer van meghívva egy objektumhoz, mivel az összes későbbi szerializáció csak írja a hivatkozást a streambe. Ha preserveObjectReferences be van állítva false, akkor a rendszer minden alkalommal meghívja a helyettest, amikor egy példányt észlel.

Ha a szerializált példány típusa eltér a deklarált típustól, a rendszer beírja a típusadatokat a streambe, például annak érdekében, xsi:type hogy a példány deszerializálható legyen a másik végén. Ez a folyamat akkor fordul elő, ha az objektum helyettesítő vagy sem.

A fenti példa a példány adatait a Inventory következőre konvertálja InventorySurrogated: . Ellenőrzi az objektum típusát, és végrehajtja a szükséges manipulációkat a helyettesítő típusra való konvertáláshoz. Ebben az esetben az osztály mezői Inventory közvetlenül át lesznek másolva az InventorySurrogated osztálymezőkbe.

GetDeserializedObject metódus

A GetDeserializedObject metódus a helyettesítő típuspéldányt az eredeti típuspéldánysá alakítja. Deszerializáláshoz szükséges.

A következő feladat annak meghatározása, hogy a fizikai adatok hogyan lesznek leképezve a helyettesítő példányról az eredetire. Példa:

public object GetDeserializedObject(object obj, Type targetType)
{
    Console.WriteLine("GetDeserializedObject");
    if (obj is InventorySurrogated)
    {
        Inventory invent = new Inventory();
        invent.pens = ((InventorySurrogated)obj).pens;
        invent.pencils = ((InventorySurrogated)obj).numpencils;
        invent.paper = ((InventorySurrogated)obj).numpaper;
        return invent;
    }
    return obj;
}

Ezt a metódust csak egy objektum deszerializálása során hívjuk meg. Fordított adatleképezést biztosít a deszerializáláshoz a helyettesítő típustól az eredeti típusig. A módszerhez GetObjectToSerialize hasonlóan egyes lehetséges felhasználási módok lehetnek a mezőadatok közvetlen cseréje, az adatokon végzett műveletek végrehajtása és AZ XML-adatok tárolása. Deszerializáláskor előfordulhat, hogy az adatátalakítás manipulációi miatt nem mindig kapja meg a pontos adatértékeket az eredetitől.

A targetType paraméter a tag deklarált típusára hivatkozik. Ez a paraméter a metódus által GetDataContractType visszaadott helyettesítő típus. A obj paraméter a deszerializált objektumra hivatkozik. Az objektum visszaalakítható az eredeti típusára, ha helyettesítve van. Ez a metódus visszaadja a bemeneti objektumot, ha a helyettesítő nem kezeli az objektumot. Ellenkező esetben a deszerializált objektum az átalakítás befejezése után lesz visszaadva. Ha több helyettesítő típus is létezik, az egyes típusokat és azok átalakítását megadva megadhat adatátalakítást helyettesről elsődleges típusra.

Objektum visszaadásakor a belső objektumtáblák a helyettesítő által visszaadott objektummal frissülnek. A példányra való későbbi hivatkozások az objektumtáblákból szerzik be a helyettesítő példányt.

Az előző példa a típusobjektumokat InventorySurrogated a kezdeti típusra Inventoryalakítja vissza. Ebben az esetben az adatok közvetlenül visszakerülnek InventorySurrogated a megfelelő mezőkbe a következőben Inventory: . Mivel nincsenek adatkezelések, az egyes tagmezők ugyanazokat az értékeket tartalmazzák, mint a szerializálás előtt.

GetCustomDataToExport metódus

Séma exportálása esetén a GetCustomDataToExport metódus nem kötelező. A rendszer további adatokat vagy tippeket szúr be az exportált sémába. A tag- vagy típusszinten további adatok is beszúrhatók. Példa:

public object GetCustomDataToExport(System.Reflection.MemberInfo memberInfo, Type dataContractType)
{
    Console.WriteLine("GetCustomDataToExport(Member)");
    System.Reflection.FieldInfo fieldInfo = (System.Reflection.FieldInfo)memberInfo;
    if (fieldInfo.IsPublic)
    {
        return "public";
    }
    else
    {
        return "private";
    }
}

Ez a módszer (két túlterheléssel) lehetővé teszi további információk felvételét a metaadatokba tag- vagy típusszinten. Tartalmazhat tippeket arról, hogy egy tag nyilvános vagy privát-e, valamint a séma exportálása és importálása során megőrzendő megjegyzések. Ez az információ e módszer nélkül elveszne. Ez a módszer nem okozza a tagok vagy típusok beszúrását vagy törlését, hanem további adatokat ad hozzá a sémákhoz ezen szintek valamelyikén.

A metódus túlterhelt, és egy (clrtypeparaméter) vagy MemberInfo (memberInfoparaméter) paramétert is tartalmazhat Type . A második paraméter mindig egy Type (dataContractType paraméter). Ezt a metódust a helyettes típus minden tagjára és típusára meghívjuk dataContractType .

Ezen túlterhelések bármelyikének vagy szerializálható objektumot kell visszaadnia null . A nem null értékű objektumokat a program széljegyzetként szerializálja az exportált sémába. A túlterhelés esetén a Type sémába exportált típusokat a rendszer az első paraméterben erre a metódusra küldi, paraméterként dataContractType pedig a helyettesítő típust. A túlterhelés esetén a MemberInfo sémába exportált tagok a második paraméterben a helyettesítő típussal rendelkező paraméterként memberInfo küldik el az adatait.

GetCustomDataToExport metódus (típus, típus)

A IDataContractSurrogate.GetCustomDataToExport(Type, Type) metódust a rendszer a sémaexportálás során hívja meg minden típusdefinícióhoz. A metódus adatokat ad hozzá a sémán belüli típusokhoz exportáláskor. A rendszer minden definiált típust erre a metódusra küld annak megállapításához, hogy vannak-e további adatok, amelyeket fel kell venni a sémába.

GetCustomDataToExport metódus (MemberInfo, type)

Az IDataContractSurrogate.GetCustomDataToExport(MemberInfo, Type) exportálás során a rendszer az exportált típusok minden tagját meghívja. Ez a függvény lehetővé teszi, hogy testre szabja az exportáláskor a sémában szereplő tagok megjegyzéseit. Az osztály minden tagjának adatait erre a metódusra küldi a rendszer, hogy ellenőrizze, kell-e további adatokat hozzáadni a sémához.

A fenti példa végigkeresi a dataContractType helyettesek minden tagját. Ezután visszaadja az egyes mezők megfelelő hozzáférési módosítóit. A testreszabás nélkül a hozzáférési módosítók alapértelmezett értéke nyilvános. Ezért minden tag nyilvánosként lesz definiálva az exportált sémával létrehozott kódban, függetlenül attól, hogy a tényleges hozzáférési korlátozások milyenek. Ha nem használja ezt a megvalósítást, a tag numpens nyilvános lesz az exportált sémában, annak ellenére, hogy a helyettesben privátként lett definiálva. Ennek a módszernek a használatával az exportált sémában a hozzáférés-módosító privátként hozható létre.

GetReferencedTypeOnImport metódus

Ez a módszer megfelelteti a Type helyettest az eredeti típusnak. Ez a módszer nem kötelező a séma importálásához.

Ha olyan helyettesítő példányt hoz létre, amely importál egy sémát, és kódot hoz létre hozzá, a következő feladat a helyettesítő példány típusának meghatározása az eredeti típusra.

Ha a létrehozott kódnak egy meglévő felhasználói típusra kell hivatkoznia, ezt a GetReferencedTypeOnImport metódus implementálásával hajtja végre.

Séma importálásakor a rendszer minden típusdeklarációhoz meghívja ezt a metódust, hogy a helyettesítő adatszerződést típusra képezhesse le. A sztring paraméterei typeName , valamint typeNamespace a helyettesítő típus neve és névtere. A visszaadott GetReferencedTypeOnImport érték annak meghatározására szolgál, hogy létre kell-e hozni egy új típust. Ennek a metódusnak érvényes vagy null értéket kell visszaadnia. Érvényes típusok esetén a visszaadott típus hivatkozási típusként lesz használva a létrehozott kódban. Ha null értéket ad vissza, a rendszer nem hivatkozik típusra, és létre kell hozni egy új típust. Ha több helyettes létezik, az egyes helyettesítő típusok leképezését vissza lehet hajtani a kezdeti típusra.

A customData paraméter az eredetileg visszaadott GetCustomDataToExportobjektum. Ez customData akkor használatos, ha a helyettesítő szerzők további adatokat/tippeket szeretnének beszúrni a metaadatokba, amelyeket az importálás során használnak a kód létrehozásához.

ProcessImportedType metódus

A ProcessImportedType metódus testre szabja a sémaimportálásból létrehozott összes típust. Ez a módszer nem kötelező.

Séma importálásakor ez a módszer lehetővé teszi az importált típus- és fordítási információk testreszabását. Példa:

public System.CodeDom.CodeTypeDeclaration ProcessImportedType(System.CodeDom.CodeTypeDeclaration typeDeclaration, System.CodeDom.CodeCompileUnit compileUnit)
{
    Console.WriteLine("ProcessImportedType");
    foreach (CodeTypeMember member in typeDeclaration.Members)
    {
        object memberCustomData = member.UserData[typeof(IDataContractSurrogate)];
        if (memberCustomData != null
          && memberCustomData is string
          && ((string)memberCustomData == "private"))
        {
            member.Attributes = ((member.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Private);
        }
    }
    return typeDeclaration;
}

Az importálás során a rendszer minden létrehozott típushoz meghívja ezt a metódust. Módosítsa a megadott CodeTypeDeclaration értéket, vagy módosítsa a CodeCompileUnit. Ebbe beletartozik a név, a tagok, az attribútumok és a többi tulajdonság módosítása is CodeTypeDeclaration. A feldolgozással CodeCompileUnitmódosíthatja az irányelveket, a névtereket, a hivatkozott szerelvényeket és számos egyéb szempontot.

A CodeTypeDeclaration paraméter tartalmazza a kód DOM-típusdeklarációját. A CodeCompileUnit paraméter lehetővé teszi a kód feldolgozásának módosítását. Az elvetett típusdeklaráció eredményének visszaadása null . Ezzel szemben a módosítások a visszatéréskor CodeTypeDeclarationmegmaradnak.

Ha egyéni adatokat szúr be a metaadatok exportálása során, az importálás során meg kell adni a felhasználónak, hogy azok felhasználhatók legyenek. Ezek az egyéni adatok felhasználhatók a programozási modell tippjeihez vagy más megjegyzésekhez. CodeTypeMember Minden CodeTypeDeclaration egyes példány egyéni adatokat tartalmaz tulajdonságkéntUserData, és a IDataContractSurrogate típusra öntött.

A fenti példa néhány módosítást hajt végre az importált sémán. A kód egy helyettes használatával megőrzi az eredeti típusú magánszemélyeket. A séma importálásakor az alapértelmezett hozzáférési módosító a public. Ezért a helyettesítő séma minden tagja nyilvános lesz, kivéve, ha módosítják, mint ebben a példában. Az exportálás során az egyéni adatok be lesznek szúrva a privát tagok metaadataiba. A példa megkeresi az egyéni adatokat, ellenőrzi, hogy a hozzáférés-módosító privát-e, majd az attribútumok beállításával módosítja a megfelelő tagot, hogy privát legyen. A testreszabás nélkül a tag privát numpens helyett nyilvánosként lesz definiálva.

GetKnownCustomDataTypes metódus

Ez a metódus a sémából definiált egyéni adattípusokat szerzi be. A módszer nem kötelező a séma importálásához.

A metódus meghívása a sémaexportálás és -importálás elején történik. A metódus az exportált vagy importált sémában használt egyéni adattípusokat adja vissza. A metódus átad egy Collection<T> (paraméter customDataTypes ) paramétert, amely típusgyűjtemény. A metódusnak további ismert típusokat kell hozzáadnia ehhez a gyűjteményhez. Az ismert egyéni adattípusok szükségesek az egyéni adatok szerializálásának és deszerializálásának engedélyezéséhez a DataContractSerializer. További információ: Adatszerződés ismert típusai.

Béranya megvalósítása

Ha a WCF-ben szeretné használni az adatszerződést, be kell tartania néhány speciális eljárást.

Helyettesítő használata szerializáláshoz és deszerializáláshoz

A helyettesítővel DataContractSerializer szerializálhatja és deszerializálhatja az adatokat. A DataContractSerializer létrehozva a DataContractSerializerOperationBehavior. A helyettest is meg kell adni.

Szerializálás és deszerializálás megvalósítása

1. Hozzon létre egy példányt a ServiceHost szolgáltatáshoz. A teljes útmutatásért tekintse meg az alapszintű WCF-programozást.

2. A megadott szolgáltatásgazda mindegyikéhez ServiceEndpoint keresse meg a OperationDescription.

3. Keresse meg a művelet viselkedését, és állapítsa meg, hogy megtalálható-e a DataContractSerializerOperationBehavior példány.

4. Ha talál egy DataContractSerializerOperationBehavior tulajdonságot, állítsa be a tulajdonságát DataContractSurrogate a helyettes új példányára. Ha nem DataContractSerializerOperationBehavior található, hozzon létre egy új példányt, és állítsa az DataContractSurrogate új viselkedés tagját a helyettes új példányára.

5. Végül adja hozzá ezt az új viselkedést az aktuális műveleti viselkedéshez, ahogyan az a következő példában látható:

   using (ServiceHost serviceHost = new ServiceHost(typeof(InventoryCheck)))
       foreach (ServiceEndpoint ep in serviceHost.Description.Endpoints)
       {
           foreach (OperationDescription op in ep.Contract.Operations)
           {
               DataContractSerializerOperationBehavior dataContractBehavior =
                   op.Behaviors.Find<DataContractSerializerOperationBehavior>()
                   as DataContractSerializerOperationBehavior;
               if (dataContractBehavior != null)
               {
                   dataContractBehavior.DataContractSurrogate = new InventorySurrogated();
               }
               else
               {
                   dataContractBehavior = new DataContractSerializerOperationBehavior(op);
                   dataContractBehavior.DataContractSurrogate = new InventorySurrogated();
                   op.Behaviors.Add(dataContractBehavior);
               }
           }
       }
   

Helyettesítő használata metaadatok importálásához

Ha olyan metaadatokat importál, mint a WSDL és az XSD az ügyféloldali kód létrehozásához, a helyettesítőt hozzá kell adni ahhoz az összetevőhöz, amely az XSD-sémából származó kód generálásáért felelős. XsdDataContractImporter Ehhez közvetlenül módosítsa a WsdlImporter metaadatok importálásához használt adatokat.

Helyettesítő metaadatok importálásának megvalósítása

1. Importálja a metaadatokat az WsdlImporter osztály használatával.

2. Ezzel a TryGetValue módszerrel ellenőrizheti, hogy van-e definiálva.XsdDataContractImporter

3. Ha a TryGetValue metódus visszatér false, hozzon létre egy újat XsdDataContractImporter , és állítsa be a tulajdonságát Options az ImportOptions osztály új példányára. Ellenkező esetben használja a módszer paramétere által out visszaadott importőrt TryGetValue .

4. Ha a XsdDataContractImporter tulajdonság nincs ImportOptions definiálva, állítsa be a tulajdonságot az ImportOptions osztály új példányának.

5. Állítsa be a DataContractSurrogateImportOptions helyettes tulajdonságát XsdDataContractImporter egy új példányra.

6. Adja hozzá az XsdDataContractImporter osztály tulajdonsága WsdlImporter által State visszaadott MetadataExporter gyűjteményhez.)

7. ImportAllContracts A metódus használatával importálhatja az WsdlImporter összes adatszerződést a sémán belül. Az utolsó lépés során a rendszer a helyettesítőbe való behívással létrehozott sémákból hoz létre kódot.

   MetadataExchangeClient mexClient = new MetadataExchangeClient(metadataAddress);
   mexClient.ResolveMetadataReferences = true;
   MetadataSet metaDocs = mexClient.GetMetadata();
   WsdlImporter importer = new WsdlImporter(metaDocs);
   object dataContractImporter;
   XsdDataContractImporter xsdInventoryImporter;
   if (!importer.State.TryGetValue(typeof(XsdDataContractImporter),
       out dataContractImporter))
       xsdInventoryImporter = new XsdDataContractImporter();
   
   xsdInventoryImporter = (XsdDataContractImporter)dataContractImporter;
   xsdInventoryImporter.Options ??= new ImportOptions();
   xsdInventoryImporter.Options.DataContractSurrogate = new InventorySurrogated();
   importer.State.Add(typeof(XsdDataContractImporter), xsdInventoryImporter);
   
   Collection<ContractDescription> contracts = importer.ImportAllContracts();
   

Helyettesítő használata metaadatok exportálásához

Ha metaadatokat exportál egy szolgáltatás WCF-éből, alapértelmezés szerint WSDL- és XSD-sémát is létre kell hozni. A helyettesítőt hozzá kell adni az XSD-séma adatszerződés-típusokhoz való létrehozásához felelős összetevőhöz. XsdDataContractExporter Ehhez használjon olyan viselkedést, amely implementálja IWsdlExportExtension a WsdlExportermetaadatok módosítását, vagy közvetlenül módosítsa a WsdlExporter metaadatok exportálásához használt adatokat.

Helyettesítő használata metaadatok exportálásához

1. Hozzon létre egy újat WsdlExporter , vagy használja a wsdlExporter metódusnak átadott paramétert ExportContract .

2. A függvény használatával TryGetValue ellenőrizheti, hogy van-e definiálva.XsdDataContractExporter

3. Ha TryGetValue visszaadjafalse, hozzon létre egy újat XsdDataContractExporter a létrehozott XML-sémákkal a WsdlExporterfájlból, és adja hozzá a gyűjteményhez, amelyet a WsdlExporterState tulajdonság visszaadott. Ellenkező esetben használja a módszer paramétere által out visszaadott exportőrt TryGetValue .

4. Ha a XsdDataContractExporter tulajdonság nincs ExportOptions definiálva, állítsa a Options tulajdonságot az ExportOptions osztály új példányára.

5. Állítsa be a DataContractSurrogateExportOptions helyettes tulajdonságát XsdDataContractExporter egy új példányra. A metaadatok exportálásának további lépései nem igényelnek módosításokat.

   WsdlExporter exporter = new WsdlExporter();
   //or
   //public void ExportContract(WsdlExporter exporter,
   // WsdlContractConversionContext context) { ... }
   object dataContractExporter;
   XsdDataContractExporter xsdInventoryExporter;
   if (!exporter.State.TryGetValue(typeof(XsdDataContractExporter),
       out dataContractExporter))
   {
       xsdInventoryExporter = new XsdDataContractExporter(exporter.GeneratedXmlSchemas);
   }
   else
   {
       xsdInventoryExporter = (XsdDataContractExporter)dataContractExporter;
   }
   
   exporter.State.Add(typeof(XsdDataContractExporter), xsdInventoryExporter);
   
   if (xsdInventoryExporter.Options == null)
       xsdInventoryExporter.Options = new ExportOptions();
   xsdInventoryExporter.Options.DataContractSurrogate = new InventorySurrogated();
   

Lásd még

• DataContractSerializer
• IDataContractSurrogate
• DataContractSerializerOperationBehavior
• ImportOptions
• ExportOptions
• Adatszerződések használata