var vs dynamic keyword in C# 4.0

To put it as simple as possible, there is a simple difference between the C# ‘var’ and ‘dynamic’ keyword. When using the ‘var’ keyword, the type is decided by the compiler at compile time, whereas when using the ‘dynamic’ keyword, the type is decided by the runtime.

If you have been doing C# programming lately, you are already aware of the ‘var’ keyword, a strongly implicitly typed local variable for which the compiler is able to determine the type from the initialization expression - very useful when doing LINQ programming.

The ‘dynamic’ keyword was introduced in .NET 4.0 framework which also introduced the Dynamic Language Runtime (DLR) to accommodate dynamic languages like IronRuby and IronPython [are they dead?]. C# 4.0 provides access to this DLR using the new ‘dynamic’ keyword. C# is a statically typed language and the ‘dynamic' type automatically tells the compiler that it is a dynamic invocation, so ignore the compile time checking for this type. This also means that any invalid operations will only be detected at runtime.

Let’s see an example. Consider this piece of code:

var emp = new Employee();

dynamic emp = new Employee();

In the first case, i.e. when you are using the ‘var’ keyword, the type is statically inferred. So the line of code evaluates as

Employee emp = new Employee()

The compiler will check to see if a TakeBreak() method exists, if not, fail the compilation.

However that’s not the case when using the ‘dynamic’ type. Using the ‘dynamic’ type does not make it type-safe, hence the compiler is bypassed and the compiler does not check if the TakeBreak() method exists.

No type-safety? Why the hell do I need the ‘dynamic’ keyword for?

Well you need it because it is very useful in certain areas like interoperability. To start with an obvious one, it is very useful in dynamic languages that require runtime binding. Also, if you have an object declared as dynamic, then it’s no more your concern to handle how this object obtains it’s value. It’s value can be taken from a DOM object, or from a dynamic language like IronRuby, Reflection, Service or a COM API etc. The runtime takes care of the operations on this object.

The ‘dynamic’ type is also extremely useful when you are interoperating with Office Automation API’s. This saves you from casting everything from the object.

If you are interested, I will write a couple of more articles on the new ‘dynamic’ type and how you can use it to interoperate with the new Office Automation API’s. Let me know via the comments section if you care to see an example!

About The Author

Suprotim Agarwal
Suprotim Agarwal, Developer Technologies MVP (Microsoft Most Valuable Professional) is the founder and contributor for DevCurry, DotNetCurry and SQLServerCurry. He is the Chief Editor of a Developer Magazine called DNC Magazine. He has also authored two Books - 51 Recipes using jQuery with ASP.NET Controls. and The Absolutely Awesome jQuery CookBook.

Follow him on twitter @suprotimagarwal.


Anonymous said...

Please do so.

Anonymous said...

I'd also like to see some examples from real life projects of that new feature

Anonymous said...

Thanks - I would like to see how to use this to bind methods at run-time

Anonymous said...

yeah, it will help.

Suprotim Agarwal said...

Thanks all for your feedback. Watch out for an update on this post with an example, by the end of this week!

Unknown said...

Thank you very much for your blog. Outstanding.

Yes, would love to see an office automation example

Unknown said...

ya why not,will be great if post a tutorial or an example with WCF.

Alex Ford said...

More please.

Unknown said...

Thank you for the above.

Yes, I would like to see more of this especially in an OBA context with VSTO or interop.


Anonymous said...

Very good example..please provide some example for how dynamic works..

Anonymous said...


Venkat Rao Tammineni said...

Please come with more stuff...


senthil dhakshna said...

Nice one..

Difference between Var and Dynamic in c#
1. The Var(Implicit typed local variable) keyword is used to define local variables.In case of Var , the underlying data type is determined at compile time itself based on the initial assignment.Once the initial assignment has been made with Var type , then it will become strongly typed.If you try to store any incompatible value with the Var type it will result in compile time error.


Var strNameList=new List(); By using this statement we can store list of names in the string format.

strNameList.add(45); // This statement will cause the compile time error.

But in Dynamic type, the underlying type is determined only at run time.Dynamic data type is not checked at compile time and also it is not strongly typed.We can assign any initial value for dynamic type and then it can be reassigned to any new value during its life time.

dynamic test="Senthil";
Console.Writeline(test.GetType()) // System.String

Console.Writeline(test.GetType()) // System.Int32

test=new List();
Console.Writeline(test.GetType()) //System.Collections.Generic.List'1[System.String]

It doesn't provide IntelliSense support also.It doesn't give better support when we give work with linq also.Because it doesn't support lambda expressions ,extension methods and anonymous methods.

Check this blog for info about var and dynamic:-