Y at-il une fonction pour vérifier si un objet est un type de données intégré?

Question

Je voudrais voir si un objet est builtin data type en C#

Je ne veux pas vérifier tous si possible.
C'est, je ne le font pas veulent faire:

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

Mise à jour

Je suis en train de créer un récursive PropertyDescriptorCollection où les types de PropertyDescriptor pourraient ne pas être des valeurs intrinsèques. Donc, je voulais faire quelque chose comme ça (ndlr: cela ne fonctionne pas encore, mais je travaille là-dessus):

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

Eh bien, un moyen facile consiste à les lister explicitement dans un ensemble, par ex.

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

... 


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

Je dois demander pourquoi il est important que - je peux comprendre comment il pourrait faire une différence si c'est un .NET primitive type, mais pourriez-vous expliquer pourquoi vous voulez que votre application se comporte différemment si elle est l'un des plus pour C# lui-même? Est-ce pour un outil de développement? Selon la réponse à cette question, vous pouvez considérer la situation avec dynamic dans C# 4 - qui n'est pas un type à l'exécution en tant que tel, mais System.Object + un attribut lorsqu'il est appliqué à un paramètre de méthode, etc. .

Answer 2

Pas directement, mais vous pouvez faire la vérification simplifiée suivante

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 vérification IsPrimitive capture tout sauf les chaînes, les objets et les décimales.

EDIT

Bien que cette méthode fonctionne, je préférerais la solution de Jon. La raison est simple, vérifiez le nombre de modifications que j'ai dû apporter à ma solution en raison des types que j'ai oublié étaient ou n'étaient pas des primitives. Il est plus facile de tous les énumérer explicitement dans un ensemble.

Answer 3

Je pense que c'est l'un des meilleurs possibilies:

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