Передача байтового массива в управляемую структуру

Ответ 1

Я бы превратил массив байтов в поток памяти. Затем создайте двоичный ридер в этом потоке. А затем определите вспомогательные функции, которые берут двоичный считыватель и анализируют один класс.

Встраиваемый класс BinaryReader всегда использует малое значение endian.

Я бы использовал классы вместо структур.

class PacketHeader 
{
    uint16_t magic;
    uint16_t packet_size;
    uint32_t unknown1;
    uint32_t unknown2;
    uint32_t unknown3;
    uint32_t unknown4;
    uint16_t unknown5;
    uint16_t unknown6;
    uint32_t unknown7;
    uint32_t unknown8;
    string packet_type; // replaced with a real string
};

PacketHeader ReadPacketHeader(BinaryReader reader)
{
  var result=new PacketHeader();
  result.magic = reader.ReadInt16();
  ...
  result.packet_type=ReadCString();//Some helper function you might need to define yourself
  return result;
}

Ответ 2

//Я нашел это по адресу: http://code.cheesydesign.com/?p=572 (я еще не тестировал, но // на первый взгляд это будет хорошо работать.)

    /// <summary>
    /// Reads in a block from a file and converts it to the struct
    /// type specified by the template parameter
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="reader"></param>
    /// <returns></returns>
    private static T FromBinaryReader<T>(BinaryReader reader)
    {

        // Read in a byte array
        byte[] bytes = reader.ReadBytes(Marshal.SizeOf(typeof(T)));

        // Pin the managed memory while, copy it out the data, then unpin it
        GCHandle handle = GCHandle.Alloc(bytes, GCHandleType.Pinned);
        T theStructure = (T)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(T));
        handle.Free();

        return theStructure;
    }

Ответ 3

Вот как я это сделал:

using System;
using System.Runtime.InteropServices;
public static object GetObjectFromBytes(byte[] buffer, Type objType)
{
    object obj = null;
    if ((buffer != null) && (buffer.Length > 0))
    {
        IntPtr ptrObj = IntPtr.Zero;
        try
        {
            int objSize = Marshal.SizeOf(objType);
            if (objSize > 0)
            {
                if (buffer.Length < objSize)
                    throw new Exception(String.Format("Buffer smaller than needed for creation of object of type {0}", objType));
                ptrObj = Marshal.AllocHGlobal(objSize);
                if (ptrObj != IntPtr.Zero)
                {
                    Marshal.Copy(buffer, 0, ptrObj, objSize);
                    obj = Marshal.PtrToStructure(ptrObj, objType);
                }
                else
                    throw new Exception(String.Format("Couldn't allocate memory to create object of type {0}", objType));
            }
        }
        finally
        {
            if (ptrObj != IntPtr.Zero)
                Marshal.FreeHGlobal(ptrObj);
        }
    }
    return obj;
}

И в определении структуры я не использовал какой-либо области fixed, вместо этого я использовал атрибут MarshalAs, если стандартная сортировка не работала. Это то, что вам, вероятно, понадобится для строки.

Вы использовали бы эту функцию следующим образом:

PacketHeader ph = (PacketHeader)GetObjectFromBytes(buffer, typeof(PacketHeader));

Изменить: В примере кода я не видел ваше ограничение "BigEndian". Это решение будет работать, только если байты LittleEndian.

Изменить 2: В строке вашего примера вы должны украсить ее:

[MarshalAs(UnmanagedType.LPStr)]

В массивах я бы сделал что-то вроде этого для массива n-size:

[MarshalAs(UnmanagedType.ByValArray, SizeConst = n)]

Ответ 4

Ну, на самом деле у вас есть две задачи. Во-первых, интерпретировать байт [] как структуру по существу, а во-вторых, иметь дело с возможной различной степенью точности.

Итак, они несколько расходятся. AFAIK, если вы хотите использовать маршалинг - он будет просто интерпретировать байты, как если бы это была управляемая структура. Таким образом, перевод с одного конца на другой остается вам. Это не сложно, но это не будет автоматически.

Итак, чтобы интерпретировать байт [] как структуру, вы должны иметь что-то вроде этого:

