C＃将通用列表传递给方法，然后转换为类型

Question

I have a method that uses a list which I need to pass into it.

Depending on where I call this method the type of the list is different.

Is it possible to pass the list in as a generic list and then cast it to a certain type, or do I need to create parameters for every type of list that can be used (see below)?

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

Instead of making a single method with multiple parameters, why don't you make several methods with a single List type? It seems you are not sharing much code from one List type to another anyway.

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

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

Answer 2

you can create a generic function that accepts generic type like this

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>();
    }

In my example I passed a IEnumerable to my function and it returns a List (where is the type of my object). I don't specify what is the type of the object.

I hope it's helpful.

Answer 3

You could do something like this:

---

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 4

Thanks for all the answers.

Another solution I just discovered would be to use a new feature in 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         
   } 
 }

Then I could just call the method like so and not have to specify all the parameters:

MyMethod(list1: mylist1)

Answer 5

Yes, this can be done easly by passing parameter with Object type, as shown below:

    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;
        }

    }

You can call this function this way:

        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);