汎用またはオブジェクトパラメータを参照型に変換する方法

Question

このシナリオでは、TypeAとTypeBの両方から派生する基本型を作成できないため、メソッドにWhere：TypeBaseを追加できません。私はこれを解決する別の方法があるかどうかを見たいと思います。

class TypeA 
{ 
    int number; 
    string someString; 
} 

class TypeB 
{ 
    int number; 
    decimal someDecimal; 
} 

private List<int> Test(object inputs) 
{ 
    List<int> rv = new List<int>(); 

    if (inputs is List<TypeA>) 
     inputs = (List<TypeA>)inputs; 
    else if(inputs is List<TypeB>) 
     inputs = (List<TypeB>)inputs; 

    foreach(item in inputs) 
    { 
     rv.Add(item.number); 
    } 
    return rv; 
} 

Answer 1

private void GenericTest<T>(IEnumerable<T> inputs) 
{ 
    MethodInfo property = typeof(T).GetProperty(/*YOUR PROPERTY*/).GetMethod; 
    foreach (var input in inputs) 
    { 
     object value = property.Invoke(input, null); 
     // Logic 
    } 
} 

// To protect it from error 
public void Test(IEnumerable<TypeA> inputs) 
{ 
    GenericTest(inputs); 
} 

// To protect it from error 
public void Test(IEnumerable<TypeB> inputs) 
{ 
    GenericTest(inputs); 
} 

それでは、プロパティ名をTestメソッドに渡すのはなぜですか？

Answer 2

あなたはIEnumerableにキャストし、その後foreach -loop行うことができます。ロジックは、クラスごとに異なることが必要である場合

private void Test(object inputs) 
{ 
    // you can also change the parameter to IEnumerable to take advantage of compile-time type-checking. 
    var items = inputs as IEnumerable; 
    if (items == null) 
     throw new ArgumentException("inputs"); 

    foreach (var item in items) 
    { 

    } 
} 

を、これを使用する：

private void Test(object inputs) 
{ 
    var typeAs = inputs as IEnumerable<TypeA>; 
    if (typeAs != null) 
    { 
     foreach (var item in typeAs) 
     { 

     } 
     return; 
    } 
    var typeBs = inputs as IEnumerable<TypeB>; 
    if (typeBs != null) 
    { 
     foreach (var item in typeBs) 
     { 

     } 
     return; 
    } 

    throw new ArgumentException("inputs"); 
} 

Answer 3

独立して繰り返し処理する場合は、追加の作業を行いません。

class Program 
{ 
    private void Test(object inputs) 
    { 
     if (inputs is List<TypeA>) 
      loop((List<TypeA>) inputs); 
     if (inputs is List<TypeB>) 
      loop((List<TypeB>)inputs); 
    } 

    private void loop(IEnumerable<TypeA> inputs) 
    { 
     foreach (var input in inputs) 
     { 
      logic(input.i); 
     } 
    } 

    private void loop(IEnumerable<TypeB> inputs) 
    { 
     foreach (var input in inputs) 
     { 
      logic(input.i); 
     } 
    } 

    private void logic(int i) 
    { 
     // magic happens here 
    } 
} 

class TypeA 
{ 
    public int i; 
} 

class TypeB 
{ 
    public int i; 
} 

しかし、世界のすべてのものの愛のために、これをしないでください。

あなたが実際にいくつかの理由で一度にリストを反復しなければならない、とあなたはテストのみTypeAsとTypeBsで呼び出されますを知って場合は、dynamic typeでこれを扱うことができます。

class Program 
{ 
    static void Main(string[] args) 
    { 
     var w = new TypeA {i = 8}; 
     var x = new TypeA {i = 16}; 
     var y = new TypeB {i = 32}; 
     var z = new TypeC(); // don't pass this to Test! 
     var l = new List<dynamic> {w, x, y}; 
     Test(l); 
    } 

    private static void Test(IEnumerable<dynamic> inputs) 
    { 
     foreach (var input in inputs) 
     { 
      logic(input.i); 
     } 
    } 

    private static void logic(int i) 
    { 
     // magic happens here 
    } 
} 

class TypeA 
{ 
    public int i; 
} 

class TypeB 
{ 
    public int i; 
} 

class TypeC {} // no members