objet sérialisation et IDisposable

Question

 public static string SerializeObject<T>(T obj) 
     { 
      try 
      { 
       string xmlString = null; 
       MemoryStream memoryStream = new MemoryStream(); 
       XmlSerializer xs = new XmlSerializer(typeof(T)); 
       XmlTextWriter xmlTextWriter = new XmlTextWriter(memoryStream, Encoding.UTF8); 
       xs.Serialize(xmlTextWriter, obj); 
       memoryStream = (MemoryStream)xmlTextWriter.BaseStream; 
       xmlString = UTF8ByteArrayToString(memoryStream.ToArray());  return xmlString; 
      } 
      catch 
      { 
       return string.Empty; 
      } 
     } 

c'est de - http://geekswithblogs.net/paulwhitblog/archive/2007/07/20/114076.aspx

Est-il possible d'écrire ce où l'objet MemoryStream n'a pas besoin d'être réaffecté? Ne devrait-il pas être jeté (enveloppé dans un bloc d'utilisation)? Quel est le memoryStream utilisé puis réaffecté?

Answer 1

Vous avez raison. Vous devriez encapsulé le flux dans un bloc utilisant. Et la réaffectation n'est pas autorisée lorsque la variable est utilisée dans le bloc using. Et ce n'est même pas nécessaire de faire la sérialisation. Vous pouvez le faire comme ceci:

public static string SerializeObject<T>(T obj) 
{ 
    try 
    { 
     string xmlString = null; 
     using (MemoryStream memoryStream = new MemoryStream()) 
     { 
      XmlSerializer xs = new XmlSerializer(typeof(T)); 
      XmlTextWriter xmlTextWriter = new XmlTextWriter(memoryStream, Encoding.UTF8); 
      xs.Serialize(xmlTextWriter, obj); 
      xmlString = UTF8ByteArrayToString(memoryStream.ToArray()); 
      return xmlString; 
     } 
    } 
    catch 
    { 
     return string.Empty; 
    } 
} 

Answer 2

Je ne comprends pas la réaffectation de flux mémoire non plus. Voici ma version refactorisée.

public static string SerializeObject<T>(T obj) 
{ 
    try 
    { 
     using (MemoryStream ms = new MemoryStream()) 
     { 
     XmlSerializer xs = new XmlSerializer(typeof(T)); 
     XmlTextWriter xwriter = new XmlTextWriter(ms, Encoding.UTF8); 
     xs.Serialize(xwriter, obj); 
     return UTF8ByteArrayToString(ms.ToArray()); 
     } 
    } 
    catch 
    { 
     return string.Empty; 
    } 
} 

Answer 3

Je refactoriserais ce code légèrement différemment des autres réponses pour vérifier d'abord si le type est sérialisable. Il n'y a aucun moyen de le faire en utilisant des contraintes (http://bit.ly/c2Hq4s) mais vous pouvez le vérifier facilement de toute façon. Je viens de laisser de côté l'utilisation et inclus le Enfin juste pour montrer que vous pourrait le faire sans l'utilisation aussi.

public static string SerializeObject<T>(T obj) 
    { 
     if (!typeof(T).IsSerializable) 
     { 
      throw new ArgumentException("type is not serializable"); 
     } 

     string xmlString = string.Empty; 
     MemoryStream memoryStream = new MemoryStream(); 

     try 
     { 
      XmlSerializer xs = new XmlSerializer(typeof(T)); 
      XmlTextWriter xmlTextWriter = new XmlTextWriter(memoryStream, Encoding.UTF8); 
      xs.Serialize(xmlTextWriter, obj); 
      xmlString = UTF8ByteArrayToString(memoryStream.ToArray());  
     } 
     catch // something useful here 
     { 
      // Do something useful here 
     } 
     finally 
     { 
      // Dispose of what you want here 
     } 

     return xmlString; 
    } 

Answer 4

Si vous souhaitez utiliser l'encodage actuel, voici un autre exemple de la même chose.

public static string SerializeObject<T>(T o) 
    { 
     string serializeObject = string.Empty; 
     if (o != null) 
     { 
      try 
      { 
       using (MemoryStream ms = new MemoryStream()) 
       { 
        XmlSerializer xs = new XmlSerializer(typeof(T)); 
        xs.Serialize(ms, o); 
        using (System.IO.StreamReader sr = new StreamReader(ms)) 
        { 
         serializeObject = sr.CurrentEncoding.GetString(ms.ToArray()); 
        } 
       } 
      } 
      catch { } 
     } 
     return serializeObject; 
    } 

Answer 5

public static string SerializeObject<T>(T o) 
{ 
    var serialized = ""; 
    try 
    { 
     using (var ms = new MemoryStream()) 
     { 
      var xs = new XmlSerializer(typeof(T)); 
      xs.Serialize(ms, o); 
      using (var reader = new StreamReader(ms)) 
      { 
       serialized = sr.CurrentEncoding.GetString(ms.ToArray()); 
      } 
     } 
    } 
    catch 
    { 
     // bad stuff happened. 
    } 

    return serialized; 
}