sérialisation binaire de types définis dans un assemblage silverlight

Question

J'ai un ensemble silverlight qui est référencé par une application silverlight et une application ASP.Net.

Dans l'application ASP.Net, je dois sérialiser (Binary) certaines des instances de types définis dans l'assembly silverlight. Est-ce que quelqu'un peut m'aider avec ça?

Modifier

Mon problème est que j'ai un ensemble de silverlight qui est utilisé par une application silverilght, une application asp.net et une application WinForms, dans mon application asp.net et WinForms application je dois sérialiser les types définis dans la silverlight partagée.

Également sur une note légèrement différente peut-on expliquer pourquoi cet attribut est nécessaire?

Answer 1

je quelque chose appelé le sharp serializer qui est en mesure de types de sérialisation binaires sans attribut sérialisable.

Answer 2

Vous pouvez utiliser #if directives pour inclure des attributs de sérialisation (et code) pour les non-Silverlight construit:

#if !SILVERLIGHT 
[Serializable] 
#endif 
public class SomeClass 
{ 
} 

Answer 3

également sur une note légèrement différente peut quelqu'un expliquer pourquoi cet attribut est nécessaires ?

En cours de sérialisation, BinaryFormatter appelle les méthodes de la classe FormatterServices L'un d'elles est

private static MemberInfo[] InternalGetSerializableMembers(RuntimeType type) 

Cette méthode contient le code suivant:

if (!CheckSerializable(type)) 
    { 
     throw new SerializationException(Environment.GetResourceString("Serialization_NonSerType", new object[] { type.FullName, type.Module.Assembly.FullName })); 
    } 

permet de vérifier la méthode CheckSerializable de classe FormatterServices:

private static bool CheckSerializable(RuntimeType type) 
{ 
    return type.IsSerializable; 
} 

Ce code similaire à:

Type t = typeof (SomeClass); 
    bool isTypeSerializable = t.IsSerializable; 

Dans cet exemple isTypeSerializable sera vrai si la classe SomeClass a SerializableAttribute. Sinon faux.
Soo ... Réponse simple: cet attribut est l'indicateur indiquant que les instances de la classe peuvent être sérialisées. Donc, il a juste besoin et c'est tout. En ce qui concerne votre question principale:
Malheureusement vous ne pouvez pas utiliser le formateur binaire par exemple de la classe définie dans l'assemblage Silverlight directement.
Une façon de le faire pour utiliser une classe proxy.
Exemple:
classe dans votre ensemble silverlight:

public class SomeClass 
{ 
    public int IntValue { get; set; } 
    public string StringValue { get; set; } 
    public bool BoolValue { get; set; } 
} 

classe Proxy qui prend en charge la sérialisation à l'intérieur assemly .NET commun avec référence à l'assemblage silverlight:

[Serializable] 
    public class SomeClassProxy 
    { 
     public int IntValue { get; set; } 
     public string StringValue { get; set; } 
     public bool BoolValue { get; set; } 

     public static SomeClassProxy GetSerializableObject(SomeClass silverlightClass) 
     { 
      return new SomeClassProxy 
        { 
         IntValue = silverlightClass.IntValue, 
         StringValue = silverlightClass.StringValue, 
         BoolValue = silverlightClass.BoolValue 
        }; 
     } 

     public static SomeClass DeserializeSilverlightCompatible(Stream stream) 
     { 
      BinaryFormatter formatter = new BinaryFormatter(); 
      SomeClassProxy proxy = formatter.Deserialize(stream) as SomeClassProxy; 

      return new SomeClass 
      { 
       IntValue = proxy.IntValue, 
       StringValue = proxy.StringValue, 
       BoolValue = proxy.BoolValue 
      }; 
     } 
    } 

Donc, dans votre asp.net ou les applications WinForms vous devez fonctionner avec classe proxy:

using(MemoryStream memoryStream = new MemoryStream()) 
     { 
      BinaryFormatter formatter = new BinaryFormatter(); 
          //create instance of silverlight class 
      SomeClass mySilverlightClass = new SomeClass(); 
      mySilverlightClass.IntValue = 555; 
      mySilverlightClass.StringValue = "Hello World!"; 
      mySilverlightClass.BoolValue = true; 

      //<===serialize and take care of silverlight instance 
      formatter.Serialize(memoryStream, SomeClassProxy.GetSerializableObject(mySilverlightClass)); 

      memoryStream.Seek(0, SeekOrigin.Begin); 
      //===>deserialize to silverlight instance 
      SomeClass mySilverlightClassRestored = SomeClassProxy.DeserializeSilverlightCompatible(memoryStream); 
     } 

Donc, ce proxy se charge à la fois sérialisation et désérialisation (après désérialisation vous recevrez instance de SomeClass de classe qui définit dans l'assemblage silverlight).

Si formatter binaire est rescriction douce alors je vous recommande d'utiliser xml sérialiseur à la place:

XmlSerializer s = new XmlSerializer(typeof(SomeClass)); 
s.Serialize(memoryStream, mySilverlightClass); 
memoryStream.Seek(0, SeekOrigin.Begin); 
SomeClass restored = s.Deserialize(memoryStream) as SomeClass; 

Il SerializableAttribute que des cas n'est pas nécessaire.

Answer 4

Vous pouvez essayer mon sérialiseur qui est capable de données binaires se déplaçant entre .NET et Silverlight ... http://whydoidoit.com