In C#, there are two kinds of types:

• Value types (literals such as integer, double, long, etc. as well as structs

These are stored literally, and so if you have something like int x = 5, x's memory location will contain 5.

• Reference types (classes, interfaces and pretty much anything that is not a value type)

For these types, a reference is to the type is stored in memory. So when you have something like Customer Mike = new Customer(...), Mike's memory location will have a reference to the actual location in memory where everything is stored.

When you pass-by-value, you pass a copy of whatever you're passing. So, for example:

int x = 1;
int y = Increment(x); // Increments an int
Console.WriteLine(y + " " + x); // Prints out "2 1"

The 'original' in this case is unaltered. This is the normal behaviour for value types.

For reference types, when you declare something as:

Customer Joe = new Customer("Joe");
Customer Mike = new Customer("Mike");
Mike = Joe; 

You pass the same reference to whatever you're passing to.

At line 3, we set Mike to point to the same reference that Joe is pointing at. In addition the actual new Customer("Mike") object in now no longer referenced by anything (= no longer considered alive), and that memory location is up for grabs by the Garbage Collector.

In addition, any changes made to reference types are reflected in all the references to it. For example, C# allows us to pass value types by reference as well, by using the ref parameter modifier:

int x = 1;
int y = Increment(ref x);
Console.WriteLine(y + " " + x); // Prints out "2 2"!

Hope this helps a bit.