C# 编译器“优化代码”：仅在代码片段上禁用

Question

我有一个 C# 代码，当“优化代码”选项关闭时运行良好，否则失败。是否有任何函数或类属性可以阻止函数或类的优化，而让编译器优化其他的？

（我尝试了 unsafe 或 MethodImpl，但没有成功）

谢谢

编辑： 我又做了一些测试... 代码是这样的：

double arg = (Math.PI / 2d - Math.Atan2(a, d)); 

当 a = 1 和 d = 0 时，arg 应该是 0。 该代码是Excel通过ExcelDNA调用的函数。

从优化的控制台应用程序调用相同的代码：好的

在没有优化的情况下从 Excel 调用此代码：好的

通过优化从 Excel 调用此代码：不好，arg == 0 为假（相反，arg 是接近 0 的一个非常小的值，但不是 0）

与调用函数前的 [MethodImpl(MethodImplOptions.NoOptimization)] 结果相同。

Answer 1

这很可能与 Excel 可能设置的 floating point mode 有关 - 这意味着您的程序计算浮点数略有不同，因为程序 (Excel) 托管您的程序集 (DLL)。这可能会影响您的结果的计算方式，或者如何/哪些值被自动强制为零。

为了绝对确保您不会遇到不同浮点模式和/或错误的问题，您应该检查是否相等，而不是检查值是否非常接近。 This is not really a hack.

public class AlmostDoubleComparer : IComparer<double>
{
    public static readonly AlmostDoubleComparer Default = new AlmostDoubleComparer();
    public const double Epsilon = double.Epsilon * 64d; // 0.{322 zeroes}316

    public static bool IsZero(double x)
    {
        return Compare(x, 0) == 0;
    }

    public static int Compare(double x, double y)
    {
        // Very important that cmp(x, y) == cmp(y, x)
        if (Double.IsNaN(x) || Double.IsNaN(y))
            return 1;
        if (Double.IsInfinity(x) || Double.IsInfinity(y))
            return 1;

        var absX = Math.Abs(x);
        var absY = Math.Abs(y);
        var diff = absX > absY ? absX - absY : absY - absX;
        if (diff < Epsilon)
            return 0;
        if (x < y)
            return -1;
        else
            return 1;
    }

    int IComparer<double>.Compare(double x, double y)
    {
        return Compare(x, y);
    }
}

// E.g.
double arg = (Math.PI / 2d - Math.Atan2(a, d));
if (AlmostDoubleComparer.IsZero(arg))
   // Regard it as zero.

我还移植了重新解释整数比较，以防你发现它更合适（它更一致地处理更大的值）。

public class AlmostDoubleComparer : IComparer<double>
{
    public static readonly AlmostDoubleComparer Default = new AlmostDoubleComparer();
    public const double MaxUnitsInTheLastPlace = 3;

    public static bool IsZero(double x)
    {
        return Compare(x, 0) == 0;
    }

    public static int Compare(double x, double y)
    {
        // Very important that cmp(x, y) == cmp(y, x)
        if (Double.IsNaN(x) || Double.IsNaN(y))
            return 1;
        if (Double.IsInfinity(x) || Double.IsInfinity(y))
            return 1;

        var ix = DoubleInt64.Reinterpret(x);
        var iy = DoubleInt64.Reinterpret(y);
        var diff = Math.Abs(ix - iy);
        if (diff < MaxUnitsInTheLastPlace)
            return 0;

        if (ix < iy)
            return -1;
        else
            return 1;
    }

    int IComparer<double>.Compare(double x, double y)
    {
        return Compare(x, y);
    }
}

[StructLayout(LayoutKind.Explicit)]
public struct DoubleInt64
{
    [FieldOffset(0)]
    private double _double;
    [FieldOffset(0)]
    private long _int64;

    private DoubleInt64(long value)
    {
        _double = 0d;
        _int64 = value;
    }

    private DoubleInt64(double value)
    {
        _int64 = 0;
        _double = value;
    }

    public static double Reinterpret(long value)
    {
        return new DoubleInt64(value)._double;
    }

    public static long Reinterpret(double value)
    {
        return new DoubleInt64(value)._int64;
    }
}

或者，您可以尝试NGen 程序集，看看您是否可以解决 Excel 的模式，或者它如何托管 CLR。​​

Answer 2

这就是您在使用浮点数据类型时得到的结果。你得到的不是精确的 0，而是一个非常接近的值，因为 double 的精度有限，并不是每个值都可以表示，有时这些微小的精度误差会加起来。您要么需要预料到这一点（检查该值是否接近 足够 到 0）。