Objective:
This article will introduce dynamic type. This article will be giving samples on different usage of dynamic type in programming.
Prerequisite: Visual Studio 2010
Dynamic type in c# 4.0 C# 4.0 is all about Dynamic Programming and type. 
10 facts about Dynamic type:
- C# 4.0 allows a new static type called "dynamic".
- Any operation on the object of type dynamic resolve at runtime.
- The dynamic allows us to access the object, without knowing type of the object at compile time.
- Dynamic types are internally treated as System.Object.
- At compile time we declare a dynamic type but at run time we get a strongly typed object.
- Dynamic type gets escaped from compile type checking. But if any error, it caught at runtime.
- Dynamic type is assumed to perform any task at compile time.
- Variable of type dynamic compiled into type object. So, after compilation dynamic does not exist.
- Dynamic type does not support intelli-sense.
- Object of any language type could be treated as dynamic type provided they are capable of naturally dispatch them.
Usage:
This is used to call and consume object of dynamic type languages like Python and Ruby. Now C# could call object of any dynamic language in the type dynamic.
Sample 1:
Program.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace DynamicTypeSample1
{
class Program
{
static void Main(string[] args)
{
dynamic dobj = "Hi I am Dynamic ";
Console.WriteLine(dobj);
Console.ReadKey(true);
}
}
}
Output:
Explanation:
- In above code, I am defining a variable dobj of type dynamic.
- This type is resolved in type string at runtime.
- We are printing the string value.
To get the runtime type of the dynamic type, I am adding one line of code in above code as
class Program
{
static void Main(string[] args)
{
dynamic dobj = "Hi I am Dynamic ";
Type dobjtype = dobj.GetType();
Console.WriteLine(dobjtype);
Console.WriteLine(dobj);
Console.ReadKey(true);
}
}
Output:
Explanation: - GetType() operation on dynamic type is use to get the runtime type of the dynamic type.
- As output, we are getting System.String. This is runtime type of the dynamic type.
Dynamic type could be used with
- Local type.
- Function return type
- Properties
- Indexers
- Class type
- Function argument
- Type constraint.
Conversion on dynamic type
Any object type can be converted into dynamic type implicitly.
dynamic dobj = 9;
dynamic dobj1 = " Dhananjay Kumar";
dynamic dobj3 = System.DateTime.Today;
Dynamic type could also get converted into any type implicitly
int i = dobj;
string s = dobj1;
string sd = dobj3;
Sample 2:
In this sample - We will make a class SampleForDynamimc.
- There are two properties, one is of type string and another is of type dynamic.
- There is one method, and return type of this method is dynamic and it is taking an input parameter of the type dynamic.
- In Main class, we are making object of type dynamic. This is getting resolved SampleForDynamic type at run time.
- Calling the dynamic type method with dynamic type argument.
- Printing the output.
SampleForDynamic class
Operations are resolved at run time. So there is no information about operations or properties are available at run time.
Program.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace DynamicTypeSample1
{
class Program
{
static void Main(string[] args)
{
dynamic obj = new SampleForDynamimc();
obj.Name = " Mahesh Chand";
obj.Sex = "Male";
dynamic message =" Welcome to Dynamimc World ";
dynamic result = obj.Getinformation(message);
Console.WriteLine(result);
Console.ReadKey(true);
}
}
public class SampleForDynamimc
{
public dynamic Name { get; set; }
public string Sex { get; set; }
public dynamic Getinformation(dynamic param1)
{
return Name +"\t" + Sex + "\t"+ param1 ;
}
}
}
Output:
| 
No comments:
Post a Comment