Wie würde ich wissen, wenn eine Eigenschaft eine generische Sammlung ist

Question

Ich muss wissen, ob der Typ einer Eigenschaft in einer Klasse eine generische Auflistung (List, ObservableCollection) mit der PropertyInfo-Klasse ist.

foreach (PropertyInfo p in (o.GetType()).GetProperties()) 
{ 
    if(p is Collection<T> ?????) 

} 

Answer 1

GetGenericTypeDefinition und typeof(Collection<>) wird die Arbeit machen:

if(p.PropertyType.IsGenericType && typeof(Collection<>).IsAssignableFrom(p.PropertyType.GetGenericTypeDefinition()) 

Answer 2

Type tColl = typeof(ICollection<>); 
foreach (PropertyInfo p in (o.GetType()).GetProperties()) { 
    Type t = p.PropertyType; 
    if (t.IsGenericType && tColl.IsAssignableFrom(t.GetGenericTypeDefinition()) || 
     t.GetInterfaces().Any(x => x.IsGenericType && x.GetGenericTypeDefinition() == tColl)) { 
     Console.WriteLine(p.Name + " IS an ICollection<>"); 
    } else { 
     Console.WriteLine(p.Name + " is NOT an ICollection<>"); 
    } 
} 

Sie müssen die Tests t.IsGenericType und x.IsGenericType, sonst GetGenericTypeDefinition() eine Exception aus, wenn der Typ nicht generisch ist. Wenn die Eigenschaft als ICollection<T> deklariert wird, gibt tColl.IsAssignableFrom(t.GetGenericTypeDefinition())true zurück.

Wenn die Eigenschaft als Typ deklariert wird, die ICollection<T> implementiert dann t.GetInterfaces().Any(x => x.IsGenericType && x.GetGenericTypeDefinition() == tColl) wird true zurück.

Beachten Sie, dass tColl.IsAssignableFrom(t.GetGenericTypeDefinition()) zum Beispiel false für einen List<int> zurückgibt.

---

ich getestet habe alle diese Kombinationen für MyT o = new MyT();

private interface IMyCollInterface1 : ICollection<int> { } 
private interface IMyCollInterface2<T> : ICollection<T> { } 
private class MyCollType1 : IMyCollInterface1 { ... } 
private class MyCollType2 : IMyCollInterface2<int> { ... } 
private class MyCollType3<T> : IMyCollInterface2<T> { ... } 

private class MyT 
{ 
    public ICollection<int> IntCollection { get; set; } 
    public List<int> IntList { get; set; } 
    public IMyCollInterface1 iColl1 { get; set; } 
    public IMyCollInterface2<int> iColl2 { get; set; } 
    public MyCollType1 Coll1 { get; set; } 
    public MyCollType2 Coll2 { get; set; } 
    public MyCollType3<int> Coll3 { get; set; } 
    public string StringProp { get; set; } 
} 

Ausgang:

IntCollection IS an ICollection<> 
IntList IS an ICollection<> 
iColl1 IS an ICollection<> 
iColl2 IS an ICollection<> 
Coll1 IS an ICollection<> 
Coll2 IS an ICollection<> 
Coll3 IS an ICollection<> 
StringProp is NOT an ICollection<>