How to get the Count property using reflection for Generic types

I have a list of objects, of which I cannot know the type of at compile-time.

I need to identify any of these objects where a 开发者_StackOverflow社区'Count' property exists, and get the value if it does.

This code works for simple Collection types:

PropertyInfo countProperty = objectValue.GetType().GetProperty("Count");
 if (countProperty != null)
 {
     int count = (int)countProperty.GetValue(objectValue, null);
 }

The problem is that this doesn't work for generic types, such as IDictionary<TKey,TValue>. In those cases, the 'countProperty' value is returned as null, even though a 'Count' property exists in the instanced object.

All I want to do is identify any collection/dictionary based object and find the size of it, if it has one.

Edit: as requested, here's the entire listing of code that doesn't work

private static void GetCacheCollectionValues(ref CacheItemInfo item, object cacheItemValue)
{
    try
        {
        //look for a count property using reflection
        PropertyInfo countProperty = cacheItemValue.GetType().GetProperty("Count");
        if (countProperty != null)
        {
            int count = (int)countProperty.GetValue(cacheItemValue, null);
            item.Count = count;
        }
        else
        {
            //poke around for a 'values' property
            PropertyInfo valuesProperty = cacheItemValue.GetType().GetProperty("Values");
            int valuesCount = -1;
            if (valuesProperty != null)
            {
                object values = valuesProperty.GetValue(cacheItemValue, null);
                if (values != null)
                {
                    PropertyInfo valuesCountProperty = values.GetType().GetProperty("Count");
                    if (countProperty != null)
                    {
                        valuesCount = (int)valuesCountProperty.GetValue(cacheItemValue, null);
                    }
                }
            }
            if (valuesCount > -1)
                item.Count = valuesCount;
            else
                item.Count = -1;
        }
    }
    catch (Exception ex)
    {
        item.Count = -1;
        item.Message = "Exception on 'Count':" + ex.Message;
    }
}

This works OK on simple collections, but not on an object created from a class I have which is derived from Dictionary<TKey,TValue>. Ie

CustomClass : 
    Dictionary<TKey,TValue>

CacheItemInfo is just a simple class that contains properties for cache items - ie, key, count, type, expiration datetime

The first thing you should try is casting to ICollection, as this has a very cheap .Count:

ICollection col = objectValue as ICollection;
if(col != null) return col.Count;

The Count for dictionary should work though - I've tested this with Dictionary<,> and it works fine - but note that even if something implements IDictionary<,>, the concrete type (returned via GetType()) doesn't have to have a .Count on the public API - it could use explicit interface implementation to satisfy the interface while not having a public int Count {get;}. Like I say: it works for Dictionary<,> - but not necessarily for every type.

As a last ditch effort if everything else fails:

IEnumerable enumerable = objectValue as IEnumerable;
if(enumerable != null)
{
    int count = 0;
    foreach(object val in enumerable) count++;
    return count;
}

Edit to look into the Dictionary<,> question raised in comments:

using System;
using System.Collections;
using System.Collections.Generic;
public class CustomClass : Dictionary<int, int> { }
public class CacheItemInfo
{
    public int Count { get; set; }
    public string Message { get; set; }
}
class Program {
    public static void Main() {
        var cii = new CacheItemInfo();
        var data = new CustomClass { { 1, 1 }, { 2, 2 }, { 3, 3 } };
        GetCacheCollectionValues(ref cii, data);
        Console.WriteLine(cii.Count); // expect 3
    }
    private static void GetCacheCollectionValues(ref CacheItemInfo item, object cacheItemValue)
    {
        try
        {
            ICollection col;
            IEnumerable enumerable;
            if (cacheItemValue == null)
            {
                item.Count = -1;
            }
            else if ((col = cacheItemValue as ICollection) != null)
            {
                item.Count = col.Count;
            }
            else if ((enumerable = cacheItemValue as IEnumerable) != null)
            {
                int count = 0;
                foreach (object val in enumerable) count++;
                item.Count = count;
            }
            else
            {
                item.Count = -1;
            }
        }
        catch (Exception ex)
        {
            item.Count = -1;
            item.Message = "Exception on 'Count':" + ex.Message;
        }
    }
}

How about adding this after your first check (!untested!) ...

foreach (Type interfaceType in objectValue.GetType().GetInterfaces())
{
    countProperty = interfaceType.GetProperty("Count");
    //etc.
}