Using .Net, how can I determine if a type is a Numeric ValueType?

Question

But here is an example:

Dim desiredType as Type if IsNumeric(desiredType) then ... 

EDIT: I only know the type and not the value as a string.

Well, unfortunately, I have to cycle through using TypeCode.

But this is a good way to do this:

  if ((desiredType.IsArray)) return 0; switch (Type.GetTypeCode(desiredType)) { case 3: case 6: case 7: case 9: case 11: case 13: case 14: case 15: return 1; } ;return 0; 

Answer 1

A few years later, but here is my solution (you can choose whether to include boolean). Solves for the Nullable case. XUnit test included

 /// <summary> /// Determines if a type is numeric. Nullable numeric types are considered numeric. /// </summary> /// <remarks> /// Boolean is not considered numeric. /// </remarks> public static bool IsNumericType( Type type ) { if (type == null) { return false; } switch (Type.GetTypeCode(type)) { case TypeCode.Byte: case TypeCode.Decimal: case TypeCode.Double: case TypeCode.Int16: case TypeCode.Int32: case TypeCode.Int64: case TypeCode.SByte: case TypeCode.Single: case TypeCode.UInt16: case TypeCode.UInt32: case TypeCode.UInt64: return true; case TypeCode.Object: if ( type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>)) { return IsNumericType(Nullable.GetUnderlyingType(type)); } return false; } return false; } /// <summary> /// Tests the IsNumericType method. /// </summary> [Fact] public void IsNumericTypeTest() { // Non-numeric types Assert.False(TypeHelper.IsNumericType(null)); Assert.False(TypeHelper.IsNumericType(typeof(object))); Assert.False(TypeHelper.IsNumericType(typeof(DBNull))); Assert.False(TypeHelper.IsNumericType(typeof(bool))); Assert.False(TypeHelper.IsNumericType(typeof(char))); Assert.False(TypeHelper.IsNumericType(typeof(DateTime))); Assert.False(TypeHelper.IsNumericType(typeof(string))); // Arrays of numeric and non-numeric types Assert.False(TypeHelper.IsNumericType(typeof(object[]))); Assert.False(TypeHelper.IsNumericType(typeof(DBNull[]))); Assert.False(TypeHelper.IsNumericType(typeof(bool[]))); Assert.False(TypeHelper.IsNumericType(typeof(char[]))); Assert.False(TypeHelper.IsNumericType(typeof(DateTime[]))); Assert.False(TypeHelper.IsNumericType(typeof(string[]))); Assert.False(TypeHelper.IsNumericType(typeof(byte[]))); Assert.False(TypeHelper.IsNumericType(typeof(decimal[]))); Assert.False(TypeHelper.IsNumericType(typeof(double[]))); Assert.False(TypeHelper.IsNumericType(typeof(short[]))); Assert.False(TypeHelper.IsNumericType(typeof(int[]))); Assert.False(TypeHelper.IsNumericType(typeof(long[]))); Assert.False(TypeHelper.IsNumericType(typeof(sbyte[]))); Assert.False(TypeHelper.IsNumericType(typeof(float[]))); Assert.False(TypeHelper.IsNumericType(typeof(ushort[]))); Assert.False(TypeHelper.IsNumericType(typeof(uint[]))); Assert.False(TypeHelper.IsNumericType(typeof(ulong[]))); // numeric types Assert.True(TypeHelper.IsNumericType(typeof(byte))); Assert.True(TypeHelper.IsNumericType(typeof(decimal))); Assert.True(TypeHelper.IsNumericType(typeof(double))); Assert.True(TypeHelper.IsNumericType(typeof(short))); Assert.True(TypeHelper.IsNumericType(typeof(int))); Assert.True(TypeHelper.IsNumericType(typeof(long))); Assert.True(TypeHelper.IsNumericType(typeof(sbyte))); Assert.True(TypeHelper.IsNumericType(typeof(float))); Assert.True(TypeHelper.IsNumericType(typeof(ushort))); Assert.True(TypeHelper.IsNumericType(typeof(uint))); Assert.True(TypeHelper.IsNumericType(typeof(ulong))); // Nullable non-numeric types Assert.False(TypeHelper.IsNumericType(typeof(bool?))); Assert.False(TypeHelper.IsNumericType(typeof(char?))); Assert.False(TypeHelper.IsNumericType(typeof(DateTime?))); // Nullable numeric types Assert.True(TypeHelper.IsNumericType(typeof(byte?))); Assert.True(TypeHelper.IsNumericType(typeof(decimal?))); Assert.True(TypeHelper.IsNumericType(typeof(double?))); Assert.True(TypeHelper.IsNumericType(typeof(short?))); Assert.True(TypeHelper.IsNumericType(typeof(int?))); Assert.True(TypeHelper.IsNumericType(typeof(long?))); Assert.True(TypeHelper.IsNumericType(typeof(sbyte?))); Assert.True(TypeHelper.IsNumericType(typeof(float?))); Assert.True(TypeHelper.IsNumericType(typeof(ushort?))); Assert.True(TypeHelper.IsNumericType(typeof(uint?))); Assert.True(TypeHelper.IsNumericType(typeof(ulong?))); // Testing with GetType because of handling with non-numerics. See: // http://msdn.microsoft.com/en-us/library/ms366789.aspx // Using GetType - non-numeric Assert.False(TypeHelper.IsNumericType((new object()).GetType())); Assert.False(TypeHelper.IsNumericType(DBNull.Value.GetType())); Assert.False(TypeHelper.IsNumericType(true.GetType())); Assert.False(TypeHelper.IsNumericType('a'.GetType())); Assert.False(TypeHelper.IsNumericType((new DateTime(2009, 1, 1)).GetType())); Assert.False(TypeHelper.IsNumericType(string.Empty.GetType())); // Using GetType - numeric types // ReSharper disable RedundantCast Assert.True(TypeHelper.IsNumericType((new byte()).GetType())); Assert.True(TypeHelper.IsNumericType(43.2m.GetType())); Assert.True(TypeHelper.IsNumericType(43.2d.GetType())); Assert.True(TypeHelper.IsNumericType(((short)2).GetType())); Assert.True(TypeHelper.IsNumericType(((int)2).GetType())); Assert.True(TypeHelper.IsNumericType(((long)2).GetType())); Assert.True(TypeHelper.IsNumericType(((sbyte)2).GetType())); Assert.True(TypeHelper.IsNumericType(2f.GetType())); Assert.True(TypeHelper.IsNumericType(((ushort)2).GetType())); Assert.True(TypeHelper.IsNumericType(((uint)2).GetType())); Assert.True(TypeHelper.IsNumericType(((ulong)2).GetType())); // ReSharper restore RedundantCast // Using GetType - nullable non-numeric types bool? nullableBool = true; Assert.False(TypeHelper.IsNumericType(nullableBool.GetType())); char? nullableChar = ' '; Assert.False(TypeHelper.IsNumericType(nullableChar.GetType())); DateTime? nullableDateTime = new DateTime(2009, 1, 1); Assert.False(TypeHelper.IsNumericType(nullableDateTime.GetType())); // Using GetType - nullable numeric types byte? nullableByte = 12; Assert.True(TypeHelper.IsNumericType(nullableByte.GetType())); decimal? nullableDecimal = 12.2m; Assert.True(TypeHelper.IsNumericType(nullableDecimal.GetType())); double? nullableDouble = 12.32; Assert.True(TypeHelper.IsNumericType(nullableDouble.GetType())); short? nullableInt16 = 12; Assert.True(TypeHelper.IsNumericType(nullableInt16.GetType())); short? nullableInt32 = 12; Assert.True(TypeHelper.IsNumericType(nullableInt32.GetType())); short? nullableInt64 = 12; Assert.True(TypeHelper.IsNumericType(nullableInt64.GetType())); sbyte? nullableSByte = 12; Assert.True(TypeHelper.IsNumericType(nullableSByte.GetType())); float? nullableSingle = 3.2f; Assert.True(TypeHelper.IsNumericType(nullableSingle.GetType())); ushort? nullableUInt16 = 12; Assert.True(TypeHelper.IsNumericType(nullableUInt16.GetType())); ushort? nullableUInt32 = 12; Assert.True(TypeHelper.IsNumericType(nullableUInt32.GetType())); ushort? nullableUInt64 = 12; Assert.True(TypeHelper.IsNumericType(nullableUInt64.GetType())); } 

