Jak przekonwertować obiekt na tablicę bajtów w języku C #

Mam zbiór obiektów, które muszę zapisać w pliku binarnym.

Potrzebuję, aby bajty w pliku były kompaktowe, więc nie mogę ich użyć BinaryFormatter. BinaryFormatterzgłasza wszelkiego rodzaju informacje na potrzeby deserializacji.

Jeśli spróbuję

byte[] myBytes = (byte[]) myObject 

Otrzymuję wyjątek czasu wykonywania.

Potrzebuję tego, aby był szybki, więc wolałbym nie kopiować tablic bajtów. Chciałbym tylko, żeby obsada byte[] myBytes = (byte[]) myObjectdziałała!

OK, żeby było jasne, nie mogę mieć żadnych metadanych w pliku wyjściowym. Tylko bajty obiektu. Upakowany obiekt-obiekt. Na podstawie otrzymanych odpowiedzi wygląda na to, że będę pisać Buffer.BlockCopykod niskiego poziomu . Być może przy użyciu niebezpiecznego kodu.

Aby przekonwertować obiekt na tablicę bajtów:

// Convert an object to a byte array
public static byte[] ObjectToByteArray(Object obj)
{
    BinaryFormatter bf = new BinaryFormatter();
    using (var ms = new MemoryStream())
    {
        bf.Serialize(ms, obj);
        return ms.ToArray();
    }
}

Wystarczy skopiować tę funkcję do swojego kodu i wysłać do niego obiekt, który chcesz przekonwertować na tablicę bajtów. Jeśli potrzebujesz ponownie przekonwertować tablicę bajtów na obiekt, możesz użyć poniższej funkcji:

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

Możesz używać tych funkcji z niestandardowymi klasami. Wystarczy dodać [Serializable]atrybut w swojej klasie, aby włączyć serializację

Jeśli chcesz, aby serializowane dane były naprawdę kompaktowe, możesz samodzielnie napisać metody serializacji. W ten sposób będziesz mieć minimum kosztów ogólnych.

Przykład:

public class MyClass {

   public int Id { get; set; }
   public string Name { get; set; }

   public byte[] Serialize() {
      using (MemoryStream m = new MemoryStream()) {
         using (BinaryWriter writer = new BinaryWriter(m)) {
            writer.Write(Id);
            writer.Write(Name);
         }
         return m.ToArray();
      }
   }

   public static MyClass Desserialize(byte[] data) {
      MyClass result = new MyClass();
      using (MemoryStream m = new MemoryStream(data)) {
         using (BinaryReader reader = new BinaryReader(m)) {
            result.Id = reader.ReadInt32();
            result.Name = reader.ReadString();
         }
      }
      return result;
   }

}

Dobrze odlew z myObjectaby byte[]nigdy nie będzie działać, chyba że masz wyraźne konwersję lub jeśli myObject jestbyte[] . Musisz ram serializacji jakiegoś rodzaju. Jest ich wiele, w tym bufory protokołów, które są mi bliskie i drogie. Jest dość „chudy i wredny” zarówno pod względem przestrzeni, jak i czasu.

Przekonasz się, że prawie wszystkie struktury serializacji mają znaczące ograniczenia dotyczące tego, co można serializować - więcej niż niektóre bufory protokołów, ponieważ są wieloplatformowe.

Jeśli możesz podać więcej wymagań, możemy Ci pomóc - ale nigdy nie będzie to tak proste, jak rzucanie ...

EDYCJA: Wystarczy odpowiedzieć na to:

Potrzebuję, aby mój plik binarny zawierał bajty obiektu. Tylko bajty, żadnych metadanych. Upakowany obiekt-obiekt. Więc zaimplementuję niestandardową serializację.

Pamiętaj, że bajty w twoich obiektach są dość często odwołaniami ... więc musisz dowiedzieć się, co z nimi zrobić.

Podejrzewam, że projektowanie i wdrażanie własnej niestandardowej platformy serializacji jest trudniejsze niż sobie wyobrażasz.

Osobiście poleciłbym, jeśli potrzebujesz to zrobić tylko dla kilku określonych typów, nie zawracaj sobie głowy próbą wymyślenia ogólnej struktury serializacji. Po prostu zaimplementuj metodę instancji i metodę statyczną we wszystkich potrzebnych typach:

public void WriteTo(Stream stream)
public static WhateverType ReadFrom(Stream stream)

