轉換動態對象來動態類型的在c＃

Question

陣列我有2種類型：

public class Type1 
    { 
     public string Name { get; set; } 
    } 

    public class Type2 
    { 
     public string Name { get; set; } 
    } 

我有元素的列表（每個元素是一個對象類型）。有些元素可能是數組。 （陣列可以是TYPE1 []或2型[]）

我的目標是：
我的元素的列表上1-迭代
-2-確定哪些是TYPE1 []數組PR TYPE2 []數組
3送那些前一陣

的元素名稱值屬性這是我做了什麼：

foreach (var Myobject in MyList) 
    { 
     if (myObject.GetType().IsArray) 
     { 
      var elementType = myObject.GetType().GetElementType()// should me return the element type, ie Type1 or Type2 

      //This is where I am stuck, I know that my object is an array but I cannot cast if in type1[] or type2[] array by using elementType 
      //The following is not working 
      elementType[] myArrat = (elementType[])myObject; 

      // And I don't want to hardwrite each case for each possible type like this : 
      Type1[] myArrat = (Type1[])myObject; 
      Type2[] myArrat = (Type2[])myObject; 
      // I want to use the elementType that I got previously 

     } 
    } 

在此先感謝您的幫助。

Answer 1

的ElementType [] myArrat =（的ElementType []）myObje

elementTypr不是類型名稱，那麼它不會編譯。但是這裏還有其他幾個問題。首先你可以通過MyList元素平陣列的項目要循環：

private static IEnumerable<object> Flat(IEnumerable<object> items) 
{ 
    foreach (var item in items) 
    { 
     var array = item as Array; 
     if (array != null) 
     { 
      foreach (var arrayItem in array) 
       yield return arrayItem; 
     } 
     else 
      yield return item; 
    } 
} 

現在，你可以通過你的列表枚舉，而不必擔心，如果一些項目是一個數組或不：

foreach (var item in Flat(Mylist)) 
{ 
} 

你應該真正做的是添加一個接口（或抽象基類）來抽象具體類型：

interface INamedObject 
{ 
    string Name { get; set; } 
} 

class Type1 : INamedObject { ... } 
class Type2 : INamedObject { ... } 

現在你可以用INamedObject替換Flat()返回類型中的對象（不要忘記爲yield return添加一個強制轉換）。然後，您會使用這樣的：

foreach (var item in Flat(Mylist)) 
{ 
    item.Name = ""; // It doesn't matter if it's Type1 or Type2! 
} 

請注意，如果你不想（!!!）來添加一個基類/接口，那麼你仍然可以進行類型檢查。這是一個非常糟糕的做法，你應該考慮改變你的設計以避免這種情況。我建議至少 - 不要使用GetType()，而應該直接使用as鑄造操作員。

Answer 2

你不能做你想做的事情。坦率地說，你可能也不需要這樣做。如果你期待不同的類型，這意味着你將會對每種類型做不同的事情。你可以做的是改變Type1和Type2來擴展相同的基類，並改爲使用基類：

public class TypeBase 
{ 
    public virtual string Name { get; set; } 
} 

public class Type1 : TypeBase 
{ 
} 

public class Type2 : TypeBase 
{ 
} 


foreach (var myobject in MyList) 
{ 
    if (myObject.GetType().IsArray) 
    { 
     object[] array = (object[]) myObject; 
     TypeBase[] yourArray = array.Cast<TypeBase>(); 
     //use the properties and methods of TypeBase instead of Type1 and Type2 
     //mark the methods and properties in TypeBase as virtual and 
     //override them on Type1 and Type2 if needed 
    } 
}