如果我定义了一个类
[DataContract()]
class MyObject {
[DataMember()]
ImmutableList<string> Strings { get; private set}
}
ImmutableList<T> 类型来自不可变库https://www.nuget.org/packages/Microsoft.Bcl.Immutable。请注意，类 ImmutableList 没有默认构造函数或可变的 Add 方法。将事物添加到列表中采用表单。
myList = myList.Add("new string");
我可以为 .NET 序列化机制添加一些自定义支持来支持这种类型并展示如何反序列化它吗？
目前该集合只是在反序列化时被跳过，尽管可以序列化它。
【问题讨论】：
标签： c# .net serialization immutability datacontractserializer
通过IDataContractSurrogate 接口还有另一种干净的方法可以做到这一点。 DataContractSerializer 允许您为不可序列化的对象提供代理。下面是ImmutableList<T> 的示例和测试用例。它使用反射，可能会由比我更聪明的人进行优化，但就是这样。
测试用例
using FluentAssertions;
using System.Collections.Immutable;
using System.IO;
using System.Linq;
using System.Runtime.Serialization;
using System.Text;
using System.Xml;
using Xunit;
namespace ReactiveUI.Ext.Spec
{
[DataContract(Name="Node", Namespace="http://foo.com/")]
class Node
{
[DataMember()]
public string Name;
}
[DataContract(Name="Fixture", Namespace="http://foo.com/")]
class FixtureType
{
[DataMember()]
public ImmutableList<Node> Nodes;
public FixtureType(){
Nodes = ImmutableList<Node>.Empty.AddRange( new []
{ new Node(){Name="A"}
, new Node(){Name="B"}
, new Node(){Name="C"}
});
}
}
public class ImmutableSurrogateSpec
{
public static string ToXML(object obj)
{
var settings = new XmlWriterSettings { Indent = true };
using (MemoryStream memoryStream = new MemoryStream())
using (StreamReader reader = new StreamReader(memoryStream))
using (XmlWriter writer = XmlWriter.Create(memoryStream, settings))
{
DataContractSerializer serializer =
new DataContractSerializer
( obj.GetType()
, new DataContractSerializerSettings() { DataContractSurrogate = new ImmutableSurrogateSerializer() }
);
serializer.WriteObject(writer, obj);
writer.Flush();
memoryStream.Position = 0;
return reader.ReadToEnd();
}
}
public static T Load<T>(Stream data)
{
DataContractSerializer ser = new DataContractSerializer
( typeof(T)
, new DataContractSerializerSettings() { DataContractSurrogate = new ImmutableSurrogateSerializer() }
);
return (T)ser.ReadObject(data);
}
public static T Load<T>(string data)
{
using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(data)))
{
return Load<T>(stream);
}
}
[Fact]
public void ShouldWork()
{
var o = new FixtureType();
var s = ToXML(o);
var oo = Load<FixtureType>(s);
oo.Nodes.Count().Should().Be(3);
var names = oo.Nodes.Select(n => n.Name).ToList();
names.ShouldAllBeEquivalentTo(new[]{"A", "B", "C"});
}
}
}
实施
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Runtime.Serialization;
namespace ReactiveUI.Ext
{
class ImmutableListListConverter<T>
{
public static ImmutableList<T> ToImmutable( List<T> list )
{
return ImmutableList<T>.Empty.AddRange(list);
}
public static List<T> ToList(ImmutableList<T> list){
return list.ToList();
}
public static object ToImmutable( object list )
{
return ToImmutable(( List<T> ) list);
}
public static object ToList(object list){
return ToList(( ImmutableList<T> ) list);
}
}
static class ImmutableListListConverter {
static ConcurrentDictionary<Tuple<string, Type>, Func<object,object>> _MethodCache
= new ConcurrentDictionary<Tuple<string, Type>, Func<object,object>>();
public static Func<object,object> CreateMethod( string name, Type genericType )
{
var key = Tuple.Create(name, genericType);
if ( !_MethodCache.ContainsKey(key) )
{
_MethodCache[key] = typeof(ImmutableListListConverter<>)
.MakeGenericType(new []{genericType})
.GetMethod(name, new []{typeof(object)})
.MakeLambda();
}
return _MethodCache[key];
}
public static Func<object,object> ToImmutableMethod( Type targetType )
{
return ImmutableListListConverter.CreateMethod("ToImmutable", targetType.GenericTypeArguments[0]);
}
public static Func<object,object> ToListMethod( Type targetType )
{
return ImmutableListListConverter.CreateMethod("ToList", targetType.GenericTypeArguments[0]);
}
private static Func<object,object> MakeLambda(this MethodInfo method )
{
return (Func<object,object>) method.CreateDelegate(Expression.GetDelegateType(
(from parameter in method.GetParameters() select parameter.ParameterType)
.Concat(new[] { method.ReturnType })
.ToArray()));
}
}
public class ImmutableSurrogateSerializer : IDataContractSurrogate
{
static ConcurrentDictionary<Type, Type> _TypeCache = new ConcurrentDictionary<Type, Type>();
public Type GetDataContractType( Type targetType )
{
if ( _TypeCache.ContainsKey(targetType) )
{
return _TypeCache[targetType];
}
if(targetType.IsGenericType && targetType.GetGenericTypeDefinition() == typeof(ImmutableList<>))
{
return _TypeCache[targetType]
= typeof(List<>).MakeGenericType(targetType.GetGenericArguments());
}
else
{
return targetType;
}
}
public object GetDeserializedObject( object obj, Type targetType )
{
if ( _TypeCache.ContainsKey(targetType) )
{
return ImmutableListListConverter.ToImmutableMethod(targetType)(obj);
}
return obj;
}
public object GetObjectToSerialize( object obj, Type targetType )
{
if ( targetType.IsGenericType && targetType.GetGenericTypeDefinition() == typeof(ImmutableList<>) )
{
return ImmutableListListConverter.ToListMethod(targetType)(obj);
}
return obj;
}
public object GetCustomDataToExport( Type clrType, Type dataContractType )
{
throw new NotImplementedException();
}
public object GetCustomDataToExport( System.Reflection.MemberInfo memberInfo, Type dataContractType )
{
throw new NotImplementedException();
}
public void GetKnownCustomDataTypes( System.Collections.ObjectModel.Collection<Type> customDataTypes )
{
throw new NotImplementedException();
}
public Type GetReferencedTypeOnImport( string typeName, string typeNamespace, object customData )
{
throw new NotImplementedException();
}
public System.CodeDom.CodeTypeDeclaration ProcessImportedType( System.CodeDom.CodeTypeDeclaration typeDeclaration, System.CodeDom.CodeCompileUnit compileUnit )
{
throw new NotImplementedException();
}
public ImmutableSurrogateSerializer() { }
}
}
【讨论】：
GetObjectToSerializer 不应该同时考虑实际类型和目标类型吗？我必须调整该方法以使 ImmutableSurrogate 与 ImmutableHashSet 一起使用。
一种方法是使用代理可变列表并使用 OnSerializing 和 OnDeserialized 挂钩
[DataContract()]
class MyObject {
public ImmutableList<string> Strings { get; private set}
[DataMember(Name="Strings")]
private List<String> _Strings;
[OnSerializing()]
public void OnSerializing(StreamingContext ctxt){
_Strings = Strings.ToList();
}
[OnDeserialized()]
public void OnDeserialized(StreamingContext ctxt){
Strings = ImmutableList<string>.Empty.AddRange(_Strings);
}
}
它不是超级漂亮，但正如 Marc Gravell 在他的回答中指出的那样，DataContract 序列化程序在不可变集合方面被破坏了，并且没有简单的钩子可以教它如何在没有上述类型的黑客攻击的情况下表现。
更新
DataContract 序列化程序没有损坏。有一种方法可以连接代理。请参阅这个单独的答案，显示另一种技术。
【讨论】：
MyObjectDTO，例如）确实与序列化程序很好地配合，并在两个模型之间添加了转换方法。所以MyObjectDTO 将有一个简单的List<string>，MyObject 保留ImmutableList<string>，并且转换代码具有在它们之间切换的魔力。
嘿;我可以想象这里发生了什么......生成的代码可能正在做（释义）：
var list = obj.Strings;
while(CanReadNextItem()) {
list.Add(ReadNextItem());
}
问题在于 BCL 不可变 API 会要求您每次都捕获结果，即
var list = obj.Strings;
while(CanReadNextItem()) {
list = list.Add(ReadNextItem());
}
obj.Strings = list; // the private set is not a problem for this
预先存在的列表反序列化代码不能以这种方式工作，因为它从来不需要 - 事实上，Add 有许多不同的实现，其中一些返回非空结果需要忽略。
缺少非公共构造函数也可能会让人有些不安，但如果这是主要问题，我会在它尝试创建非空列表时出现异常。
当然，就性能而言，list = list.Add(...) API 可能并不是最适合使用的 API无论如何（尽管它应该可以工作）。
我最近写了一篇关于这个主题的博客（在 protobuf-net 的上下文中，它现在已经更新为与这些集合类型一起工作）：http://marcgravell.blogspot.co.uk/2013/09/fun-with-immutable-collections.html希望这篇博客文章能解释为什么这些差异意味着它不能播放与现有的序列化技术完美结合，以及如何更新序列化库以适应这种情况。
要直接回答这个问题，我想说的答案很简单：因为尚未对DataContractSerializer 进行支持不可变集合所需的更改。我不知道是否有计划解决这个问题。但是：我很高兴地声明：“在 protobuf-net 中工作”；p
【讨论】：
DataMember，并使用 OnSerializing 和 OnDeserialized 挂钩通过可变列表代理不可变集合。它可以工作，从公共接口的角度来看，它仍然是不可变的集合。