¿Cómo evitar que XmlSerializer mate NewLines en cadenas?

Question

Supongamos que tengo una clase simple con solo un miembro en una cadena.

public class Abc 
{ 
    private String text; 

    public String Text 
    { 
     get { return this.text; } 
     set { this.text = value; } 
    } 
} 

Ahora cuando serializar y luego deserializar con el XmlSerializer cuestionable cualquier saltos de línea de texto que contiene ('\ r \ n' o Environment.NewLine) se transforman a '\ n'.

¿Cómo guardo las nuevas líneas?

Answer 1

No es el XmlSerializer sino el XmlWriter que está eliminando su CR. Para retenerlo, debemos hacer que el escritor convierta CR en su entidad de caracteres 
.

XmlWriterSettings ws = new XmlWriterSettings(); 
ws.NewLineHandling = NewLineHandling.Entitize; 

XmlSerializer ser = new XmlSerializer(typeof(Abc)); 
using (XmlWriter wr = XmlWriter.Create("abc.xml", ws)) { 
    ser.Serialize(wr, s); 
} 

Esto es exactamente lo mismo con DataContractSerializer:

var ser = new DataContractSerializer(typeof(Abc)); 
using (XmlWriter wr = XmlWriter.Create("abc.xml", ws)) { 
    ser.Serialize(wr, s); 
} 

¿Por qué tenemos que hacer esto?

Esto se debe a que los analizadores XML compatibles deben, antes del análisis, traducir CRLF y cualquier CR no seguido de una LF en una sola LF. Este comportamiento se define en la sección End-of-Line handling de la especificación XML 1.0.

Como esto sucede antes del análisis, debe codificar CR como su entidad de caracteres si desea que el CR exista en el documento.

Answer 2

Usar este código:

public static FilterOptions Deserialize(string serializedData) 
{ 
    try 
    { 
     var xmlSerializer = new XmlSerializer(typeof(FilterOptions)); 
     var xmlReader = new XmlTextReader(serializedData,XmlNodeType.Document,null); 
     var collection = (FilterOptions)xmlSerializer.Deserialize(xmlReader); 
     return collection; 
    } 
    catch (Exception) 
    { 


    } 

    return new FilterOptions(); 
} 

Answer 3

public class SerializeAny<TF> where TF : new() 
{ 
    public static TF Deserialize(string serializedData) 
    { 
     try 
     { 
      var xmlSerializer = new XmlSerializer(typeof(TF)); 
      TF collection; 
      using (var xmlReader = new XmlTextReader(serializedData, XmlNodeType.Document, null)) 
      { 
       collection = (TF)xmlSerializer.Deserialize(xmlReader); 
      } 
      return collection; 
     } 
     catch (Exception) 
     { 


     } 

     return new TF(); 
    } 


    public static TF DeserializeZip(string path) 
    { 
     try 
     { 
      var bytes = File.ReadAllBytes(path); 

      string serializedData = Unzip(bytes); 

      TF collection = Deserialize(serializedData); 


      return collection; 
     } 
     catch (Exception) 
     { 


     } 

     return new TF(); 
    } 

    public static string Serialize(TF options) 
    { 
     var xml = ""; 

     try 
     { 
      var xmlSerializer = new XmlSerializer(typeof(TF)); 
      using (var stringWriter = new StringWriter()) 
      { 
       xmlSerializer.Serialize(stringWriter, options); 
       xml = stringWriter.ToString(); 
      } 
     } 
     catch (Exception ex) 
     { 

      return ex.Message; 
     } 



     return xml; 
    } 

    public static string SerializeZip(TF options, string path) 
    { 
     var xml = ""; 

     try 
     { 
      xml = Serialize(options); 
      var zip = Zip(xml); 
      File.WriteAllBytes(path, zip); 
     } 
     catch (Exception ex) 
     { 

      return ex.Message; 
     } 



     return xml; 
    } 



    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2202:Do not dispose objects multiple times")] 
    internal static String SerializeObject<T>(T obj, Encoding enc) 
    { 
     using (var ms = new MemoryStream()) 
     { 
      var xmlWriterSettings = new System.Xml.XmlWriterSettings() 
      { 
       // If set to true XmlWriter would close MemoryStream automatically and using would then do double dispose 
       // Code analysis does not understand that. That's why there is a suppress message. 
       CloseOutput = false, 
       Encoding = enc, 
       OmitXmlDeclaration = false, 
       Indent = true 
      }; 
      using (var xw = XmlWriter.Create(ms, xmlWriterSettings)) 
      { 
       var s = new XmlSerializer(typeof(T)); 
       s.Serialize(xw, obj); 
      } 

      return enc.GetString(ms.ToArray()); 
     } 
    } 

    private static void CopyTo(Stream src, Stream dest) 
    { 
     byte[] bytes = new byte[4096]; 

     int cnt; 

     while ((cnt = src.Read(bytes, 0, bytes.Length)) != 0) 
     { 
      dest.Write(bytes, 0, cnt); 
     } 
    } 

    private static byte[] Zip(string str) 
    { 
     var bytes = Encoding.UTF8.GetBytes(str); 

     using (var msi = new MemoryStream(bytes)) 
     using (var mso = new MemoryStream()) 
     { 
      using (var gs = new GZipStream(mso, CompressionMode.Compress)) 
      { 
       //msi.CopyTo(gs); 
       CopyTo(msi, gs); 
      } 

      return mso.ToArray(); 
     } 
    } 

    private static string Unzip(byte[] bytes) 
    { 
     using (var msi = new MemoryStream(bytes)) 
     using (var mso = new MemoryStream()) 
     { 
      using (var gs = new GZipStream(msi, CompressionMode.Decompress)) 
      { 
       CopyTo(gs, mso); 
      } 

      return Encoding.UTF8.GetString(mso.ToArray()); 
     } 
    } 

} 

Answer 4

BinarySerialize clase pública donde T: new() { pública cadena Serialize estática (opciones T, string path) {

  var xml = ""; 
      try 
      { 
       File.Delete(path); 
      } 
      catch (Exception) 
      { 


      } 

      try 
      { 
       using (var fs = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.ReadWrite)) 
       { 
        var bf = new BinaryFormatter(); 


        bf.Serialize(fs, options); 
       } 


      } 
      catch (Exception ex) 
      { 

       return ex.Message; 
      } 



      return xml; 





     } 

     public static T Deserialize(string path) 
     { 
      T filteroptions; 
      using (var fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read)) 
      { 
       var bf = new BinaryFormatter(); 
       filteroptions = (T)bf.Deserialize(fs); 
      } 
      return filteroptions; 

     } 
    }