Difference between Object, Dynamic and Var

Question

I need to know the difference between these three keywords Object , Dynamic and var in C#.

I have seen this link but i don't understand in which case i have to use each one.

Can you explain for me, please, the difference between these keywords ? What are the utilities of each keyword?

Chromatics

Just use var everywhere. If you needed something else - you would know that. – Diffidence

Check this link. Easy to grasp - clear English: dotnettricks.com/learn/csharp/… – Underclothes

thanks for help me to understand that dynamic is useful when coding using reflection or dynamic language support or with the COM objects, because we require to write less amount of code. And I also find Using Type dynamic (C# Programming Guide)-COM Interop – Heiress

Answer 1

Everything is Object because it is a base type for every type in .net environment. Every type inherit from Object in a moment, a simple int variable can be boxed to an object and unboxed as well. For example:

object a = 10; // int
object b = new Customer(); // customer object
object c = new Product(); // product object
object d = "Jon"; // string
object e = new { Name = "Felipe", Age = 20 }; // anonymous type

It is the most abstraction for any type and it is a reference type. If you want to get the real type, you need to unbox it (using a conversaion strategy such as methods, casts, etc):

object a = "Some Text";
string text = a.ToString();

// call a string method
text = text.ToUpper();

object i = 10; // declared as object but instance of int
int intValue = (int) i; //declare as an int ... typed

Dynamic is an implementation of a dynamic aspect in C#, it is not strongly typed. For example:

dynamic a = new Class();
a.Age = 18;
a.Name = "Jon";
a.Product = new Product();

string name  a.Name; // read a string
int age = a.Age; // read an int
string productName = a.Product.Name; // read a property
a.Product.MoveStock(-1); // call a method from Product property.

var is just a keyword of the C# language that allows you define any object of a type since you initialize it with a value and it will determinate the type from this value, for example:

var a = 10; // int
var b = 10d; // double
var c = "text"; // string
var d = 10m; // decimal
var p = new Product(); // Product type

The compiler will check the type of the value you have defined and set it on the object.

Kino

Since this answer was just plagiarised elsewhere, I'll add my comment where here: it should be noted that dynamic doesn't change the underlying type, so calling a.FavouriteFood = "pizza"; would throw an exception at runtime, because Class doesn't define FavouriteFood. – Valentia

Answer 2

Object:

Each object in C# is derived from object type, either directly or indirectly. It is compile time variable and require boxing and unboxing for conversion and it makes it slow. You can change value type to reference type and vice versa.

public void CheckObject()
{
    object test = 10;
    test = test + 10;    // Compile time error
    test = "hello";      // No error, Boxing happens here
}

Var:

It is compile time variable and does not require boxing and unboxing. Since Var is a compile time feature, all type checking is done at compile time only. Once Var has been initialized, you can't change type stored in it.

public void CheckVar()
{
    var test = 10;         // after this line test has become of integer type
    test = test + 10;      // No error
    test = "hello";        // Compile time error as test is an integer type
}

Dynamic:

It is run time variable and not require boxing and unboxing. You can assign and value to dynamic and also can change value type stored in same. All errors on dynamic can be discovered at run time only. We can also say that dynamic is a run time object which can hold any type of data.

public void CheckDynamic()
{
    dynamic test = 10;
    test = test + 10;     // No error
    test = "hello";       // No error, neither compile time nor run time
}

Sorgo

Answer 3

1) var is used for implicit type definition. For example if you define a variable like this:

var number = 123;

Compiler infers the type based on the assigned value and your variable initialized as integer in compile time. After this definition you can't assign a string to your variable because it is an integer.And you can't use var like this:

var number;
number = 123;

Because you have to assign something to your variable if you are using var keyword so that the type can be determined.

2) Object is a base class for all classes. In C# all classes inherits from object class, therefore you can assign everything to an object.For example:

object str = "bla bla bla..."; 
str = 234;
str = DateTime.Now;

This is working because when you doing this boxing/unboxing performing automatically for you. And as opposed to var keyword you can use object like this:

object myVariable;
myVariable = "bla bla bla..";

3) dynamic is a cool feature that came with C# 4.0, you can use dynamic if you don't know returning type from your function in compile time.Your type will be determined in run-time.Therefore you can't use intellisense with dynamic variables.

You can use dynamic like this:

dynamic myObj = SomeMethod();
myObj.DoSomething();
myObj.Method1();

But you must be careful when you are using dynamic.Because if you call a method or property which doesn't exist you will get a RuntimeBinderException in runtime.

And last thing I want to mention, dynamic and object can be parameter type, but var can't. For example you can do this:

public void SomeMethod(dynamic arg1)

But you can't do this:

