¿Cómo comparo tipos cuando uso genéricos?

Question

Estoy tratando de derivar el tipo de un objeto en tiempo de ejecución. Específicamente necesito saber dos cosas si implementa ICollection o IDto. Actualmente, mi única solución que he podido encontrar es esta:

   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;
    }

Sin embargo, estoy convencido de que tiene que haber una mejor manera que esta. He intentado comparar de manera normal, como:

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

Sin embargo, esto falla cuando se usa la reflexión, pero cuando no se usa la reflexión, funciona bien.

No quiero iterar a través de las interfaces para cada campo de mi entidad. ¿Podría alguien arrojar algo de luz sobre otro método para hacer esto? Sí, estoy optimizando prematuramente, pero también se ve feo, así que por favor hágame caso.

Advertencias:

1. Podría o no ser genérico, como IList < > o simplemente ArrayList, por eso estoy buscando ICollection o ICollection < > ;. Por lo tanto, supongo que debería usar IsGenericType en una instrucción if para saber si probar usando ICollection & Lt; & Gt; o no.

¡Gracias de antemano!

Answer 1

Esto:

type == typeof(ICollection)

verificará si el tipo de propiedad es exactamente ICollection. Es decir, volverá verdadero para:

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

pero no para:

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

Si desea verificar si el tipo de propiedad es, o se deriva de , Type.IsAssignableFrom, la forma más sencilla es utilizar <=>:

typeof(ICollection).IsAssignableFrom(type)

y lo mismo aplica para genéricos:

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

Answer 2

¿Ayuda type.IsAssignable en este caso?

EDITAR: Lo sentimos, debería haber sido Type.IsAssignableFrom