Come verificare se il tipo è primitivo

Ho un blocco di codice che serializza un tipo in un tag HTML.

Type t = typeof(T); // I pass <T> in as a paramter, where myObj is of type T
tagBuilder.Attributes.Add("class", t.Name);
foreach (PropertyInfo prop in t.GetProperties())
{
    object propValue = prop.GetValue(myObj, null);
    string stringValue = propValue != null ? propValue.ToString() : String.Empty;
    tagBuilder.Attributes.Add(prop.Name, stringValue);
}

Questa grande opera, tranne che voglio fare solo questo per i tipi primitivi, come int, double, boolecc, e di altri tipi che non sono primitive, ma può essere serializzato facilmente come string. Voglio che ignori tutto il resto come Elenchi e altri tipi personalizzati.

Qualcuno può suggerire come faccio? O devo specificare i tipi che voglio consentire da qualche parte e attivare il tipo di proprietà per vedere se è consentito? È un po 'disordinato, quindi sarebbe bello se ci fosse un modo più ordinato.

Puoi usare la proprietà Type.IsPrimitive, ma fai attenzione perché ci sono alcuni tipi che possiamo pensare che siano primitivi, ma non lo sono, per esempio Decimale String.

Modifica 1: aggiunto codice di esempio

Ecco un codice di esempio:

if (t.IsPrimitive || t == typeof(Decimal) || t == typeof(String) || ... )
{
    // Is Primitive, or Decimal, or String
}

Modifica 2: Come commenta @SLaks , ci sono altri tipi che potresti voler trattare anche come primitivi. Penso che dovrai aggiungere queste variazioni una per una .

Modifica 3: IsPrimitive = (Booleano, Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, IntPtr, UIntPtr, Char, Double e Single), Anther Tipo di tipo primitivo da controllare (t == typeof (DateTime ))

Ho appena trovato questa domanda mentre cercavo una soluzione simile e ho pensato che potresti essere interessato al seguente approccio usando System.TypeCodee System.Convert.

È facile serializzare qualsiasi tipo mappato su un System.TypeCodealtro System.TypeCode.Object, quindi puoi fare:

object PropertyValue = ...
if(Convert.GetTypeCode(PropertyValue) != TypeCode.Object)
{
    string StringValue = Convert.ToString(PropertyValue);
    ...
}

Il vantaggio di questo approccio è che non è necessario nominare ogni altro tipo non primitivo accettabile. È inoltre possibile modificare leggermente il codice sopra per gestire qualsiasi tipo che implementa IConvertible.

Lo facciamo nel nostro ORM:

Type t;
bool isPrimitiveType = t.IsPrimitive || t.IsValueType || (t == typeof(string));

So che usare IsValueTypenon è l'opzione migliore (puoi avere le tue strutture molto complesse) ma funziona nel 99% dei casi (e include Nullables).

Dalla risposta di @Ronnie Overby e dal commento di @jonathanconway, ho scritto questo metodo che funziona per Nullable ed escludo le strutture dell'utente.

public static bool IsSimpleType(Type type)
{
    return
        type.IsPrimitive ||
        new Type[] {
            typeof(string),
            typeof(decimal),
            typeof(DateTime),
            typeof(DateTimeOffset),
            typeof(TimeSpan),
            typeof(Guid)
        }.Contains(type) ||
        type.IsEnum ||
        Convert.GetTypeCode(type) != TypeCode.Object ||
        (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) && IsSimpleType(type.GetGenericArguments()[0]))
        ;
}

Con il seguente TestCase:

struct TestStruct
{
    public string Prop1;
    public int Prop2;
}

class TestClass1
{
    public string Prop1;
    public int Prop2;
}

enum TestEnum { TheValue }

[Test]
public void Test1()
{
    Assert.IsTrue(IsSimpleType(typeof(TestEnum)));
    Assert.IsTrue(IsSimpleType(typeof(string)));
    Assert.IsTrue(IsSimpleType(typeof(char)));
    Assert.IsTrue(IsSimpleType(typeof(Guid)));

    Assert.IsTrue(IsSimpleType(typeof(bool)));
    Assert.IsTrue(IsSimpleType(typeof(byte)));
    Assert.IsTrue(IsSimpleType(typeof(short)));
    Assert.IsTrue(IsSimpleType(typeof(int)));
    Assert.IsTrue(IsSimpleType(typeof(long)));
    Assert.IsTrue(IsSimpleType(typeof(float)));
    Assert.IsTrue(IsSimpleType(typeof(double)));
    Assert.IsTrue(IsSimpleType(typeof(decimal)));

    Assert.IsTrue(IsSimpleType(typeof(sbyte)));
    Assert.IsTrue(IsSimpleType(typeof(ushort)));
    Assert.IsTrue(IsSimpleType(typeof(uint)));
    Assert.IsTrue(IsSimpleType(typeof(ulong)));

    Assert.IsTrue(IsSimpleType(typeof(DateTime)));
    Assert.IsTrue(IsSimpleType(typeof(DateTimeOffset)));
    Assert.IsTrue(IsSimpleType(typeof(TimeSpan)));

    Assert.IsFalse(IsSimpleType(typeof(TestStruct)));
    Assert.IsFalse(IsSimpleType(typeof(TestClass1)));

    Assert.IsTrue(IsSimpleType(typeof(TestEnum?)));
    Assert.IsTrue(IsSimpleType(typeof(char?)));
    Assert.IsTrue(IsSimpleType(typeof(Guid?)));

    Assert.IsTrue(IsSimpleType(typeof(bool?)));
    Assert.IsTrue(IsSimpleType(typeof(byte?)));
    Assert.IsTrue(IsSimpleType(typeof(short?)));
    Assert.IsTrue(IsSimpleType(typeof(int?)));
    Assert.IsTrue(IsSimpleType(typeof(long?)));
    Assert.IsTrue(IsSimpleType(typeof(float?)));
    Assert.IsTrue(IsSimpleType(typeof(double?)));
    Assert.IsTrue(IsSimpleType(typeof(decimal?)));

    Assert.IsTrue(IsSimpleType(typeof(sbyte?)));
    Assert.IsTrue(IsSimpleType(typeof(ushort?)));
    Assert.IsTrue(IsSimpleType(typeof(uint?)));
    Assert.IsTrue(IsSimpleType(typeof(ulong?)));

    Assert.IsTrue(IsSimpleType(typeof(DateTime?)));
    Assert.IsTrue(IsSimpleType(typeof(DateTimeOffset?)));
    Assert.IsTrue(IsSimpleType(typeof(TimeSpan?)));

    Assert.IsFalse(IsSimpleType(typeof(TestStruct?)));
}

