《Effective C#》快速筆記 - C# 中的動態編程靜態類型和動態類型各有所長，靜態類型能夠讓編譯器幫你找出更多的錯誤，因為編譯器能夠在編譯時進行大部分的檢查工作。C# 是一種靜態類型的語言，不過它加入了動態類型的語言特性，可以更高效地解決問題。本系列《Effective C#》快速筆 ...

《Effective C#》快速筆記 - C# 中的動態編程

　　靜態類型和動態類型各有所長，靜態類型能夠讓編譯器幫你找出更多的錯誤，因為編譯器能夠在編譯時進行大部分的檢查工作。C# 是一種靜態類型的語言，不過它加入了動態類型的語言特性，可以更高效地解決問題。　　

本系列

　　《Effective C#》快速筆記（一）- C# 語言習慣

　　《Effective C#》快速筆記（二）- .NET 資源托管

　　《Effective C#》快速筆記（三）- 使用 C# 表達設計

　　《Effective C#》快速筆記（四） - 使用框架

　　《Effective C#》快速筆記（五） - C# 中的動態編程

一、目錄

三十八、理解動態類型的優劣
三十九、使用動態類型表達泛型類型參數的運行時類型
四十、將接受匿名類型的參數聲明為 dynamic
四十一、用 DynamicObject 或 IDynamicMetaObjectProvider 實現數據驅動的動態類型
四十二、如何使用表達式 API
四十三、使用表達式將延遲綁定轉換為預先綁定
四十四、儘量減少在公有 API 中使用動態類型

三十八、理解動態類型的優劣

C# 動態類型是為了讓靜態代碼能夠更加平滑地與其他使用動態類型的環境進行交互，而不是鼓勵在一般場景中使用 dynamic 進行動態編程。
只要對象在運行時包含成員，那麼即可正常使用。
若是一個操作數（包括 this）為動態類型，那麼返回結果也會是動態類型。不過，最後依然要轉換成靜態類型，以便被其它 C# 代碼所使用，以及被編譯器感知。
當你需要不知道具體類型的運行時解析方法的時候，動態類型是最佳的工具。如果你能在編譯期間明確類型，那麼可以使用 lambda 表達式和函數式編程來解決問題。
表達式樹，一種在運行時創建代碼的方法（下麵提供示例）。
大多數情況，可以使用 Lambda 表達式創建泛型 API，讓調用者自己動態定義所需要執行的代碼即可。
優先使用靜態類型，靜態類型比動態類型更高效，動態類型和在運行時創建表達式樹都會帶來性能上的影響，即便這點影響微不足道。
若你能控製程序中所有涉及的類型時，可以引入一個介面，而不是動態類型，即基於介面編程，並讓所有需要支持該介面行為的類型都實現該介面。通過 C# 類型系統可以減少代碼在運行時所產生的錯誤，編譯器也能夠生成更加高效的代碼。
動態類型做法的效率比純粹的靜態類型下降挺大，但實現的難度卻比解析表達式樹要簡單地挺多。

　　這裡，我使用 3 種數字相加的方法，dynamic 動態、Func 委托以及使用表達式樹進行相加的區別：

        [TestMethod]
        public void Test()
        {
            var result1 = AddDynamic(2, 3);
            Console.WriteLine((int)result1);

            var result2 = AddFunc(3, 4, (x, y) => x + y);
            Console.WriteLine(result2);

            var result3 = AddExpressionTree(4, 5);
            Console.WriteLine(result3);
        }

        /// <summary>
        /// Add，動態
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        private dynamic AddDynamic(dynamic a, dynamic b)
        {
            return a + b;
        }

        /// <summary>
        /// Add，使用委托
        /// </summary>
        /// <typeparam name="T1"></typeparam>
        /// <typeparam name="T2"></typeparam>
        /// <typeparam name="TR"></typeparam>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="func"></param>
        /// <returns></returns>
        private TR AddFunc<T1, T2, TR>(T1 a, T2 b, Func<T1, T2, TR> func)
        {
            return func(a, b);
        }

        /// <summary>
        /// Add，使用表達式樹
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        private T AddExpressionTree<T>(T a, T b)
        {
            ParameterExpression leftOperand = Expression.Parameter(typeof(T), "left");
            ParameterExpression rightOperand = Expression.Parameter(typeof(T), "right");
            BinaryExpression body = Expression.Add(leftOperand, rightOperand);
            Expression<Func<T, T, T>> adder = Expression.Lambda<Func<T, T, T>>(body, leftOperand, rightOperand);

            Func<T, T, T> theDelegate = adder.Compile();
            return theDelegate(a, b);
        }
    }

三十九、使用動態類型表達泛型類型參數的運行時類型

System.Linq.Enumerable.Cast<T> 將序列中的對象轉換成 T，從而使得 LINQ 可以配合 IEnumerable 進行工作。
Convert<T> 要比 Cast<T> 適用性更廣，但同時也會執行更多的工作。

四十、將接受匿名類型的參數聲明為 dynamic

不要過度使用動態類型，因為動態調用會增加系統的額外開銷，即便不大。
長遠來看，具體類型更易於維護，編譯器和類型系統也會為其提供更好的支持。
擴展方法不能基於動態對象定義。

