Marshal.AllocHGlobal द्वारा आवंटित स्मृति को शून्य कैसे करें?

Question

मैं Marshal.AllocHGlobal के माध्यम से अपने आवेदन में कुछ अप्रबंधित स्मृति आवंटित कर रहा हूं। मैं फिर Marshal.FreeHGlobal के माध्यम से स्मृति को मुक्त करने से पहले इस स्थान पर बाइट्स का एक सेट कॉपी कर रहा हूं और मेमोरी के परिणामी सेगमेंट को struct में परिवर्तित कर रहा हूं।

यहाँ विधि है:

public static T Deserialize<T>(byte[] messageBytes, int start, int length) 
    where T : struct 
{ 
    if (start + length > messageBytes.Length) 
     throw new ArgumentOutOfRangeException(); 

    int typeSize = Marshal.SizeOf(typeof(T)); 
    int bytesToCopy = Math.Min(typeSize, length); 

    IntPtr targetBytes = Marshal.AllocHGlobal(typeSize); 
    Marshal.Copy(messageBytes, start, targetBytes, bytesToCopy); 

    if (length < typeSize) 
    { 
     // Zero out additional bytes at the end of the struct 
    } 

    T item = (T)Marshal.PtrToStructure(targetBytes, typeof(T)); 
    Marshal.FreeHGlobal(targetBytes); 
    return item; 
} 

यह सबसे अधिक भाग के लिए काम करता है, फिर भी अगर मैं कम बाइट की तुलना में struct के आकार, आवश्यकता है तो 'यादृच्छिक' मान पिछले क्षेत्रों के लिए (मैं कर रहा हूँ आवंटित कर रहे हैं लक्ष्य संरचना पर LayoutKind.Sequential का उपयोग कर)। मैं इन लटकते क्षेत्रों को यथासंभव कुशलतापूर्वक शून्य करना चाहता हूं।

संदर्भ के लिए, यह कोड लिनक्स पर सी ++ से भेजे गए उच्च आवृत्ति मल्टीकास्ट संदेशों को deserializing है।

// Give only one byte, which is too few for the struct 
var s3 = MessageSerializer.Deserialize<S3>(new[] { (byte)0x21 }); 
Assert.AreEqual(0x21, s3.Byte); 
Assert.AreEqual(0x0000, s3.Int); // hanging field should be zero, but isn't 

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)] 
private struct S3 
{ 
    public byte Byte; 
    public int Int; 
} 

इस परीक्षण चल रहा है बार-बार एक अलग मूल्य के साथ हर बार विफल दूसरा ज़ोर का कारण बनता है:

यहाँ एक असफल परीक्षण का मामला है।

---

संपादित

अंत में, मैं unsafe जा रहा है और stackalloc का उपयोग करने का leppie's suggestion इस्तेमाल किया। इसने एक बाइट सरणी आवंटित की जिसे आवश्यकतानुसार शून्य किया गया था, और संदेश आकार के आधार पर 50% से 100% के बीच थ्रूपुट में सुधार हुआ (बड़े संदेशों में अधिक लाभ देखा गया)।

public static T Deserialize<T>(byte[] messageBytes, int startIndex, int length) 
    where T : struct 
{ 
    if (length <= 0) 
     throw new ArgumentOutOfRangeException("length", length, "Must be greater than zero."); 
    if (startIndex < 0) 
     throw new ArgumentOutOfRangeException("startIndex", startIndex, "Must be greater than or equal to zero."); 
    if (startIndex + length > messageBytes.Length) 
     throw new ArgumentOutOfRangeException("length", length, "startIndex + length must be <= messageBytes.Length"); 

    int typeSize = Marshal.SizeOf(typeof(T)); 
    unsafe 
    { 
     byte* basePtr = stackalloc byte[typeSize]; 
     byte* b = basePtr; 
     int end = startIndex + Math.Min(length, typeSize); 
     for (int srcPos = startIndex; srcPos < end; srcPos++) 
      *b++ = messageBytes[srcPos]; 
     return (T)Marshal.PtrToStructure(new IntPtr(basePtr), typeof(T)); 
    } 
} 

