Piszę prototypowe połączenie TCP i mam problem z ujednoliceniem wysyłanych danych.

W tej chwili wysyłam tylko napisy, ale w przyszłości chcemy mieć możliwość wysyłania dowolnego obiektu.

Kod jest w tej chwili dość prosty, ponieważ myślałem, że wszystko można rzucić na tablicę bajtów:

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[]'.
  ...
}

Oczywiście można to łatwo rozwiązać za pomocą pliku

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

Problem polega na tym, że jeśli robię to w ten sposób, muszę sprawdzić KAŻDY typ obiektu, którego nie można rzutować na bajt [] w czasie wykonywania.

Ponieważ nie znam każdego obiektu, którego nie można wrzucić do bajtu [] w czasie wykonywania, tak naprawdę nie ma takiej opcji.

Jak przekonwertować dowolny obiekt na tablicę bajtów w C # .NET 4.0?

Użyj 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();
    }
}

Zauważ, że obji wszystkie właściwości / pola w obrębie obj(i tak dalej dla wszystkich ich właściwości / pól) będą musiały być oznaczone Serializableatrybutem, aby pomyślnie zserializować z tym.

sprawdź ten artykuł: http://www.morgantechspace.com/2013/08/convert-object-to-byte-array-and-vice.html

Użyj poniższego kodu

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

Tak jak inni powiedzieli wcześniej, możesz użyć serializacji binarnej, ale może ona wygenerować dodatkowe bajty lub zostać zdeserializowana do obiektów z nie dokładnie tymi samymi danymi. Z drugiej strony korzystanie z refleksji jest dość skomplikowane i bardzo powolne. Istnieje inne rozwiązanie, które może ściśle konwertować twoje obiekty na bajty i vice versa - 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);

I przekonwertować bajty na obiekt:

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

Jest to zauważalnie wolniejsze i częściowo niebezpieczne, aby używać tego podejścia do małych obiektów i struktur w porównaniu do własnej serializacji pole po polu (z powodu podwójnego kopiowania z / do niezarządzanej pamięci), ale jest to najłatwiejszy sposób na ścisłą konwersję obiektu na bajt [] bez implementowania serializacji i bez atrybutu [Serializable].

To, czego szukasz, to serializacja. Na platformie .Net dostępnych jest kilka form serializacji

• Serializacja binarna
• Serializacja XML: tworzy ciąg, który można łatwo przekształcić w plik byte[]
• ProtoBuffers

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

Możesz go użyć jak poniżej kodu.

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>();

Używanie Encoding.UTF8.GetBytesjest szybsze niż używanie MemoryStream. Tutaj używam NewtonsoftJson, aby przekonwertować obiekt wejściowy na ciąg JSON, a następnie pobrać bajty z ciągu JSON.

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

Benchmark dla wersji @Daniel DiPaolo z tą wersją

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 |

Połączone rozwiązania w klasie Extensions:

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

}

Można użyć wbudowanych narzędzi serializacji w ramach i serializować do MemoryStream . Może to być najprostsza opcja, ale może generować większy bajt [], niż może to być absolutnie konieczne w Twoim scenariuszu.

W takim przypadku można użyć odbicia do iteracji po polach i / lub właściwościach obiektu, który ma zostać serializowany, i ręcznie zapisać je w MemoryStream, wywołując cykliczne wywołanie serializacji w razie potrzeby w celu serializacji nietrywialnych typów. Ta metoda jest bardziej złożona i jej wdrożenie zajmie więcej czasu, ale umożliwia znacznie większą kontrolę nad serializowanym strumieniem.

A może coś tak prostego?

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

Wolę raczej użyć wyrażenia „serializacja” niż „rzutowanie na bajty”. Serializacja obiektu oznacza konwersję go na tablicę bajtów (lub XML lub coś innego), której można użyć na zdalnym urządzeniu do ponownego skonstruowania obiektu. W .NETSerializable atrybut oznacza typy, których obiekty mogą być serializowane.

Alternatywny sposób konwersji obiektu na tablicę bajtów:

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

Jedna dodatkowa implementacja, która korzysta z binarnego formatu JSON Newtonsoft.Json i nie wymaga oznaczania wszystkiego atrybutem [Serializable]. Jedyną wadą jest to, że obiekt musi być opakowany w anonimową klasę, więc tablica bajtów uzyskana za pomocą serializacji binarnej może się różnić od tej.

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

Używana jest klasa anonimowa, ponieważ BSON powinien zaczynać się od klasy lub tablicy. Nie próbowałem deserializować bajtu [] z powrotem do obiektu i nie jestem pewien, czy to działa, ale przetestowałem szybkość konwersji na bajt [] i całkowicie spełnia moje potrzeby.

A co z serializacją? spójrz tutaj .