Answer 2

You can find out if a variable is numeric using the Type.GetTypeCode() method:

 TypeCode typeCode = Type.GetTypeCode(desiredType); if (typeCode == TypeCode.Double || typeCode == TypeCode.Integer || ...) return true; 

You will need to fill in all available numeric types in the "..." section;)

Read more here: Enumerating TypeCode

Answer 3

Great article here Exploring IsNumeric for C # .

Option 1:

Link Microsoft.VisualBasic.dll, then follow these steps:

 if (Microsoft.VisualBasic.Information.IsNumeric("5")) { //Do Something } 

Option 2:

 public static bool Isumeric (object Expression) { bool f; ufloat64 a; long l; IConvertible iConvertible = null; if ( ((Expression is IConvertible))) { iConvertible = (IConvertible) Expression; } if (iConvertible == null) { if ( ((Expression is char[]))) { Expression = new String ((char[]) Expression); goto IL_002d; // hopefully inserted by optimizer } return 0; } IL_002d: TypeCode typeCode = iConvertible.GetTypeCode (); if ((typeCode == 18) || (typeCode == 4)) { string str = iConvertible.ToString (null); try { if ( (StringType.IsHexOrOctValue (str, l))) { f = true; return f; } } catch (Exception ) { f = false; return f; }; return DoubleType.TryParse (str, a); } return Utils.IsNumericTypeCode (typeCode); } internal static bool IsNumericType (Type typ) { bool f; TypeCode typeCode; if ( (typ.IsArray)) { return 0; } switch (Type.GetTypeCode (typ)) { case 3: case 6: case 7: case 9: case 11: case 13: case 14: case 15: return 1; }; return 0; } 

Answer 4

If you have a link to the actual object, here is a simple solution for C #, which is very simple:

  /// <summary> /// Determines whether the supplied object is a .NET numeric system type /// </summary> /// <param name="val">The object to test</param> /// <returns>true=Is numeric; false=Not numeric</returns> public static bool IsNumeric(ref object val) { if (val == null) return false; // Test for numeric type, returning true if match if ( val is double || val is float || val is int || val is long || val is decimal || val is short || val is uint || val is ushort || val is ulong || val is byte || val is sbyte ) return true; // Not numeric return false; } 

Answer 5

With all due respect to @ SFun28 and @nawfal (thanks!), I used both of their answers, slightly tweaked and came up with these extension methods:

 public static class ReflectionExtensions { public static bool IsNullable(this Type type) { return type != null && type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>); } public static bool IsNumeric(this Type type) { if (type == null || type.IsEnum) return false; if (IsNullable(type)) return IsNumeric(Nullable.GetUnderlyingType(type)); switch (Type.GetTypeCode(type)) { case TypeCode.Byte: case TypeCode.Decimal: case TypeCode.Double: case TypeCode.Int16: case TypeCode.Int32: case TypeCode.Int64: case TypeCode.SByte: case TypeCode.Single: case TypeCode.UInt16: case TypeCode.UInt32: case TypeCode.UInt64: return true; default: return false; } } } 

Answer 6

This is how MS implemented it in System.Dynamic.Utils.TypeUtils , which is an inner class. It turns out that they do not consider System.Decimal as a numeric type ( Decimal omitted from the enumeration). And interestingly, MS finds a System.Char type for numerical. Otherwise, it is exactly the same as SFun28's answer. I believe his answer is "more correct."

 internal static bool IsNumeric(Type type) { type = type.GetNonNullableType(); if (!type.IsEnum) { switch (Type.GetTypeCode(type)) { case TypeCode.Char: case TypeCode.SByte: case TypeCode.Byte: case TypeCode.Int16: case TypeCode.UInt16: case TypeCode.Int32: case TypeCode.UInt32: case TypeCode.Int64: case TypeCode.UInt64: case TypeCode.Single: case TypeCode.Double: return true; } } return false; } //where GetNonNullableType is defined as internal static Type GetNonNullableType(this Type type) { if (type.IsNullableType()) { return type.GetGenericArguments()[0]; } return type; } //where IsNullableType is defined as internal static bool IsNullableType(this Type type) { return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>); } 

Answer 7

I know this is a VERY late answer, but here is the function I use:

 public static bool IsNumeric(Type type) { var t = Nullable.GetUnderlyingType(type) ?? type; return t.IsPrimitive || t == typeof(decimal); } 

If you want to exclude char as a numeric type, you can use this example:

 return (t.IsPrimitive || t == typeof(decimal)) && t != typeof(char); 

According to MSDN :

Primitive types are Boolean, Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, IntPtr, UIntPtr, Char, Double and Single.

Note. This check includes IntPtr and UIntPtr .

Here is the same function as the general extension method (I know this does not work for the OP case, but it may seem useful to someone):

 public static bool IsNumeric<T>(this T value) { var t = Nullable.GetUnderlyingType(value.GetType()) ?? value.GetType(); return t.IsPrimitive || t == typeof(decimal); } 

Answer 8

 ''// Return true if a type is a numeric type. Private Function IsNumericType(ByVal this As Type) As Boolean ''// All the numeric types have bits 11xx set whereas non numeric do not. ''// That is if you include char type which is 4(decimal) = 100(binary). If this.IsArray Then Return False If (Type.GetTypeCode(this) And &HC) > 0 Then Return True Return False End Function 

Answer 9

Now you can use the .NET Framework method

 typeof(decimal?).IsNumericType() 

Answer 10

Use Type.IsValueType () and TryParse ():

 public bool IsInteger(Type t) { int i; return t.IsValueType && int.TryParse(t.ToString(), out i); }