devolviendo un genérico IEnumerable <T>

Question

Estoy jugando con genéricos e IEnumerable abit, pero estoy un poco atrapado. Esto es lo que estoy tratando de hacer: - (?) Quiero tener un método que devuelve cualquier tipo de colección que implementa IEnumerable - (así por ejemplo: Lista, pila, cola, ...)

además, Quiero poder devolver cualquier tipo de colección, de cualquier tipo de datos. así que quiero este método sea capaz de devolver un List<string>, así como un Stack<int>, así como un List<double> ... etc etc.

public IEnumerable<T> returnSomething() 
    { 
     Stack<int> stackOfInts = new Stack<int>(); 
     List<string> listOfStrings = new List<string>(); 
     return stackOfInts; 
    } 

esto es lo que he probado hasta ahora. Sin embargo, esto no funciona, me sale este error:

Cannot implicitly convert type 'System.Collections.Generic.Stack<int>' to 'System.Collections.Generic.IEnumerable<T>'. An explicit conversion exists (are you missing a cast?) 

sin embargo, si se sustituye la IEnumerable<T> en la firma del método a IEnumerable<int>, puedo devolver cualquier colección de tipo int. Sin embargo, esto significa que ahora ya no puedo devolver el ListOfStrings.

agradecería cualquier sugerencia o idea :)

Answer 1

es necesario agregar un generic type parameter a su método:

parámetro

public IEnumerable<T> ReturnSomething<T>() 
{ 
    Stack<T> stackOfT = new Stack<T>(); 
    return stackOfT; 
} 

El tipo aparece después del nombre del método, pero antes de los parámetros. También es posible tener un método con más de un parámetro de tipo.

Cuando se llama al método puede especificar el tipo:

IEnumerable<int> myInts = ReturnSomething<int>(); 

Answer 2

El truco es declarar<T> derecha, si se define genérica <T>, entonces usted tiene que atenerse a ella en sus métodos, por lo si tiene IEnumerable<T>, entonces, en cualquier otro lugar de su método, debe usar <T> y no <int> o cualquier otro tipo.

Es solo el último cuando realmente usa tipo genérico que sustituye <T> genérico por un tipo real.

ver una muestra

class Foo<T> 
{ 
    public IEnumerable<T> GetList() 
    { 
     return new List<T>(); 
    } 

    public IEnumerable<T> GetStack() 
    { 
     return new Stack<T>(); 
    } 
} 

class Program 
{ 
    static void Main(string[] args) 
    { 
     Foo<int> foo = new Foo<int>(); 
     IEnumerable<int> list = foo.GetList(); 
     IEnumerable<int> stack = foo.GetStack(); 

     Foo<string> foo1 = new Foo<string>(); 
     IEnumerable<string> list1 = foo1.GetList(); 
     IEnumerable<string> stack1 = foo1.GetStack(); 
    } 
} 

Answer 3

sí se puede devolver cualquier tipo si cambia I Enumerable<T> to IEnumerable<dynamic>

así:

public IEnumerable<dynamic> returnSomething() 
{ 
..... 

Answer 4

public IEnumerable<T> returnSomething() 
{ 
    Stack<int> stackOfInts = new Stack<int>(); 
    return (IEnumerable<T>) stackOfInts; 
} 

Answer 5

El parámetro de tipo necesita ser especificado por la persona que llama en alguna parte.

ya sea cuando una instancia de una clase genérica:

public class MyClass<T> 
{ 
    public IEnumerable<T> returnSomething() 
    { 
     Stack<T> stackOfTs = new Stack<T>(); 
     List<T> listOfTs = new List<T>(); 
     return stackOfTs; 
    } 
} 

var v = new MyClass<int>(); 
foreach(var item in v.returnSomething()) 
{ 
} 

O cuando se llama a un método genérico de una clase no genérica:

public class MyClass 
{ 
    public IEnumerable<T> returnSomething<T>() 
    { 
     Stack<T> stackOfTs = new Stack<T>(); 
     List<T> listOfTs = new List<T>(); 
     return stackOfTs; 
    } 
} 


var v = new MyClass(); 
foreach(var item in v.returnSomething<int>()) 
{ 
}