Як перевірити, чи тип примітивний

У мене є блок коду, який серіалізує тип у тег 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, але будьте обережні , тому що є деякі типи , які ми можемо думати , що примітиви, але вони are not, наприклад , Decimalі String.

Редагувати 1: Доданий зразок коду

Ось зразок коду:

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

Редагувати 2: Як зазначає @SLaks , є й інші типи, які, можливо, ви теж хочете вважати примітивами. Я думаю, що вам доведеться додавати ці варіанти по черзі .

Редагувати 3: IsPrimitive = (Boolean, Byte, 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% випадків (і включає Nullables).

З відповіді @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, щоб перебирати типи, а потім отримувати їх ім’я та значення для зберігання в таблиці символів. Ключ - у пункті "куди", який я обрав для роздумів. Я вибрав примітивні, перелічені, типові значення та серіалізаційні типи. Це дозволило рядкам і об'єктам DateTime проходити так, як я очікував.

Ура!

Це те, що я маю в своїй бібліотеці. Коментарі вітаються.

Спочатку я перевіряю IsValueType, оскільки він обробляє більшість типів, а потім String, оскільки це другий за поширеністю. Я не можу придумати примітиву, який не є ціннісним типом, тому я не знаю, чи вдариться ця нога, якщо коли-небудь потрапить.

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