Jak sprawdzić, czy typ T metody ogólnej jest IEnumerable <> i zapętlić go?

Question

chciałbym zrobić coś takiego

void DoSomething<T>(T param) 
{ 
    if param is IEnumerable<?> 
    { 
     loop param and do stuff 
    } 
} 

nie wiem, co robić w miejscu znaku zapytania. I czy to w ogóle możliwe?

Answer 1

Co szukasz jest:

if (T is IEnumerable) { .. } 

ale jeśli oczekujesz T być IEnumerable cały czas można zrobić:

void DoSomething<T>(T param) where T : IEnumerable 
{ 
    foreach (var t in param) { ... } 
} 

lub sprawdzanie typ wartości wewnątrz IEnumerable :

public void DoSomething<T,U>(T val) where T : IEnumerable<U> 
{ 
    foreach (U a in val) 
    { 
    } 
} 

Nie martwiąc się, aby sprawdzić to sam, kompilator zrobi to za Ciebie, co jest jedną z miłych rzeczy o statyczny system typu i kompilator :)

Answer 2

Istnieje kilka sposobów:

void DoSomething<T>(T param) 
{ 
    if (param is IEnumerable) 
    { 
     foreach (var item in (IEnumerable)param) 
     { 
      // Do something 
     } 
    } 
} 

void DoSomething<T>(T param) 
{ 
    if (param is IEnumerable<string>) 
    { 
     foreach (var item in (IEnumerable<string>)param) 
     { 
      // Do something 
     } 
    } 
} 

void DoSomething<T,TItem>(T param) 
{ 
    if (param is IEnumerable<TItem>) 
    { 
     foreach (var item in (IEnumerable<TItem>)param) 
     { 
      // Do something 
     } 
    } 
} 

Answer 3

Trzeba sprawdzić otwarty ogólny typ każdego interfejsu, który implementuje klasy, takie jak tak:

bool implements = typeof(T).GetInterfaces().Where(t => t.IsGenericType && 
    t.GetGenericTypeDefinition() == typeof(IEnumerable<>)).Any(); 

to pozwoli Ci określić, czy dany typ implementuje IEnumerable<T> bez faktycznie wiedząc, co typ T jest. Pamiętaj, że ten typ może wielokrotnie implementować IEnumerable<T>.

Jeśli chcesz po prostu sekwencji typów, które są parametrami typu dla IEnumerable<T>, możesz zmienić powyższe zapytanie na;

IEnumerable<Type> types = typeof(T).GetInterfaces(). 
    Where(t => t.IsGenericType && 
     t.GetGenericTypeDefinition() == typeof(IEnumerable<>)). 
    Select(t => t.GetGenericArguments()[0]);