serialización personalizada con DataContractSerializer

Question

Actualmente estoy utilizando clases contenedoras para mis DataSets, con el fin de implementar la serialización personalizada. Me gustaría usar DataContractSerializer (más como tener que usarlo) pero aún así soporte la serialización personalizada. El problema es que los atributos [DataContract] y [Serializable] no parecen llevarse tan bien ... ¿cómo podría anular la serialización y admitir AMBOS DataContract & serialización ISerializable? El código para la clase contenedora conjunto de datos se lleva aquí:

[Serializable()]  
[System.Runtime.InteropServices.ComVisible(false)] 
public class TestDatasetWrapper : TestDataSet, ISerializable 
{ 
    public TestDatasetWrapper() 
     : base() 
    {} 

    protected TestDatasetWrapper(SerializationInfo info, StreamingContext context) 
    { 
     SerializationHelper.DeserializeTypedDataSet(info, this); 
    } 

    public override void GetObjectData(SerializationInfo info, StreamingContext context) 
    { 
     SerializationHelper.AddTypedDataSetObjectData(info, this); 
    } 
} 

Gracias!

Answer 1

Tanto DataContractAttribute como SerializableAttribute se pueden usar juntos. La ventaja aquí es que no necesita usar serializadores separados tampoco. DataContractSerialzer es un XmlObjectSerializer, que a su vez admite [Serializable]. Por ejemplo:

[Serializable] 
public class TestClass 
{ 
    public string Name { get; set; } 
} 

{ 
    var formatter = new DataContractSerializer(typeof(TestClass)); 
    using (var stream = new MemoryStream()) 
    { 
     var instance = new TestClass { Name = "Matt" }; 
     formatter.WriteObject(stream, instance); 

     stream.Seek(0, SeekOrigin.Begin); 

     var second = (TestClass) formatter.ReadObject(stream); 
     Console.WriteLine(second.Name); 
    } 
} 

SALIDA: "Matt"

El uso de un solo SerializableAttribute atribuimos podemos serializar y deserialise un objeto utilizando DataContractSerializer éxito ...

Usando ISerializable, podemos hacer lo mismo:

[Serializable] 
public class TestClass2 : ISerializable 
{ 
    public TestClass2() { } 
    protected TestClass2(SerializationInfo info, StreamingContext context) 
    { 
     Name = info.GetString("name").ToUpper(); 
    } 

    public void GetObjectData(SerializationInfo info, StreamingContext context) 
    { 
     info.AddValue("name", Name); 
    } 

    public string Name { get; set; } 
} 

{ 
    var formatter = new DataContractSerializer(typeof(TestClass2)); 
    using (var stream = new MemoryStream()) 
    { 
     var instance = new TestClass2 { Name = "Matt" }; 
     formatter.WriteObject(stream, instance); 

     stream.Seek(0, SeekOrigin.Begin); 

     var second = (TestClass2)formatter.ReadObject(stream); 
     Console.WriteLine(second.Name); 
    } 
} 

SALIDA: "Matt"

Y con un DataContractAttribute:

[DataContract, Serializable] 
public class TestClass3 
{ 
    public int Age { get; set; } 

    [DataMember] 
    public string Name { get; set; } 
} 

{ 
    var formatter = new DataContractSerializer(typeof(TestClass3)); 
    using (var stream = new MemoryStream()) 
    { 
     var instance = new TestClass3 { Name = "Matt", Age = 26 }; 
     formatter.WriteObject(stream, instance); 

     stream.Seek(0, SeekOrigin.Begin); 

     var second = (TestClass3)formatter.ReadObject(stream); 
     Console.WriteLine(second.Name); 
     Console.WriteLine(second.Age); 
    } 
} 

SALIDA: "Matt"

SALIDA: 0

Cuando DataContractSerializer se encuentra con un tipo con un DataContractAttribute , usará eso en lugar de pasar la serialización a su tipo base, que maneja SerializableAttribute y ISerializable int erfaces.

Si tiene problemas, ¿es con serialización, con deserialización o con ambos?