Należy pamiętać o jednej rzeczy: wszystko staje się trudniejsze, jeśli w grę wchodzi dziedziczenie. Bez dziedziczenia, jeśli wiesz, od jakiego typu zaczynasz, nie musisz uwzględniać żadnych informacji o typie. Oczywiście jest też kwestia wersjonowania - czy musisz się martwić o wsteczną i przyszłą kompatybilność z różnymi wersjami twoich typów?

Wziąłem odpowiedź Crystalonics i przekształciłem je w metody rozszerzające. Mam nadzieję, że ktoś inny uzna je za przydatne:

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

public static T Deserialize<T>(this byte[] byteArray) where T : class
{
    if (byteArray == null)
    {
        return null;
    }
    using (var memStream = new MemoryStream())
    {
        var binForm = new BinaryFormatter();
        memStream.Write(byteArray, 0, byteArray.Length);
        memStream.Seek(0, SeekOrigin.Begin);
        var obj = (T)binForm.Deserialize(memStream);
        return obj;
    }
}

Naprawdę mówisz o serializacji, która może przybierać różne formy. Ponieważ chcesz małych i binarnych, bufory protokołów mogą być realną opcją - zapewniającą również tolerancję wersji i przenośność. W przeciwieństwie do tego BinaryFormatter, format łącznika buforów protokołów nie obejmuje wszystkich metadanych typu; po prostu bardzo zwięzłe znaczniki do identyfikacji danych.

W .NET istnieje kilka implementacji; w szczególności

• protobuf-net
• dotnet-protobufs

Pokornie twierdzę, że protobuf-net (który napisałem) pozwala na większe użycie idiomatycznego .NET z typowymi klasami C # („zwykłe” bufory protokołów zwykle wymagają generowania kodu); na przykład:

[ProtoContract]
public class Person {
   [ProtoMember(1)]
   public int Id {get;set;}
   [ProtoMember(2)]
   public string Name {get;set;}
}
....
Person person = new Person { Id = 123, Name = "abc" };
Serializer.Serialize(destStream, person);
...
Person anotherPerson = Serializer.Deserialize<Person>(sourceStream);

To zadziałało dla mnie:

byte[] bfoo = (byte[])foo;

foo jest obiektem, co do którego mam 100% pewności, że jest tablicą bajtów.

Przyjrzyj się serializacji , technice „konwertowania” całego obiektu na strumień bajtów. Możesz wysłać go do sieci lub zapisać do pliku, a następnie przywrócić później do obiektu.

Znalazłem inny sposób konwersji obiektu na bajt [], oto moje rozwiązanie:

IEnumerable en = (IEnumerable) myObject;
byte[] myBytes = en.OfType<byte>().ToArray();

pozdrowienia

Aby uzyskać bezpośredni dostęp do pamięci obiektu (aby wykonać „zrzut pamięci”), musisz przejść do niebezpiecznego kodu.

Jeśli chcesz czegoś bardziej kompaktowego niż BinaryWriter lub surowy zrzut pamięci, musisz napisać niestandardowy kod serializacji, który wyodrębnia krytyczne informacje z obiektu i pakuje je w optymalny sposób.

edit PS Bardzo łatwo jest zawinąć podejście BinaryWriter do DeflateStream w celu skompresowania danych, co zwykle zmniejsza rozmiar danych o około połowę.

Wierzę, że to, co próbujesz zrobić, jest niemożliwe.

Tworzone śmieci BinaryFormattersą niezbędne do odzyskania obiektu z pliku po zatrzymaniu programu.
Jednak możliwe jest uzyskanie danych obiektu, wystarczy znać dokładny ich rozmiar (trudniejszy niż się wydaje):

public static unsafe byte[] Binarize(object obj, int size)
{
    var r = new byte[size];
    var rf = __makeref(obj);
    var a = **(IntPtr**)(&rf);
    Marshal.Copy(a, r, 0, size);
    return res;
}

można to odzyskać poprzez:

public unsafe static dynamic ToObject(byte[] bytes)
{
    var rf = __makeref(bytes);
    **(int**)(&rf) += 8;
    return GCHandle.Alloc(bytes).Target;
}

Powodem, dla którego powyższe metody nie działają w przypadku serializacji, jest to, że pierwsze cztery bajty w zwróconych danych odpowiadają rozszerzeniu RuntimeTypeHandle. RuntimeTypeHandleOpisuje Układ / typ obiektu, ale jego wartość zmienia się za każdym razem, gdy program jest prowadzony.

EDYCJA: to jest głupie, nie rób tego -> Jeśli znasz już typ obiektu do deserializacji na pewno, możesz zamienić te bajty BitConvertes.GetBytes((int)typeof(yourtype).TypeHandle.Value)w momencie deserializacji.