Casting ein byte-array in eine verwaltete Struktur

Ich würde schalten Sie den byte-array in einen memory-stream. Anschließend instanziieren Sie ein binary-reader auf dem stream. Und dann definieren Sie die helper-Funktionen, die eine binäre Leser und analysieren einer einzelnen Klasse.

Den eingebauten BinaryReader Klasse verwendet immer little-endian.

Ich würde verwenden Sie Klassen anstelle von Strukturen hier.

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;
}

InformationsquelleAutor CodesInChaos

Dies ist, wie ich getan habe:

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;
}

Und in der struct-definition, die ich nicht alle fixed region, die ich stattdessen verwendet die MarshalAs Attribut, wenn die standard-marshalling nicht gearbeitet. Dies ist, was Sie probally müssen für die Zeichenfolge.

Verwenden Sie diese Funktion wie folgt:

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

Bearbeiten:
Ich nicht sehen, Ihre BigEndian "Einschränkung" im code-Beispiel. Diese Lösung funktioniert nur, wenn die bytes sind LittleEndian.

Edit 2:
Im string des Beispiels würden Sie schmücken Sie mit:

[MarshalAs(UnmanagedType.LPStr)]

In den arrays würde ich mit so etwas für eine n-sortierte array:

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

InformationsquelleAutor Vladimir

Mein Ansatz ist anders. Ich wollte nicht kopieren, byte.

Ich wollte nur, Sie zu benutzen, ändern Sie einige von Ihnen und nutzen verändert byte [] - array an anderer Stelle als byte[].

Nach dem Graben google und stackoverflow habe ich beschlossen zu gehen in unsicheren/behoben werden.

Es spielen mit code, den ich gefunden habe, schnellen code ohne kopieren.

Dies ist die DEBUG - /TEST-code. Überprüfen Sie dies im debug-Modus.

Denken Sie daran, dass diese Weise, die Sie nicht machen Sie eine Kopie und Sie arbeiten auf raw byte[] data.

Jede änderung in der Struktur widerspiegeln, in byte [] - array ändern und Umgekehrt.

++GETESTET++ ARBEITET

//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
                }
            }
        }
    }
}

InformationsquelleAutor MrHIDEn

Umwandeln byte-array in einen string Sie dies tun;

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

Und konvertieren den string in ein ByteArray zurück,

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

Nun Lesen Sie den Text und sehen, was mit Ihren Daten ist.

InformationsquelleAutor KenL