[StructLayout(LayoutKind.Sequential)]
internal struct X
{
    public int IntValue;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3, ArraySubType = UnmanagedType.U1)] 
    public byte[] Array;
}

static void Main(string[] args)
{
    byte[] data = {1, 0, 0, 0, 9, 8, 7}; // IntValue = 1, Array = {9,8,7}
    IntPtr ptPoit = Marshal.AllocHGlobal(data.Length);
    Marshal.Copy(data, 0, ptPoit, data.Length);
    var x = (X) Marshal.PtrToStructure(ptPoit, typeof (X));
    Marshal.FreeHGlobal(ptPoit);

    Console.WriteLine("x.IntValue = {0}", x.IntValue);
    Console.WriteLine("x.Array = ({0}, {1}, {2})", x.Array[0], x.Array[1], x.Array[2]);
}

Итак, первые 4 байта перейдут в IntValue (1,0,0,0) → [little endian] → 1 Следующие 3 байта переходят непосредственно к массиву.

Если вы хотите BigEndian, вы должны сделать это сами:

int LittleToBigEndian(int littleEndian)
{
    byte[] buf = BitConverter.GetBytes(littleEndian).Reverse().ToArray();
    return BitConverter.ToInt32(buf, 0);
}

Это немного грязно, поэтому, вероятно, вам будет лучше придерживаться написанного вами парсера, который берет байты один за другим из исходного байта [] и заполняет ваш класс данных без StructLayout и другого встроенного взаимодействия.

Ответ 5

Мой подход отличается. Я не хотел копировать любой байт. Я просто хотел их использовать, изменить некоторые из них и использовать измененный массив byte [] в другом месте как byte [].
После копания google и stackoverflow я решил перейти в небезопасное/исправленное.
Там, играя с кодом, я нашел быстрый код без копирования.
Это код DEBUG/TEST. Проверьте это в режиме отладки.
Помните, что таким образом вы не делаете копию, и вы работаете над сырыми байтами [].
Любые изменения в структуре отразятся в изменении массива байтов [] и наоборот.
++ TESTED ++ WORKS

//FOR DEBUG/TEST ONLY
using System.Runtime.InteropServices;
namespace ByteStructCast1
{
    class Program
    {
        [StructLayout(LayoutKind.Sequential, Pack = 1)]
        unsafe struct StructTest//4B
        {
            [MarshalAs(UnmanagedType.U2)]
            public ushort item1;//2B
            public fixed byte item2[2];//2B =2x 1B
        }
        static void Main(string[] args)
        {
            //managed byte array
            byte[] DB1 = new byte[7];//7B more than we need. byte buffer usually is greater.
            DB1[0] = 2;//test data |> LITTLE ENDIAN
            DB1[1] = 0;//test data |
            DB1[2] = 3;//test data
            DB1[3] = 4;//test data
            unsafe //OK we are going to pin unmanaged struct to managed byte array
            {
                fixed(byte* db1 = DB1) //db1 is pinned pointer to DB1 byte[] array
                {
                    //StructTest t1 = *(StructTest*)db1;    //does not change DB1/db1
                    //t1.item1 = 11;                        //does not change DB1/db1
                    db1[0] = 22;                            //does CHANGE DB1/db1
                    DB1[0] = 33;                            //does CHANGE DB1/db1
                    StructTest* ptest = (StructTest*)db1;   //does CHANGE DB1/db1
                    ptest->item1 = 44;                      //does CHANGE DB1/db1
                    ptest->item2[0]++;                      //does CHANGE DB1/db1
                    ptest->item2[1]--;                      //does CHANGE DB1/db1
                }
            }
        }
    }
}

Ответ 6

Чтобы преобразовать массив байтов в строку, вы это сделаете:

byte [] dBytes = ...
string str;
System.Text.UTF8Encoding enc = new System.Text.UTF8Encoding();
str = enc.GetString(dBytes);

И чтобы преобразовать строку обратно в массив байтов

public static byte[] StrToByteArray(string str)
{
    System.Text.UTF8Encoding  encoding=new System.Text.UTF8Encoding();
    return encoding.GetBytes(str);
}

Теперь прочитайте свою строку и посмотрите, каковы ваши данные.