Cách chuyển đổi một đối tượng thành một mảng byte trong C #

Tôi có một bộ sưu tập các đối tượng mà tôi cần ghi vào tệp nhị phân.

Tôi cần các byte trong tệp nhỏ gọn, vì vậy tôi không thể sử dụng BinaryFormatter. BinaryFormattercung cấp tất cả các loại thông tin cho nhu cầu giải trí.

Nếu tôi cố gắng

byte[] myBytes = (byte[]) myObject 

Tôi nhận được một ngoại lệ thời gian chạy.

Tôi cần điều này nhanh chóng vì vậy tôi không muốn sao chép các mảng byte xung quanh. Tôi chỉ muốn dàn diễn viên byte[] myBytes = (byte[]) myObjectlàm việc!

OK, nói rõ là tôi không thể có bất kỳ siêu dữ liệu nào trong tệp đầu ra. Chỉ các byte đối tượng. Đối tượng-đối tượng được đóng gói. Dựa trên câu trả lời nhận được, có vẻ như tôi sẽ viết Buffer.BlockCopymã cấp thấp . Có lẽ đang sử dụng mã không an toàn.

Để chuyển đổi một đối tượng thành một mảng byte:

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

Bạn chỉ cần sao chép hàm này vào mã của mình và gửi cho nó đối tượng mà bạn cần chuyển đổi thành một mảng byte. Nếu bạn cần chuyển đổi lại mảng byte thành một đối tượng, bạn có thể sử dụng hàm bên dưới:

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

Bạn có thể sử dụng các hàm này với các lớp tùy chỉnh. Bạn chỉ cần thêm [Serializable]thuộc tính trong lớp của mình để kích hoạt tuần tự hóa

Nếu bạn muốn dữ liệu được tuần tự hóa thực sự nhỏ gọn, bạn có thể tự viết các phương pháp tuần tự hóa. Bằng cách đó, bạn sẽ có chi phí tối thiểu.

Thí dụ:

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

}

Vâng, một dàn diễn viên từ myObjectđến byte[]sẽ không bao giờ hoạt động trừ khi bạn có một chuyển đổi rõ ràng hoặc nếu myObject là một byte[]. Bạn cần một số loại khung tuần tự hóa . Có rất nhiều thứ ở đó, bao gồm cả Bộ đệm giao thức ở gần và thân thiết với tôi. Nó khá "gọn gàng và có ý nghĩa" cả về không gian và thời gian.

Tuy nhiên, bạn sẽ thấy rằng hầu hết tất cả các khuôn khổ tuần tự hóa đều có những hạn chế đáng kể về những gì bạn có thể tuần tự hóa - Bộ đệm giao thức nhiều hơn một số, do là nền tảng chéo.

Nếu bạn có thể đưa ra nhiều yêu cầu hơn, chúng tôi có thể giúp bạn nhiều hơn - nhưng sẽ không bao giờ đơn giản như đúc ...

CHỈNH SỬA: Chỉ để trả lời điều này:

Tôi cần tệp nhị phân của mình để chứa các byte của đối tượng. Chỉ các byte, không có siêu dữ liệu nào. Đối tượng-đối tượng được đóng gói. Vì vậy, tôi sẽ thực hiện tuần tự hóa tùy chỉnh.

Xin lưu ý rằng các byte trong các đối tượng của bạn thường là các tham chiếu ... vì vậy bạn sẽ cần phải tìm ra những gì cần làm với chúng.

Tôi nghi ngờ rằng bạn sẽ thấy rằng việc thiết kế và triển khai khuôn khổ tuần tự hóa tùy chỉnh của riêng bạn khó hơn bạn tưởng tượng.

Cá nhân tôi khuyên rằng nếu bạn chỉ cần làm điều này cho một số loại cụ thể, bạn không cần cố gắng tìm ra một khuôn khổ tuần tự hóa chung. Chỉ cần triển khai một phương thức phiên bản và một phương thức tĩnh trong tất cả các kiểu bạn cần:

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

