C # में किसी ऑब्जेक्ट को बाइट सरणी में कैसे बदलें

Question 1

मेरे पास वस्तुओं का एक संग्रह है जो मुझे एक बाइनरी फ़ाइल में लिखने की आवश्यकता है।

मुझे कॉम्पैक्ट होने के लिए फ़ाइल में बाइट्स की आवश्यकता है, इसलिए मैं उपयोग नहीं कर सकता BinaryFormatter। BinaryFormatterdeserialization की जरूरत के लिए जानकारी के सभी प्रकार में फेंकता है।

अगर मैं कोशिश करूँ

byte[] myBytes = (byte[]) myObject

मुझे एक रनटाइम अपवाद मिलता है।

मुझे इसकी आवश्यकता है कि मैं तेज़ हो जाऊं, इसलिए मैं बाइट्स के चारों ओर सरणियों की नकल नहीं करूंगा। मैं सिर्फ कलाकारों byte[] myBytes = (byte[]) myObjectको काम करना चाहूंगा !

ठीक है, स्पष्ट होने के लिए, मैं आउटपुट फ़ाइल में कोई मेटाडेटा नहीं रख सकता । बस वस्तु बाइट करती है। पैक वस्तु-वस्तु। प्राप्त उत्तरों के आधार पर, ऐसा लगता है कि मैं निम्न-स्तरीय Buffer.BlockCopyकोड लिखूंगा। शायद असुरक्षित कोड का उपयोग करना।

Question 2

ऑब्जेक्ट को बाइट सरणी में बदलने के लिए:

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

आपको बस इस फ़ंक्शन को अपने कोड में कॉपी करना होगा और इसे उस ऑब्जेक्ट पर भेजना होगा जिसे आपको बाइट सरणी में बदलने की आवश्यकता है। यदि आपको बाइट सरणी को किसी ऑब्जेक्ट में बदलने की आवश्यकता है तो आप नीचे दिए गए फ़ंक्शन का उपयोग कर सकते हैं:

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

आप इन कार्यों का उपयोग कस्टम कक्षाओं के साथ कर सकते हैं। [Serializable]सीरियलाइज़ेशन को सक्षम करने के लिए आपको अपनी कक्षा में विशेषता जोड़ने की आवश्यकता है

Question 3

यदि आप चाहते हैं कि क्रमबद्ध डेटा वास्तव में कॉम्पैक्ट हो, तो आप क्रमांकन विधियों को स्वयं लिख सकते हैं। इस तरह से आपके पास कम से कम ओवरहेड होगा।

उदाहरण:

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

}

Question 4

खैर से एक डाली myObjectको byte[]कभी नहीं काम करने के लिए जा जब तक आप एक स्पष्ट रूपांतरण या अगर मिल गया है है myObject है एक byte[]। आपको किसी प्रकार की क्रमबद्धता की आवश्यकता है । वहाँ बहुत सारे हैं, जिसमें प्रोटोकॉल बफ़र्स भी शामिल हैं जो मेरे निकट है और मुझे प्रिय है। यह अंतरिक्ष और समय दोनों के मामले में बहुत "दुबला और मतलबी" है।

आप पाएंगे कि लगभग सभी सीरियलाइज़ेशन फ्रेमवर्क में महत्वपूर्ण प्रतिबंध हैं कि आप क्या-क्या सीरीज़ कर सकते हैं, हालांकि - क्रॉस-प्लेटफॉर्म होने के कारण प्रोटोकॉल बफ़र्स कुछ से अधिक हैं।

यदि आप अधिक आवश्यकताएं दे सकते हैं, तो हम आपकी अधिक सहायता कर सकते हैं - लेकिन यह कास्टिंग के रूप में सरल नहीं है ...

संपादित करें: बस इस पर प्रतिक्रिया करने के लिए:

ऑब्जेक्ट की बाइट्स को सम्‍मिलित करने के लिए मुझे अपनी बाइनरी फ़ाइल की आवश्‍यकता है। केवल बाइट्स, कोई मेटाडेटा जो भी हो। पैक वस्तु-वस्तु। तो मैं कस्टम क्रमांकन लागू करूंगा।

कृपया ध्यान रखें कि आपकी वस्तुओं में बाइट्स अक्सर संदर्भ होते हैं ... इसलिए आपको उनके साथ क्या करना है, यह जानने की आवश्यकता होगी।

मुझे लगता है कि आपको लगता है कि डिजाइन और अपने खुद के कस्टम क्रमांकन ढांचे को लागू करना आपके द्वारा कल्पना की तुलना में कठिन है।

मैं व्यक्तिगत रूप से सिफारिश करूंगा कि यदि आपको केवल कुछ विशिष्ट प्रकारों के लिए ऐसा करने की आवश्यकता है, तो आप सामान्य क्रमबद्ध रूपरेखा के साथ आने की कोशिश नहीं करते। बस एक इंस्टेंस मेथड और सभी प्रकार के स्टैटिक मेथड को लागू करें जिनकी आपको आवश्यकता है:

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

