C# Concepts - Value Type And Reference Type

Vishal Verma

4y274.1k15100Article

C#Value Type Reference TypeConcepts of C#

15 Comments

Join the conversation! Your thoughts help the community grow.

Onkar Sharma1y ago
For a detailed explanation of Value Types vs Reference Types in C#, check out the following resource: https://www.c-sharpcorner.com/blogs/value-types-vs-reference-types-in-c-sharp
Priyanka Singh5y ago
Hello, I think by mistake you type this in place of reference you type value. Please correct it. A value type is basically stored on the heap and passed by creating a reference." in "Reference Type.
Satish Kumar Vadlavalli10y ago
Nice share, keep up good work :)
Jaco Zwarts10y ago
Thank you for posting Vishal
Rakesh11y ago
Well Explain
Yashwanth Muthineni11y ago
Nice share
Santhakumar Munuswamy11y ago
Good Article. Thanks for sharing
Sumit Joshi11y ago
Thanks for sharing...
Vaikesh K P11y ago
Nice share
Gowtham K11y ago
Good one
Chervine Bhiwoo11y ago
Nice work
Rajeesh Menoth11y ago
Good One
Nilesh Jadav11y ago
Good one
Gopi Chand11y ago
Nice work
Karthikeyan K11y ago
Thanks for share

This seems to be a basic but very important part of C# programming.

Value type

Value types are generally (not always) stored on the stack and are passed by copying.

The way in which a variable assignment works differs between reference and value types.

If we have something like:

class Program   
{  
    static void Main(string[] args)   
    {  
        A obj1 = new A(12);  
        int v1 = 12;  
        int v2 = 22;  
        v2 = v1;  
        Console.WriteLine(v2);  
        Console.ReadLine();  
    }  
}

Implementation

Here, both v1 and v2 will be on the stack and are different entities.

Reference Type

A value type is basically stored on the heap and passed by creating a reference.

using System;  
class A {  
    public int value   
    {  
        get;  
        set;  
    }  
    public A(int passbyref)  
    {  
        this.value = passbyref;  
    }  
}  
class Program  
{  
    static void Main(string[] args)  
    {  
        A v1 = new A(12);  
        A v2 = new A(22); //Breakpoint  
        v2 = v1;  
        Console.WriteLine(v1.value);  
        Console.WriteLine(v2.value);  
        Console.ReadLine();  
    }  
}

Implementation

v1 and v2 will be on the heap as two entities until a breakpoint.

And after the breakpoint, they both point to one entity.

Figure 1: BreakPoin1

Figure 2: BreakPoint2

So, a change in one will affect the other.

Conclusion

Once you pass a value type, you pass a copy to the other method.

But what if we want to change it? Use the “ref” keyword for that.

Suggestion

The difference between ref and out should be studied (I will try to write another article for that topic).

Use of ref in value types

The ref keyword passes the value by reference (details to be explained later).

class Program   
{  
    static void Main(string[] args)  
    {  
        int v1 = 12;  
        methodtoshowref(ref v1);  
        Console.WriteLine(v1);  
        Console.ReadLine();  
    }  
    public static void methodtoshowref(ref int v2)  
    {  
        v2 = 100;  
    }  
}

Now, v1 becomes 100 because both share the same reference (one entity).

Passing Arguments

We have the following four possibilities:

Pass value type by value.
pass value type by reference
pass reference type by value.
pass reference type by reference.

Pass value type by value

struct A  
{  
    public int val   
    {  
        get;  
        set;  
    }  
}  
class Program   
{  
    static void Main(string[] args)  
    {  
        A v1 = new A();  
        v1.val = 10;  
        methodtoshowref(v1);  
        Console.WriteLine(v1.val);  
        Console.ReadLine();  
    }  
    public static void methodtoshowref(A obj)  
    {  
        obj = new A();;  
    }  
}

Output

10 (because one more copy is created and thus the original is not affected).

Pass value type by reference

using System;  
struct A  
{  
    public int val   
    {  
        get;  
        set;  
    }  
}  
class Program  
{  
    static void Main(string[] args)  
    {  
        A v1 = new A();  
        v1.val = 10;  
        methodtoshowref(ref v1);  
        Console.WriteLine(v1.val);  
        Console.ReadLine();  
    }  
    public static void methodtoshowref(ref A obj)   
    {  
        obj = new A();;  
    }  
}

Output

0 (since now one copy is shared by both methods).

Pass reference type by value (by default)

using System;  
class A   
{  
    public int val   
    {  
        get;  
        set;  
    }  
}  
class Program  
{  
    static void Main(string[] args)  
    {  
        A v1 = new A();  
        v1.val = 10;  
        methodtoshowref(v1);  
        Console.WriteLine(v1.val);  
        Console.ReadLine();  
    }  
    public static void methodtoshowref(A obj)  
    {  
        obj = null;  
    }  
}

Output

10 (this happens because we are passing it by value).

Now here if we do, obj.val=100 then it will print 100 (this is because passing a variable to a function by value is equivalent to instantiating a new variable and assigning it to the first).

More to be discussed in the section on shallow copy vs deep copy (in a later article).

Pass reference type by reference

using System;  
class A   
{  
    public int val   
    {  
        get;  
        set;  
    }  
}  
class Program   
{  
    static void Main(string[] args)  
    {  
        A v1 = new A();  
        v1.val = 10;  
        methodtoshowref(ref v1);  
        Console.WriteLine(v1.val);  
        Console.ReadLine();  
    }  
    public static void methodtoshowref(ref A obj)   
    {  
        obj = null;  
    }  
}

Output

The error we have now is obj=null so it will give a nullobject error.

Disclaimer - I got inspiration from JonSkeet and various other talented guys.