object obj = 10;
            Console.WriteLine(obj.GetType());
            // 使用object類型此時需要強制類型轉換，不能編譯器會出現(xiàn)編譯錯誤
            obj = (int)obj + 10;

            dynamic dynamicnum = 10;
            Console.WriteLine(dynamicnum.GetType());
            // 對于動態(tài)類型而言，編譯時編譯器根本不知道它是什么類型，
            // 所以編譯器就判斷不了dynamicnum的類型了，所以下面的代碼不會出現(xiàn)編譯時錯誤
            // 因為dynamicnum有可能是int類型，編譯器不知道該變量的具體類型不能憑空推測類型
            // 當然也就不能提示我們編譯時錯誤了
            dynamicnum = dynamicnum + 10;

            dynamic dyn = 5;
            Console.WriteLine(dyn.GetType());
            dyn = "test string";
            Console.WriteLine(dyn.GetType());
            dynamic startIndex = 2;
            string substring = dyn.Substring(startIndex);
            Console.WriteLine(substring);
            Console.Read();

            // 引入動態(tài)類型之后
        // 可以在C#語言中與動態(tài)語言進行交互
        // 下面演示在C#中使用動態(tài)語言Python
            ScriptEngine engine = Python.CreateEngine();
            Console.Write("調用Python語言的print函數(shù)輸出: ");
            // 調用Python語言的print函數(shù)來輸出
            engine.Execute("print 'Hello world'");
            Console.Read();

 class Program
    {
        static void Main(string[] args)
        {
            dynamic text = "test text";
            int startIndex = 2;
            string substring = text.Substring(startIndex); 
            Console.Read();
        }
    }

private static void Main(string[] args)
{
    object text = "test text";
    int startIndex = 2;
    if (<Main>o__SiteContainer0.<>p__Site1 == null)
    {
        // 創(chuàng)建用于將dynamic類型隱式轉換為字符串的調用點
        <Main>o__SiteContainer0.<>p__Site1 = CallSite<Func<CallSite, object, string>>.Create(Binder.Convert(CSharpBinderFlags.None, typeof(string), typeof(Program)));
    }
    if (<Main>o__SiteContainer0.<>p__Site2 == null)
    {
        // 創(chuàng)建用于調用Substring函數(shù)的調用點
        <Main>o__SiteContainer0.<>p__Site2 = CallSite<Func<CallSite, object, int, object>>.Create(Binder.InvokeMember(CSharpBinderFlags.None, "Substring", null, typeof(Program), new CSharpArgumentInfo[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null), CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.UseCompileTimeType, null) }));
    }
    
    // 調用調用點，首先調用<>p_Site2,即Substring方法，再調用<>P_Site1來將結果進行轉換
    string substring = <Main>o__SiteContainer0.<>p__Site1.Target(<Main>o__SiteContainer0.<>p__Site1, <Main>o__SiteContainer0.<>p__Site2.Target(<Main>o__SiteContainer0.<>p__Site2, text, startIndex));
    Console.Read();
}

//編譯器生成的內嵌類型為
[CompilerGenerated]
private static class <Main>o__SiteContainer0
{
    // Fields
    public static CallSite<Func<CallSite, object, string>> <>p__Site1;
    public static CallSite<Func<CallSite, object, int, object>> <>p__Site2;
}

var numbers = Enumerable.Range(10, 10);
            dynamic number = 4;
            var error = numbers.Take(number);  // 編譯時錯誤

            // 通過下面的方式來解決這個問題
            // 1. 將動態(tài)類型轉換為正確的類型
            var right1 = numbers.Take((int)number);
            // 2. 用調用靜態(tài)方法的方式來進行調用
            var right2 = Enumerable.Take(numbers, number);

dynamic lambdarestrict = x => x + 1; // 編譯時錯誤
            // 解決方案
            dynamic rightlambda =(Func<int,int>)( x=>x+1);

            dynamic methodrestrict = Console.WriteLine; // 編譯時錯誤
            // 解決方案
            dynamic rightmethod =(Action<string>)Console.WriteLine;

  dynamic s = new dynamic();

 // 基類不能為dynamic 類型
    class DynamicBaseType : dynamic
    {
    }
    // dynamic類型不能為類型參數(shù)的約束
    class DynamicTypeConstrain<T> where T : dynamic
    { 
    }
    // 不能作為所實現(xiàn)接口的一部分
    class DynamicInterface : IEnumerable<dynamic>
    {
    }

 static void Main(string[] args)
        {  
            dynamic dynamicobj2 = new DynamicType2();
            dynamicobj2.Call();
            Console.Read();
}
public class DynamicType2 : IDynamicMetaObjectProvider
    {
        public DynamicMetaObject GetMetaObject(Expression parameter)
        {
            Console.WriteLine("開始獲得元數(shù)據(jù)......");
            return new Metadynamic(parameter,this);
        }
    }

    // 自定義Metadynamic類
    public class Metadynamic : DynamicMetaObject
    {
        internal Metadynamic(Expression expression, DynamicType2 value)
            : base(expression, BindingRestrictions.Empty, value)
        {
        }
        // 重寫響應成員調用方法
        public override DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args)
        {
            // 獲得真正的對象
            DynamicType2 target = (DynamicType2)base.Value;
            Expression self = Expression.Convert(base.Expression, typeof(DynamicType2));
            var restrictions = BindingRestrictions.GetInstanceRestriction(self, target);
            // 輸出綁定方法名
            Console.WriteLine(binder.Name + " 方法被調用了");
            return new DynamicMetaObject(self, restrictions);
        }
    }