Marshalling einer big-endian-byte-Sammlung in ein struct, um pull-out-Werte

Hier ist eine andere Lösung für das austauschen von endian.

Es ist einstellbar von Adam Robinsons Lösung hier: https://stackoverflow.com/a/2624377/1254743

Es ist sogar in der Lage, die Handhabung von geschachtelten Strukturen.

public static class FooTest
{
    [StructLayout(LayoutKind.Sequential, Pack = 1)]
    public struct Foo2
    {
        public byte b1;
        public short s;
        public ushort S;
        public int i;
        public uint I;
        public long l;
        public ulong L;
        public float f;
        public double d;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)]
        public string MyString;
    }

    [StructLayout(LayoutKind.Sequential, Pack = 1)]
    public struct Foo
    {
        public byte b1;
        public short s;
        public ushort S;
        public int i;
        public uint I;
        public long l;
        public ulong L;
        public float f;
        public double d;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)]
        public string MyString;
        public Foo2 foo2;
    }

    public static void test()
    {
        Foo2 sample2 = new Foo2()
        {
            b1 = 0x01,
            s = 0x0203,
            S = 0x0405,
            i = 0x06070809,
            I = 0x0a0b0c0d,
            l = 0xe0f101112131415,
            L = 0x161718191a1b1c,
            f = 1.234f,
            d = 4.56789,
            MyString = @"123456789", //null terminated => only 9 characters!
        };

        Foo sample = new Foo()
        {
            b1 = 0x01,
            s = 0x0203,
            S = 0x0405,
            i = 0x06070809,
            I = 0x0a0b0c0d,
            l = 0xe0f101112131415,
            L = 0x161718191a1b1c,
            f = 1.234f,
            d = 4.56789,
            MyString = @"123456789", //null terminated => only 9 characters!
            foo2 = sample2,
        };

        var bytes_LE = Dummy.StructToBytes(sample, Endianness.LittleEndian);
        var restoredLEAsLE = Dummy.BytesToStruct<Foo>(bytes_LE, Endianness.LittleEndian);
        var restoredLEAsBE = Dummy.BytesToStruct<Foo>(bytes_LE, Endianness.BigEndian);

        var bytes_BE = Dummy.StructToBytes(sample, Endianness.BigEndian);
        var restoredBEAsLE = Dummy.BytesToStruct<Foo>(bytes_BE, Endianness.LittleEndian);
        var restoredBEAsBE = Dummy.BytesToStruct<Foo>(bytes_BE, Endianness.BigEndian);

        Debug.Assert(sample.Equals(restoredLEAsLE));
        Debug.Assert(sample.Equals(restoredBEAsBE));
        Debug.Assert(restoredBEAsLE.Equals(restoredLEAsBE));
    }

    public enum Endianness
    {
        BigEndian,
        LittleEndian
    }

    private static void MaybeAdjustEndianness(Type type, byte[] data, Endianness endianness, int startOffset = 0)
    {
        if ((BitConverter.IsLittleEndian) == (endianness == Endianness.LittleEndian))
        {
            //nothing to change => return
            return;
        }

        foreach (var field in type.GetFields())
        {
            var fieldType = field.FieldType;
            if (field.IsStatic)
                //don't process static fields
                continue;

            if (fieldType == typeof(string)) 
                //don't swap bytes for strings
                continue;

            var offset = Marshal.OffsetOf(type, field.Name).ToInt32();

            //handle enums
            if (fieldType.IsEnum)
                fieldType = Enum.GetUnderlyingType(fieldType);

            //check for sub-fields to recurse if necessary
            var subFields = fieldType.GetFields().Where(subField => subField.IsStatic == false).ToArray();

            var effectiveOffset = startOffset + offset;

            if (subFields.Length == 0)
            {
                Array.Reverse(data, effectiveOffset, Marshal.SizeOf(fieldType));
            }
            else
            {
                //recurse
                MaybeAdjustEndianness(fieldType, data, endianness, effectiveOffset);
            }
        }
    }

    internal static T BytesToStruct<T>(byte[] rawData, Endianness endianness) where T : struct
    {
        T result = default(T);

        MaybeAdjustEndianness(typeof(T), rawData, endianness);

        GCHandle handle = GCHandle.Alloc(rawData, GCHandleType.Pinned);

        try
        {
            IntPtr rawDataPtr = handle.AddrOfPinnedObject();
            result = (T)Marshal.PtrToStructure(rawDataPtr, typeof(T));
        }
        finally
        {
            handle.Free();
        }

        return result;
    }

    internal static byte[] StructToBytes<T>(T data, Endianness endianness) where T : struct
    {
        byte[] rawData = new byte[Marshal.SizeOf(data)];
        GCHandle handle = GCHandle.Alloc(rawData, GCHandleType.Pinned);
        try
        {
            IntPtr rawDataPtr = handle.AddrOfPinnedObject();
            Marshal.StructureToPtr(data, rawDataPtr, false);
        }
        finally
        {
            handle.Free();
        }

        MaybeAdjustEndianness(typeof(T), rawData, endianness);

        return rawData;
    }

}

