सी # कचरा बनाने के बिना बफर में वैरिएबल कॉपी करें?

Question

क्या प्रक्रिया में कोई कचरा तैयार किए बिना एक चर [] बफर में एक चर की प्रतिलिपि बनाने के लिए सी # .Net (3.5 और ऊपर) में यह संभव है?

उदाहरण के लिए:

int variableToCopy = 9861; 

byte[] buffer = new byte[1024]; 
byte[] bytes = BitConverter.GetBytes(variableToCopy); 
Buffer.BlockCopy(bytes, 0, buffer, 0, 4); 

float anotherVariableToCopy = 6743897.6377f; 
bytes = BitConverter.GetBytes(anotherVariableToCopy); 
Buffer.BlockCopy(bytes, 0, buffer, 4, sizeof(float)); 

... 

बाइट [] बाइट्स मध्यस्थ वस्तु जो कचरा (एक रेफरी मानते हुए नहीं रह गया है इसे करने के लिए आयोजित किया जाता है) हो जाता है बनाता है ...

मुझे आश्चर्य है अगर बिटवाइज़ ऑपरेटर्स का उपयोग कर इंटरमीडिएरी बाइट [] बनाने के बिना चर को सीधे बफर में कॉपी किया जा सकता है?

Answer 1

उपयोग संकेत सबसे अच्छा और सबसे तेज़ तरीका है: आप कर सकते हैं किसी भी प्रकार की चर के साथ ऐसा करें, कोई बर्बाद स्मृति नहीं है, निश्चित कथन में थोड़ा ओवरहेड है लेकिन यह बहुत छोटा है

 int v1 = 123; 
     float v2 = 253F; 
     byte[] buffer = new byte[1024]; 
     fixed (byte* pbuffer = buffer) 
     { 
      //v1 is stored on the first 4 bytes of the buffer: 
      byte* scan = pbuffer; 
      *(int*)(scan) = v1; 
      scan += 4; //4 bytes per int 

      //v2 is stored on the second 4 bytes of the buffer: 
      *(float*)(scan) = v2; 
      scan += 4; //4 bytes per float 
     } 

Answer 2

तुम सिर्फ क्यों नहीं कर सकते हैं:

byte[] buffer = BitConverter.GetBytes(variableToCopy); 

ध्यान दें कि सरणी यहाँ मूल Int32 के लिए भंडारण में एक अविवेक नहीं है, यह बहुत ज्यादा एक प्रति है।

आप शायद चिंता है कि आपके उदाहरण में bytes के बराबर है कर रहे हैं:

unsafe 
{ 
    byte* bytes = (byte*) &variableToCopy; 
} 

.. लेकिन मैं आपको विश्वास दिलाता है कि यह नहीं है, यह स्रोत Int32 में बाइट्स की बाइट कॉपी द्वारा बाइट है।

संपादित:

आपके संपादन के आधार, मुझे लगता है कि आप कुछ इस तरह चाहते हैं (असुरक्षित संदर्भ की आवश्यकता है):

public unsafe static void CopyBytes(int value, byte[] destination, int offset) 
{ 
    if (destination == null) 
     throw new ArgumentNullException("destination"); 

    if (offset < 0 || (offset + sizeof(int) > destination.Length)) 
     throw new ArgumentOutOfRangeException("offset"); 

    fixed (byte* ptrToStart = destination) 
    { 
     *(int*)(ptrToStart + offset) = value; 
    } 
}