C# 泛型中的資料型別判定與轉換
提到型別轉換，首先要明確C#中的資料型別，主要分為值型別和引用型別：
1.常用的值型別有：（struct）
整型家族：int，byte，char，short，long等等一系列
浮點家族：float，double，decimal
孤獨的列舉：enum
孤獨的布林：bool
2.常用的引用型別有：
string，class，array，delegate，interface
值得注意的是，無論是值型別還是引用型別，在C#中都派生於object，沒錯，這傢伙就是萬惡之源！
正是因為有了這一特性，於是我們才能通過裝箱和拆箱愉快地將這些資料型別在值型別，object，引用型別間反覆橫跳。
當然了，無論是裝箱和拆箱，對於效能都是有消耗的，不到萬不得已的時候儘量不要用（雖然我才不管這些，只要我用的爽就行了233）
雖然一般不提倡用object型別作為函式引數，取而代之使用泛型成為首選，那麼如何判斷泛型引數的具體資料型別並進行有效轉換呢？
比如下面的例子：
1 [System.Serializable]
2 public struct Property<T> where T : struct
3 {
4 public string Label { get; }
5 public T Value { get; }
6 public PropertyType Type { get; }
7 public Property(string label, T value, PropertyType type = PropertyType.Sub)
8 {
9 Label = label;
10 Value = value;
11 Type = type;
12 }
13
14 public static Property<T> operator +(Property<T> a, Property<T> b)
15 {
16 var prop = new Property<T>();
17 if (a.Label == b.Label && a.Type == b.Type)
18 {
19 //怎麼知道這個值到底是int還是float...
20 }
21 return prop;
22 }
23 }1 public enum PropertyType
2 {
3 Main,
4 Sub
5 }
定義了一個名叫「屬性」的結構體，包含標籤，具體值和屬性類別（是主屬性還是副屬性），並使用泛型約束資料為值型別。
現在想要快速對這個結構體進行加法操作，於是增加操作符過載函式，方便愉快的對兩個屬性的值相加，但問題是泛型是無法強轉為任何一種非object資料型別，直接相加則更是不可能。
這時就想到了以object型別作為橋樑，進行具體的型別判定與轉換：
1 public static Property<T> operator +(Property<T> a, Property<T> b)
2 {
3 if (a.Label == b.Label && a.Type == b.Type)
4 {
5 object tempa = a.Value;
6 object tempb = b.Value;
7
8 object add;
9 if (tempa is int)
10 {
11 add = (int)tempa + (int)tempb;
12 }
13 else if (tempa is float)
14 {
15 add = (float)tempa + (float)tempb;
16 }
17 //...其他型別
18 else
19 {
20 return new Property<T>();
21 }
22
23 return new Property<T>(a.Label, (T)add, a.Type);
24 }
25 return new Property<T>();
26 }判定型別時可以使用is關鍵字，也可直接取得值的型別或泛型型別進行判定：
1 if (tempa.GetType() == typeof(float))
2 {
3
4 }
5 //or
6 if (typeof(T) == typeof(float))
7 {
8
9 }
上面的方案雖然可以解決型別轉換的需求，但頻繁的拆箱和裝箱以及型別判定對效能的還是有一定影響，而且如果每一種型別都寫進if-else，看上去像千層塔一般難受。是時候輪到dynamic登場了。
.Net 4.0 以後開始支援動態資料型別——也就是dynamic關鍵字；令人興奮的是，dynamic可以被賦值為任何一種型別的值，當然也包括泛型。
然而值得注意的是，dynamic關鍵字並不會在程式編譯的時候進行校驗，而只在執行時動態判定，所以使用的時需要格外小心。
當然了，多次執行時的效能要遠遠高於裝箱和拆箱，而且書寫起來也是相當簡潔美觀(¯﹃¯)：
1 public static Property<T> operator +(Property<T> a, Property<T> b)
2 {
3 if (a.Label == b.Label && a.Type == b.Type)
4 {
5 dynamic x1 = a.Value;
6 dynamic x2 = b.Value;
7 return new Property<T>(a.Label, (T)(x1 + x2), a.Type);
8 }
9 return new Property<T>();
10 }
可以直接執行相加操作，但如果實際傳入的兩個資料型別並不能相加如bool，則會在執行時報錯；當然了，如果想進一步防止安全，還可以增加更多的型別判定語句，如：
1 public static Property<T> operator +(Property<T> a, Property<T> b)
2 {
3 if (a.Label == b.Label && a.Type == b.Type)
4 {
5 if (typeof(T) != typeof(bool) && typeof(T)!=typeof(Enum))
6 {
7 dynamic x1 = a.Value;
8 dynamic x2 = b.Value;
9 return new Property<T>(a.Label, (T)(x1 + x2), a.Type);
10 }
11 }
12 return new Property<T>();
13 }
補充一句，dynamic關鍵字在Unity中可能會報錯，因為Unity預設用的是.Net Api為2.0版本，需要升級為4.0之後的版本才能使用該關鍵字，具體設定如下：
下面做一個簡單測試：
1 using UnityEngine;
2
3 public class MicrosoftCSharpTest : MonoBehaviour
4 {
5 void Start()
6 {
7 dynamic a = 5.1f;
8 dynamic b = 3;
9 Debug.Log(a + b);
10
11 var hp1 = new Property<int>("Hp", 41);
12 var hp2 = new Property<int>("Hp", 5);
13 var hp = hp1 + hp2;
14 Debug.Log(hp.Label + " : " + hp.Value);
15
16 var miss1 = new Property<float>("MissRate", .1f);
17 var miss2 = new Property<float>("MissRate", .05f);
18 var miss = miss1 + miss2;
19 Debug.Log(miss.Label + " : " + miss.Value);
20 }
21 }