// x is not initialized. in Visual Studio .NET

Drawing Code 39 in Visual Studio .NET // x is not initialized.

// The following line fails to compile, producing // error CS0165: Use of unassigned local variable x . AddVal(ref x);

Console.WriteLine(x); // Displays "15" } static void AddVal(ref Int32 v) { v += 10; // This method can use the initialized value in v. } }

Important I m frequently asked why C# requires that a call to a method must specify out or ref. After all, the compiler knows whether the method being called requires out or ref and should be able to compile the code correctly. It turns out that the compiler can indeed do the right thing automatically. However, the designers of the C# language felt that the caller should explicitly state its intention. This way, at the call site, it s obvious that the method being called is expected to change the value of the variable being passed. In addition, the CLR allows you to overload methods based on their use of out and ref parameters. For example, in C#, the following code is legal and compiles just fine:

class Point { static void Add(Point p) { ... } static void Add(ref Point p) { ... } }

It s not legal to overload methods that differ only by out and ref because the JIT compiled code for the methods would be identical. So I couldn t define the following method in the preceding Point type:

static void Add(out Point p) { ... }

Using out and ref with value types gives you the same behavior that you already get when passing reference types by value. With value types, out and ref allow a method to manipulate a single value type instance. The caller must allocate the memory for the instance, and the callee manipulates that memory. With reference types, the caller allocates memory for a pointer to a reference object and the callee manipulates this pointer. Because of this behavior, using out and ref with reference types is useful only when the method is going to "return" a reference to an object that it knows about. The following code demonstrates:

class App { static public void Main() { FileStream fs; // Open the first file to be processed. StartProcessingFiles(out fs); // Continue while there are more files to process. for (; fs != null; ContinueProcessingFiles(ref fs)) { // Process a file. fs.Read(...); } } static void StartProcessingFiles(out FileStream fs) { fs = new FileStream(...); } static void ContinueProcessingFiles(ref FileStream fs) { fs.Close(); // Close the last file worked on.

// Open the next file, or if no more files, return null. if (noMoreFilesToProcess) fs = null; else fs = new FileStream (...); } }

As you can see, the big difference with this code is that the methods that have out or ref reference type parameters are constructing an object and the pointer to the new object is returned to the caller. You ll also notice that the ContinueProcessingFiles method can manipulate the object being passed into it before returning a new object. This is possible because the parameter is marked with the ref keyword. You can simplify the preceding code a bit, as shown here:

class App { static public void Main() { FileStream fs = null; // Initialized to null (required) // Open the first file to be processed. ProcessFiles(ref fs); // Continue while there are more files to process. for (; fs != null; ProcessFiles(ref fs)) { // Process a file. fs.Read(...); } } void ProcessingFiles(ref FileStream fs) { // Close the previous file if one was open. if (fs != null) fs.Close(); // Close the last file worked on. // Open the next file, or if no more files, return null. if (noMoreFilesToProcess) fs = null; else fs = new FileStream (...); } }

Here s another example that demonstrates how to use the ref keyword to implement a method that swaps two reference types:

static public void Swap(ref Object a, ref Object b) { Object t = b; b = a; a = t; }

To swap references to two String objects, you d probably think that you could write code like this:

static public void SomeMethod() { String s1 = "Jeffrey"; String s2 = "Richter"; Swap(ref s1, ref s2); Console.WriteLine(s1); // Displays "Richter" Console.WriteLine(s2); // Displays "Jeffrey" }

However, this code won t compile. The problem is that variables passed by reference to a method must be the same type. In other words, Swap expects two references to an Object type, not two references to a String type. To swap the two String references, you must do this:

static public void SomeMethod() { String s1 = "Jeffrey"; String s2 = "Richter"; // Variables that are passed by reference // must match what the method expects. Object o1 = s1, o2 = s2; Swap(ref o1, ref o2); // Now cast the objects back to strings. s1 = (String) o1; s2 = (String) o2; Console.WriteLine(s1); Console.WriteLine(s2); } // Displays "Richter" // Displays "Jeffrey"

This version of SomeMethod does compile and execute as expected. The reason why the parameters passed must match the parameters expected by the method is to ensure that type safety is preserved. The following code, which thankfully won t compile, shows how type safety could be compromised.

class SomeType { public Int32 val; } class App { static void Main() { SomeType st; // The following line generates error CS1503: Argument 1 : // cannot convert from ref SomeType to ref object . GetAnObject(out st); Console.WriteLine(st.val); } void GetAnObject(out Object o) { o = new String( X , 100); } }

In this code, Main clearly expects GetAnObject to return a SomeType object. However, because GetAnObject s signature indicates a reference to an Object, GetAnObject is free to initialize o to an object of any type. In this example, when GetAnObject returned to Main, st would refer to a String, which is clearly not a SomeType object, and the call to Console.WriteLine would certainly fail. Fortunately, the C# compiler won t compile the preceding code because st is a reference to SomeType but GetAnObject requires a reference to an Object.