blocks|key|1088218|text|假设你有一个如下的函数签名：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1088219|void+foo<T>()+|code-block|syntax|javascript|1088220|您可以添加一个泛型约束来仅允许值类型：|1088221|void+foo<T>()+where+T+:+struct|1088222|请注意，这不仅允许T的基元类型，还允许任何值类型。|1088223|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Assuming you have a function signature like this:

<pre><code>void foo&lt;T&gt;() 
</code></pre>

You could add a generic constraint to allow value types only:

<pre><code>void foo&lt;T&gt;() where T : struct
</code></pre>

Notice that this allows not only primitive types for T, but any value type.

blocks|key|1303428|text|我是在寻找类似的解决方案时发现这个问题的，我想您可能会对以下使用System.TypeCode和System.Convert的方法感兴趣。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1303429|序列化映射到System.TypeCode.Object以外的System.TypeCode的任何类型都很容易，因此您可以这样做：|1303430|object+PropertyValue+=+...
if(Convert.GetTypeCode(PropertyValue)+!=+TypeCode.Object)
{
++++string+StringValue+=+Convert.ToString(PropertyValue);
++++...
}|code-block|syntax|javascript|1303431|这种方法的优点是，您不必命名所有其他可接受的非原语类型。您还可以稍微修改上面的代码，以处理任何实现IConvertible的类型。|1303432|entityMap^0|W|F|1C|E|0|6|M|V|F|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|11|8|@]|D|@]|E|$]]|$1|O|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|P|$]]

I just found this question while looking for a similar solution, and thought you might be interested in the following approach using <code>System.TypeCode</code> and <code>System.Convert</code>.

It is easy to serialize any type that is mapped to a <code>System.TypeCode</code> other than <code>System.TypeCode.Object</code>, so you could do:

<pre><code>object PropertyValue = ...
if(Convert.GetTypeCode(PropertyValue) != TypeCode.Object)
{
 string StringValue = Convert.ToString(PropertyValue);
 ...
}
</code></pre>

The advantage with this approach is you don't have to name every other acceptable non-primitive type. You could also modify the above code slightly to handle any type that implements IConvertible.

blocks|key|1303517|text|我们在ORM中这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1303518|Type+t;
bool+isPrimitiveType+=+t.IsPrimitive+%7C%7C+t.IsValueType+%7C%7C+(t+==+typeof(string));|code-block|syntax|javascript|1303519|我知道使用IsValueType不是最好的选择(你可以有自己的非常复杂的结构)，但它在99%25的情况下都有效(包括Nullable)。|offset|length|style|CODE|1303520|entityMap^0|0|0|5|B|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

We do it like this in our ORM:

<pre><code>Type t;
bool isPrimitiveType = t.IsPrimitive || t.IsValueType || (t == typeof(string));
</code></pre>

I know that using <code>IsValueType</code> is not the best option (you can have your own very complex structs) but it works in 99% cases (and includes Nullables).

blocks|key|1303582|text|这就是我的书库里的东西。欢迎提出意见。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1303583|我首先检查IsValueType，因为它处理大多数类型，然后是String，因为它是第二常见的。我想不出不是值类型的原语，所以我不知道if的那条腿是否会被击中。|1303584|++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|code-block|syntax|javascript|1303585|然后我可以像这样使用它：|1303586|++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|1303587|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

This is what I have in my library. Comments are welcome.

I check IsValueType first, since it handles most types, then String, since it's the second most common. I can't think of a primitive that isn't a value type, so I don't know if that leg of the if ever gets hit.

<pre class="lang-vb prettyprint-override"><code> 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
</code></pre>

Then I can use it like this:

<pre class="lang-vb prettyprint-override"><code> 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
</code></pre>

blocks|key|1088489|text|这就是我是如何做到的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1088490|+++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;
+++++++}
+++}|code-block|syntax|javascript|1088491|2020年更新|1088492|从@Xav987的答案派生而来，它的性能更好，代码更少。|1088493|++++static+readonly+ConcurrentDictionary<Type,+bool>+IsSimpleTypeCache+=+new+ConcurrentDictionary<System.Type,+bool>();

++++public+static+bool+IsSimpleType(Type+type)
++++{
++++++++return+IsSimpleTypeCache.GetOrAdd(type,+t+=>
++++++++++++type.IsPrimitive+%7C%7C
++++++++++++type.IsEnum+%7C%7C
++++++++++++type+==+typeof(string)+%7C%7C
++++++++++++type+==+typeof(decimal)+%7C%7C
++++++++++++type+==+typeof(DateTime)+%7C%7C
++++++++++++type+==+typeof(DateTimeOffset)+%7C%7C
++++++++++++type+==+typeof(TimeSpan)+%7C%7C
++++++++++++type+==+typeof(Guid)+%7C%7C
++++++++++++IsNullableSimpleType(type));

++++++++static+bool+IsNullableSimpleType(Type+t)
++++++++{
++++++++++++var+underlyingType+=+Nullable.GetUnderlyingType(t);
++++++++++++return+underlyingType+!=+null+&&+IsSimpleType(underlyingType);
++++++++}
++++}|1088494|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Here's how I did it.
<pre><code> 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&lt;&gt;).MakeGenericType(t);

 List = types.Concat(nullTypes).ToArray();
 }

 public static bool Test(Type type)
 {
 if (List.Any(x =&gt; x.IsAssignableFrom(type)))
 return true;

 var nut = Nullable.GetUnderlyingType(type);
 return nut != null &amp;&amp; nut.IsEnum;
 }
 }