public void SomeMethod(var arg1)

Because var is not a type rather it's a syntactic sugar to let the compiler infer the type for you.

Clump

This is by far the best answer it this post. Unfortunate that both the accepted answer and the highest rating answer both contains mistakes, while the best answer has such a lower score in comparison. – Beechnut

Answer 4

Object is the root class that all .net objects derive from.

var is used as a shortcut if you don't want to write say string x = "a", but instead write var x = "a". It only works if the compiler can figure out what you mean.

dynamic implies that what you do with the object is only evaulated at runtime (x.StrangeMethod() will not cause a compile error, even if the method does not exist), useful when interacting with scripting languages.

Exeter

Answer 5

It’s pretty simple…

Object is a base type in .NET. All others types are inherit from it. So variable of object type can contain everything. But it should be done only there are no other options, for the following reasons:

1. Before read/write to this variable we have to done unboxing/boxing operations, which are expensive.

2. Compiler can’t do type checking at compile time that may result bugs and exceptions at run time. For example this code will be compiled successfully but throw an exception at run time:

   object o = "2"; 
   int i = 1 + (int)o;
   

Var is not a type, but the instruction for the compiler to conclude a variable type from the program context. It needed for anonymous methods but also can be used everywhere you wish. Beware only your program not became hard to read. The compiler makes its decision at compile time so it will not any influence on program efficiency.

Dynamic – is a special type for which the compiler don’t do type checking at compile time. The type is specified at run time by CLR. This is static (!) type and after the variable type is specified, it can not later be changed. We should use this type only there are no other options for similar reasons with object type:

1. There is an addition operation to specify the type at run time - which reduces the program efficiency.

2. Compiler don’t perform type checking that may result bugs and exceptions at run time.

Godsend

Answer 6

A summery of the difference between Object, Var, and Dynamic type. In case you don't understand the concepts in each table row cell, please refer it somewhere else. Source: https://www.dotnettricks.com/learn/csharp/differences-between-object-var-and-dynamic-type

Asternal

Answer 7

Object

Base object of .net, most of the time you will not need to use it.

Var

Just a syntactic sugar, whenever you use var, the variable type would be decided in compile time according to the value assigned to it.

Dynamic

Comes from the DLR part of .net, you will only need it when you want to use a non strong type typing.

Rocambole

Answer 8

Following are the difference between System.Object , dynamic and var.

Everything in .net is derived from System.Object type. But if you looking for specific difference, here are they.

Difference between Object and dynamic.

1.You cannot implicitly cast a variable of type Object into any other type. Compiler will not let you do that. On the other hand you can implicitly cast any type to dynamic. Compiler will not complain because casting will be performed during run time and exception, if required will raised during run time. 2.Because dynamic is same as object, You cannot write overloaded methods which differ in Object and dynamic in arguments.

Difference between dynamic and var.

1.Declaring a local variable as dynamic or var has only syntactical difference. 2. You cannot declare a variable of type var without initializing it, But you can do that for a dynamic variable 3. You cannot use a var variable to pass as method argument or return from a method. 4. You cannot a cast an expression to var but you can do it for a dynamic variable.

Jerrybuilt

Best answer so far... all other answer are saying the same thing about object : "base type in .net shit" ... but the guy just asked for THE DIFFERENCE between Dynamic and Object ... he did not ask for the definition of object... – Ormazd

Answer 9

compiler says var is contextual keyword used for variable declaration. that is why we need to assign a value at the time of declaration. compiler then checks for their datatype and treat it in the same way. In this way compiler knows everything about that variable and implies type safety on it.

Tollefson

Answer 10

In C#, var, dynamic, and object are all used for different purposes and have distinct characteristics. Here's a brief explanation of each with code examples:

var:

var is a strongly typed variable declaration. The compiler determines the variable's type based on the assigned expression. The type is known at compile time, and once assigned, it cannot be changed. Example:

var number = 42; // 'number' is of type 'int'
var name = "John"; // 'name' is of type 'string'

dynamic:

dynamic is a type that is resolved at runtime, allowing late binding. It is not checked by the compiler for type safety at compile time, which can lead to runtime errors if used incorrectly. Example:

dynamic dynamicVar = 42; // 'dynamicVar' can change its type at runtime
dynamicVar = "John"; // Now 'dynamicVar' is a string

object:

object is a base type for all C# types and allows you to store objects of any type. It is a reference type and provides a high degree of flexibility, but type safety is reduced. Example:

object obj = 42; // 'obj' is an 'int' boxed into an 'object'
obj = "John"; // 'obj' can be changed to a string

// To use 'obj' as its original type, you need to cast it:
int num = (int)obj;

Counterpart