自定义序列化与DataContractSerializer的 [英] Custom serialization with DataContractSerializer
问题描述
我目前使用的包装类为我数据集，以实现自定义序列化。我想用的DataContractSerializer （更像是不得不使用它），但仍支持自定义序列化。问题是，在 [DataContract] 和 [Serializable接口] 属性似乎并没有相处甚欢..我怎么可能重写序列化和支持的 BOTH DataContract和放大器; ISerializable的序列化？
为包装的DataSet类的代码被带到这里：
[序列化（）]
[系统.Runtime.InteropServices.ComVisible（假）]
公共类TestDatasetWrapper：TestDataSet，ISerializable的
{
公共TestDatasetWrapper（）
：基地（）
{}
保护TestDatasetWrapper（的SerializationInfo信息，的StreamingContext上下文）
{
SerializationHelper.DeserializeTypedDataSet（信息，这一点）;
}
公共覆盖无效GetObjectData使用（的SerializationInfo信息，的StreamingContext上下文）
{
SerializationHelper.AddTypedDataSetObjectData（信息，这一点）;
}
}
谢谢！
<格类=h2_lin>解决方案
的DataContractAttribute和SerializableAttribute都可以一起使用。这里的好处是，你并不需要的将是使用单独的序列化器。该DataContractSerialzer是XmlObjectSerializer，它本身支持[Serializable接口。例如：
[Serializable接口]
公共类识别TestClass
{
公共字符串名称{得到;组; }
}
{
变种格式化=新的DataContractSerializer（typeof运算（识别TestClass））;
使用（VAR流=新的MemoryStream（））
{
无功实例=新识别TestClass {名称=马特};
formatter.WriteObject（流实例）;
stream.Seek（0，SeekOrigin.Begin）;
VAR秒=（识别TestClass）formatter.ReadObject（流）;
Console.WriteLine（second.Name）;
}
}
输出：马特
使用只是一个SerializableAttribute属性，我们可以成功地连载和deserialise使用的DataContractSerializer ...
<检体p >使用ISerializable的，我们可以做同样的事情：
[Serializable接口]
公共类TestClass2：ISerializable的
{
公共TestClass2（）{}
保护TestClass2（的SerializationInfo信息，的StreamingContext上下文）
{
名称= info.GetString（name）的ToUpper的（）。
}
公共无效GetObjectData使用（的SerializationInfo信息，的StreamingContext上下文）
{
info.AddValue（名，名称）;
}
公共字符串名称{;组; }
}
{
变种格式化=新的DataContractSerializer（typeof运算（TestClass2））;
使用（VAR流=新的MemoryStream（））
{
无功实例=新TestClass2 {名称=马特};
formatter.WriteObject（流实例）;
stream.Seek（0，SeekOrigin.Begin）;
VAR秒=（TestClass2）formatter.ReadObject（流）;
Console.WriteLine（second.Name）;
}
}
输出：MATT
和用DataContractAttribute：
[DataContract，序列化]
公共类TestClass3
{
公众诠释年龄{搞定;组; }
[数据成员]
公共字符串名称{;组; }
}
{
变种格式化=新的DataContractSerializer（typeof运算（TestClass3））;
使用（VAR流=新的MemoryStream（））
{
无功实例=新TestClass3 {名称=马特，年龄= 26};
formatter.WriteObject（流实例）;
stream.Seek（0，SeekOrigin.Begin）;
VAR秒=（TestClass3）formatter.ReadObject（流）;
Console.WriteLine（second.Name）;
Console.WriteLine（second.Age）;
}
}
输出：马特
输出：0
在DataContractSerializer的遇到一个类型与DataContractAttribute ，它将使用，而不是通过序列化的基本类型，它处理SerializableAttribute和ISerializable的接口。
如果您遇到的问题，是它与系列化，或deserialisation，或两者兼而有之？
I'm currently using wrapper classes for my DataSets ,in order to implement custom serialization. I would like to use DataContractSerializer (more like have to use it) but still support the custom serialization. The problem is that the [DataContract] and [Serializable] attributes don't seem to get along so well... how could I override the serialization, and support BOTH DataContract & ISerializable serialization?
The code for the wrapper DataSet class is brought here:
[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);
}
}
Thanks!
The DataContractAttribute and the SerializableAttribute can both be used together. The bonus here is, you don't need to use seperate serialisers either. The DataContractSerialzer is an XmlObjectSerializer, which itself supports [Serializable]. For instance:
[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);
}
}
OUTPUT: "Matt"
Using a just a SerializableAttribute attribute we can successfully serialise and deserialise an object using the DataContractSerializer...
Using ISerializable, we can do the same thing:
[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);
}
}
OUTPUT: "MATT"
And with a 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);
}
}
OUTPUT: "Matt"
OUTPUT: 0
When the DataContractSerializer encounters a type with a DataContractAttribute, it will use that instead of passing serialization to its base type, which handles the SerializableAttribute and ISerializable interfaces.
If you are encountering issues, is it with serialisation, or with deserialisation, or both?
这篇关于自定义序列化与DataContractSerializer的的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
