Csharp/CSharp Tutorial/Language Basics/ref

Change string using ref keyword

using System;
class MainClass
{
  public static void UpperCaseThisString(ref string s)
  {
    s = s.ToUpper();
  }
  public static void Main() 
  {
    string s = "str";
    Console.WriteLine("-> Before: {0}", s);
    UpperCaseThisString(ref s);
    Console.WriteLine("-> After: {0}\n", s);
  }
}

-> Before: str
-> After: STR

Passing Parameters by Value

public class Swapper {
    public void Swap(int x, int y) {
        System.Console.WriteLine("In Swap(): initial x = " + x + ", y = " + y);
        int temp = x;
        x = y;
        y = temp;
        System.Console.WriteLine("In Swap(): final   x = " + x + ", y = " + y);
    }
}

class MainClass {
    public static void Main() {
        int x = 2;
        int y = 5;
        System.Console.WriteLine("In Main(): initial x = " + x + ", y = " + y);
        Swapper mySwapper = new Swapper();
        mySwapper.Swap(x, y);
        System.Console.WriteLine("In Main(): final   x = " + x + ", y = " + y);
    }
}

Swap two references.

using System; 
 
class RefSwap { 
  int a, b; 
   
  public RefSwap(int i, int j) { 
    a = i; 
    b = j; 
  } 
 
  public void show() { 
    Console.WriteLine("a: {0}, b: {1}", a, b); 
  } 
 
  // This method changes its arguments. 
  public void swap(ref RefSwap ob1, ref RefSwap ob2) { 
    RefSwap t; 
  
    t = ob1; 
    ob1 = ob2; 
    ob2 = t; 
  } 
} 
 
class MainClass { 
  public static void Main() { 
    RefSwap x = new RefSwap(1, 2); 
    RefSwap y = new RefSwap(3, 4); 
 
    Console.Write("x before call: "); 
    x.show(); 
 
    Console.Write("y before call: "); 
    y.show(); 
 
    Console.WriteLine(); 
 
    // exchange the objects to which x and y refer 
    x.swap(ref x, ref y);  
 
    Console.Write("x after call: "); 
    x.show(); 
 
    Console.Write("y after call: "); 
    y.show(); 
 
  } 
}

x before call: a: 1, b: 2
y before call: a: 3, b: 4
x after call: a: 3, b: 4
y after call: a: 1, b: 2

Swap two values

using System; 
 
class Swap { 
  // This method now changes its arguments. 
  public void swap(ref int a, ref int b) { 
    int t; 
  
    t = a; 
    a = b; 
    b = t; 
  } 
} 
 
class MainClass { 
  public static void Main() { 
    Swap ob = new Swap(); 
 
    int x = 10, y = 20; 
 
    Console.WriteLine("x and y before call: " + x + " " + y); 
 
    ob.swap(ref x, ref y);  
 
    Console.WriteLine("x and y after call: " + x + " " + y); 
  } 
}

x and y before call: 10 20
x and y after call: 20 10

Use out for reference type

using System;
class MyClass
{
   public int Val = 20;                     
}
class MainClass
{
   static void MyMethod(out MyClass f1, out int f2)
   {
      f1 = new MyClass();                   
      f1.Val = 25;                          
      f2 = 15;                              
   }
   static void Main()
   {
      MyClass myObject = null;
      int intValue;
      MyMethod(out myObject, out intValue);             
      Console.WriteLine("After  -- myObject.Val: {0}, intValue: {1}", myObject.Val, intValue);
   }
}

After  -- myObject.Val: 25, intValue: 15

Use ref for int value

using System;

class MyClass
{
   public int Val = 20;                  
}
class MainClass
{
   static void MyMethod(ref MyClass myObject, ref int intValue)
   {
      myObject.Val = myObject.Val + 5;               
      intValue = intValue + 5;                       
   }
   static void Main()
   {
      MyClass myObject = new MyClass();
      int intValue = 10;
      Console.WriteLine("Before -- myObject.Val: {0}, intValue: {1}", myObject.Val, intValue);
      MyMethod(ref myObject, ref intValue);          
      Console.WriteLine("After  -- myObject.Val: {0}, intValue: {1}", myObject.Val, intValue);
   }
}

Before -- myObject.Val: 20, intValue: 10
After  -- myObject.Val: 25, intValue: 15

Use ref for reference type

using System;

class MyClass
{
   public int Val = 20;                  
}
class MainClass
{
   static void MyMethod(ref MyClass myObject, ref int intValue)
   {
      myObject.Val = myObject.Val + 5;               
      intValue = intValue + 5;                       
   }
   static void Main()
   {
      MyClass myObject = new MyClass();
      int intValue = 10;
      Console.WriteLine("Before -- myObject.Val: {0}, intValue: {1}", myObject.Val, intValue);
      MyMethod(ref myObject, ref intValue);          
      Console.WriteLine("After  -- myObject.Val: {0}, intValue: {1}", myObject.Val, intValue);
   }
}

Before -- myObject.Val: 20, intValue: 10
After  -- myObject.Val: 25, intValue: 15

Use ref to pass a value type by reference

The ref parameter modifier causes C# to create a call-by-reference, rather than a call-by-value.

using System; 
 
class RefTest { 
  /* This method changes its argument. 
     Notice the use of ref. */ 
  public void sqr(ref int i) { 
    i = i * i; 
  } 
} 
 
class MainClass { 
  public static void Main() { 
    RefTest ob = new RefTest(); 
 
    int a = 10; 
 
    Console.WriteLine("a before call: " + a); 
 
    ob.sqr(ref a); // notice the use of ref 
 
    Console.WriteLine("a after call: " + a); 
  } 
}

a before call: 10
a after call: 100