タイプがプリミティブかどうかをテストする方法

タイプを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);
}

私はそれが唯一のプリミティブ型、などのためにこれをしたい除いて、これは素晴らしい作品int、double、bool原始的ではないが、同様に簡単にシリアル化できるなど、および他のタイプstring。リストやその他のカスタムタイプなど、他のすべてを無視するようにします。

誰も私がこれをどのように行うか提案できますか？または、どこかで許可するタイプを指定し、プロパティのタイプをオンにして、許可されているかどうかを確認する必要がありますか？それは少し面倒なので、私がもっときちんとした方法があったらいいでしょう。

プロパティを使用Type.IsPrimitiveできますが、プリミティブであると考えることができるいくつかのタイプがあるので注意してください。たとえばDecimal、およびはそうではありませんString。

編集1： サンプルコードを追加

これがサンプルコードです：

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

編集2：@SLaksコメントとして、おそらくプリミティブとして扱いたい他のタイプもあります。このバリエーションを1つずつ追加する必要があると思います。

編集3： IsPrimitive =（ブール、バイト、SByte、Int16、UInt16、Int32、UInt32、Int64、UInt64、IntPtr、UIntPtr、Char、Double、およびSingle）、チェックするAnther Primitive-Likeタイプ（t == typeof（DateTime ））

同様の解決策を探しているときにこの質問を見つけました。System.TypeCodeそして、とを使用した次のアプローチに興味があるかもしれないと思いましたSystem.Convert。

System.TypeCode以外にマッピングされているタイプをシリアル化するのは簡単なSystem.TypeCode.Objectので、次のようにすることができます。

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

このアプローチの利点は、他のすべての受け入れ可能な非プリミティブ型に名前を付ける必要がないことです。上記のコードを少し変更して、IConvertibleを実装する任意の型を処理することもできます。

ORMでは次のようにします。

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

私は使用IsValueTypeが最良のオプションではないことを知っています（独自の非常に複雑な構造体を使用できます）が、99％のケースで機能します（Nullableも含まれます）。

@Ronnie Overby応答と@jonathanconwayコメントから、Nullableで機能するこのメソッドを作成し、ユーザー構造体を除外しました。

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

次の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?)));
}

ここに私がそれをした方法があります。

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

また、良い可能性：

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

次のような関数シグネチャがあると仮定します。

void foo<T>() 

ジェネリック制約を追加して、値タイプのみを許可することができます。

void foo<T>() where T : struct

これにより、Tのプリミティブ型だけでなく、あらゆる値型が許可されることに注意してください。

XMLにエクスポートするために、型をシリアル化する必要がありました。これを行うために、オブジェクトを反復処理し、プリミティブ、列挙型、値型、またはシリアル化可能なフィールドを選択しました。これは私のクエリの結果でした：

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

LINQを使用して型を反復処理し、その名前と値を取得してシンボルテーブルに格納しました。その鍵は、私が反省のために選んだ「where」節にあります。私は、プリミティブ、列挙型、値型、およびシリアライズ可能な型を選択しました。これにより、期待どおりに文字列とDateTimeオブジェクトを取得できました。

乾杯！

これは私のライブラリにあるものです。コメントは大歓迎です。

IsValueTypeを最初にチェックします。これは、ほとんどのタイプを処理するためです。次に、Stringが2番目に一般的であるためです。私は値型ではないプリミティブを考えることができないので、そのレッグがヒットするかどうかはわかりません。

  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

次に、次のように使用できます。

  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

私のソリューションを共有したいだけです。多分それは誰にとっても便利です。

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

匿名オブジェクトには名前空間が割り当てられていないため、NULL名前空間を確認することを忘れないでください

ここに別の実行可能なオプションがあります。

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