dynamic vs object type
Solution 1
They're hugely different.
If you use dynamic
you're opting into dynamic typing, and thus opting out of compile-time checking for the most part. And yes, it's less performant than using static typing where you can use static typing.
However, you can't do much with the object
type anyway - it has hardly any members. Where do you find yourself using it? When you want to write general purpose code which can work with a variety of types, you should usually consider generics rather than object
.
Solution 2
With the advancement in C# language, we have seen the dynamic and object types. Here are the two types, as I learned by comparing these 7 points:
Object
- Microsoft introduced the Object type in C# 1.0.
- It can store any value because "object" is the base class of all types in the .NET framework.
- Compiler has little information about the type.
- We can pass the object type as a method argument, and the method also can return the object type.
- We need to cast object variables to the original type to use it and to perform desired operations.
- Object can cause problems at run time if the stored value is not converted or cast to the underlying data type.
- Useful when we don't have more information about the data type.
Dynamic
- Dynamic was introduced with C# 4.0
- It can store any type of variable, similar to how Visual Basic handles a variable.
- It is not type-safe, i.e., the compiler doesn't have any information about the type of variable.
- A method can both accept a Dynamic type as an argument and return it.
- Casting is not required, but you need to know the properties and methods related to stored type.
- The Dynamic type can cause problems if the wrong properties or methods are accessed because all the information about the stored value is resolved at run time, compared to at compilation.
- Useful when we need to code using reflection or dynamic languages or with the COM objects due to writing less code.
Hopefully, this would help somebody.
Solution 3
In simple language:
Assume we have the following method:
public static void ConsoleWrite(string inputArg)
{
Console.WriteLine(inputArg);
}
Object: the following code has compile error unless cast object to string:
public static void Main(string[] args)
{
object obj = "String Sample";
ConsoleWrite(obj);// compile error
ConsoleWrite((string)obj); // correct
Console.ReadKey();
}
dynamic: the following code compiles successfully but if it contains a value except string
it throws Runtime error
public static void Main(string[] args)
{
dynamic dyn = "String Sample";
ConsoleWrite(dyn); // correct
dyn = 1;
ConsoleWrite(dyn);// Runtime Error
Console.ReadKey();
}
Solution 4
There is an article explaining the different types, including object and dynamic types. The article also explains the difference between the two with a nice example.
https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/reference-types
I shall give a short gist of the difference explained in the article:
The object type is an alias for System.Object in .NET. In the unified type system of C#, all types, predefined and user-defined, reference types and value types, inherit directly or indirectly from System.Object. You can assign values of any type to variables of type object.
The dynamic type indicates that use of the variable and references to its members bypass compile-time type checking. Instead, these operations are resolved at run time. The dynamic type simplifies access to COM APIs such as the Office Automation APIs, to dynamic APIs such as IronPython libraries, and to the HTML Document Object Model (DOM).
Type dynamic behaves like type object in most circumstances. In particular, any non-null expression can be converted to the dynamic type. The dynamic type differs from object in that operations that contain expressions of type dynamic are not resolved or type checked by the compiler. The compiler packages together information about the operation, and that information is later used to evaluate the operation at run time. As part of the process, variables of type dynamic are compiled into variables of type object. Therefore, type dynamic exists only at compile time, not at run time.
Summary:
What this essentially means is object is a type and all other types inherit from it. Dynamic is not really a type, it is more like a pointer or representation of some other type, which will be resolved at run time.
Luke101
Updated on June 06, 2022Comments
-
Luke101 about 2 years
I have used the dynamic and the object type interchangeably. Is there any difference between these two types? Is there any performance implications of using one over the other? Which one of these is more flexible?
-
Steven Sudit almost 14 yearsIf Luke just called the handful of methods available in
System.Object
, would they also be called dynamically? -
Jon Skeet almost 14 years@Steven: Yes, it does - even for
GetType
which is non-virtual! (You can set a delegate to react toGetType
calls onExpandoObject
, for example. Scary stuff.) -
Steven Sudit almost 14 yearsThat's what I was afraid of. Looks like we'd need to "box" a
dynamic
by upcasting toobject
if we even want to know the truth about its type. :-) -
Jon Skeet almost 14 years@Steven: That wouldn't perform any actual boxing. It might involve a dynamic attempt at conversion, but the underlying field (or local variable) type for a dynamic variable is already
object
. -
Steven Sudit almost 14 yearsYes, that's why I put "box" in scare-quotes. I meant assigning the
dynamic
instance to anobject
alias to avoid the run-time check when callingGetType
. But now that you mention it, there's no reason to think that the cast will be performed statically. Perhaps it could try to define an implicit conversion! -
Nanomurf over 6 yearsIt is my understanding that var is not a type at all -- it just implicitly decides the type based on the initialized value. For example: var x = 2; x is NOT a var type, it is an int type.
-
Navjyot over 5 yearsThen Doesn't dynamic makes C# type unsafe ?
-
MVijayvargia about 2 yearsFor dynamic also it will not throw error as you mentioned in your last sample. it will compile and return same result as it would for object type. check here: dotnetfiddle.net/l5K4Cl