Como faço para comparar tipos ao usar genéricos?

Question

Estou tentando derivar o tipo de objeto em tempo de execução. Especificamente, preciso saber duas coisas, se ela implementa o ICOLLECTION ou o IDTO. Atualmente, minha única solução que pude encontrar é a seguinte:

   private static bool IsACollection(PropertyDescriptor descriptor)
    {
        bool isCollection = false;

        foreach (Type type in descriptor.PropertyType.GetInterfaces())
        {
            if (type.IsGenericType)
            {
                if (type.GetGenericTypeDefinition() == typeof(ICollection<>))
                {
                    isCollection = true;
                    break;
                }
            }
            else
            {
                if (type == typeof(ICollection))
                {
                    isCollection = true;
                    break;
                }
            }
        }


        return isCollection;
    }

    private static bool IsADto(PropertyDescriptor descriptor)
    {
        bool isDto = false;

        foreach (Type type in descriptor.PropertyType.GetInterfaces())
        {
            if (type == typeof(IDto))
            {
                isDto = true;
                break;
            }
        }          
        return isDto;
    }

No entanto, estou convencido de que deve haver uma maneira melhor do que isso. Eu tentei comparar de maneira normal, como:

if(descriptor.PropertyType == typeof(ICollection<>))

No entanto, isso falha ao usar a reflexão, mas quando não estiver usando a reflexão, funciona bem.

Não quero iterar através das interfaces para todos os campos da minha entidade. Alguém poderia lançar alguma luz sobre outro método para fazer isso? Sim, estou otimizando prematuramente, mas parece feio também, por favor, me humor.

Ressalvas:

1. Isso não poderia ou não ser genérico, como ilist <> ou apenas ArrayList, portanto, estou procurando o ICOLLECTION ou ICOLLECÇÃO <>. Por isso, presumo que eu deva usar o ISGenerictype em uma declaração IF para saber se deve testar usando o iCollection <> ou não.

Desde já, obrigado!

Answer 1

Este:

type == typeof(ICollection)

verificará se o tipo de propriedade é exatamente ICollection. Isto é, ele retornará verdadeiro para:

public ICollection<int> x { get; set; }

Mas não para:

public List<int> x { get; set; }

Se você quiser verificar se é o tipo de propriedade, ou é derivado de, ICollection, a maneira mais simples é usar Type.IsAssignableFrom:

typeof(ICollection).IsAssignableFrom(type)

E o mesmo vale para genérico:

typeof(ICollection<>).IsAssignableFrom(type.GetGenericTypeDefinition())

Answer 2

Faz type.IsAssignable ajuda neste caso?

Editar: Desculpe, deveria ter sido Type.IsAssignableFrom