// C# is a strongly typed language. This means that when the program is compiled the compiler ensures that all actions that are performed are valid in the context of
// the types that have been defined in the program.As an example, if a class does not contain a method with a particular name, the C# compiler will refuse to
// generate a call to that method.As a way of making sure that C# programs are valid at the time that they are executed, strong typing works very well.Such a
// strong typing regime, however, can cause problems when a C# program is required to interact with systems that do not have their origins in C# code. Such
// situations arise when using Common Object Model(COM) interop, the Document Object Model(DOM), working with objects generated by C#
// reflection, or when interworking with dynamic languages such as JavaScript. In these situations, you need a way to force the compiler to interact with
// objects for which the strong typing information that is generated from compiled C# is not available. The keyword dynamic is used to identify items for which
// the C# compiler should suspend static type checking. The compiler will then generate code that works with the items as described, without doing static
// checking to make sure that they are valid.Note that this doesn’t mean that a program using dynamic objects will always work; if the description is incorrect
// the program will fail at run time.
public void DynamicTypes()
{
MessageDisplay m = new MessageDisplay();
m.Display("Hello");
dynamic d = new MessageDisplay();
d.MethodThatDoesNotExist("Hello");
//This program will compile, but when the program is executed an exception will be generated when the method is called.
// This aspect of the dynamic keyword makes it possible to interact with objects that have behaviors, but not the C# type information that the C# compiler would
// normally use to ensure that any interaction is valid.
}
