Dynamic Data Type In C#

Article

Dynamic data type was introduced with C# 4.0 in Visual Studio 2010. Dynamic data types are dynamic in nature and don’t require initialization at the time of declaration. We can define this data type using the keyword “dynamic" in our code. A variable of the dynamic data type can be initialized by any type of data like int, float ,string or object. Dynamic variables can be used to create properties and return values from a function.

Example

class Demo
{
dynamic Data = 12;
public int Method(int A, int B)
{
return (A + B) * Data;
}
}
class Program
{
static void Main(string[] args)
{
DemoObj = newDemo();
dynamic value1 = 10;
dynamic value2 = 11;
dynamic Str = "Your Result Is: ";
Console.WriteLine(Str + Obj.Method(value1, value2));
Console.ReadLine();
}
}

Output

result

Expression for dynamic data types is evaluated at run time, it means all the member functions and the member variables that are associated with dynamic keywords are ignored at the compile time. The compiler preserves all the information about the expression, such as the data types, and uses it later to evaluate the expression at the runtime.

Example:

class Demo
{
dynamic Data = 12;
public int Method(int A, int B)
{
return (A + B) * Data;
}
}
class Program
{
static void Main(string[] args)
{
//Obj As A Object of Demo Class
dynamicObj = newDemo();
dynamic value1 = 10;
dynamic value2 = 11;
dynamicStr = "Your Result Is: ";
Console.WriteLine(Str + Obj.Method(value1, value2));
//Obj as a String
Obj = "Pankaj Kumar Choudhary";
Console.WriteLine(Obj);
//Obj as a Integer
Obj = 12345;
Console.WriteLine(Obj);
//Obj as a Float
Obj = 123.45;
Console.WriteLine(Obj);
//Obj as a Boolean
Obj = false;
Console.WriteLine(Obj);
//Obj as a Dictionary
Obj = newDictionary < int, String > ();
Obj[0] = "Haryana";
Obj[1] = "Rajasthan";
Obj[2] = "Punjab";
Obj[3] = "Goa";
foreach(var index inObj.Keys)
{
Console.WriteLine(Obj[index]);
}
Console.ReadLine();
}
}

Output

see output

We can change the types for a dynamic data type. In the above example we assign the int, float, string, object and types for dynamic data type(obj). Size of dynamic data type is calculated the values that is assigned for dynamic data type.

Conversion

Conversion b/w dynamic type and implicit data type is very easy. It enables the developer to switch between dynamic and non-dynamic behavior.

Example:

class Demo
{
dynamic Data = 12;
public int Method(int A, int B)
{
return (A + B) * Data;
}
}
class Program
{
static void Main(string[] args)
{
//Conversion From Implicit Type To Dynamic Type
dynamicObj = new Demo();
dynamic value1 = 10;
dynamic value2 = 112.45;
dynamicStr = "This is a string";
//Conversion From Dynamic Type To Implicit Type
Demodm = Obj;
int int_ = value1;
double ft = value2;
string Str_ = Str;
Console.WriteLine(Obj.Method(100, 20));
Console.WriteLine(value1);
Console.WriteLine(value2);
Console.WriteLine(Str);
Console.WriteLine(dm.Method(11, 12));
Console.WriteLine(int_);
Console.WriteLine(ft);
Console.WriteLine(Str_);
Console.ReadLine();
}
}

Output

run

Overload Resolution with Arguments of Type Dynamic

Overload resolution occurs at run time instead of at compile time if one or more of the arguments in a method call have the type dynamic. In the below example in the main method we are passing two dynamic data types in Method. In Demo class all argument of Call method are integers but in the main method weare passing two dynamic data types in which the first dynamic type(value1) contains string value, so an error will occur at run time instead of compile time.

Example:

class Demo
{
dynamic Data = 12;
public int Call(int A, int B)
{
return (A + B) * Data;
}
}
class Program
{
static void Main(string[] args)
{
dynamic Obj = newDemo();
dynamic value1 = "10";
dynamic value2 = 112;
Console.WriteLine(Obj.Call(value1, value2));
Console.ReadLine();
}
}

Output

Output

Difference between var and dynamic keyword

The var keyword can be used to store any data type value. The var keyword will know the value assigned to it at compile time while dynamic keyword will resolve value assigned to it at run time. The var keyword was introduced in C# 3.0 and dynamic was introduced in C# 4.0. Let us consider some differences between both keywords.

Statically Typed and Dynamically Typed

This means the type of variable declared for var is decided by the compiler at compile time but the type of dynamic variable declared is decided by the compiler at runtime. So type of var variable is known at compile time so error for var variable is generated at compile time but in case of dynamic, type of variable is unknown till runtime so error is generated for dynamic time variable at run time.

Need of Initialization

Need of initialization for var is required at the time of declaration; if we don’t initialize the value we will get an error but in the case of dynamicthere is no need to initialize at the time of declaration.

Multiple Initialization with different Data Type

We can not change the data type for a var keyword. It means if we assign the integer value at time of declaration then further we can assign string, double, or other data type value for var keyword. If we try to do so then compiler will throw an error. In case of dynamic type there are no such types of restrictions, we can assign different types of value for dynamic type variable.

Multiple Initialization

Function Parameter

We can’t use the var keyword as a parameter for any function but the dynamic type can be used as parameter for any function .

Return Type

We can’t create a method with var as return type but we can create a method whose return type is dynamic.

Error

Conclusion

Dynamic Type is a nice feature to use dynamic language runtime. However, dynamic type also makes it the responsibility of the developer for the correct usage of the calls.

Read more articles on C# Programming: