Ich schreibe einen Prototyp einer TCP-Verbindung und habe Probleme beim Homogenisieren der zu sendenden Daten.

Im Moment sende ich nur Zeichenfolgen, aber in Zukunft möchten wir in der Lage sein, jedes Objekt zu senden.

Der Code ist im Moment recht einfach, da ich dachte, alles könnte in ein Byte-Array umgewandelt werden:

void SendData(object headerObject, object bodyObject)
{
  byte[] header = (byte[])headerObject;  //strings at runtime, 
  byte[] body = (byte[])bodyObject;      //invalid cast exception

  // Unable to cast object of type 'System.String' to type 'System.Byte[]'.
  ...
}

Dies ist natürlich leicht genug mit einem zu lösen

if( state.headerObject is System.String ){...}

Das Problem ist, wenn ich es so mache, muss ich nach JEDEM Objekttyp suchen, der zur Laufzeit nicht in ein Byte [] umgewandelt werden kann.

Da ich nicht jedes Objekt kenne, das zur Laufzeit nicht in ein Byte [] umgewandelt werden kann, ist dies wirklich keine Option.

Wie konvertiert man ein Objekt überhaupt in ein Byte-Array in C # .NET 4.0?

Verwenden Sie die BinaryFormatter:

byte[] ObjectToByteArray(object obj)
{
    if(obj == null)
        return null;
    BinaryFormatter bf = new BinaryFormatter();
    using (MemoryStream ms = new MemoryStream())
    {
        bf.Serialize(ms, obj);
        return ms.ToArray();
    }
}

Beachten Sie, dass objalle darin enthaltenen Eigenschaften / Felder obj(und so weiter für alle ihre Eigenschaften / Felder) mit dem SerializableAttribut versehen werden müssen, damit dies erfolgreich serialisiert werden kann.

Überprüfen Sie diesen Artikel: http://www.morgantechspace.com/2013/08/convert-object-to-byte-array-and-vice.html

Verwenden Sie den folgenden Code

// Convert an object to a byte array
private byte[] ObjectToByteArray(Object obj)
{
    if(obj == null)
        return null;

    BinaryFormatter bf = new BinaryFormatter();
    MemoryStream ms = new MemoryStream();
    bf.Serialize(ms, obj);

    return ms.ToArray();
}

// Convert a byte array to an Object
private Object ByteArrayToObject(byte[] arrBytes)
{
    MemoryStream memStream = new MemoryStream();
    BinaryFormatter binForm = new BinaryFormatter();
    memStream.Write(arrBytes, 0, arrBytes.Length);
    memStream.Seek(0, SeekOrigin.Begin);
    Object obj = (Object) binForm.Deserialize(memStream);

    return obj;
}

Wie andere bereits gesagt haben, können Sie die binäre Serialisierung verwenden, diese kann jedoch zusätzliche Bytes erzeugen oder in Objekte mit nicht genau denselben Daten deserialisiert werden. Die Verwendung von Reflexion ist dagegen ziemlich kompliziert und sehr langsam. Es gibt eine andere Lösung, mit der Sie Ihre Objekte strikt in Bytes konvertieren können und umgekehrt: Marshalling:

var size = Marshal.SizeOf(your_object);
// Both managed and unmanaged buffers required.
var bytes = new byte[size];
var ptr = Marshal.AllocHGlobal(size);
// Copy object byte-to-byte to unmanaged memory.
Marshal.StructureToPtr(your_object, ptr, false);
// Copy data from unmanaged memory to managed buffer.
Marshal.Copy(ptr, bytes, 0, size);
// Release unmanaged memory.
Marshal.FreeHGlobal(ptr);

Und um Bytes in Objekt umzuwandeln:

var bytes = new byte[size];
var ptr = Marshal.AllocHGlobal(size);
Marshal.Copy(bytes, 0, ptr, size);
var your_object = (YourType)Marshal.PtrToStructure(ptr, typeof(YourType));
Marshal.FreeHGlobal(ptr);

Es ist merklich langsamer und teilweise unsicher, diesen Ansatz für kleine Objekte und Strukturen zu verwenden, die Feld für Feld mit Ihrer eigenen Serialisierung verglichen werden (aufgrund des doppelten Kopierens von / in nicht verwalteten Speicher), aber es ist die einfachste Möglichkeit, Objekte strikt in Byte [] zu konvertieren, ohne die Serialisierung zu implementieren und ohne [Serializable] -Attribut.

Was Sie suchen, ist Serialisierung. Für die .Net-Plattform stehen verschiedene Formen der Serialisierung zur Verfügung

• Binäre Serialisierung
• XML-Serialisierung: Erzeugt eine Zeichenfolge, die leicht in eine konvertierbar ist byte[]
• ProtoBuffer

public static class SerializerDeserializerExtensions
{
    public static byte[] Serializer(this object _object)
    {   
        byte[] bytes;
        using (var _MemoryStream = new MemoryStream())
        {
            IFormatter _BinaryFormatter = new BinaryFormatter();
            _BinaryFormatter.Serialize(_MemoryStream, _object);
            bytes = _MemoryStream.ToArray();
        }
        return bytes;
    }

