static void Main(string[] args)
{
dynamic dyn = 1;
object obj = 1;
// Rest the mouse pointer over dyn and obj to see their
// types at compile time.
Console.WriteLine(dyn.GetType());
Console.WriteLine(obj.GetType());
dyn = dyn + 3;
//obj = obj + 3;//CTE
ExampleClass ec = new ExampleClass();
// The following line causes a compiler error if exampleMethod1 has only
// one parameter.
//ec.exampleMethod1(10, 4);
dynamic dynamic_ec = new ExampleClass();
// The following line is not identified as an error by the
// compiler, but it causes a run-time exception.
//dynamic_ec.exampleMethod1(10, 4);
// The following calls also do not cause compiler errors, whether
// appropriate methods exist or not.
//dynamic_ec.someMethod("some argument", 7, null);
dynamic_ec.exampleMethod2("some argument");
dynamic_ec.nonexistentMethod();
}
static void Main(string[] args)
{
//For example, if instance method exampleMethod1 in the following code has only one parameter,
//the compiler recognizes that the first call to the method, ec.exampleMethod1(10, 4),
//is not valid because it contains two arguments.The call causes a compiler error.
//The second call to the method, dynamic_ec.exampleMethod1(10, 4), is not checked by the
//compiler because the type of dynamic_ec is dynamic.Therefore, no compiler error is reported.
//However, the error does not escape notice indefinitely.It is caught at run time and causes a
//run-time exception.
ExampleClass ec = new ExampleClass();
// The following call to exampleMethod1 causes a compiler error
// if exampleMethod1 has only one parameter. Uncomment the line
// to see the error.
//ec.exampleMethod1(10, 4);
dynamic dynamic_ec = new ExampleClass();
// The following line is not identified as an error by the
// compiler, but it causes a run-time exception.
dynamic_ec.exampleMethod1(10, 4);
// The following calls also do not cause compiler errors, whether
// appropriate methods exist or not.
dynamic_ec.someMethod("some argument", 7, null);
dynamic_ec.nonexistentMethod();
//Conversions
//Conversions between dynamic objects and other types are easy.
//This enables the developer to switch between dynamic and non - dynamic behavior.
//Any object can be converted to dynamic type implicitly, as shown in the following examples.
dynamic d1 = 7;
dynamic d2 = "a string";
dynamic d3 = System.DateTime.Today;
dynamic d4 = System.Diagnostics.Process.GetProcesses();
//Conversely, an implicit conversion can be dynamically applied to any expression of type dynamic.
int i = d1;
string str = d2;
DateTime dt = d3;
System.Diagnostics.Process[] procs = d4;
//Overload resolution with arguments of type dynamic
//Overload resolution occurs at run time instead of at compile time if one or more of the arguments
//in a method call have the type dynamic, or if the receiver of the method call is of type dynamic.
//In the following example, if the only accessible exampleMethod2 method is defined to take a
//string argument, sending d1 as the argument does not cause a compiler error, but it does cause
//a run-time exception.Overload resolution fails at run time because the run - time type of d1 is int,
//and exampleMethod2 requires a string.
// Valid.
ec.exampleMethod2("a string");
// The following statement does not cause a compiler error, even though ec is not
// dynamic. A run-time exception is raised because the run-time type of d1 is int.
ec.exampleMethod2(d1);
// The following statement does cause a compiler error.
//ec.exampleMethod2(7);
//Further Reference
//https://docs.microsoft.com/en-us/dotnet/framework/reflection-and-codedom/dynamic-language-runtime-overview
//https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/types/walkthrough-creating-and-using-dynamic-objects
//https://visualstudiomagazine.com/Articles/2011/02/01/Understanding-the-Dynamic-Keyword-in-C4.aspx
//Use of Dynamic
//https://stackoverflow.com/questions/2690623/what-is-the-dynamic-type-in-c-sharp-4-0-used-for
//var v/s dynamic
//References: https://www.c-sharpcorner.com/UploadFile/f0b2ed/dynamic-data-type-in-C-Sharp/
// https://www.c-sharpcorner.com/UploadFile/b1df45/var-vs-dynamic-keywords-in-C-Sharp/
//1. Need of initialization for var is required at the time of declaration;
//In the case of dynamicthere is no need to initialize at the time of declaration.
dynamic dynamicVariable;
dynamicVariable = "No Initialization Required.";
//Error
//var varVariable;
//varVariable = "Initialization Required";
//2. Multiple Initialization with different Data Type
//We can not change the data type for a var keyword.It means if we assign the integer
//value at time of declaration then further we can assign string, double,
//or other data type value for var keyword.
//In case of dynamic type there are no such types of restrictions,
//we can assign different types of value for dynamic type variable.
dynamic dynamicVariable2 = "Initialized as String";
dynamicVariable2 = 5; //Then a number is Assigned
//Error
var varVariable = "Initialized as String";
//varVariable = 5; //Then a number is Assigned
}