<?xml version="1.0"?>
<clause number="25.8" title="Dynamic memory allocation">
  <paragraph>Except for the stackalloc operator, C# provides no predefined constructs for managing non-garbage collected memory. Such services are typically provided by supporting class libraries or imported directly from the underlying operating system. <example>[Example: For example, the Memory class below illustrates how the heap functions of an underlying operating system might be accessed from C#: <code_example><![CDATA[
using System;  
using System.Runtime.InteropServices;  
public unsafe class Memory  
{  
   // Handle for the process heap. This handle is used in all calls to  
   the  
   // HeapXXX APIs in the methods below.  
   static int ph = GetProcessHeap();  
   // Private instance constructor to prevent instantiation.  
   private Memory() {}  
   // Allocates a memory block of the given size. The allocated memory is  
   // automatically initialized to zero.  
   public static void* Alloc(int size) {  
      void* result = HeapAlloc(ph, HEAP_ZERO_MEMORY, size);  
      if (result == null) throw new OutOfMemoryException();  
      return result;  
   }  
   // Copies count bytes from src to dst. The source and destination  
   // blocks are permitted to overlap.  
   public static void Copy(void* src, void* dst, int count) {  
      byte* ps = (byte*)src;  
      byte* pd = (byte*)dst;  
      if (ps > pd) {  
         for (; count != 0; count--) *pd++ = *ps++;  
      }  
      else if (ps < pd) {  
         for (ps += count, pd += count; count != 0; count--) *--pd = *--  
         ps;  
      }  
   }  
   // Frees a memory block.  
   public static void Free(void* block) {  
      if (!HeapFree(ph, 0, block)) throw new InvalidOperationException();  
   }  
   // Re-allocates a memory block. If the reallocation request is for a  
   // larger size, the additional region of memory is automatically  
   // initialized to zero.  
   public static void* ReAlloc(void* block, int size) {  
      void* result = HeapReAlloc(ph, HEAP_ZERO_MEMORY, block, size);  
      if (result == null) throw new OutOfMemoryException();  
      return result;  
   }  
   // Returns the size of a memory block.  
   public static int SizeOf(void* block) {  
      int result = HeapSize(ph, 0, block);  
      if (result == -1) throw new InvalidOperationException();  
      return result;  
   }  
   // Heap API flags  
   const int HEAP_ZERO_MEMORY = 0x00000008;  
   // Heap API functions  
   [DllImport("kernel32")]  
   static extern int GetProcessHeap();  
   [DllImport("kernel32")]  
   static extern void* HeapAlloc(int hHeap, int flags, int size);  
   [DllImport("kernel32")]  
   static extern bool HeapFree(int hHeap, int flags, void* block);  
   [DllImport("kernel32")]  
   static extern void* HeapReAlloc(int hHeap, int flags,  
   void* block, int size);  
   [DllImport("kernel32")]  
   static extern int HeapSize(int hHeap, int flags, void* block);  
}  
]]></code_example></example></paragraph>
  <paragraph>
    <example>An example that uses the Memory class is given below: <code_example><![CDATA[
class Test  
{  
   static void Main() {  
      unsafe {  
         byte* buffer = (byte*)Memory.Alloc(256);  
         for (int i = 0; i < 256; i++) buffer[i] = (byte)i;  
         byte[] array = new byte[256];  
         fixed (byte* p = array) Memory.Copy(buffer, p, 256);   
         Memory.Free(buffer);  
         for (int i = 0; i < 256; i++) Console.WriteLine(array[i]);  
      }  
   }  
}  
]]></code_example></example>
  </paragraph>
  <paragraph>
    <example>The example allocates 256 bytes of memory through Memory.Alloc and initializes the memory block with values increasing from 0 to 255. It then allocates a 256-element <keyword>byte</keyword> array and uses Memory.Copy to copy the contents of the memory block into the <keyword>byte</keyword> array. Finally, the memory block is freed using Memory.Free and the contents of the <keyword>byte</keyword> array are output on the console. end example]</example>
  </paragraph>
  <paragraph>End of conditionally normative text. </paragraph>
</clause>