    public static T Deserializer<T>(this byte[] _byteArray)
    {   
        T ReturnValue;
        using (var _MemoryStream = new MemoryStream(_byteArray))
        {
            IFormatter _BinaryFormatter = new BinaryFormatter();
            ReturnValue = (T)_BinaryFormatter.Deserialize(_MemoryStream);    
        }
        return ReturnValue;
    }
}

Sie können es wie unten Code verwenden.

DataTable _DataTable = new DataTable();
_DataTable.Columns.Add(new DataColumn("Col1"));
_DataTable.Columns.Add(new DataColumn("Col2"));
_DataTable.Columns.Add(new DataColumn("Col3"));

for (int i = 0; i < 10; i++) {
    DataRow _DataRow = _DataTable.NewRow();
    _DataRow["Col1"] = (i + 1) + "Column 1";
    _DataRow["Col2"] = (i + 1) + "Column 2";
    _DataRow["Col3"] = (i + 1) + "Column 3";
    _DataTable.Rows.Add(_DataRow);
}

byte[] ByteArrayTest =  _DataTable.Serializer();
DataTable dt = ByteArrayTest.Deserializer<DataTable>();

Verwenden Encoding.UTF8.GetBytesist schneller als Verwenden MemoryStream. Hier verwende ich NewtonsoftJson , um das Eingabeobjekt in eine JSON-Zeichenfolge zu konvertieren und dann Bytes von der JSON-Zeichenfolge abzurufen .

byte[] SerializeObject(object value) =>Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(value));

Benchmark für die Version von @Daniel DiPaolo mit dieser Version

Method                    |     Mean |     Error |    StdDev |   Median |  Gen 0 | Allocated |
--------------------------|----------|-----------|-----------|----------|--------|-----------| 
ObjectToByteArray         | 4.983 us | 0.1183 us | 0.2622 us | 4.887 us | 0.9460 |    3.9 KB |
ObjectToByteArrayWithJson | 1.548 us | 0.0309 us | 0.0690 us | 1.528 us | 0.3090 |   1.27 KB |

Kombinierte Lösungen in der Erweiterungsklasse:

public static class Extensions {

    public static byte[] ToByteArray(this object obj) {
        var size = Marshal.SizeOf(data);
        var bytes = new byte[size];
        var ptr = Marshal.AllocHGlobal(size);
        Marshal.StructureToPtr(data, ptr, false);
        Marshal.Copy(ptr, bytes, 0, size);
        Marshal.FreeHGlobal(ptr);
        return bytes;
   }

    public static string Serialize(this object obj) {
        return JsonConvert.SerializeObject(obj);
   }

}

Sie könnten die Verwendung Einbau-Serialisierung - Tool im Rahmen und serialize zu einem Memorystream . Dies ist möglicherweise die einfachste Option, erzeugt jedoch möglicherweise ein größeres Byte [], als für Ihr Szenario unbedingt erforderlich ist.

In diesem Fall können Sie mithilfe der Reflexion die Felder und / oder Eigenschaften des zu serialisierenden Objekts durchlaufen und manuell in den MemoryStream schreiben. Bei Bedarf wird die Serialisierung rekursiv aufgerufen, um nicht triviale Typen zu serialisieren. Diese Methode ist komplexer und benötigt mehr Zeit für die Implementierung, ermöglicht Ihnen jedoch eine wesentlich bessere Kontrolle über den serialisierten Stream.

Wie wäre es mit so etwas Einfachem?

return ((object[])value).Cast<byte>().ToArray(); 

Ich würde lieber den Ausdruck "Serialisierung" als "Umwandlung in Bytes" verwenden. Das Serialisieren eines Objekts bedeutet, dass es in ein Byte-Array (oder XML oder etwas anderes) konvertiert wird, das auf der Remote-Box zum Rekonstruieren des Objekts verwendet werden kann. In .NET markiert das SerializableAttribut Typen, deren Objekte serialisiert werden können.

Alternative Möglichkeit, ein Objekt in ein Byte-Array zu konvertieren:

TypeConverter objConverter = TypeDescriptor.GetConverter(objMsg.GetType());
byte[] data = (byte[])objConverter.ConvertTo(objMsg, typeof(byte[]));

Eine zusätzliche Implementierung, die Newtonsoft.Json- Binär-JSON verwendet und nicht erfordert, dass alles mit dem Attribut [Serializable] markiert wird. Der einzige Nachteil besteht darin, dass ein Objekt in eine anonyme Klasse eingeschlossen werden muss, sodass sich das mit der binären Serialisierung erhaltene Byte-Array von diesem unterscheiden kann.

public static byte[] ConvertToBytes(object obj)
{
    using (var ms = new MemoryStream())
    {
        using (var writer = new BsonWriter(ms))
        {
            var serializer = new JsonSerializer();
            serializer.Serialize(writer, new { Value = obj });
            return ms.ToArray();
        }
    }
}

Anonyme Klasse wird verwendet, da BSON mit einer Klasse oder einem Array beginnen sollte. Ich habe nicht versucht, Byte [] zurück zum Objekt zu deserialisieren und bin mir nicht sicher, ob es funktioniert, habe aber die Konvertierungsgeschwindigkeit in Byte [] getestet und es erfüllt meine Anforderungen vollständig.

Wie wäre es mit Serialisierung? Schauen Sie hier .