วิธีการทดสอบว่า Type เป็นแบบดั้งเดิมหรือไม่

ฉันมีบล็อกของรหัสที่ทำให้ประเภทเป็นอนุกรมในแท็ก 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แต่ต้องระวังเพราะมีบางชนิดที่เราสามารถคิดว่าเป็นพื้นฐาน แต่พวกเขาทางจะยกตัวอย่างและDecimalString

แก้ไข 1: เพิ่มรหัสตัวอย่าง

นี่คือตัวอย่างรหัส:

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

แก้ไข 2:ในฐานะที่เป็นความเห็นของ@SLaksมีประเภทอื่น ๆ ที่บางทีคุณอาจต้องการที่จะถือว่าเป็นสิ่งพื้นฐาน ฉันคิดว่าคุณจะต้องเพิ่มรูปแบบนี้ทีละรายการ

แก้ไข 3: IsPrimitive = (บูลีน, ไบต์, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, IntPtr, UIntPtr, Char, Double, และ Single), Anther Primitive-like type เพื่อตรวจสอบ (t == typeof (DateTime) ))

ฉันเพิ่งพบคำถามนี้ขณะที่กำลังมองหาวิธีการแก้ปัญหาที่คล้ายกันและคิดว่าคุณอาจจะสนใจในวิธีการต่อไปนี้โดยใช้และSystem.TypeCodeSystem.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 เมื่อต้องการทำสิ่งนี้ฉันทำซ้ำผ่านวัตถุและเลือกเขตข้อมูลที่เป็นแบบดั้งเดิม enum ชนิดของค่าหรือเป็นอนุกรม นี่คือผลลัพธ์ของแบบสอบถามของฉัน:

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