四十一、用 DynamicObject 或 IDynamicMetaObjectProvider 實現數據驅動的動態類型

創建帶有動態功能的類型的最簡單的方法就是繼承 System.Dynamic.DynamicObject。若能直接繼承 DynamicObject，那麼創建動態類就會比較簡單。
實現 IDynamicMetaObjectProvider 就意味著需要實現方法 GetmetaObject()。
創建動態類型時首選繼承，如果必須使用其他基類，可以手工實現 IDynamicMetaObjectProvider 介面，雖然所有的動態類型都會帶來性能上的損失，但這種手工實現介面的方式所帶來的損失往往更大一些。

　　這是一個實現動態類型模型的一個示例。除了需要繼承 DynamicObject，還需要重寫 TryGetMemebr() 和 TrySetMemebr()。

        [TestMethod]
        public void Test1()
        {
            dynamic propDynamic = new DynamicPropertyBag();
            propDynamic.Now = DateTime.Now;

            Console.WriteLine(propDynamic.Now);
        }

        /// <summary>
        /// 動態屬性綁定模型
        /// </summary>
        internal class DynamicPropertyBag : DynamicObject
        {
            private readonly Dictionary<string, object> _storage = new Dictionary<string, object>();

            /// <summary>
            /// 獲取屬性值
            /// </summary>
            /// <param name="binder"></param>
            /// <param name="result"></param>
            /// <returns></returns>
            public override bool TryGetMember(GetMemberBinder binder, out object result)
            {
                var key = binder.Name;

                if (_storage.ContainsKey(key))
                {
                    result = _storage[key];
                    return true;
                }

                result = null;
                return false;
            }

            /// <summary>
            /// 設置屬性值
            /// </summary>
            /// <param name="binder"></param>
            /// <param name="value"></param>
            /// <returns></returns>
            public override bool TrySetMember(SetMemberBinder binder, object value)
            {
                var key = binder.Name;

                try
                {
                    if (_storage.ContainsKey(key))
                    {
                        _storage[key] = value;
                    }
                    else
                    {
                        _storage.Add(key, value);
                    }

                    return true;
                }
                catch (Exception e)
                {
                    Console.WriteLine(e);
                    return false;
                }
            }

四十二、如何使用表達式 API

傳統的反射 API 可以用表達式和表達式樹進行更好的替代，表達式可以直接編譯為委托。
介面使我們可以得到一個更為清晰、也更具可維護性的系統，反射是一個很強大的晚期綁定機制（雖然效率有所降低），.NET 框架使用它來實現 Windows 控制項和 Web 控制項的數據綁定。

　　這裡提供了一個示例：

        [TestMethod]
        public void Test2()
        {
            var result = Call<int, string>((x) => (x * 2).ToString("D"));

            Console.WriteLine(result);
        }

        /// <summary>
        /// 調用
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="TResult"></typeparam>
        /// <param name="op"></param>
        /// <returns></returns>
        private TResult Call<T, TResult>(Expression<Func<T, TResult>> op)
        {
            var exp = op.Body as MethodCallExpression;
            var result = default(TResult);

            if (exp == null)
            {
                return result;
            }

            var methodName = exp.Method.Name;
            var parameters = exp.Arguments.Select(ProcessArgument);

            Console.WriteLine($"方法名 {methodName}");

            foreach (var parameter in parameters)
            {
                Console.WriteLine("參數：");
                Console.WriteLine($"\t{parameter.Item1}：{parameter.Item2}");
            }

            return result;
        }

        /// <summary>
        /// 處理參數
        /// </summary>
        /// <param name="expression"></param>
        /// <returns></returns>
        private Tuple<Type, object> ProcessArgument(Expression expression)
        {
            object arg = default(object);
            LambdaExpression l = Expression.Lambda(Expression.Convert(expression, expression.Type));

            Type parmType = l.ReturnType;
            arg = l.Compile().DynamicInvoke();

            return Tuple.Create(parmType, arg);
        }

四十三、使用表達式將延遲綁定轉換為預先綁定

延遲綁定API要使用符號（symbol）信息來實現，而預先編譯好的 API 則無需這些信息，表達式 API 正是二者之間的橋梁。
延遲綁定常見於 Silverlight 和 WPF 中使用的屬性通知介面，通過實現 INotifyPropertyChanged 和 INotifyPropertyChanging 介面來實現屬性變更的預綁定。

四十四、儘量減少在公有 API 中使用動態類型

優先使用 C# 的靜態類型，並儘可能地降低動態類型的作用範圍。若是想一直使用動態特性，你應該直接選用一種動態語言，而非 C#。
若要在程式中使用動態特性，請儘量不要在公有介面中使用，這樣會將動態類型限制在一個單獨的對象（或類型）中。

【博主】反骨仔

【原文】http://www.cnblogs.com/liqingwen/p/6816100.html

【GitHub】https://github.com/liqingwen2015/XMind 可以下載 XMind

【參考】《Effective C#》

【參考】http://blog.csdn.net/w174504744/article/details/50562109

[.NET] 《Effective C#》快速筆記 - C# 中的動態編程