Gibt es eine Funktion, um zu überprüfen, ob ein Objekt ein eingebauter Datentyp ist?

Question

Ich würde gerne sehen, ob ein Objekt ist ein builtin data type in C#

Ich möchte nicht gegen alle von ihnen, wenn möglich zu überprüfen.
Das heißt, ich nicht wollen, dies zu tun:

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

aktualisieren

Ich versuche rekursiv eine PropertyDescriptorCollection zu schaffen, in dem die PropertyDescriptor Typen Werte werden möglicherweise nicht gebautet. Also wollte ich so etwas wie dies tun (Anmerkung: Dies funktioniert noch nicht, aber ich arbeite daran):

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

Nun, ein einfacher Weg besteht darin, sie nur explizit in einer Menge aufzulisten, z.

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

... 


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

Ich habe zu fragen, warum es zwar wichtig ist - ich kann verstehen, wie könnte es einen Unterschied machen, wenn es eine .NET primitive type ist, aber könnten Sie erklären, warum Sie Ihre Anwendung würde sich anders verhalten, wenn es einer von denen ist für C# selbst? Ist das ein Entwicklungswerkzeug?

Je nach Antwort auf diese Frage möchten Sie vielleicht die Situation mit dynamic in C# 4 betrachten - die kein Typ zur Ausführungszeit ist, aber System.Object + ein Attribut, wenn es auf einen Methodenparameter angewendet wird .

Answer 2

Nicht direkt, aber Sie können die folgende vereinfachte Kontrolle tun

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

Der IsPrimitive-Check erfasst alles außer String, Objekt und Dezimal.

EDIT

Während diese Methode funktioniert, würde ich Jon-Lösung bevorzugen. Der Grund ist einfach: Überprüfen Sie die Anzahl der Bearbeitungen, die ich an meiner Lösung vornehmen musste, weil die Typen, die ich vergessen habe, keine Primitive waren oder waren. Einfacher, sie alle nur explizit in einem Set aufzulisten.

Answer 3

ich denke, das ist eine der besten possibilies ist:

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