Difference between var and dynamic in C#

Difference between var and dynamic in C#

Implicitly Typed Local Variables – var are those variables which are declared without specifying the .NET type explicitly. In implicitly typed variable, the type of the variable is automatically deduced at compile time by the compiler from the value used to initialize the variable. The implicitly typed variable concept is introduced in C# 3.0. The implicitly typed variable is not designed to replace the normal variable declaration, it is designed to handle some special-case situation like LINQ(Language-Integrated Query).

Example:

// C# program to illustrate the concept
// of the implicitly typed variable
using System;
 
class GFG {
 
    // Main method
    static public void Main()
    {
 
        // Creating and initializing
        // implicitly typed variables
        // Using var keyword
        var a = 'f';
        var b = "GeeksforGeeks";
        var c = 30.67d;
        var d = false;
        var e = 54544;
 
        // Display the type
        Console.WriteLine("Type of 'a' is : {0} ", a.GetType());
 
        Console.WriteLine("Type of 'b' is : {0} ", b.GetType());
 
        Console.WriteLine("Type of 'c' is : {0} ", c.GetType());
 
        Console.WriteLine("Type of 'd' is : {0} ", d.GetType());
 
        Console.WriteLine("Type of 'e' is : {0} ", e.GetType());
    }
}

Output:

Type of 'a' is : System.Char 
Type of 'b' is : System.String 
Type of 'c' is : System.Double 
Type of 'd' is : System.Boolean 
Type of 'e' is : System.Int32 

In C# 4.0, a new type is introduced that is known as a dynamic type. It is used to avoid the compile-time type checking. The compiler does not check the type of the dynamic type variable at compile time, instead of this, the compiler gets the type at the run time. The dynamic type variable is created using dynamic keyword.

Example:

// C# program to illustrate how to get the
// actual type of the dynamic type variable
using System;
 
class GFG {
 
    // Main Method
    static public void Main()
    {
 
        // Dynamic variables
        dynamic val1 = "GeeksforGeeks";
        dynamic val2 = 3234;
        dynamic val3 = 32.55;
        dynamic val4 = true;
 
        // Get the actual type of
        // dynamic variables
        // Using GetType() method
        Console.WriteLine("Get the actual type of val1: {0}",
                                  val1.GetType().ToString());
 
        Console.WriteLine("Get the actual type of val2: {0}",
                                  val2.GetType().ToString());
 
        Console.WriteLine("Get the actual type of val3: {0}",
                                  val3.GetType().ToString());
 
        Console.WriteLine("Get the actual type of val4: {0}",
                                  val4.GetType().ToString());
    }
}

Output:

Get the actual type of val1: System.String
Get the actual type of val2: System.Int32
Get the actual type of val3: System.Double
Get the actual type of val4: System.Boolean

Below are some differences between var and dynamic keyword in C#:

.var_vs_dynamic-table {
border-collapse: collapse;
width: 100%;
}
.var_vs_dynamic-table td {
border: 1px solid #5fb962;
text-align: left !important;
padding: 8px;
}
.var_vs_dynamic-table th {
border: 1px solid #5fb962;
padding: 8px;
}
.var_vs_dynamic-table tr>th{
background-color: #c6ebd9;
vertical-align: middle;
}
.var_vs_dynamic-table tr:nth-child(odd) {
background-color: #ffffff;
}

VARDYNAMIC
It is introduced in C# 3.0.It is introduced in C# 4.0
The variables are declared using var keyword are statically typed.The variables are declared using dynamic keyword are dynamically typed.
The type of the variable is decided by the compiler at compile time.The type of the variable is decided by the compiler at run time.
The variable of this type should be initialized at the time of declaration. So that the compiler will decide the type of the variable according to the value it initialized.The variable of this type need not be initialized at the time of declaration. Because the compiler does not know the type of the variable at compile time.
If the variable does not initialized it throw an error.If the variable does not initialized it will not throw an error.
It support intelliSense in visual studio.It does not support intelliSense in visual studio
var myvalue = 10; // statement 1
myvalue = “GeeksforGeeks”; // statement 2
Here the compiler will throw an error because the compiler has already decided the type of the myvalue variable using statement 1 that is an integer type. When you try to assign a string to myvalue variable, then the compiler will give an error because it violating safety rule type.
dynamic myvalue = 10; // statement 1
myvalue = “GeeksforGeeks”; // statement 2
Here, the compiler will not throw an error though the type of the myvalue is an integer. When you assign a string to myvalue it recreates the type of the myvalue and accepts string without any error.
It cannot be used for properties or returning values from the function. It can only used as a local variable in function.It can be used for properties or returning values from the function.

About Faezeh

Avatar

Leave a Reply

Your email address will not be published. Required fields are marked *

*

code

eighteen − 17 =

 

Enter your email address: