c# - saber - ¿Hay una función para verificar si un objeto es un tipo de datos integrado?

obtener elemento de una lista c#

Question

Me gustaría ver si un objeto es un tipo de datos incorporado en C #

No quiero verificar contra todos ellos si es posible.
Es decir, no quiero hacer esto:

        Object foo = 3;
        Type type_of_foo = foo.GetType();
        if (type_of_foo == typeof(string))
        {
            ...
        }
        else if (type_of_foo == typeof(int))
        {
            ...
        }
        ...

Actualizar

Estoy intentando crear recursivamente una PropertyDescriptorCollection donde los tipos PropertyDescriptor pueden no ser valores incorporados. Así que quería hacer algo como esto (nota: esto no funciona todavía, pero estoy trabajando en ello):

    public override PropertyDescriptorCollection GetProperties(Attribute[] attributes)
    {
        PropertyDescriptorCollection cols = base.GetProperties(attributes);

        List<PropertyDescriptor> list_of_properties_desc = CreatePDList(cols);
        return new PropertyDescriptorCollection(list_of_properties_desc.ToArray());
    }

    private List<PropertyDescriptor> CreatePDList(PropertyDescriptorCollection dpCollection)
    {
        List<PropertyDescriptor> list_of_properties_desc = new List<PropertyDescriptor>();
        foreach (PropertyDescriptor pd in dpCollection)
        {
            if (IsBulitin(pd.PropertyType))
            {
                list_of_properties_desc.Add(pd);
            }
            else
            {
                list_of_properties_desc.AddRange(CreatePDList(pd.GetChildProperties()));
            }
        }
        return list_of_properties_desc;
    }

    // This was the orginal posted answer to my above question
    private bool IsBulitin(Type inType)
    {
        return inType.IsPrimitive || inType == typeof(string) || inType == typeof(object);
    }

Answer 1

Bueno, una manera fácil es simplemente enumerarlos explícitamente en un conjunto, por ejemplo

static readonly HashSet<Type> BuiltInTypes = new HashSet<Type>
    (typeof(object), typeof(string), typeof(int) ... };

...


if (BuiltInTypes.Contains(typeOfFoo))
{
    ...
}

Sin embargo, tengo que preguntar por qué es importante. Puedo entender cómo podría marcar la diferencia si se trata de un tipo de primitiva .NET , pero ¿podría explicar por qué querría que su aplicación se comportase de manera diferente si es una de las propias de C #? ¿Esto es para una herramienta de desarrollo?

Dependiendo de la respuesta a esa pregunta, es posible que desee considerar la situación con dynamic en C # 4, que no es un tipo en el tiempo de ejecución como tal, sino que es System.Object + un atributo cuando se aplica a un parámetro de método, etc.

Answer 2

Creo que esta es una de las mejores posibilidades:

private static bool IsBulitinType(Type type)
{
    return (type == typeof(object) || Type.GetTypeCode(type) != TypeCode.Object);
}

Answer 3

No directamente, pero puede hacer el siguiente control simplificado

public bool IsBulitin(object o) {
  var type = o.GetType();
  return (type.IsPrimitive && type != typeof(IntPtr) && type != typeof(UIntPtr))
        || type == typeof(string) 
        || type == typeof(object) 
        || type == typeof(Decimal);
}

La comprobación IsPrimitive capturará todo menos cadena, objeto y decimal.

EDITAR

Si bien este método funciona, preferiría la solución de Jon. La razón es simple, verifique la cantidad de ediciones que tuve que hacer en mi solución debido a que los tipos que olvidé eran o no eran primitivos. Es más fácil simplemente enumerarlos todos explícitamente en un conjunto.