एक बात ध्यान में रखें: यदि आपको विरासत में मिला है तो सब कुछ अधिक मुश्किल हो जाता है। विरासत के बिना, यदि आप जानते हैं कि आप किस प्रकार से शुरू कर रहे हैं, तो आपको किसी भी प्रकार की जानकारी शामिल करने की आवश्यकता नहीं है। बेशक, वहाँ भी संस्करण की बात है - क्या आप अपने प्रकार के विभिन्न संस्करणों के साथ पिछड़े और आगे संगतता के बारे में चिंता करने की ज़रूरत है?

Question 5

मैंने क्रिस्टलनिक्स का जवाब लिया और उन्हें विस्तार विधियों में बदल दिया। मुझे आशा है कि कोई और उन्हें उपयोगी पाएगा:

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

Question 6

आप वास्तव में क्रमांकन के बारे में बात कर रहे हैं, जो कई रूप ले सकता है। चूंकि आप छोटे और द्विआधारी चाहते हैं, इसलिए प्रोटोकॉल बफ़र एक व्यवहार्य विकल्प हो सकता है - साथ ही संस्करण सहिष्णुता और पोर्टेबिलिटी भी दे सकता है। इसके विपरीत BinaryFormatter, प्रोटोकॉल बफ़र्स वायर प्रारूप में सभी प्रकार के मेटाडेटा शामिल नहीं हैं; डेटा की पहचान करने के लिए सिर्फ बहुत ही मार्मिक मार्कर।

.NET में कुछ कार्यान्वयन हैं; विशेष रूप से

मैं विनम्रतापूर्वक तर्क देता हूं कि प्रोटोबुफ़-नेट (जो मैंने लिखा था) ठेठ सी # कक्षाओं के साथ अधिक .NET-मुहावरेदार उपयोग की अनुमति देता है ("नियमित" प्रोटोकॉल-बफ़र्स कोड-पीढ़ी की मांग करता है ); उदाहरण के लिए:

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

Question 7

यह मेरे लिए काम किया:

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

foo एक वस्तु है कि मैं 100% निश्चित हूँ कि एक बाइट सरणी है।

Question 8

Serialization पर एक नज़र डालें , एक संपूर्ण वस्तु को एक बाइट स्ट्रीम में "कन्वर्ट" करने की तकनीक। आप इसे नेटवर्क पर भेज सकते हैं या इसे एक फ़ाइल में लिख सकते हैं और फिर बाद में किसी ऑब्जेक्ट पर वापस रख सकते हैं।

Question 9

मुझे एक वस्तु को बाइट में बदलने का एक और तरीका मिला [], यहाँ मेरा समाधान है:

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

सादर

Question 10

किसी ऑब्जेक्ट की मेमोरी को सीधे एक्सेस करने के लिए ("कोर डंप" करने के लिए) आपको असुरक्षित कोड में प्रवेश करना होगा।

यदि आप बाइनरीविटर की तुलना में कुछ अधिक कॉम्पैक्ट चाहते हैं या एक कच्चा मेमोरी डंप आपको देगा, तो आपको कुछ कस्टम क्रमांकन कोड लिखना होगा जो ऑब्जेक्ट से महत्वपूर्ण जानकारी को निकालता है और इसे एक इष्टतम तरीके से पैक करता है।

PS संपादित करें डेटा को संपीड़ित करने के लिए एक DeflateStream में BinaryWriter दृष्टिकोण को लपेटना बहुत आसान है, जो आमतौर पर डेटा के आकार को लगभग आधा कर देता है।

Question 11

मेरा मानना है कि आप जो करना चाह रहे हैं वह असंभव है। आपके प्रोग्राम को बंद करने के बाद फ़ाइल से ऑब्जेक्ट को पुनर्प्राप्त करने के लिए आवश्यक

रद्दी BinaryFormatterआवश्यक है।
हालांकि, वस्तु डेटा प्राप्त करना संभव है, आपको बस इसके सटीक आकार को जानने की जरूरत है (इससे अधिक कठिन लगता है):

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

इसके माध्यम से पुनर्प्राप्त किया जा सकता है:

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

कारण यह है कि उपरोक्त तरीके क्रमबद्धता के लिए काम नहीं करते हैं क्योंकि लौटे डेटा में पहले चार बाइट्स ए RuntimeTypeHandle। RuntimeTypeHandleवस्तु के लेआउट / प्रकार का वर्णन करता लेकिन इसके बारे में मूल्य हर बार कार्यक्रम में भाग गया है बदल जाता है।

संपादित करें: यह बेवकूफ है कि ऐसा मत करो -> यदि आप पहले से ही वस्तु के प्रकार को जानते हैं तो निश्चित होने के लिए आप BitConvertes.GetBytes((int)typeof(yourtype).TypeHandle.Value)deserialization के समय उन बाइट्स को स्विच कर सकते हैं ।