Click here to Skip to main content
Click here to Skip to main content

Tagged as

Go to top

Dynamic vs. Var vs. Object

, 1 Oct 2013
Rate this:
Please Sign up or sign in to vote.
In this blog, I will try to highlight the differences from the CLR and the compiler’s perspective.

C# by nature is a very strongly typed language which signifies that most of the verifications are executed statically during compile time. If not all, but most of features and structs exposed by C# language adheres to this principle. With the introduction of Dynamic in C# 4.0, I found there is confusion in developer’s community around the difference between Var, Object, and Dynamic. In this blog, I will try to highlight the differences from the CLR and the compiler’s perspective.

System.Object

All the objects (value and referenced types) in managed environment are directly or indirectly inherit from System.Object. With this inheritance in place, a variable of System.Object can hold the reference of instance of any type.

c12

In above example, o1 is holding the reference of XmlDocument and o2 is holding the reference of boxed double value. However in either case, compiler will allow to call only those methods /properties which exists in System.Object type. In other words compiler will not allow you to call ChildNodes property from o1 and similarly o2 cannot be used for any arithmetic operation. All of these restrictions are in place because from compiler’s perspective, o1 and o2 are holding the reference of System.Object type. The only way to access the ChildNodes property is to typecast it into XmlDocument type. In that case, compiler will emit the code to validate the type casting during runtime.

Hence:

  1. Though variable of System.Object type can hold the reference of any type, compiler will ensure the type safety. If type casting is happening, compiler will emit the code to validate the type safety during runtime.
  2. Assigning the value type to a variable of System.Object will suffer from Boxing / Unboxing.

Var Keyword

The var keyword was introduced in C# 3.0. It was primarily introduced to support the notion of anonymous types (which was the key requirement for LINQ). But important part is, var is resolved at the compile time, i.e., the actual type is resolved by the compiler during the compile time. Hence it provides same type safety as using normal typed variable.

c21

In above example, var1 is resolved by compiler as double, var2 is resolved by compiler as int and var3 is resolved by compiler as string. From CLR perspective, there is nothing known as var.

Hence,

  1. var is a compile time feature resolved to a valid underlying type. Due to this, compiler enforces you to assign a value during the declaration so it can infer the actual type.
  2. Since var is resolved to a valid type during compilation, compiler will enforce all type safety and code will not suffer from boxing / unboxing.

In my own opinion, we should use “varonly when actual type is not known during development i.e. type is anonymous as shown in following example.

c3

If the actual type is known, then I will not recommend using var to save few keyboard strokes as it reduces the readability of code.

Dynamic

With C# 4.0, Microsoft introduces dynamic. When you define a variable of type dynamic, compiler internally performs two steps. The first thing compiler does is, it converts the type to System.Object and then it postpones all the type validation to the runtime. The following example uses the dynamic to declare an int type.

c4

In the above example, Double declares the multiplier as dynamic. During compilation, dynamic will be converted to System.Object and compiler will emit the code for type safety during runtime as shown in the following IL.

c5

Hence

  1. During compilation time, dynamic is converted to System.Object and compiler will emit the code for type safety during runtime.
  2. As dynamic is treated as System.Object, it suffers from boxing / unboxing similar to System.Object.
  3. Since compiler emits the code for all the type safety, application’s performance will suffer.

dynamic was introduced only to simplify the access to the COM APIs. I strongly recommend that we should restrict the use of dynamic only when handling the COM APIs as it might cause runtime exceptions and can cause performance issues.

License

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

Share

About the Author

Tariq A Karim
Software Developer (Senior) RBS Bank
United Kingdom United Kingdom
Over 14 years of experience in enterprise / real-time software development using Microsoft Technologies.


More details in LinkedIn Or Blog
Follow on   LinkedIn

Comments and Discussions

 
GeneralNice explanation.......... PinprofessionalAnupam Singh_20-Apr-14 21:54 
GeneralMy vote of 5 PinprofessionalRenju Vinod18-Nov-13 16:58 
GeneralMy vote of 5 PinprofessionalS. M. Ahasan Habib9-Nov-13 2:25 
Nice!
QuestionVery very nice PinmemberMekki Ahmedi6-Oct-13 22:47 
GeneralMy vote of 3 PinmemberMember 102537902-Oct-13 20:58 
GeneralThanks! Pinprofessionalklim_vlad1-Oct-13 21:32 
SuggestionGood article, but ... PinmemberKlaus Luedenscheidt1-Oct-13 19:59 
GeneralRe: Good article, but ... PinmemberTariq A Karim1-Oct-13 22:12 
GeneralRe: Good article, but ... PinmemberCarlos19072-Oct-13 0:34 
GeneralRe: Good article, but ... PinmemberTariq A Karim2-Oct-13 2:33 

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

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

| Advertise | Privacy | Mobile
Web02 | 2.8.140916.1 | Last Updated 1 Oct 2013
Article Copyright 2013 by Tariq A Karim
Everything else Copyright © CodeProject, 1999-2014
Terms of Service
Layout: fixed | fluid