</code></pre>
<h2>2020 update</h2>
Derived from @Xav987's answer, this performs better and has less code.
<pre><code> static readonly ConcurrentDictionary&lt;Type, bool&gt; IsSimpleTypeCache = new ConcurrentDictionary&lt;System.Type, bool&gt;();

 public static bool IsSimpleType(Type type)
 {
 return IsSimpleTypeCache.GetOrAdd(type, t =&gt;
 type.IsPrimitive ||
 type.IsEnum ||
 type == typeof(string) ||
 type == typeof(decimal) ||
 type == typeof(DateTime) ||
 type == typeof(DateTimeOffset) ||
 type == typeof(TimeSpan) ||
 type == typeof(Guid) ||
 IsNullableSimpleType(type));

 static bool IsNullableSimpleType(Type t)
 {
 var underlyingType = Nullable.GetUnderlyingType(t);
 return underlyingType != null &amp;&amp; IsSimpleType(underlyingType);
 }
 }

</code></pre>

blocks|key|1303705|text|我需要序列化类型，以便将它们导出到XML。为此，我遍历了对象，并选择了原语、枚举、值类型或可序列化的字段。这是我查询的结果：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1303706|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+%7C+BindingFlags.GetField+%7C+BindingFlags.Public),
+++++++++++++++++++++++++++++++++++++null,+null,+null)
+++++++++++++++++++++++++where+(type.IsPrimitive+%7C%7C+type.IsEnum+%7C%7C+type.IsValueType+%7C%7C+type.IsSerializable)
+++++++++++++++++++++++++select+new+{+Name+=+name,+Value+=+value});|code-block|syntax|javascript|1303707|我使用LINQ遍历类型，然后获取它们的名称和值以存储在符号表中。关键在于我选择用于反射的“where”子句。我选择了原始类型、枚举类型、值类型和可序列化类型。这允许字符串和DateTime对象如我所期望的那样通过。|1303708|干杯!|1303709|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I had a need to serialize types for the purposes of exporting them to XML. To do this, I iterated through the object and opted for fields that were primitive, enum, value types or serializable. This was the result of my query:

<pre><code>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});
</code></pre>

I used LINQ to iterate through the types, then get their name and value to store in a symbol table. The key is in the 'where' clause that I chose for reflection. I chose primitive, enumerated, value types and serializable types. This allowed for strings and DateTime objects to come through as I expected.

Cheers!

blocks|key|1088600|text|还有一个很好的可能性：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1088601|private+static+bool+IsPrimitiveType(Type+type)
{
++++return+(type+==+typeof(object)+%7C%7C+Type.GetTypeCode(type)+!=+TypeCode.Object);
}|code-block|syntax|javascript|1088602|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Also a good possibility:

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

blocks|key|1088655|text|我只想分享我的解决方案。也许它对任何人都有用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1088656|public+static+bool+IsPrimitiveType(Type+fieldType)
{
+++return+fieldType.IsPrimitive+%7C%7C+fieldType.Namespace.Equals("System");
}|code-block|syntax|javascript|1088657|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I just want to share my solution. Perhaps it's useful to anyone.

<pre><code>public static bool IsPrimitiveType(Type fieldType)
{
 return fieldType.IsPrimitive || fieldType.Namespace.Equals("System");
}
</code></pre>

blocks|key|1088689|text|public+static+bool+IsPrimitiveType(object+myObject)
{
+++var+myType+=+myObject.GetType();
+++return+myType.IsPrimitive+%7C%7C+myType.Namespace+==+null+%7C%7C++myType.Namespace.Equals("System");
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1088690|不要忘记检查NULL名称空间，因为匿名对象没有分配的名称空间|unstyled|1088691|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>public static bool IsPrimitiveType(object myObject)
{
 var myType = myObject.GetType();
 return myType.IsPrimitive || myType.Namespace == null || myType.Namespace.Equals("System");
}
</code></pre>

Don't forget to check NULL namespace, because anonymous objects don't have assigned namespace

blocks|key|1088742|text|从@Ronnie+Overby响应和@jonathanconway注释中，我编写了此方法，该方法适用于Nullable，并排除了用户结构。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1088743|public+static+bool+IsSimpleType(Type+type)
{
++++return
++++++++type.IsPrimitive+%7C%7C
++++++++new+Type[]+{
++++++++++++typeof(string),
++++++++++++typeof(decimal),
++++++++++++typeof(DateTime),
++++++++++++typeof(DateTimeOffset),
++++++++++++typeof(TimeSpan),
++++++++++++typeof(Guid)
++++++++}.Contains(type)+%7C%7C
++++++++type.IsEnum+%7C%7C
++++++++Convert.GetTypeCode(type)+!=+TypeCode.Object+%7C%7C
++++++++(type.IsGenericType+&&+type.GetGenericTypeDefinition()+==+typeof(Nullable<>)+&&+IsSimpleType(type.GetGenericArguments()[0]))
++++++++;
}|code-block|syntax|javascript|1088744|使用以下TestCase：|1088745|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?)));
}|1088746|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

