[英]Protobuf-net serialization without annotation
我看了這個答案,我的情況是我不需要保持向后兼容性,我必須有一個解決方案,無需用protobuf-net所需的屬性裝飾數十個類。 所以我嘗試使用RuntimeTypeModel.Default.InferTagFromNameDefault = true;
但我可能沒有正確使用它,因為Serializer.Serialize調用仍然會引發異常請求合同。 這是我的快速測試,我做錯了什么?
public enum CompanyTypes
{
None, Small, Big, Enterprise, Startup
}
public class BaseUser
{
public string SSN { get; set; }
}
public class User : BaseUser
{
public string FirstName { get; set; }
public string LastName { get; set; }
public int Age { get; set; }
public DateTime BirthDate { get; set; }
public List<string> Friends { get; set; }
public Company Company { get; set; }
}
public class Company
{
public string Name { get; set; }
public string Address { get; set; }
public CompanyTypes Type { get; set; }
public List<Product> Products { get; set; }
}
public class Product
{
public string Name { get; set; }
public string Sku { get; set; }
}
[TestClass]
public class SerializationTest
{
[TestMethod]
public void SerializeDeserializeTest()
{
var user = new User
{
Age = 10,
BirthDate = DateTime.Now.AddYears(-10),
FirstName = "Test First",
LastName = "Test Last",
Friends = new List<string> { "Bob", "John" },
Company = new Company
{
Name = "Test Company",
Address = "Timbuktu",
Type = CompanyTypes.Startup,
Products = new List<Product>
{
new Product{Name="Nerf Rocket", Sku="12324AC"},
new Product{Name="Nerf Dart", Sku="DHSN123"}
}
}
};
RuntimeTypeModel.Default.InferTagFromNameDefault = true;
using (var memoryStream = new MemoryStream())
{
Serializer.Serialize(memoryStream, user);
var serialized = Convert.ToBase64String(memoryStream.GetBuffer(), 0, (int)memoryStream.Length);
}
}
}
InferTagFromName
(並且它是雙胞胎, InferTagFromNameDefault
)只有在需要解析成員的標簽號時才會牽手; 它們不會影響哪些成員需要序列化(所以目前答案就是:沒有,即使系統知道它們)。 您可能選擇的選項是ImplicitFields
,但目前只能作為[ProtoContract(...)]
標記使用。 如果你不介意一點注釋,一個實用的修復可能是:
[ProtoContract(ImplicitFields = ImplicitFields.AllPublic)]
User
, Company
和Product
,以及BaseUser
更復雜的BaseUser
(因為繼承):
[ProtoContract(ImplicitFields = ImplicitFields.AllPublic, ImplicitFirstTag = 10)]
[ProtoInclude(1, typeof(User))]
請注意,我們不必添加大量的每個成員注釋。 如果你真的是反屬性,那么也可以通過代碼配置整個模型,通過:
RuntimeTypeModel.Default.Add(typeof(Product), false).Add("Name", "Sku");
RuntimeTypeModel.Default.Add(typeof(Company), false).Add("Name", "Address",
"Type", "Products");
RuntimeTypeModel.Default.Add(typeof(User), false).Add("FirstName", "LastName",
"Age", "BirthDate", "Friends", "Company");
RuntimeTypeModel.Default.Add(typeof(BaseUser), false).Add(10, "SSN")
.AddSubType(1, typeof(User));
問題是陳舊的,但也許有人會需要這個。 我實現了ProtobufSerializer類,它將在使用時構造你的Type圖。 您只需要使用[KnownTypeAttribute]和[DataMember] / [IgnoreDataMember]屬性來注釋您的DTO。 大多數情況下,這是來自某個人的另一個nuget項目的重構版本。 這樣您就不需要在合同依賴項中包含protobuf:
internal sealed class ProtobufSerializer
{
private readonly RuntimeTypeModel _model;
private const BindingFlags Flags = BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
private readonly Dictionary<Type, HashSet<Type>> _subTypes = new Dictionary<Type, HashSet<Type>>();
private readonly ConcurrentDictionary<Type, bool> _builtTypes = new ConcurrentDictionary<Type, bool>();
private static readonly Type[] ComplexPrimitives = new [] { typeof(object), typeof(ValueType), typeof(Enum), typeof(Array)};
private readonly object _sync = new object();
public ProtobufSerializer()
{
_model = TypeModel.Create();
}
public void Serialize(Stream s, object input)
{
EnsureType(input.GetType());
_model.Serialize(s, input);
}
public T Deserialize<T>(Stream s)
{
EnsureType(typeof(T));
return (T)_model.Deserialize(s, null, typeof(T));
}
public void EnsureType(Type type)
{
if (_builtTypes.ContainsKey(type))
{
return;
}
lock (_sync)
{
if (_builtTypes.ContainsKey(type))
{
return;
}
var all = GetGraph(type).ToArray();
foreach (var t in all)
{
InternalBuild(t);
}
}
}
private void InternalBuild(Type type)
{
if (IsPrimitive(type))
{
return;
}
FlatBuild(type);
EnsureBaseClasses(type);
EnsureGenerics(type);
_builtTypes.TryAdd(type, false);
}
private bool IsPrimitive(Type type)
{
return type == null || type.IsPrimitive || _model.CanSerializeBasicType(type) || _builtTypes.ContainsKey(type) || ComplexPrimitives.Contains(type);
}
private static IEnumerable<Type> GetGraph(Type type)
{
return type.TraverseDistinct(GetConnections).Distinct().OrderBy(x=> x.FullName);
}
private static Type GetParent(Type type)
{
return type.BaseType;
}
private static IEnumerable<Type> GetChildren(Type type)
{
var knownTypes = type.GetCustomAttributes(typeof(KnownTypeAttribute)).Cast<KnownTypeAttribute>().Select(x => x.Type).ToArray();
foreach (var t in knownTypes)
{
yield return t;
}
var fields = GetFields(type);
var props = GetProperties(type);
foreach (var memberType in fields.Select(f => f.FieldType))
{
yield return memberType;
}
foreach (var memberType in props.Select(f => f.PropertyType))
{
yield return memberType;
}
}
private static IEnumerable<Type> GetConnections(Type type)
{
var parent = GetParent(type);
if (parent != null)
{
yield return parent;
}
var children = GetChildren(type);
if (children != null)
{
foreach (var c in children)
{
yield return c;
}
}
}
private void FlatBuild(Type type)
{
if(type.IsAbstract)
return;
var meta = _model.Add(type, false);
var fields = GetFields(type);
var props = GetProperties(type);
meta.Add(fields.Select(m => m.Name).ToArray());
meta.Add(props.Select(m => m.Name).ToArray());
meta.UseConstructor = false;
foreach (var memberType in fields.Select(f => f.FieldType).Where(t => !t.IsPrimitive))
{
InternalBuild(memberType);
}
foreach (var memberType in props.Select(f => f.PropertyType).Where(t => !t.IsPrimitive))
{
InternalBuild(memberType);
}
}
private static FieldInfo[] GetFields(Type type)
{
return type.GetFields(Flags).Where(x => x.IsDefined(typeof(DataMemberAttribute))).Where(x => !x.IsDefined(typeof(IgnoreDataMemberAttribute))).ToArray();
}
private static PropertyInfo[] GetProperties(Type type)
{
return type.GetProperties(Flags).Where(x => x.IsDefined(typeof(DataMemberAttribute))).Where(x=> !x.IsDefined(typeof(IgnoreDataMemberAttribute))).ToArray();
}
private void EnsureBaseClasses(Type type)
{
var baseType = type.BaseType;
var inheritingType = type;
while (!IsPrimitive(baseType))
{
HashSet<Type> baseTypeEntry;
if (!_subTypes.TryGetValue(baseType, out baseTypeEntry))
{
baseTypeEntry = new HashSet<Type>();
_subTypes.Add(baseType, baseTypeEntry);
}
if (!baseTypeEntry.Contains(inheritingType))
{
InternalBuild(baseType);
_model[baseType].AddSubType(baseTypeEntry.Count + 500, inheritingType);
baseTypeEntry.Add(inheritingType);
}
inheritingType = baseType;
baseType = baseType.BaseType;
}
}
private void EnsureGenerics(Type type)
{
if (type.IsGenericType || (type.BaseType != null && type.BaseType.IsGenericType))
{
var generics = type.IsGenericType ? type.GetGenericArguments() : type.BaseType.GetGenericArguments();
foreach (var generic in generics)
{
InternalBuild(generic);
}
}
}
}
還有一些簡單的擴展:
public static IEnumerable<T> TraverseDistinct<T>(this T enumer, Func<T, IEnumerable<T>> getChildren)
{
return new[] { enumer }.TraverseDistinct(getChildren);
}
public static IEnumerable<T> TraverseDistinct<T>(this IEnumerable<T> enumer, Func<T, IEnumerable<T>> getChildren)
{
HashSet<T> visited = new HashSet<T>();
Stack<T> stack = new Stack<T>();
foreach (var e in enumer)
{
stack.Push(e);
}
while (stack.Count > 0)
{
var i = stack.Pop();
yield return i;
visited.Add(i);
var children = getChildren(i);
if (children != null)
{
foreach (var child in children)
{
if (!visited.Contains(child))
{
stack.Push(child);
}
}
}
}
}
它在這個階段非常具有實驗性,但是我創建了一個小型庫,它可以獲取大多數類型並在運行時生成Protobuf-net序列化程序: https : //github.com/fnicollier/AutoProtobuf
聲明:本站的技術帖子網頁,遵循CC BY-SA 4.0協議,如果您需要轉載,請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.