¿Cómo serializar la matriz de bytes a XML usando XmlSerializer en C#?

Question

Digamos que tenemos una estructura que se trata de datos es proporcionada por el conjunto de bytes no-administrado con Marshal.PtrToStructure.

El diseño # struct C:

[StructLayout(LayoutKind.Sequential, Size = 128, CharSet = CharSet.Ansi, Pack = 1)] 
public struct MNG_Y_Params 
{ 
    public byte Number; 
    public byte Version; 
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)] 
    public byte[] OliNumber; 
    public byte InterfaceType; 
} 

La matriz de bytes representan una cadena (ASCII) en el código-un administrado.

Esta estructura es un miembro de otra estructura (que tiene algunos otros miembros):

public struct MyData 
{ 
    public int ID; 
    public StructType structType; 
    [XmlElement(ElementName="MNG_Y_Params")] 
    public MNG_Y_Params y_params; 
    [XmlElement(ElementName = "SimpleStruct2")] 
    public SimpleStruct2 ss2; 
}; 

Así que también tenemos el código de apoyo

public class XMLIgnore 
{ 
    static public XmlSerializer customserialiser(MyData d) 
    { 
     XmlAttributes attrs = new XmlAttributes(); 
     attrs.XmlIgnore = true; 
     XmlAttributeOverrides xmlOveride = new XmlAttributeOverrides(); 
     switch (d.structType) 
     { 
      case StructType.ST_1: 
       xmlOveride.Add(typeof(MyData), "ss2", attrs); 
       break; 
      case StructType.ST_2: 
       xmlOveride.Add(typeof(MyData), "y_params", attrs); 
       break; 
      default: 
       break; 
     } 
     return new XmlSerializer(typeof(MyData), xmlOveride); 
    } 
} 

y el método Save

static void SaveToXml(object obj, string fileName, XmlSerializer writer) 
    { 
     //XmlSerializer writer = new XmlSerializer(obj.GetType()); 
     using (StreamWriter file = new StreamWriter(fileName)) 
     { 
      writer.Serialize(file, obj); 
     } 
    } 

Por ejemplo, solo generaríamos algunos datos.

 MNG_Y_Params yParams = new MNG_Y_Params(); 
     yParams.Version = 1; 
     yParams.InterfaceType = 15; 
     yParams.Number = 35; 
     ASCIIEncoding enc = new ASCIIEncoding(); 
     yParams.OliNumber = enc.GetBytes("#1"); 

     MyData md1 = new MyData(); 
     md1.ID = 1; 
     md1.structType = StructType.ST_1; 
     md1.y_params = yParams; 

     XmlSerializer writer = XMLIgnore.customserialiser(md1); 
     SaveToXml(md1, @"C:\temp\dataOne.xml", writer); 

XML esperado:

<?xml version="1.0" encoding="utf-8"?> 
<MyData xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
    <ID>1</ID> 
    <structType>ST_1</structType> 
    <MNG_Y_Params> 
    <Number>35</Number> 
    <Version>1</Version> 
    <OliNumber>#1</OliNumber> 
    <InterfaceType>15</InterfaceType> 
    </MNG_Y_Params> 
</MyData> 

Resultado XML:

<?xml version="1.0" encoding="utf-8"?> 
<MyData xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
    <ID>1</ID> 
    <structType>ST_1</structType> 
    <MNG_Y_Params> 
    <Number>35</Number> 
    <Version>1</Version> 
    <OliNumber>IzE=</OliNumber> 
    <InterfaceType>15</InterfaceType> 
    </MNG_Y_Params> 
</MyData> 

Por favor, se centran en el (OliNumber) Resultado miembro de la matriz de bytes.

¿Hay un atributo que podríamos utilizar aquí? ¿Qué me estoy perdiendo?

Gracias por su tiempo y ayuda.

Ilan

Para reference

Answer 1

El XmlSerializer por defecto codificará las matrices de bytes usando la base 64 de codificación. Si utiliza this sitio y pegar en IzE= y decodificarlo, el resultado será #1. Puede cambiar la codificación configurando XmlElementAttribute.DataType. No estoy seguro si funcionará [XmlElement(DataType = "string")], pero puede intentarlo. El uso de [XmlElement(DataType = "hexBinary")] generará los bytes sin procesar.

Answer 2

que tiene esto funcione utilizando la siguiente:

public class MySerializableClass 
    { 
    [XmlIgnore] 
    public string NaughtyXmlCharactersAsString { get; set; } 

    [XmlElement(ElementName = "NaughtyXmlCharacters", DataType = "hexBinary")] 
    public byte[] NaughtyXmlCharactersAsBytes 
    { 
     get { return Encoding.UTF8.GetBytes(NaughtyCharactersAsString ?? string.Empty); } 
     set { NaughtyXmlCharactersAsString = Encoding.UTF8.GetString(value); } 
    } 

que sería entonces sólo acceder a la "AsString" versión de la propiedad.

Answer 3

Esto es cómo lo hice:

public class MySerializableClass 
{ 
    private string dummy; 

    [XmlElement("NaughtyXmlCharacters")] 
    public string NaughtyXmlCharactersAsString 
    { 
     get 
     { 
      return BitConverter.ToString(NaughtyXmlCharacters); 
     } 
     set 
     { 
      // without this, the property is not serialized. 
      dummy = value; 
     } 
    } 

    [XmlIgnore] 
    public byte[] NaughtyXmlCharacters 
    { 
     get; 
     set; 
    } 
} 

Los bytes son entonces formateados como valores hexadecimales y se separan con un signo menos: 00-AF-B1