From @Ronnie Overby response and @jonathanconway comment, I wrote this method that works for Nullable, and exclude user structs.

<pre><code>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 &amp;&amp; type.GetGenericTypeDefinition() == typeof(Nullable&lt;&gt;) &amp;&amp; IsSimpleType(type.GetGenericArguments()[0]))
 ;
}
</code></pre>

With the following TestCase :

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

blocks|key|1304024|text|这是另一个可行的选择。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1304025|public+static+bool+CanDirectlyCompare(Type+type)
{
++++return+typeof(IComparable).IsAssignableFrom(type)+%7C%7C+type.IsPrimitive+%7C%7C+type.IsValueType;
}|code-block|syntax|javascript|1304026|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is another viable option.

<pre><code>public static bool CanDirectlyCompare(Type type)
{
 return typeof(IComparable).IsAssignableFrom(type) || type.IsPrimitive || type.IsValueType;
}
</code></pre>

blocks|key|1304083|text|一种扩展方法，仅适用于基本类型、字符串、小数、DateTime、DateTimeOffset、TimeSpan和Guid。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1304084|如果你想包含泛型、结构和枚举，你可以在OR中添加type.IsValueType。|1304085|++++private+static+readonly+Type[]+PrimitiveLikeTypes+=+new[]
++++{
++++++++++++++++typeof(string),
++++++++++++++++typeof(decimal),
++++++++++++++++typeof(DateTime),
++++++++++++++++typeof(DateTimeOffset),
++++++++++++++++typeof(TimeSpan),
++++++++++++++++typeof(Guid)
++++};

++++///+<summary>
++++///+Determine+whether+a+type+is+simple+(Primitive,+String,+Decimal,+DateTime,+etc)+
++++///+or+complex+(i.e.+structs,+Enums,+custom+class+with+public+properties+and+methods).
++++///+Returns+false+for+structs+and+Enums
++++///+</summary>
++++///+<param+name="type">System.Type</param>
++++///+<returns>+boolean+value+indicating+whether+the+type+is+simple+or+not</returns>
++++public+static+bool+IsSimpleType(this+Type+type)
++++{
++++++++return+type.IsPrimitive+%7C%7C+PrimitiveLikeTypes.Contains(type);
++++}|code-block|syntax|javascript|1304086|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

An Extension method which works only for Primitive types, String, Decimal, DateTime, DateTimeOffset, TimeSpan and Guid. You can add type.IsValueType in OR if you want to include generics, structs and enums.
<pre><code> private static readonly Type[] PrimitiveLikeTypes = new[]
 {
 typeof(string),
 typeof(decimal),
 typeof(DateTime),
 typeof(DateTimeOffset),
 typeof(TimeSpan),
 typeof(Guid)
 };

 /// &lt;summary&gt;
 /// Determine whether a type is simple (Primitive, String, Decimal, DateTime, etc) 
 /// or complex (i.e. structs, Enums, custom class with public properties and methods).
 /// Returns false for structs and Enums
 /// &lt;/summary&gt;
 /// &lt;param name=&quot;type&quot;&gt;System.Type&lt;/param&gt;
 /// &lt;returns&gt; boolean value indicating whether the type is simple or not&lt;/returns&gt;
 public static bool IsSimpleType(this Type type)
 {
 return type.IsPrimitive || PrimitiveLikeTypes.Contains(type);
 }
 
</code></pre>

I have a block of code that serializes a type into a Html tag.

<pre><code>Type t = typeof(T); // I pass &lt;T&gt; 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);
}
</code></pre>

This works great, except I want it to only do this for primitive types, like <code>int</code>, <code>double</code>, <code>bool</code> etc, and other types that aren't primitive but can be serialized easily like <code>string</code>. I want it to ignore everything else like Lists &amp; other custom types.

Can anyone suggest how I do this? Or do I need to specify the types I want to allow somewhere and switch on the property's type to see if it's allowed? That's a little messy, so it'd be nice if I there was a tidier way.

How To Test if Type is Primitive

我有一段将类型序列化为Html标记的代码。Type t = typeof(T); // I pass <T> in as a paramter, where myObj is of type TtagBuilder.Attributes.Add("class", t.Name);foreach (PropertyInf...

问如何测试类型是否为原语
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何测试类型是否为原语EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何测试类型是否为原语
EN