C# Passing a generic list into method and then casting to type

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
        }

Solution 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
}
...

Solution 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.

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

---

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

View more solutions

Comments

[Kevin B Burns]

Operator overloading is good an all, but it would have been much more elegant to use Generics in this situation. Generics allow the programmer to not waste so much time coding.