programacion - posible comparacion de referencias no intencionada c#

¿Cómo puedo comparar cualquier tipo numérico a cero en C#

Question

Me gustaría crear una función que compruebe si un valor numérico pasado como argumento tiene un valor mayor que cero. Algo como esto:

public bool IsGreaterThanZero(object value)
{
    if(value is int)
    {
        return ((int)value > 0);
    }
    else if(value is float)
    {
        // Similar code for float
    }

    return false;
}

¿Puedo intentar convertir el objeto pasado como el argumento de la función en un tipo de datos numéricos para poder compararlo a cero en lugar de verificar para cada tipo en mi sentencia if? Si el lanzamiento falla, devolvería falso. ¿Hay una forma mejor (leer más corta, más legible) para hacer esto?

Editar: Algunos han preguntado si sé que el tipo será un número, por qué el objeto, etc. Espero que esto aclare las cosas.

Esta función sería parte de un convertidor de Silverlight que implementa la interfaz IValueConverter que tiene una firma de conversión de

public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)

En primer lugar, solo quería que el convertidor funcionara con Ints, pero mi imaginación comenzó a funcionar de forma salvaje y pienso qué pasaría si tuviera números de coma flotante y otros tipos numéricos. Quería hacer el convertidor lo más flexible posible. Inicialmente pensé que toda esta información adicional se interpondría en el camino de lo que quería hacer, así que no lo incluí en mi pregunta.

Answer 1

¿La persona que llama sabe el tipo? Si es así, ¿qué tal?

public static bool GreaterThanZero<T>(T value) where T : struct, IComparable<T>
{
    return value.CompareTo(default(T)) > 0;
}

No se necesitan conversiones, y deberían funcionar para cualquiera de los tipos numéricos incorporados, y cualquier tipo de valores razonables que se te ocurran. (Por ejemplo, esto estaría bien con la estructura de Duration Noda Time).

Tenga en cuenta que la persona que llama no tiene que saber el tipo directamente , solo puede conocerlo como otro parámetro de tipo con las mismas restricciones. Es cierto que esto puede no ser apropiado para su situación, pero pensé que lo mencionaría de todos modos. Si nada sabe el tipo en tiempo de compilación (¡y no le apetece que teclee dinámicamente para hacer el trabajo por usted en C # 4!), Entonces llamar a Convert.ToDouble es probablemente su mejor Convert.ToDouble , solo tenga en cuenta que puede tener problemas para System.Numerics.BigInteger de .NET 4.0.

Answer 2

¿Por qué no simplemente Convert.ToDouble o Convert.ToDecimal y luego hacer la comparación? Parece que eso manejaría la mayoría de los tipos que alguien podría pasar.

Answer 3

Eh? ¿Qué tipos numéricos te importan?

public bool IsGreaterThanZero(double value)
{
    return value > 0;
}

Todo esto funciona ...

    IsGreaterThanZero((int)2);
    IsGreaterThanZero((long)2);
    IsGreaterThanZero((double)2);
    IsGreaterThanZero((float)2);
    IsGreaterThanZero((byte)2);
    IsGreaterThanZero((ulong)2);

Answer 4

Mi preferencia sería:

public bool IsGreaterThanZero(object value)
{
    if(value is IConvertible)
    {
        return Convert.ToDouble(value) > 0.0;
    }

    return false;
}

Esto manejará todos los tipos IConvertible de forma segura (que incluye todos los tipos de punto flotante y entero en el marco, pero también cualquier tipo personalizado).

Answer 5

Puedes evitar el boxeo y el unboxing usando genéricos:

Aquí está la definición de una función

class GenericComparation {
    public static bool IsGreaterThanZero<T>(T value) where T : IComparable<T> {
        // Console.WriteLine(value.GetType().Name)
        return value.CompareTo(default(T)) > 0;
    }
}

Uso:

Console.WriteLine(GenericComparation.IsGreaterThanZero(1));
Console.WriteLine(GenericComparation.IsGreaterThanZero(-1.1));
Console.WriteLine(GenericComparation.IsGreaterThanZero(Decimal.Zero));

Answer 6

Tratar:

double tempValue;
if(double.TryParse(value.ToString(), out tempValue)
{
  return (tempValue > 0)
}
else 
{
  return false;
}

Answer 7

Esta forma más simple y rápida de comparar cualquier tipo numérico con cero es la siguiente:

public bool IsGreaterThanZero(object value) 
{ 
    if (value != null && value.GetType().IsValueType)
        return System.Convert.ToDouble(value) > 0;
    return false; 
}