c# - numeros - programacion c decimales

¿Cómo comparar correctamente los valores decimales en C#?

Question

Vengo de un entorno en C ++, y sé que no se pueden comparar exactamente flotadores para la igualdad. Para C #, simplemente asumí que la misma política se aplica a valores decimales, o cualquier valor de coma flotante en general.

Básicamente, tengo dos valores decimales y si NO son iguales entre sí, necesito realizar alguna acción. p.ej:

decimal value1, value2;
// Assume value1 and value2 are set somewhere to valid values.
if( value1 != value2 )
{
    // Do something
}

Si esto no funciona como se esperaba, estoy dispuesto a aceptar una solución que haga una comparación de igualdad con un margen de error, digamos .00001 o algo así. ¿Cuál sería la solución recomendada para este problema?

Answer 1

Creo que esto resolverá tu problema.

Básicamente hay un método decimal.compare.

EDITAR: Este puede ser el mejor método:

Decimal.Equals

EDIT2: si puede comparar directamente como se sugirió anteriormente, eso puede ser más eficiente. Voy a dejar esto ya que puede ser de interés.

Answer 2

Estaba investigando algo similar, pero con una precisión en lugar de un margen de error y terminé escribiendo algunas extensiones para Float. Sin embargo, esto se puede adaptar fácilmente para cualquier tipo. Tengo una serie complicada de comparaciones y esto lo hace agradable y legible.

/// <summary>
/// A set of extensions to allow the convenient comparison of float values based on a given precision.
/// </summary>
public static class FloatingPointExtensions
{
    /// <summary>
    /// Determines if the float value is less than or equal to the float parameter according to the defined precision.
    /// </summary>
    /// <param name="float1">The float1.</param>
    /// <param name="float2">The float2.</param>
    /// <param name="precision">The precision.  The number of digits after the decimal that will be considered when comparing.</param>
    /// <returns></returns>
    public static bool LessThan(this float float1, float float2, int precision)
    {
        return (System.Math.Round(float1 - float2, precision) < 0);
    }

    /// <summary>
    /// Determines if the float value is less than or equal to the float parameter according to the defined precision.
    /// </summary>
    /// <param name="float1">The float1.</param>
    /// <param name="float2">The float2.</param>
    /// <param name="precision">The precision.  The number of digits after the decimal that will be considered when comparing.</param>
    /// <returns></returns>
    public static bool LessThanOrEqualTo(this float float1, float float2, int precision)
    {
        return (System.Math.Round(float1 - float2, precision) <= 0);
    }

    /// <summary>
    /// Determines if the float value is greater than (>) the float parameter according to the defined precision.
    /// </summary>
    /// <param name="float1">The float1.</param>
    /// <param name="float2">The float2.</param>
    /// <param name="precision">The precision.  The number of digits after the decimal that will be considered when comparing.</param>
    /// <returns></returns>
    public static bool GreaterThan(this float float1, float float2, int precision)
    {
        return (System.Math.Round(float1 - float2, precision) > 0);
    }

    /// <summary>
    /// Determines if the float value is greater than or equal to (>=) the float parameter according to the defined precision.
    /// </summary>
    /// <param name="float1">The float1.</param>
    /// <param name="float2">The float2.</param>
    /// <param name="precision">The precision.  The number of digits after the decimal that will be considered when comparing.</param>
    /// <returns></returns>
    public static bool GreaterThanOrEqualTo(this float float1, float float2, int precision)
    {
        return (System.Math.Round(float1 - float2, precision) >= 0);
    }

    /// <summary>
    /// Determines if the float value is equal to (==) the float parameter according to the defined precision.
    /// </summary>
    /// <param name="float1">The float1.</param>
    /// <param name="float2">The float2.</param>
    /// <param name="precision">The precision.  The number of digits after the decimal that will be considered when comparing.</param>
    /// <returns></returns>
    public static bool AlmostEquals(this float float1, float float2, int precision)
    {
        return (System.Math.Round(float1 - float2, precision) == 0);
    } 
}

Answer 3

Estoy de acuerdo con las otras respuestas, pero me encuentro con un problema donde se compara un decimal "auténtico" del servidor con uno proveniente de JSON / navegador (y debe haber sido un flotante en algún momento).

Terminé con este código para redondear a 2 dígitos después del punto decimal, que era lo suficientemente preciso en mi caso:

if (Decimal.Round(serverTotalPrice, 2) != Decimal.Round(request.TotalPrice, 2)) {
    throw new ArgumentException("The submitted Total Price is not valid");
}

Answer 4

Tu código funcionará como se esperaba. Las cifras decimal C # están optimizadas para ser muy precisas al representar los números de la base 10, por lo que si eso es lo que estás comparando (dinero, ...), todo debería estar bien.

Aquí hay una explicación muy clara sobre la precisión de los decimales de Jon Skeet:

Diferencia entre decimal, flotante y doble en .NET?