कैसे जांचें कि एक सामान्य विधि का एक प्रकार टी है Inumerable <> और लूप?

Question

मैं इस

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

मैं क्या प्रश्न चिह्न के स्थान पर क्या करने के लिए पता नहीं है की तरह कुछ करने के लिए करना चाहते हैं। और क्या यह बिल्कुल संभव है?

Answer 1

क्या आप के लिए देख रहे हैं:

if (T is IEnumerable) { .. } 

लेकिन अगर आप टी हर समय IEnumerable होने की उम्मीद आप कर सकते हैं:

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

या IEnumerable अंदर मूल्यों के प्रकार की जाँच :

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

इसे स्वयं जांचने के लिए चिंता किए बिना, संकलक आपके लिए यह करेगा, जो एक स्थिर प्रकार प्रणाली और संकलक होने के अच्छा चीजों में से एक है :)

Answer 2

कुछ तरीके हैं: आप प्रत्येक इंटरफ़ेस के खुले सामान्य प्रकार की जांच करने के लिए है

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

उस वर्ग उपकरण, जैसे इसलिए:

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

यह आप यह निर्धारित करने या नहीं, एक प्रकार वास्तव में किस प्रकार T है जानने के बिना IEnumerable<T> लागू करता है की अनुमति देगा। याद रखें कि प्रकार IEnumerable<T> कई बार कार्यान्वित कर सकता है।

यदि आप बस IEnumerable<T> के लिए पैरामीटर टाइप प्रकारों के अनुक्रम चाहते हैं, तो आप उपर्युक्त क्वेरी को बदल सकते हैं;

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