दुर्भाग्य से यह अभी भी Marshal.PtrToStructure के लिए एक कॉल की आवश्यकता है लक्ष्य प्रकार में बाइट्स कन्वर्ट करने के लिए:

अंतिम विधि जैसी समाप्त हो गया।

Answer 1

क्यों न केवल यह जांचें कि start + lengthtypesize के भीतर है या नहीं?

बीटीडब्लू: मैं बस unsafe पर जाऊंगा और अतिरिक्त मेमोरी को शून्य करने के लिए लूप के लिए उपयोग करता हूं।

वह आपको stackalloc का उपयोग करने का लाभ भी देगा जो AllocGlobal से अधिक सुरक्षित और तेज़ है।

Answer 2

मैंने कभी भी इस सामग्री को सी # में नहीं किया है, लेकिन मुझे एमएसडीएन में मार्शल। राइटबाइट (इंटप्रेट, इंट 32, बाइट) मिला। कोशिश करो।

Answer 3

हाँ के रूप में Jon Seigel ने कहा, आप इसे बाहर Marshal.WriteByte

का उपयोग कर निम्न उदाहरण में शून्य कर सकते हैं, मैं struct प्रतिलिपि करने से पहले बफर को शून्य।

if (start + length > messageBytes.Length) 
    throw new ArgumentOutOfRangeException(); 
int typeSize = Marshal.SizeOf(typeof(T));  
int bytesToCopy = Math.Min(typeSize, length); 
IntPtr targetBytes = Marshal.AllocHGlobal(typeSize); 
//zero out buffer 
for(int i=0; i < typeSize; i++) 
{ 
    Marshal.WriteByte(targetBytes, i, 0); 
} 
Marshal.Copy(messageBytes, start, targetBytes, bytesToCopy); 

Answer 4

[DllImport("kernel32.dll")] 
static extern void RtlZeroMemory(IntPtr dst, int length); 
... 
RtlZeroMemory(targetBytes, typeSize); 

Answer 5

यह विंडोज पर ठीक से काम करेगा:

namespace KernelPInvoke 
{ 
    /// <summary> 
    /// Implements some of the C functions declared in string.h 
    /// </summary> 
    public static class MemoryWrapper 
    { 
     [DllImport("kernel32.dll", EntryPoint = "CopyMemory", SetLastError = false)] 
     static extern void CopyMemory(IntPtr destination, IntPtr source, uint length); 

     [DllImport("kernel32.dll", EntryPoint = "MoveMemory", SetLastError = false)] 
     static extern void MoveMemory(IntPtr destination, IntPtr source, uint length); 

     [DllImport("kernel32.dll", EntryPoint = "RtlFillMemory", SetLastError = false)] 
     static extern void FillMemory(IntPtr destination, uint length, byte fill); 
    } 

    var ptr = Marshal.AllocHGlobal(size); 
    try 
    { 
     MemoryWrapper.FillMemory(ptr, size, 0); 
     // further work... 
    } 
    finally 
    { 
     Marshal.FreeHGlobal(ptr); 
    } 
} 

Answer 6

मुझे लगता है कि एक बफर को शून्य करने के लिए सबसे अच्छा तरीका यह है, अगर आप नहीं चाहते हैं, या नहीं जा सकते दूसरा रास्ता:

for(int i=0; i<buffSize; i++) 
{ 
    Marshal.WriteByte(buffer, i, 0x00); 
} 

Answer 7

for(int i=0; i < buffSize/8; i += 8) 
{ 
    Marshal.WriteInt64(buffer, i, 0x00); 
} 

for(int i= buffSize % 8 ; i < -1 ; i--) 
{ 
    Marshal.WriteByte (buffer, buffSize - i, 0x00); 
} 

मुझे लगता है कि आप इसे मिलेगा कई गुना तेजी से हमें होने के लिए 8 बिट wrights के बजाय 64 बिट wrights में प्रवेश (जो आपको अभी भी पिछले कुछ बाइट्स की आवश्यकता है)।