The stack is a block of memory for storing local variables and parameters. The stack automatically grows and shrinks as a function is entered and exited. Consider the following method (to avoid distraction, input argument checking is ignored):

	static int Factorial (int x)
	{
	  if (x == 0) return 1;
	  return x * Factorial (x-1);
	}

This method is recursive, meaning that it calls itself. Each time the method is entered, a new int is allocated on the stack, and each time the method exits, the int is deallocated.

The heap is a block of memory in which objects (i.e., reference type instances) reside. Whenever a new object is created, it is allocated on the heap, and a reference to that object is returned. During a program’s execution, the heap starts filling up as new objects are created. The runtime has a garbage collector that periodically deallocates objects from the heap, so your computer does not run out of memory. An object is eligible for deallocation as soon as nothing references it. In the following example, the StringBuilder object is created on the heap, while the sb reference is created on the stack:

	static void Test()
	{
	  StringBuilder sb = new StringBuilder();
	  Console.WriteLine (sb.Length);
	}

After the Test method finishes, sb pops off the stack, and the StringBuilder object is no longer referenced, so it becomes eligible for garbage collection.

Value type instances (and object references) live wherever the variable was declared. If the instance was declared as a field within an object, or as an array element, that instance lives on the heap.

You can’t explicitly delete objects in C#, as you can in C++. An unreferenced object is eventually collected by the garbage collector.The heap is also used to store static fields and constants. Unlike objects allocated on the heap (which can get garbage collected), these will live until the application domain is torn down.

By default, arguments in C# are passed by value, which is by far the most common case. This means a copy of the value is created when passed to the method:

	class Test
	{
	  static void Foo (int p)
	  {
	    p = p + 1;               // Increment p by 1
	    Console.WriteLine (p);   // Write p to screen
	  }
	  
	  static void Main( )
	  {
	    int x = 8;
	    Foo (x);                 // Make a copy of x
	    Console.WriteLine (x);   // x will still be 8
	  }
	}

Assigning p a new value does not change the contents of x because p and x reside in different memory locations.

Passing a reference type object by value copies the reference, but not the object. In the following example, Foo sees the same StringBuilder object that Main instantiated, but has an independent reference to it. In other words, sb and fooSB are separate variables that reference the same StringBuilder object:

	class Test
	{
	  static void Foo (StringBuilder fooSB)
	  {
	    fooSB.Append ("test");
	    fooSB = null;
	  }
	
	  static void Main( )
	  {
	    StringBuilder sb = new StringBuilder( );
	    Foo (sb);
	    Console.WriteLine (sb.ToString( ));    // test
	  }
	}

Because fooSB is a copy of a reference, setting it to null doesn’t make sb null. (If, however, fooSB was declared and called with the ref modifier, sb would become null.)

To pass by reference, C# provides the ref parameter modifier. In the following example, p and x refer to the same memory locations:

	class Test
	{
	  static void Foo (ref int p)
	  {
	    p = p + 1;              // increment p by 1
	    Console.WriteLine(p);   // write p to screen
	  }
	  static void Main( )
	  {
	    int x = 8;
	    Foo (ref x);            // Ask Foo to deal directly
	                            // with x
	    Console.WriteLine(x);   // x is now 9
	  }
	}

Now assigning p a new value changes the contents of x. Notice how the ref modifier is required both when writing and when calling the method. This makes it very clear what’s going on.

An out argument is like a ref argument, except it:

The out modifier is most commonly used to get multiple return values back from a method. Like a ref parameter, an out parameter is passed by reference.

When you pass an argument by reference, you alias the storage location of an existing variable, rather than creating a new storage location. In the following example, the variables x and y represent the same instance:

	class Test
	{
	  static int x;
	  
	  static void Main( ) { Foo (out x); }
	  static void Foo (out int y)
	  {
	    Console.WriteLine (x);          // x is 0
	    y = 1;                          // Mutate y
	    Console.WriteLine (x);          // x is 1
	  }
	}

The params modifier may be specified on the last parameter of a method so that the method accepts any number of parameters of a particular type. The parameter type must be declared as an array. For example:

	static int Sum (params int[] ints)
	{
	  int sum = 0;
	  for (int i = 0; i < ints.Length; i++)
	    sum += ints[i];        // increase sum by ints[i]
	  return sum;
	}
	
	static void Main( )
	{
	  int total = Sum (1, 2, 3, 4);
	  Console.WriteLine (total);           // 10
	}

You can also supply a params argument as an ordinary array. The first line in Main is semantically equivalent to this:

	int total = Sum (new int[] { 1, 2, 3, 4 } );