Ecco come l'ho fatto.

   static class PrimitiveTypes
   {
       public static readonly Type[] List;

       static PrimitiveTypes()
       {
           var types = new[]
                          {
                              typeof (Enum),
                              typeof (String),
                              typeof (Char),
                              typeof (Guid),

                              typeof (Boolean),
                              typeof (Byte),
                              typeof (Int16),
                              typeof (Int32),
                              typeof (Int64),
                              typeof (Single),
                              typeof (Double),
                              typeof (Decimal),

                              typeof (SByte),
                              typeof (UInt16),
                              typeof (UInt32),
                              typeof (UInt64),

                              typeof (DateTime),
                              typeof (DateTimeOffset),
                              typeof (TimeSpan),
                          };


           var nullTypes = from t in types
                           where t.IsValueType
                           select typeof (Nullable<>).MakeGenericType(t);

           List = types.Concat(nullTypes).ToArray();
       }

       public static bool Test(Type type)
       {
           if (List.Any(x => x.IsAssignableFrom(type)))
               return true;

           var nut = Nullable.GetUnderlyingType(type);
           return nut != null && nut.IsEnum;
       }
   }

Anche una buona possibilità:

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

Supponendo che tu abbia una firma di funzione come questa:

void foo<T>() 

È possibile aggiungere un vincolo generico per consentire solo i tipi di valore:

void foo<T>() where T : struct

Si noti che ciò consente non solo tipi primitivi per T, ma qualsiasi tipo di valore.

Avevo bisogno di serializzare i tipi allo scopo di esportarli in XML. Per fare ciò, ho ripetuto l'oggetto e ho optato per campi che erano primitivi, enum, tipi di valore o serializzabili. Questo è stato il risultato della mia domanda:

Type contextType = context.GetType();

var props = (from property in contextType.GetProperties()
                         let name = property.Name
                         let type = property.PropertyType
                         let value = property.GetValue(context,
                                     (BindingFlags.GetProperty | BindingFlags.GetField | BindingFlags.Public),
                                     null, null, null)
                         where (type.IsPrimitive || type.IsEnum || type.IsValueType || type.IsSerializable)
                         select new { Name = name, Value = value});

Ho usato LINQ per scorrere i tipi, quindi ottenere il loro nome e valore da memorizzare in una tabella dei simboli. La chiave sta nella clausola "dove" che ho scelto per la riflessione. Ho scelto tipi primitivi, enumerati, di valore e tipi serializzabili. Ciò ha consentito alle stringhe e agli oggetti DateTime di passare come previsto.

Saluti!

Questo è quello che ho nella mia biblioteca. I commenti sono ben accetti

Controllo prima IsValueType, poiché gestisce la maggior parte dei tipi, quindi String, poiché è il secondo più comune. Non riesco a pensare a una primitiva che non sia un tipo di valore, quindi non so se quella gamba del se mai viene colpita.

  Public Shared Function IsPersistable(Type As System.Type) As Boolean
    With TypeInformation.UnderlyingType(Type)
      Return .IsValueType OrElse Type = GetType(String) OrElse .IsPrimitive
    End With
  End Function

  Public Shared Function IsNullable(ByVal Type As System.Type) As Boolean
    Return (Type.IsGenericType) AndAlso (Type.GetGenericTypeDefinition() Is GetType(Nullable(Of )))
  End Function

  Public Shared Function UnderlyingType(ByVal Type As System.Type) As System.Type
    If IsNullable(Type) Then
      Return Nullable.GetUnderlyingType(Type)
    Else
      Return Type
    End If
  End Function

Quindi posso usarlo in questo modo:

  Public Shared Function PersistableProperties(Item As System.Type) As IEnumerable(Of System.Reflection.PropertyInfo)
    Return From PropertyInfo In Item.GetProperties()
                     Where PropertyInfo.CanWrite AndAlso (IsPersistable(PropertyInfo.PropertyType))
                     Select PropertyInfo
  End Function

Voglio solo condividere la mia soluzione. Forse è utile a chiunque.

public static bool IsPrimitiveType(Type fieldType)
{
   return fieldType.IsPrimitive || fieldType.Namespace.Equals("System");
}

public static bool IsPrimitiveType(object myObject)
{
   var myType = myObject.GetType();
   return myType.IsPrimitive || myType.Namespace == null ||  myType.Namespace.Equals("System");
}

Non dimenticare di controllare lo spazio dei nomi NULL, perché agli oggetti anonimi non è stato assegnato lo spazio dei nomi

Ecco un'altra opzione praticabile.

public static bool CanDirectlyCompare(Type type)
{
    return typeof(IComparable).IsAssignableFrom(type) || type.IsPrimitive || type.IsValueType;
}