Est-il possible de sérialiser une liste d'objets System.Object à l'aide de tampons de protocole?

Question

J'ai une liste d'objets de différents types de données (DateTime, int, decimal, string).

List<object> myObjects = new List<object>(); 
myObjects.Add(3); 
myObjects.Add(3.9m); 
myObjects.Add(DateTime.Now); 
myObjects.Add("HELLO"); 

j'ai pu sérialisation cette liste à l'aide protobuf-net, mais désérialisation lancers francs toujours l'exception: « Informations complémentaires: Type ne devrait, et aucun contrat ne peut être inférée: System.Object ».

using (var ms = new MemoryStream()) 
{ 
    Serializer.Serialize(ms, list2); 
    var bytes = ms.ToArray(); 
    ms.Position = 0; 
    var clone = Serializer.Deserialize(typeof(List<object>), ms); //Throws exception 
} 

Je n'ai aucun contrat explicite, je suppose que c'est le problème? Cependant, je sais quels sont les types attendus d'objets sérialisés, mais comment le dire à protobuf-net?

Answer 1

Vérifiez ces de voir pourquoi il est un chemin à parcourir:

1. The need for a parameterless constructor

2. why dynamic instead of object wouldn't have worked

3. pourquoi DynamicType=truewouldn't have worked

4. the need for an abstract base class and concrete implementations, par le créateur de protobuf -net

5. why no serializer for object

de base Résumé

[ProtoContract] 
    [ProtoInclude (1, typeof(ObjectWrapper<int>))] 
    [ProtoInclude(2, typeof(ObjectWrapper<decimal>))] 
    [ProtoInclude(3, typeof(ObjectWrapper<DateTime>))] 
    [ProtoInclude(4, typeof(ObjectWrapper<string>))] 
    abstract class ObjectWrapper { 
     protected ObjectWrapper() {} 
     abstract public object ObjectValue { get; set; } 
    } 

mise en œuvre

[ProtoContract()] 
    class ObjectWrapper<T> : ObjectWrapper 
    { 
     public ObjectWrapper(): base() { } 
     public ObjectWrapper(T t) { this.Value = t; } 

     [ProtoIgnore()] 
     public override object ObjectValue 
     { 
      get { return Value; } 
      set { Value = (T)value; } 
     } 

     [ProtoMember(1)] 
     public T Value { get; set; } 
    } 

test

 var myObjects = new List<ObjectWrapper>(); 
     myObjects.Add(new ObjectWrapper<int>(3)); 
     myObjects.Add(new ObjectWrapper<decimal>(3.9m)); 
     myObjects.Add(new ObjectWrapper<DateTime> (DateTime.Now)); 
     myObjects.Add(new ObjectWrapper<string> ("HELLO")); 
     var clone = Serializer.DeepClone(myObjects);