So testen Sie, ob der Typ primitiv ist

Ich habe einen Codeblock, der einen Typ in ein HTML-Tag serialisiert.

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

Dies funktioniert gut, außer ich will dies nur tun , für primitive Typen, wie int, double, boolusw., und andere Arten , die nicht primitiv sind , aber leicht wie serialisiert werden string. Ich möchte, dass alles andere wie Listen und andere benutzerdefinierte Typen ignoriert wird.

Kann mir jemand vorschlagen, wie ich das mache? Oder muss ich die Typen angeben, die ich irgendwo zulassen möchte, und den Typ der Eigenschaft aktivieren, um zu sehen, ob dies zulässig ist? Das ist ein bisschen chaotisch, also wäre es schön, wenn ich einen ordentlicheren Weg hätte.

Sie können die Eigenschaft verwenden Type.IsPrimitive, aber seien Sie vorsichtig, da es einige Typen gibt, von denen wir glauben können, dass sie primitiv sind, aber sie sind es nicht, zum Beispiel Decimalund String.

Bearbeiten 1: Beispielcode hinzugefügt

Hier ist ein Beispielcode:

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

Bearbeiten 2: Wie @SLaks kommentiert, gibt es andere Typen, die Sie möglicherweise auch als Grundelemente behandeln möchten. Ich denke , dass du wirst diese Variationen hinzuzufügen haben eins nach dem anderen .

Bearbeiten 3: IsPrimitive = (Boolescher Wert, Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, IntPtr, UIntPtr, Char, Double und Single), Anther Primitive-Like-Typ zum Überprüfen (t == typeof (DateTime) ))

Ich habe diese Frage gerade gefunden, als ich nach einer ähnlichen Lösung gesucht habe, und dachte, Sie könnten an dem folgenden Ansatz mit System.TypeCodeund interessiert sein System.Convert.

Es ist einfach, jeden Typ zu serialisieren, der einem System.TypeCodeanderen als zugeordnet System.TypeCode.Objectist. Sie können also Folgendes tun:

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

Der Vorteil dieses Ansatzes besteht darin, dass Sie nicht jeden anderen akzeptablen nicht-primitiven Typ benennen müssen. Sie können den obigen Code auch geringfügig ändern, um jeden Typ zu verarbeiten, der IConvertible implementiert.

Wir machen das in unserem ORM so:

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

Ich weiß, dass die Verwendung IsValueTypenicht die beste Option ist (Sie können Ihre eigenen sehr komplexen Strukturen haben), aber sie funktioniert in 99% der Fälle (und enthält Nullables).

Aus der Antwort von @Ronnie Overby und dem Kommentar von @jonathanconway habe ich diese Methode geschrieben, die für Nullable funktioniert und Benutzerstrukturen ausschließt.

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

Mit folgendem 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?)));
}

So habe ich es gemacht.

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

Auch eine gute Möglichkeit:

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

Angenommen, Sie haben eine Funktionssignatur wie diese:

void foo<T>() 

Sie können eine generische Einschränkung hinzufügen, um nur Werttypen zuzulassen:

void foo<T>() where T : struct

Beachten Sie, dass dies nicht nur primitive Typen für T zulässt, sondern jeden Werttyp.

Ich musste Typen serialisieren, um sie nach XML zu exportieren. Zu diesem Zweck habe ich das Objekt durchlaufen und mich für Felder entschieden, die primitiv, enum, Werttypen oder serialisierbar waren. Dies war das Ergebnis meiner Anfrage:

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

Ich habe LINQ verwendet, um die Typen zu durchlaufen und dann ihren Namen und Wert in einer Symboltabelle zu speichern. Der Schlüssel liegt in der 'where'-Klausel, die ich zum Nachdenken ausgewählt habe. Ich habe primitive, aufgezählte, Werttypen und serialisierbare Typen ausgewählt. Dadurch konnten Zeichenfolgen und DateTime-Objekte wie erwartet durchlaufen werden.

Prost!

Das habe ich in meiner Bibliothek. Kommentare sind willkommen.

Ich überprüfe zuerst IsValueType, da es die meisten Typen behandelt, dann String, da es das zweithäufigste ist. Ich kann mir kein Grundelement vorstellen, das kein Werttyp ist, also weiß ich nicht, ob dieses Bein des If jemals getroffen wird.

  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

Dann kann ich es so benutzen:

  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

Ich möchte nur meine Lösung teilen. Vielleicht ist es für jeden nützlich.

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

Vergessen Sie nicht, den NULL-Namespace zu überprüfen, da anonymen Objekten kein Namespace zugewiesen wurde

Hier ist eine weitere praktikable Option.

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