Một điều cần lưu ý: mọi thứ trở nên phức tạp hơn nếu bạn có liên quan đến tài sản thừa kế. Không cần kế thừa, nếu bạn biết loại bạn đang bắt đầu, bạn không cần bao gồm bất kỳ thông tin loại nào. Tất nhiên, cũng có vấn đề về lập phiên bản - bạn có cần lo lắng về khả năng tương thích ngược và chuyển tiếp với các phiên bản khác nhau của loại của bạn không?

Tôi lấy câu trả lời của Crystalonics và biến chúng thành các phương pháp mở rộng. Tôi hy vọng ai đó sẽ thấy chúng hữu ích:

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

Bạn đang thực sự nói về tuần tự hóa, có thể có nhiều hình thức. Vì bạn muốn nhỏ và nhị phân, bộ đệm giao thức có thể là một lựa chọn khả thi - cung cấp khả năng chịu đựng và tính di động của phiên bản. Không giống như BinaryFormatter, định dạng dây của bộ đệm giao thức không bao gồm tất cả các loại siêu dữ liệu; chỉ là những điểm đánh dấu rất ngắn gọn để xác định dữ liệu.

Trong .NET có một số triển khai; đặc biệt

• protobuf-net
• dotnet-protobufs

Tôi khiêm tốn tranh luận rằng protobuf-net (mà tôi đã viết) cho phép sử dụng nhiều .NET-idiomatic hơn với các lớp C # điển hình (bộ đệm giao thức "thông thường" có xu hướng yêu cầu tạo mã); ví dụ:

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

Điều này đã làm việc cho tôi:

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

foo là một Đối tượng mà tôi chắc chắn 100% rằng đó là một mảng byte.

Hãy xem Serialization , một kỹ thuật để "chuyển đổi" toàn bộ một đối tượng thành một luồng byte. Bạn có thể gửi nó vào mạng hoặc ghi nó vào một tệp và sau đó khôi phục nó trở lại một đối tượng sau đó.

Tôi đã tìm thấy một cách khác để chuyển đổi một đối tượng thành byte [], đây là giải pháp của tôi:

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

Trân trọng

Để truy cập trực tiếp vào bộ nhớ của một đối tượng (để thực hiện "kết xuất lõi"), bạn sẽ cần phải truy cập vào mã không an toàn.

Nếu bạn muốn thứ gì đó nhỏ gọn hơn BinaryWriter hoặc một kết xuất bộ nhớ thô sẽ cung cấp cho bạn, thì bạn cần viết một số mã tuần tự hóa tùy chỉnh trích xuất thông tin quan trọng từ đối tượng và đóng gói nó theo cách tối ưu.

chỉnh sửa PS Rất dễ dàng bọc cách tiếp cận BinaryWriter thành một DeflateStream để nén dữ liệu, thường sẽ giảm khoảng một nửa kích thước của dữ liệu.

Tôi tin rằng những gì bạn đang cố gắng làm là không thể.

Phần rác BinaryFormattertạo ra là cần thiết để khôi phục đối tượng từ tệp sau khi chương trình của bạn dừng.
Tuy nhiên, có thể lấy dữ liệu đối tượng, bạn chỉ cần biết kích thước chính xác của nó (khó hơn là nó nghe):

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

điều này có thể được phục hồi thông qua:

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

Lý do tại sao các phương thức trên không hoạt động cho tuần tự hóa là bốn byte đầu tiên trong dữ liệu trả về tương ứng với a RuntimeTypeHandle. Mô RuntimeTypeHandletả bố cục / kiểu của đối tượng nhưng giá trị của nó thay đổi mỗi khi chương trình được chạy.

CHỈNH SỬA: điều đó thật ngu ngốc, đừng làm vậy -> Nếu bạn đã biết loại đối tượng cần giải không khí nhất định, bạn có thể chuyển các byte đó BitConvertes.GetBytes((int)typeof(yourtype).TypeHandle.Value)tại thời điểm giải không khí hóa.