Esiste una funzione per verificare se un oggetto è un tipo di dati incorporato?

Question

Mi piacerebbe vedere se un oggetto è un builtin data type in C#

Se non fosse possibile, non voglio verificarli tutti.
Cioè, io non lo fanno vuole fare questo:

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

Aggiornamento

Sto cercando di creare un modo ricorsivo PropertyDescriptorCollection in cui i tipi PropertyDescriptor potrebbero non essere builtin valori. Così ho voluto fare qualcosa di simile (nota: questo non funziona ancora, ma ci sto lavorando su di esso):

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

Bene, un modo semplice è quello di elencarli esplicitamente in un set, ad es.

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

... 


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

devo chiedere perché è importante anche se - posso capire come potrebbe fare la differenza se si tratta di un .NET primitive type, ma potrebbe spiegare perché si vuole l'applicazione per comportarsi in modo diverso se si tratta di uno di quelli per C# stesso? È questo per uno strumento di sviluppo?

A seconda della risposta a questa domanda, è possibile prendere in considerazione la situazione con dynamic in C# 4 - che non è un tipo al momento dell'esecuzione in quanto tale, ma è System.Object + un attributo quando applicato a un parametro del metodo ecc. .

Answer 2

Non direttamente ma è possibile effettuare le seguenti operazioni di controllo semplificato

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

Il controllo IsPrimitive catturerà tutto tranne la stringa, l'oggetto e il decimale.

EDIT

Anche se questo metodo funziona, io preferirei la soluzione di Jon. La ragione è semplice, controlla il numero di modifiche che dovevo apportare alla mia soluzione a causa dei tipi che avevo dimenticato erano o non erano primitivi. È più facile elencarli tutti esplicitamente in un set.

Answer 3

credo che questo sia uno dei migliori possibilies:

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