using System;
class Program
{
    static void Main(string[] args)
    {
        int x = 2;
        int y = 20;
        Console.WriteLine(Add(x, y));
    }

    static int Add(int x, int y)
    {
        int ans = x + y;
         x = 20;
         y = 40;
       // return x+y;
         return ans;
        //returns 22
    }
}

using System;
class Program
{
    static void Main(string[] args)
    {
        int x = 2;
        int y = 20;
        Console.WriteLine(Add(x, y));
    }

    static int Add(int x, int y)
    {
        int ans = x + y;
         x = 20;
         y = 40;
       return x+y;
      //   return ans;
        //returns 60
    }
}

int ans = x + y;

static int Add(int x, int y)
{
    int ans = x + y;  // evaluates ans = x + y = 2 + 20 = 22
     x = 20;          // here ans = 22, x = 20, y = 20
     y = 40;          // here ans = 22, x = 20, y = 40
     return ans;      // returns ans which is still 22 since x & y are independent
}

return x + y;

static int Add(int x, int y)
{
    int ans = x + y;  // ans = 22, x = 2, y = 20
     x = 20;          // ans = 22, x = 20, y = 20
     y = 40;          // ans = 22, x = 20, y = 40
   return x+y;        // evaluates x + y = 60
}

ans = x + y;

// parameters in: x = 2, y = 20.
int ans = x + y;
// now ans contains the value 22.
x = 20;
y = 40;
// now x and y has changed, but the value in ans
// is already calculated and doesn't change.
return ans;
// returns 22;

// parameters in: x = 2, y = 20.
int ans = x + y;
// now ans contains the value 22.
x = 20;
y = 40;
// now x and y has changed, but not ans.
return x+y;
// the value of the expression is calculated with the current
// values, and 60 is returned.
// the variable ans still contains 22, but that isn't used here.

using System;
class Program
{
    static void Main(string[] args)
    {
        int x = 2;
        int y = 20;
        Console.WriteLine(Add(x, y));
        // x is still 2, y is still 20
    }

    static int Add(int x, int y)
    {
        int ans = x + y;
        // You calculate the parameters and store it in the local variable
        x = 20;
        y = 40;
        // You've adapted your local COPIES of the variables
        return ans;
        // You return the answer which was calculated earlier
    }
}

using System;
class Program
{
    private class Numbers
    {
        public int X;
        public int Y;
    }

    static void Main(string[] args)
    {
        Numbers num = new Numbers();
        num.x = 2;
        num.y = 20;
        Console.WriteLine(Add(num)); // Prints 2 + 20 = 22
        // num.x is now 20, and num.y is now 40
        Console.WriteLine(Add(num)); // Prints 20 + 40 = 60
    }

    static int Add(Numbers num)
    {
        int ans = num.x + num.y;
        // You calculate the result from the public variables of the class
        num.x = 20;
        num.y = 40;
        // You change the values of the class
        return ans;
        // You return the answer which was calculated earlier
    }
}

static void Main()
{
    int x = 5; // Value type
    List<int> list = new List<int>(new [] { 1, 2, 3 }); // Reference type

    ValueByValue(x); // x is still 5
    ReferenceByValue(list) // list still contains { 1, 2, 3 }
    ValueByReference(ref x); // x is now 10
    ReferenceByReference(ref list); // list is now a new list containing only { 4, 5, 6 }
}

static void ValueByValue(int x)
{
    x = 10; // Changes local COPY of x
}

static void ReferenceByValue(List<int> list)
{
    list = new List<int>(new [] { 4, 5, 6 }); // Changes local COPY of list
}

static void ValueByReference(ref int x)
{
    x = 10; // Changes the actual x variable in the Main method
}

static void ReferenceByReference(ref List<int> list)
{
    list = new List<int>(new [] { 4, 5, 6 }); // Changes the actual list in the Main method
}

int x=50,y=20;

Example
x+y=500;//INVALID

Example
x=500;//VALID
y=545*33+4;//VALID

static int Add(int x, int y)
 {
      int ans = x + y;
      x = 20;
      y = 40;
      // return x+y;
      return ans;
      //returns 22
 }

static int Add(int x, int y)
 {
      int ans = x + y;
      x = 20;
      y = 40;
      return x+y;
      // return ans;
      //returns 60
 }

static int Add(ref int x, int y) // x is the referenced variable in this example

using System;
class Program
{
    static void Main(string[] args)
    {
        int x = 2;
        int y = 20;


        Console.WriteLine("SUM  :: " + AddByValue(x, y));  // Call by value
        Console.WriteLine("X :: " + x + ", Y :: " + y);  // Nothing change to variable

        Console.WriteLine("SUM  :: " + AddByRef(ref x, ref y));  // Call by reference
        Console.WriteLine("X :: " + x + ", Y :: " + y);  // Value changed

    }

    static int AddByValue(int x, int y)
    {
        int ans = x + y;
         x = 20;
         y = 40;
       return ans;
    }

    static int AddByRef(ref int x, ref int y)
    {
        int ans = x + y;
        x = 20;
        y = 40;
       return ans;
    }


}

SUM  :: 60
X :: 2, Y :: 20

SUM  :: 60
X :: 20, Y :: 40