Click here to Skip to main content
15,302,857 members
Articles / Programming Languages / C#
Tip/Trick
Posted 1 Jan 2015

Tagged as

Stats

10.3K views
6 bookmarked

Understanding Dynamic Keyword Using Simple Examples

Rate me:
Please Sign up or sign in to vote.
4.00/5 (1 vote)
1 Jan 2015CPOL4 min read
Introduction to dynamic keyword for beginners

Let us first have quick look on object and var keywords. If not beginner you can skip object and var section and can directly go to dynamic section.

object

Object is root for all data types and any type of data can be assigned to it.

C#
object obj;
obj = 10;
obj = 5.5;
obj = "mystring";

Here, before assigning any value to obj compiler will first typecast it to object type. For example, in the above code “10” will not be treated as integer and will get converted to object type. Same holds true about “5.5” and “mystring”.

var

C#
var j = 2;

var variable has to be initialized at the time of declaration. Compiler identifies datatype of right hand side value and declares variable of same type at compile time (type inference). So in the above example, compiler will declare j as integer, i.e., IL (Intermediate Language) will still have the same code as if it is declared as int j = 2.

Note that as var j = 2 is the same as int j = 2 so you can’t assign any other type of data to j in scope, i.e., the following code will not get compiled:

C#
var j = 2;
j = 5.5      (Error: Cannot implicitly convert type 'double' to 'int')

var keyword plays a very important role in LINQ queries, especially when query returns collection of anonymous types using projection.

dynamic

dynamic type bypasses static type checking and it gets resolved at runtime. You can assign any value to dynamic type. (You can assign any type of value to object also but in that case value actually gets converted to object type whereas in case of dynamic it will not get converted to object type).

Compiler or IL doesn’t have any knowledge about data assigned to dynamic type. That’s why while using dynamic types, you will not get intellisense support.

You can assign and reassign any type of data to dynamic variable in scope. Try out the following code.

C#
dynamic i;
i = 1;
Console.WriteLine(i.GetType());
i = "C#";
Console.WriteLine(i.GetType());
i = 5.5;
Console.WriteLine(i.GetType());

You can observe that while typing GetType(), you are not getting intellisense support. If you will try typing the same code just by replacing dynamic with object type, you will get intellisense support (check typing GetType()). Output will be the same in both the cases but in case of dynamic compiler will not have any knowledge about type at compile time.

To understand the difference between object and dynamic, try out the following example.

Create class Student:

C#
public class Student
{
   public string FirstName { get; set; }
   //few more properties....

   public void CalculateResult()
   {
       //code
   }
}

In Main, type the following code (please do not copy paste for better understanding):

C#
//using object
object s1 = new Student();
((Student)s1).FirstName = "Anand";
((Student)s1).CalculateResult();

//using dynamic
dynamic s2 = new Student();
s2.FirstName = "Albert";
s2.CalculateResult();

When using Object type to declare reference; Student object is getting implicitly typecasted into object type. So to access Student properties and methods, you have to again type-cast it back to Student type. Also note that while typing code you are getting intellisense support (as compiler (and Visual Studio) will have knowledge about datatype of s1).

In case of dynamic, compiler will not have any knowledge about type. At compile time, s2 is neither of object type nor of student type. That’s why while typing code, you will not get intellisense support and you have to manually type property and method names. But as we are assigning Student object to s2, it will get declared as Student type at runtime. So here we need not to type-cast it.

To understand it one level up, type the following code:

C#
//using object
object s1 = new Student();
((Student)s1).Firstname = "Anand";
((Student)s1).CalculateResult();

//using dynamic
dynamic s2 = new Student();
s2.FirstName = "Albert";
s2.CalculateResult();

In the above code, we are intentionally making a mistake while typing FirstName property for s1. Now if you will compile code, compiler will not allow you to compile. As compiler knows s1 is of Student type and there is no Firstname property that exists in that class.

Now try the following:

C#
//using object
object s1 = new Student();
((Student)s1).FirstName = "Anand";
((Student)s1).CalculateResult();

//using dynamic
dynamic s2 = new Student();
s2.Firstname = "Albert";
s2.CalculateResult();

Here, we are making the same mistake for s2 but surprisingly program will get compiled successfully, as compiler doesn’t have any idea about of what type s2 will be. Yes you are right, you will definitely get an error at runtime as there is no such property that exists in Student class.

In short, compiler will simply not bother about dynamic types. As the name suggests, they will get resolved at runtime. (While typing, you need to be careful as intelligence support is not there.)

What you can do using dynamic keyword, you can do without using it. But in case of reflection and COM programming, dynamic keyword reduces your typing efforts and simplifies source code drastically!

To realize the greatness of dynamic keyword, let us try out a simple reflection example.

Create class Employee as follows:

C#
class Employee
{
   public string Name { get; set; }
   public string Designation { get; set; }

   public void PrintDetails()
   {
       Console.WriteLine("{0}, {1}",Name, Designation);
   }
}

Not to do reflection over Employee class, either you can write code without using dynamic keyword:

C#
static void Main(string[] args)
{
    //without using dynamic keyword
    //to get Employee type
    Type t = typeof(Employee);

    //to create object of Employee type
    object empObj = Activator.CreateInstance(t);

    PropertyInfo prop;

    //to get "Name" property info
    prop = t.GetProperty("Name");
    //to set value to "Name" property
       prop.SetValue(empObj, "Sachin", null);

    //to get "Designation" property info
    prop = t.GetProperty("Designation");
    //to set value to "Designation" property
    prop.SetValue(empObj, "Cricketer", null);

    //to invoke/call "PrintDetails" method
    t.InvokeMember("PrintDetails", BindingFlags.InvokeMethod |
   BindingFlags.Instance | BindingFlags.Public, null, empObj, null);

    Console.ReadKey();
}

Or you can oversimplify it using dynamic keyword!!!

C#
static void Main(string[] args)
{
    //with using dynamic keyword
    //to get Employee type
    Type t = typeof(Employee);

    //to create object of Employee type
    dynamic d = Activator.CreateInstance(t);

    //to set values to property
    d.Name = "Sachin";
    d.Designation = "Cricketer";

    //to invoke/call "PrintDetails" method
    d.PrintDetails();

    Console.ReadKey();
}

I hope this is enough to convince you about the greatness of dynamic keyword especially when working with reflection. If not, you can always Google for few more examples:)

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

13+ Years of Experience. Seen death and rise of various technologies. Started with VB - 6.0 back in 2004, then updated to .NET somewhere in 2008. used Win Forms, ASP.NET Web Forms. Switched to ASP.NET MVC in 2013 for very short time. Right now using ASP Core since 2015 when it was in RC 1.

Comments and Discussions

 
QuestionBravo Pin
Vapsy Raghav2-Jan-15 17:45
professionalVapsy Raghav2-Jan-15 17:45 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.