Désérialisation d'un tableau d'octets

Si je voulais remplir une structure à partir d'un fichier binaire, je voudrais utiliser quelque chose comme ceci:

using (BinaryReader br = new BinaryReader(File.Open(filename, FileMode.Open)))
{
    myStruct.ID = br.ReadSingle();
    myStruct.name = br.ReadBytes(20);
}

Cependant, je dois lire tout le fichier dans un tableau d'octets avant la désérialisation, parce que je veux faire un pré-traitement. Est-il géré façon de remplir ma structure à partir du tableau d'octets, de préférence similaire à celui ci-dessus?

source d'informationauteur Joulukuusi

  1. 16

    C'est un exemple à prendre certaines données (en fait un Système.Les données.DataSet) et à la sérialisation d'un tableau d'octets, lors de la compression à l'aide de DeflateStream.

    try
{
    var formatter = new BinaryFormatter();
    byte[] content;
    using (var ms = new MemoryStream())
    {
         using (var ds = new DeflateStream(ms, CompressionMode.Compress, true))
         {
             formatter.Serialize(ds, set);
         }
         ms.Position = 0;
         content = ms.GetBuffer();
         contentAsString = BytesToString(content);
     }
}
catch (Exception ex) { /* handle exception omitted */ }

    Voici le code dans le sens inverse pour désérialiser: 

            var set = new DataSet();
        try
        {
            var content = StringToBytes(s);
            var formatter = new BinaryFormatter();
            using (var ms = new MemoryStream(content))
            {
                using (var ds = new DeflateStream(ms, CompressionMode.Decompress, true))
                {
                    set = (DataSet)formatter.Deserialize(ds);                        
                }
            }
        }
        catch (Exception ex)
        {
            //removed error handling logic!
        }

    Espère que cette aide. Comme Nate implicite, nous utilisons MemoryStream ici.

  2. 1

    Prendre un coup d'oeil à la BitConverter classe. Que pourrait faire ce dont vous avez besoin.

  3. 0

    Pour de très simple des structures qui ne sont pas Sérialisables et ne contiennent que des types de base, cela fonctionne. Je l'utilise pour l'analyse des fichiers qui ont un format connu. La vérification d'erreur supprimé pour plus de clarté.

    using System;
using System.IO;
using System.Reflection;
using System.Runtime.InteropServices;

namespace FontUtil
{
    public static class Reader
    {
        public static T Read<T>(BinaryReader reader, bool fileIsLittleEndian = false)
        {
            Type type = typeof(T);
            int size = Marshal.SizeOf(type);
            byte[] buffer = new byte[size];
            reader.Read(buffer, 0, size);
            if (BitConverter.IsLittleEndian != fileIsLittleEndian)
            {
                FieldInfo[] fields = type.GetFields();
                foreach (FieldInfo field in fields)
                {
                    int offset = (int)Marshal.OffsetOf(type, field.Name);
                    int fieldSize = Marshal.SizeOf(field.FieldType);
                    for (int b = offset, t = fieldSize + b - 1; b < t; ++b, --t)
                    {
                        byte temp = buffer[t];
                        buffer[t] = buffer[b];
                        buffer[b] = temp;
                    }
                }
            }
            GCHandle h = GCHandle.Alloc(buffer, GCHandleType.Pinned);
            T obj = (T)Marshal.PtrToStructure(h.AddrOfPinnedObject(), type);
            h.Free();
            return obj;
        }
    }
}

    Les structures ont besoin d'être déclarée comme telle (et ne peut pas contenir des tableaux, je pense, n'ai pas essayé - endian swap serait probablement obtenir confus).

    [StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct NameRecord
{
    public UInt16 uPlatformID;
    public UInt16 uEncodingID;
    public UInt16 uLanguageID;
    public UInt16 uNameID;
    public UInt16 uStringLength;
    public UInt16 uStringOffset; //from start of storage area
}