usar - Usando.Net, ¿cómo puedo determinar si un tipo es un ValueType numérico?

tipos de etiquetas en git

Question

Pero aquí hay un ejemplo:

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

EDITAR: solo conozco el tipo, no el valor como una cadena.

Bien, lamentablemente tengo que pasar por el TypeCode.

Pero esta es una buena forma de hacerlo:

 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

Así es como MS lo ha implementado en System.Dynamic.Utils.TypeUtils que es una clase interna. Resulta que no consideran que System.Decimal sea ​​un tipo numérico (el Decimal se omite de la enumeración). Y curiosamente MS encuentra que el tipo System.Char es numérico. De lo contrario, es exactamente lo mismo que la respuesta de SFun28. Supongo que su respuesta es "más correcta".

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 2

Con todo el crédito debido a @ SFun28 y @nawfal (¡gracias!), Utilicé sus dos respuestas, pellizqué un poco y presenté estos métodos de extensión:

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 3

Gran artículo aquí Explorando IsNumeric para C # .

Opción 1:

Referencia Microsoft.VisualBasic.dll, a continuación, haga lo siguiente:

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

Opcion 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

Puede averiguar si una variable es numérica utilizando el método Type.GetTypeCode() :

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

Tendrá que completar todos los tipos numéricos disponibles en la parte "...";)

Más detalles aquí: Enumeración de TypeCode

Answer 5

Sé que esta es una respuesta MUY tardía, pero esta es la función que uso:

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

Si desea excluir char como un tipo numérico, puede usar este ejemplo:

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

De acuerdo con MSDN :

Los tipos primitivos son Boolean, Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, IntPtr, UIntPtr, Char, Double y Single.

Nota: esta verificación incluye IntPtr y UIntPtr .

Aquí está la misma función que un método de extensión genérico (sé que esto no funciona para el caso del OP, pero alguien más puede encontrarlo útil):

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

Answer 6

Si tiene una referencia a un objeto real, aquí hay una solución simple para C # que es muy sencilla:

 /// <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 7

Unos años más tarde aquí, pero aquí está mi solución (puede elegir si incluir boolean). Resuelve para el caso Nullable. Prueba XUnit incluida

/// <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 8

Use Type.IsValueType () y TryParse ():

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

Answer 9

''''// 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