C# Pasar una lista genérica al método y luego convertirla al tipo

Question

Tengo un método que usa una lista que necesito pasar a él.

Dependiendo de dónde llame a este método, el tipo de la lista es diferente.

¿Es posible pasar la lista como una lista genérica y luego convertirla a cierto tipo, o necesito crear parámetros para cada tipo de lista que se puede usar (ver a continuación)?

public string MyMethod(List<Type1> list1, List<Type2> list2, ...etc) 
    { 
     switch(someCondition) 
     { 
      case 1: 
      //pass list1 into a method from class1 
      break; 
      case 2: 
      //pass list2 into a method from class2 
     break; 

      ...//etc for several more lists 
     } 

Answer 1

En lugar de hacer un único método con múltiples parámetros, ¿por qué no hacer varios métodos con un solo tipo de lista? Parece que no estás compartiendo mucho código de un tipo de lista a otro de todos modos.

public string MyMethod(List<int> list) 
{ 
    //do something with list 
} 

public string MyMethod(List<bool> list) 
{ 
    //do something with list1 
} 
... 

Answer 2

Sí, esto se puede hacer easly pasando parámetro con el tipo de objeto, como se muestra a continuación:

public void Test(int SomeCondition,Object Param) 
    { 
     dynamic list; 
     switch (SomeCondition) 
     { 
      case 0: 
       list = (List<int>)Param; 
       MessageBox.Show(list[0].ToString()); 
       break; 
      case 1: 
       list = (List<string>)Param; 
       MessageBox.Show(list[0].ToString()); 
       break; 
      default: 
       MessageBox.Show("Default!"); 
       break; 
     } 

    } 

Puede llamar a esta función de esta manera:

 List<int> list1 = new List<int>(new int[]{1,2,3}); 
     List<string> list2 = new List<string>(new string[] { "one", "two", "three"}); 

     Test(0, list1); 
     Test(1, list2); 

Answer 3

puede crear una función genérica que acepta el tipo genérico como este

public virtual List<T> SelectRecord <T>(int items, IEnumerable<T> list) 
    { 
     if (items == -1) 
      return list.ToList<T>(); 
     else 
      if (items > list.Count<T>()) 
       return list.ToList<T>(); 
      else 
       return list.Take<T>(items).ToList<T>(); 
    } 

En mi ejemplo pasé un IEnumerable a mi función y devuelve una lista (donde está el tipo de mi objeto). No especifico cuál es el tipo de objeto.

Espero que sea útil.

Answer 4

se podría hacer algo como esto:

---

class GenericsExample1Class<T> 
{ 
    public string WhatsTheType(List<T> passedList) 
    { 
     string passedType = string.Empty; 

     passedType = passedList.GetType().ToString(); 

     return passedType; 
    } 
} 

---

private void ClienMethod() 
    { 
     string typeOfTheList = string.Empty; 

     // Call Type 1: Value Type 
     List<int> intergerObjectList = new List<int> { 1, 2 }; 
     typeOfTheList = (new GenericsExample1Class<int>()).WhatsTheType(intergerObjectList); 

     MessageBox.Show(typeOfTheList); 

     // Call Type 2: Reference Type 
     List<string> stringObjectList = new List<string> { "a", "b" }; 
     typeOfTheList = (new GenericsExample1Class<string>()).WhatsTheType(stringObjectList); 

     MessageBox.Show(typeOfTheList); 

     // Call Type 2: Complex-Reference Type 
     List<Employee> complexObjectList = new List<Employee> { (new Employee { Id = 1, Name = "Tathagat" }), (new Employee { Id = 2, Name = "Einstein" }) }; 
     typeOfTheList = (new GenericsExample1Class<Employee>()).WhatsTheType(complexObjectList); 

     MessageBox.Show(typeOfTheList); 
    } 

---

Answer 5

Gracias por todas las respuestas.

Otra solución que acabo de descubrir sería utilizar una nueva característica en C# 4.0:

public string MyMethod(List<Type1> list1 = null, List<Type2> list2 = null, ...etc) 
{  
    switch(someCondition)   
    {   
    case 1: 
    //pass list1 into a method from class1   
    break;   
    case 2:    
    //pass list2 into a method from class2   
    break;    
     ...//etc for several more lists   
    } 
} 

entonces podría simplemente llamar al método como tal y no tiene que especificar todos los parámetros:

MyMethod(list1: mylist1)