Cara Menguji apakah Jenis Primitif

Saya memiliki blok kode yang membuat serial suatu jenis menjadi 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);
}

Ini karya besar, kecuali saya ingin hanya melakukan ini untuk tipe primitif, seperti int, double, booldll, dan jenis lainnya yang tidak primitif tapi dapat serial dengan mudah seperti string. Saya ingin mengabaikan hal lain seperti Daftar & jenis kustom lainnya.

Adakah yang bisa menyarankan bagaimana saya melakukan ini? Atau apakah saya perlu menentukan tipe yang ingin saya izinkan di suatu tempat dan mengaktifkan tipe properti untuk melihat apakah itu diperbolehkan? Itu agak berantakan, jadi alangkah baiknya jika saya ada cara yang lebih rapi.

Anda dapat menggunakan properti Type.IsPrimitive, tetapi berhati-hatilah karena ada beberapa tipe yang dapat kita anggap primitif, tetapi mereka tidak, misalnya Decimaldan String.

Sunting 1: Menambahkan kode sampel

Berikut ini contoh kode:

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

Sunting 2: Seperti komentar @SLaks , ada jenis lain yang mungkin ingin Anda perlakukan sebagai primitif. Saya pikir Anda harus menambahkan variasi ini satu per satu .

Sunting 3: IsPrimitive = (Boolean, Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, IntPtr, UIntPtr, Char, Double, dan Single), jenis Anther Primitive-like untuk memeriksa (t == typeof (DateTime) ))

Saya baru saja menemukan pertanyaan ini sambil mencari solusi yang serupa, dan berpikir Anda mungkin tertarik pada pendekatan berikut menggunakan System.TypeCodedan System.Convert.

Sangat mudah untuk membuat serial apa pun jenis yang dipetakan ke System.TypeCodeselain System.TypeCode.Object, jadi Anda bisa melakukan:

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

Keuntungan dari pendekatan ini adalah Anda tidak perlu menyebutkan setiap tipe non-primitif lainnya yang dapat diterima. Anda juga dapat memodifikasi kode di atas sedikit untuk menangani semua jenis yang mengimplementasikan IConvertible.

Kami melakukannya seperti ini di ORM kami:

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

Saya tahu bahwa menggunakan IsValueTypebukanlah pilihan terbaik (Anda dapat memiliki struct Anda sendiri yang sangat kompleks) tetapi berfungsi dalam 99% kasus (dan termasuk Nullables).

Dari tanggapan @Ronnie Overby dan komentar @jonathanconway, saya menulis metode ini yang berfungsi untuk Nullable, dan mengecualikan struct pengguna.

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

Dengan TestCase berikut:

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

Begini cara saya melakukannya.

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

Juga kemungkinan yang baik:

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

Dengan asumsi Anda memiliki tanda tangan fungsi seperti ini:

void foo<T>() 

Anda bisa menambahkan batasan umum untuk mengizinkan hanya tipe nilai:

void foo<T>() where T : struct

Perhatikan bahwa ini memungkinkan tidak hanya tipe primitif untuk T, tetapi semua tipe nilai.

Saya memiliki kebutuhan untuk membuat cerita bersambung jenis untuk tujuan mengekspornya ke XML. Untuk melakukan ini, saya mengulangi melalui objek dan memilih bidang yang primitif, enum, tipe nilai atau serializable. Ini adalah hasil dari permintaan saya:

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

Saya menggunakan LINQ untuk beralih melalui tipe, kemudian mendapatkan nama dan nilai mereka untuk disimpan dalam tabel simbol. Kuncinya ada pada klausa 'di mana' yang saya pilih untuk refleksi. Saya memilih tipe nilai primitif, enumerasi, dan tipe serial. Ini memungkinkan untuk string dan objek DateTime untuk datang seperti yang saya harapkan.

Bersulang!

Ini yang saya miliki di perpustakaan saya. Komentar diterima.

Saya memeriksa IsValueType terlebih dahulu, karena menangani sebagian besar jenis, lalu String, karena ini yang paling umum kedua. Saya tidak bisa memikirkan primitif yang bukan tipe nilai, jadi saya tidak tahu apakah kaki itu pernah terkena.

  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

Maka saya bisa menggunakannya seperti ini:

  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

Saya hanya ingin membagikan solusi saya. Mungkin bermanfaat bagi siapa pun.

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

Jangan lupa untuk memeriksa NULL namespace, karena objek anonim tidak memiliki namespace yang ditetapkan

Berikut adalah opsi lain yang layak.

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