Contrary to what many people think about
dynamic it does not make the variables untyped, this keyword only indicates that the compiler should not check its type. C # is a static typing language (this is the correct term, there is also a lot of confusion about it) and variables can only have one type. What can happen is that the variable can have its type changed, and that's why the compiler check needs to be turned off. This can be verified with this code:
dynamic x = 1;
x = "oi";
View the demonstration in dotNetFiddle .
If in C # I have a variable that accepts any value, in what situation should it be used?
It is built for interoperability with other languages that have dynamic typing and with external APIs (for COM, for example) that do not type your data. It was made for use with reflection in some cases where dynamism is important. An example is in the question How to dynamically create properties in C #? or Pick values from a dynamic list . You have a question showing the different ways to handle when you do not know exactly what kind and
dynamic should be avoided.
In a way, it loses type security since the compiler is prevented from doing any checking. Several things are tricky to use when abusing
dynamic . This already occurs in dynamic typing languages, but people get used to it. When you mix the two things, it gets really complicated. Most C # features were designed for use with static typing; when a dynamic type comes in some things may not work as expected, although language creators have done a good job of mitigating most cases that would be weird. / p>
And why does not the language just use it as a variable type since it accepts all values?
It is a matter of the philosophy of the language of mater to type security. When you start using this, it is your responsibility to ensure that the type is always correct. Or by observing in the code or even writing code that guarantees this. If you use something wrong you will get an exception for a programming error that is not ideal. There has to be a lot more code.
var has been created so the type can be inferred , that is, it normally works as all sorts, just do not need to type the type name in the statement, the compiler finds out alone.
You can also use the type
object , the variable of this type can receive values of any type because all types are descendents of
object . Only you would need casting to access the members of the actual type of the object. The compiler protects you from accessing members that are not of the declared type. If you try to access direct by type
object you can only access the members of this type . Not ideal. The
dynamic has the advantage precisely by preventing the compiler from checking if the members are available, it accepts everything.
If you think using this feature is beneficial to generalized use of language - a lot of people do not think - then maybe C # is not the best language for you. If you want to continue in .Net it would be better to use VB.Net (it's not that dynamic) or IronPython (not supported), just to give two examples. But to tell you the truth if you want something dynamic yourself, I think it's best to forget. Net, you can use it, but it was not meant to be used this way.
To use C # you need to identify yourself with static typing. It has advantages and disadvantages. You have to choose what you want. C # put this facility to a specific goal, but to change the philosophy of language. I even thought I could use it in a more dynamic way since I've been using more languages with dynamic typing all my life, but I realized that it would be a mistake, or how the language was projected, or give it up.