¿Hay una función para verificar si un objeto es un tipo de datos incorporado?

Question

Me gustaría ver si un objeto es un builtin data type en C#

No quiero consultar con todos ellos si es posible.
Es decir, que No desee hacer esto:

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

actualización

Estoy intentando crear un recursiva PropertyDescriptorCollection donde los tipos PropertyDescriptor podrían no ser los valores de orden interna. 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 enumerarlas explícitamente en un conjunto, p. Ej.

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

... 


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

tengo que preguntar por qué es importante, aunque - Puedo entender cómo se podría hacer una diferencia si es un .NET primitive type, pero podría explicar por qué quiere que su aplicación se comporte de manera diferente si se trata de uno de los que está para C# en sí? ¿Esto es para una herramienta de desarrollo?

En función 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 tiempo de ejecución como tal, pero es System.Object + un atributo cuando se aplica a un parámetro de método, etc. .

Answer 2

No directamente, pero se puede hacer la siguiente comprobación simplificada

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, yo preferiría 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.

Answer 3

Creo que este es uno de los mejores possibilies:

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