DataContractResolverDataContractResolver

In diesem Beispiel wird veranschaulicht, wie die Serialisierungs- und Deserialisierungsprozesse mit der DataContractResolver-Klasse angepasst werden können.This sample demonstrates how the serialization and deserialization processes can be customized by using the DataContractResolver class. In diesem Beispiel wird veranschaulicht, wie DataContractResolver verwendet wird, um bei der Serialisierung und der Deserialisierung CLR-Typen einer xsi:type-Darstellung zuzuordnen bzw. diese Zuordnung wieder aufzuheben.This sample shows how to use a DataContractResolver to map CLR types to and from an xsi:type representation during serialization and deserialization.

BeispieldetailsSample Details

Im Beispiel werden folgende CLR-Typen definiert.The sample defines the following CLR types.

using System;  
using System.Runtime.Serialization;  

namespace Types  
{  
    [DataContract]  
    public class Customer  
    {  
        [DataMember]  
        public string Name { get; set; }  
    }  

    [DataContract]  
    public class VIPCustomer : Customer  
    {  
        [DataMember]  
        public string VipInfo { get; set; }  
    }  

    [DataContract]  
    public class RegularCustomer : Customer  
    {  
    }  

    [DataContract]  
    public class PreferredVIPCustomer : VIPCustomer  
    {  
    }  
}  

Die Assembly wird im Beispiel geladen, wobei jeder dieser Typen extrahiert und dann serialisiert und deserialisiert wird.The sample loads the assembly, extracts each of these types, and then serializes and deserializes them. DataContractResolver wird in den Serialisierungsprozess integriert, indem eine Instanz der von DataContractResolver abgeleiteten Klasse an den DataContractSerializer-Konstruktor übergeben wird, wie im folgenden Beispiel gezeigt.The DataContractResolver is plugged into the serialization process by passing an instance of the DataContractResolver-derived class to the DataContractSerializer constructor, as shown in the following example.

this.serializer = new DataContractSerializer(typeof(Object), null, int.MaxValue, false, true, null, new MyDataContractResolver(assembly));  

Anschließend werden die CLR-Typen serialisiert, wie im folgenden Codebeispiel gezeigt.The sample then serializes the CLR types as shown in the following code example.

Assembly assembly = Assembly.Load(new AssemblyName("Types"));  

public void serialize(Type type)  
{  
    Object instance = Activator.CreateInstance(type);  

    Console.WriteLine("----------------------------------------");  
    Console.WriteLine();  
    Console.WriteLine("Serializing type: {0}", type.Name);  
    Console.WriteLine();  
    this.buffer = new StringBuilder();  
    using (XmlWriter xmlWriter = XmlWriter.Create(this.buffer))  
    {  
        try  
        {  
            this.serializer.WriteObject(xmlWriter, instance);  
        }  
        catch (SerializationException error)  
        {  
            Console.WriteLine(error.ToString());  
        }  
    }  
    Console.WriteLine(this.buffer.ToString());  
}  

Dann werden die xsi:-Typen deserialisiert, wie im folgenden Codebeispiel gezeigt.The sample then deserializes the xsi:types as shown in the following code example.

public void deserialize(Type type)  
{  
    Console.WriteLine();  
    Console.WriteLine("Deserializing type: {0}", type.Name);  
    Console.WriteLine();  
    using (XmlReader xmlReader = XmlReader.Create(new StringReader(this.buffer.ToString())))  
    {  
        Object obj = this.serializer.ReadObject(xmlReader);  
    }  
}  

Da der benutzerdefinierte DataContractResolver an den DataContractSerializer-Konstruktor übergeben wird, wird TryResolveType während der Serialisierung aufgerufen, um einen CLR-Typ einem entsprechenden xsi:type zuzuordnen.Since the custom DataContractResolver is passed in to the DataContractSerializer constructor, the TryResolveType is called during serialization to map a CLR type to an equivalent xsi:type. Ebenso wird bei der Deserialisierung ResolveName aufgerufen, um den xsi:type einem entsprechenden CLR-Typ zuzuordnen.Similarly the ResolveName is called during deserialization to map the xsi:type to an equivalent CLR type. In diesem Beispiel ist der DataContractResolver wie im folgenden Beispiel definiert.In this sample, the DataContractResolver is defined as shown in the following example.