Scheint es, muss es eine elegantere Lösung, aber dies sollte Sie wenigstens Los:

    static T ByteArrayToStructureBigEndian<T>(byte[] bytes) where T : struct
    {
        GCHandle handle = GCHandle.Alloc(bytes, GCHandleType.Pinned);
        T stuff = (T)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(T));
        handle.Free();
        System.Type t = stuff.GetType();
        FieldInfo[] fieldInfo = t.GetFields();
        foreach (FieldInfo fi in fieldInfo)
        {                 
            if (fi.FieldType == typeof(System.Int16))
            {
                //TODO
            }
            else if (fi.FieldType == typeof(System.Int32))
            {
                //TODO
            }
            else if (fi.FieldType == typeof(System.Int64))
            {
                //TODO
            }
            else if (fi.FieldType == typeof(System.UInt16))
            {
                UInt16 i16 = (UInt16)fi.GetValue(stuff);
                byte[] b16 = BitConverter.GetBytes(i16);
                byte[] b16r = b16.Reverse().ToArray();
                fi.SetValueDirect(__makeref(stuff), BitConverter.ToUInt16(b16r, 0);
            }
            else if (fi.FieldType == typeof(System.UInt32))
            {
                //TODO
            }
            else if (fi.FieldType == typeof(System.UInt64))
            {
                //TODO
            }
        }
        return stuff;
    }

Stimme ich mit @weismat und glauben, es gibt keine Lösung.

Was Sie zeigen in Ihrem Beispiel ist, dass Sie Zugriff auf ein raw-byte-Puffer, als ob es eine ANDERE Struktur, ohne etwas zu ändern, und nicht das kopieren oder verschieben von Daten um, nichts. Einfach anpinnen, es zu vermeiden, es zu bewegen, weil der GC.

Dies ist im Grunde, was Sie erreichen in der Regel in C durch die Verwendung eines union-Typs, die beide Ihr Ziel-Struktur und ein byte-array der gleichen Größe.

Die gute Seite ist, dass es sehr effizient ist.

Dass hat mehrere Nachteile, der größte ist, dass Sie bekommen nur auf diese Weise Zugang zu Daten, die in der nativen Maschine, um (sei es LE oder BE). Damit Ihre ByteArrayToStructure ist nicht wirklich LE, es ist nur so, weil der Prozessor drunter ist LE. Wenn Sie, kompilieren Sie das gleiche Programm auf einem anderen Ziel, die geschehen WERDEN, es funktioniert in die andere Richtung und glauben, dass dein byte-array SEIN.

Andere Nachteile sind, dass müssen Sie sehr vorsichtig sein mit Daten Ausrichtung, bewusst sein, möglich Auffüllen, etc. und natürlich, dass es keine Möglichkeit gibt, ändern Sie die byte-Reihenfolge von LE zu WERDEN, ohne verschieben von Daten in Byte-array (wenn du ein 16-bit-Ganzzahlen nur die Arrays wie in deinem Beispiel ist dies nur etwa alle zwei bytes).

Ich hatte zufällig ein ähnliches problem und poundered nicht für diese Lösung, weil die bisherigen Nachteile und entschied sich zu verstecken meine input-Strukturen hinter Zugriffsmethoden verbergen Zugriff auf das Byte-array unter. Es ist vielleicht nicht so elegant, aber es ist einfach und vermeiden Sie auch das kopieren der Puffer oder verschieben von Daten in keiner Weise.

Aus meiner Sicht brauchen Sie nur ein Array hinzuzufügen.Reverse() vor der Umwandlung des byte-Arrays.