DataContractResolverDataContractResolver

In questo esempio viene illustrato come personalizzare i processi di serializzazione e deserializzazione tramite la classe DataContractResolver.This sample demonstrates how the serialization and deserialization processes can be customized by using the DataContractResolver class. Nell'esempio viene descritto come utilizzare un oggetto DataContractResolver per eseguire il mapping dei tipi CLR a una rappresentazione xsi:type e dalla stessa durante la serializzazione e la deserializzazione.This sample shows how to use a DataContractResolver to map CLR types to and from an xsi:type representation during serialization and deserialization.

Dettagli dell'esempioSample Details

Nell'esempio vengono definiti i tipi CLR seguenti.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  
    {  
    }  
}  

Nell'esempio viene caricato l'assembly e viene estratto ognuno di questi tipi. Viene quindi eseguita la serializzazione e la deserializzazione dei tipi.The sample loads the assembly, extracts each of these types, and then serializes and deserializes them. L'oggetto DataContractResolver viene collegato al processo di serializzazione passando un'istanza della classe derivata da DataContractResolver al costruttore DataContractSerializer, come illustrato nell'esempio seguente.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));  

Nell'esempio vengono quindi serializzati i tipi CLR, come illustrato nell'esempio di codice seguente.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());  
}  

Nell'esempio vengono quindi deserializzati gli oggetto xsi:type, come illustrato nell'esempio di codice seguente.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);  
    }  
}  

Poiché al costruttore DataContractResolver viene passato l'oggetto DataContractSerializer personalizzato, durante la serializzazione viene chiamato il metodo TryResolveType per eseguire il mapping di un tipo CLR a un oggetto xsi:type equivalente.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. Analogamente, durante la deserializzazione viene chiamato il metodo ResolveName per eseguire il mapping dell'oggetto xsi:type a un tipo CLR equivalente.Similarly the ResolveName is called during deserialization to map the xsi:type to an equivalent CLR type. In questo esempio, l'oggetto DataContractResolver viene definito come illustrato nell'esempio seguente.In this sample, the DataContractResolver is defined as shown in the following example.

L'esempio di codice riportato di seguito è una classe che deriva da DataContractResolver.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);  
        }  
    }  
}  

Come parte dell'esempio, il progetto Types genera l'assembly con tutti i tipi utilizzati in questo esempio.As part of the sample, the Types project generates the assembly with all the types that are used in this sample. Utilizzare il progetto per aggiungere, rimuovere o modificare i tipi che saranno serializzati.Use this project to add, remove or modify the types that will be serialized.

Per usare questo esempioTo use this sample

  1. Utilizzando Visual Studio 2012Visual Studio 2012, aprire il file della soluzione DCRSample.sln.Using Visual Studio 2012Visual Studio 2012, open the DCRSample.sln solution file.

  2. Per eseguire la soluzione, premere F5To run the solution, press F5

Importante

È possibile che gli esempi siano già installati nel computer.The samples may already be installed on your machine. Verificare la directory seguente (impostazione predefinita) prima di continuare.Check for the following (default) directory before continuing.

<InstallDrive>:\WF_WCF_Samples

Se questa directory non esiste, andare al Windows Communication Foundation (WCF) e gli esempi di Windows Workflow Foundation (WF) per .NET Framework 4 per scaricare tutti i Windows Communication Foundation (WCF) e WFWF esempi.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) and WFWF samples. Questo esempio si trova nella directory seguente.This sample is located in the following directory.

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

Vedere ancheSee Also

Uso di un resolver del contratto di datiUsing a Data Contract Resolver