Das folgende Codebeispiel ist eine vom DataContractResolver abgeleitete Klasse.The following code example is a class deriving from DataContractResolver.

class MyDataContractResolver : DataContractResolver  
{  
    private Dictionary<string, XmlDictionaryString> dictionary = new Dictionary<string, XmlDictionaryString>();  
    Assembly assembly;  

    public MyDataContractResolver(Assembly assembly)  
    {  
        this.assembly = assembly;  
    }  

    // Used at deserialization  
    // Allows users to map xsi:type name to any Type   
    public override Type ResolveName(string typeName, string typeNamespace, DataContractResolver knownTypeResolver)  
    {  
        XmlDictionaryString tName;  
        XmlDictionaryString tNamespace;  
        if (dictionary.TryGetValue(typeName, out tName) && dictionary.TryGetValue(typeNamespace, out tNamespace))  
        {  
            return this.assembly.GetType(tNamespace.Value + "." + tName.Value);  
        }  
        else  
        {  
            return null;  
        }  
    }  

    // Used at serialization  
    // Maps any Type to a new xsi:type representation  
    public override void ResolveType(Type dataContractType, DataContractResolver knownTypeResolver, out XmlDictionaryString typeName, out XmlDictionaryString typeNamespace)  
    {  
        string name = dataContractType.Name;  
        string namesp = dataContractType.Namespace;  
        typeName = new XmlDictionaryString(XmlDictionary.Empty, name, 0);   
        typeNamespace = new XmlDictionaryString(XmlDictionary.Empty, namesp, 0);  
        if (!dictionary.ContainsKey(dataContractType.Name))  
        {  
            dictionary.Add(name, typeName);  
        }  
        if (!dictionary.ContainsKey(dataContractType.Namespace))  
        {  
            dictionary.Add(namesp, typeNamespace);  
        }  
    }  
}  

Als Teil des Beispiels generiert das Typenprojekt die Assembly mit allen Typen, die in diesem Beispiel verwendet werden.As part of the sample, the Types project generates the assembly with all the types that are used in this sample. Verwenden Sie dieses Projekt, um die zu serialisierenden Typen hinzuzufügen, zu entfernen oder zu ändern.Use this project to add, remove or modify the types that will be serialized.

So verwenden Sie dieses BeispielTo use this sample

  1. Öffnen Sie mit Visual Studio 2012Visual Studio 2012 die Projektmappendatei DCRSample.sln.Using Visual Studio 2012Visual Studio 2012, open the DCRSample.sln solution file.

  2. Drücken Sie F5, um die Projektmappe auszuführen.To run the solution, press F5

Wichtig

Die Beispiele sind möglicherweise bereits auf dem Computer installiert.The samples may already be installed on your machine. Suchen Sie nach dem folgenden Verzeichnis (Standardverzeichnis), bevor Sie fortfahren.Check for the following (default) directory before continuing.

<InstallDrive>:\WF_WCF_Samples

Wenn dieses Verzeichnis nicht vorhanden ist, rufen Sie Windows Communication Foundation (WCF) and Windows Workflow Foundation (WF) Samples for .NET Framework 4 auf, um alle Windows Communication Foundation (WCF)Windows Communication Foundation (WCF) - und WFWF -Beispiele herunterzuladen.If this directory does not exist, go to Windows Communication Foundation (WCF) and Windows Workflow Foundation (WF) Samples for .NET Framework 4 to download all Windows Communication Foundation (WCF)Windows Communication Foundation (WCF) and WFWF samples. Dieses Beispiel befindet sich im folgenden Verzeichnis.This sample is located in the following directory.

<InstallDrive>:\WF_WCF_Samples\WCF\Basic\Contract\Data\DataContractResolver

Siehe auchSee Also

Verwenden eines DatenvertragsresolversUsing a Data Contract Resolver