docs/ecma334/8.4.xml

   1 <?xml version="1.0"?>
   2 <clause number="8.4" title="Automatic memory management" informative="true">
   3   <paragraph>Manual memory management requires developers to manage the allocation and de-allocation of blocks of memory. Manual memory management can be both time-consuming and difficult. In C#, automatic memory management is provided so that developers are freed from this burdensome task. In the vast majority of cases, automatic memory management increases code quality and enhances developer productivity without negatively impacting either expressiveness or performance. </paragraph>
   4   <paragraph>The example <code_example><![CDATA[
   5 using System;
   6 public class Stack
   7 {
   8    private Node first = null;
   9    public bool Empty {
  10       get {
  11          return (first == null);
  12       }
  13    }
  14    public object Pop() {
  15       if (first == null)
  16       throw new Exception("Can't Pop from an empty Stack.");
  17       else {
  18          object temp = first.Value;
  19          first = first.Next;
  20          return temp;
  21       }
  22    }
  23    public void Push(object o) {
  24       first = new Node(o, first);
  25    }
  26    class Node
  27    {
  28       public Node Next;
  29       public object Value;
  30       public Node(object value): this(value, null) {}
  31       public Node(object value, Node next) {
  32          Next = next;
  33          Value = value;
  34       }
  35    }
  36 }
  37 ]]></code_example>shows a Stack class implemented as a linked list of Node instances. Node instances are created in the Push method and are garbage collected when no longer needed. A Node instance becomes eligible for garbage collection when it is no longer possible for any code to access it. For instance, when an item is removed from the Stack, the associated Node instance becomes eligible for garbage collection. </paragraph>
  38   <paragraph>The example <code_example><![CDATA[
  39 class Test
  40 {
  41    static void Main() {
  42       Stack s = new Stack();
  43       for (int i = 0; i < 10; i++)
  44       s.Push(i);
  45       s = null;
  46    }
  47 }
  48 ]]></code_example>shows code that uses the Stack class. A Stack is created and initialized with 10 elements, and then assigned the value null. Once the variable s is assigned null, the Stack and the associated 10 Node instances become eligible for garbage collection. The garbage collector is permitted to clean up immediately, but is not required to do so. </paragraph>
  49   <paragraph>The garbage collector underlying C# may work by moving objects around in memory, but this motion is invisible to most C# developers. For developers who are generally content with automatic memory management but sometimes need fine-grained control or that extra bit of performance, C# provides the ability to write &quot;unsafe&quot; code. Such code can deal directly with pointer types and object addresses, however, C# requires the programmer to fix objects to temporarily prevent the garbage collector from moving them. </paragraph>
  50   <paragraph>This &quot;unsafe&quot; code feature is in fact a &quot;safe&quot; feature from the perspective of both developers and users. Unsafe code must be clearly marked in the code with the modifier unsafe, so developers can't possibly use unsafe language features accidentally, and the compiler and the execution engine work together to ensure that unsafe code cannot masquerade as safe code. These restrictions limit the use of unsafe code to situations in which the code is trusted. </paragraph>
  51   <paragraph>The example <code_example><![CDATA[
  52 using System;
  53 class Test
  54 {
  55    static void WriteLocations(byte[] arr) {
  56       unsafe {
  57          fixed (byte* pArray = arr) {
  58             byte* pElem = pArray;
  59             for (int i = 0; i < arr.Length; i++) {
  60                byte value = *pElem;
  61                Console.WriteLine("arr[{0}] at 0x{1:X} is {2}",
  62                i, (uint)pElem, value);
  63                pElem++;
  64             }
  65          }
  66       }
  67    }
  68    static void Main() {
  69       byte[] arr = new byte[] {1, 2, 3, 4, 5};
  70       WriteLocations(arr);
  71    }
  72 }
  73 ]]></code_example>shows an unsafe block in a method named WriteLocations that fixes an array instance and uses pointer manipulation to iterate over the elements. The index, value, and location of each array element are written to the console. One possible example of output is: <code_example><![CDATA[
  74 arr[0] at 0x8E0360 is 1
  75 arr[1] at 0x8E0361 is 2
  76 arr[2] at 0x8E0362 is 3
  77 arr[3] at 0x8E0363 is 4
  78 arr[4] at 0x8E0364 is 5
  79 ]]></code_example>but, of course, the exact memory locations may be different in different executions of the application. </paragraph>
  80 </clause>