Question

这就是我想要做的事情：

if(ABoolean || (BBoolean && CBoolean))
{
    SomeButton.Enabled = true;
    AnotherButton.Enabled = true;
}
else 
{
    SomeButton.Enabled = false;
    AnotherButton.Enabled = false;
}

我可以将其切换为：

SomeButton.Enabled = (ABoolean || (BBoolean && CBoolean));
AnotherButton.Enabled = (ABoolean || (BBoolean && CBoolean));

更简洁的代码。我的问题是，编译器是否优化了赋值，使得它将看到布尔表达式相同并为第二个按钮指定其值，或者每次都计算该值。

注意：我理解这是一个微不足道的例子，加速/减速将是微不足道的，但是它将有助于我更好地理解编译器优化。

编辑：这就是我认为可能优化第二个选项的原因：

class Program
{
    static bool ABoolean = true, BBoolean = true, CBoolean = false;
    static bool AEnable, BEnable;


    static void Main(string[] args)
    {
        Stopwatch sw = new Stopwatch();
        sw.Start();
        for (int i = 0; i < 1000000000; i++)
        {
            Operation1();
        }
        sw.Stop();
        Console.WriteLine(sw.ElapsedMilliseconds);

        Stopwatch sw1 = new Stopwatch();
        sw1.Start();
        for (int i = 0; i < 1000000000; i++)
        {
            Operation2();
        }
        sw1.Stop();
        Console.WriteLine(sw1.ElapsedMilliseconds);
        Console.Read();
    }

    static void Operation1()
    {
        if (ABoolean || (BBoolean && CBoolean))
        {
            AEnable = true;
            BEnable = true;
        }
        else
        {
            AEnable = false;
            BEnable = false;
        }
    }

    static void Operation2()
    {
        AEnable = (ABoolean || (BBoolean && CBoolean));
        BEnable = (ABoolean || (BBoolean && CBoolean));
    }
}

这导致了10亿次操作的大约8-9秒的差异（第二种选择运行得更快）。因为我添加了更多“启用”布尔值，但第二次操作变慢了。

Answer 1

不，我不希望编译器优化它。 JIT 可能会优化它（因为它有更多的信息），但我不希望C＃编译器。

编译器如何知道SomeButton.Enabled是否会产生一些可能会改变ABoolean，BBoolean或CBoolean的价值的副作用？

编辑：验证这个......让我们给C＃编译器绝对最多机会：

class Test
{
    static void Main()
    {
        Foo(true, false, true);
    }

    static void Foo(bool x, bool y, bool z)
    {
        A = x || (y && z);
        B = x || (y && z);
    }

    static bool A { get; set; }
    static bool B { get; set; }
}

编译：

csc /o+ /debug- Test.cs

通过ILDASM的Foo代码：

.method private hidebysig static void  Foo(bool x,
                                           bool y,
                                           bool z) cil managed
{
  // Code size       37 (0x25)
  .maxstack  8
  IL_0000:  ldarg.0
  IL_0001:  brtrue.s   IL_000c
  IL_0003:  ldarg.1
  IL_0004:  brfalse.s  IL_0009
  IL_0006:  ldarg.2
  IL_0007:  br.s       IL_000d
  IL_0009:  ldc.i4.0
  IL_000a:  br.s       IL_000d
  IL_000c:  ldc.i4.1
  IL_000d:  call       void Test::set_A(bool)
  IL_0012:  ldarg.0
  IL_0013:  brtrue.s   IL_001e
  IL_0015:  ldarg.1
  IL_0016:  brfalse.s  IL_001b
  IL_0018:  ldarg.2
  IL_0019:  br.s       IL_001f
  IL_001b:  ldc.i4.0
  IL_001c:  br.s       IL_001f
  IL_001e:  ldc.i4.1
  IL_001f:  call       void Test::set_B(bool)
  IL_0024:  ret
} // end of method Test::Foo

正如您所看到的，在两种情况下都会对表达式进行评估。

Answer 2

我的问题是，编译器是否优化了赋值，使得它会看到布尔表达式相同并为第二个按钮指定其值，或者每次都会计算值。

每次都会计算出这个值。

如果这是一个多线程应用程序怎么办？其他一些线程可能会改变它。

如果它们不是常量变量，则可以更改它们。

要优化你可以做到

SomeButton.Enabled = AnotherButton.Enabled = (ABoolean || (BBoolean && CBoolean));

在这种情况下，它将被计算一次，并且值首先分配给AnotherButton，然后分配给SomeButton。记住它在转让中的权利。

Answer 3

不，编译器不会根据我的经验对其进行优化，但是，您可以这样做：

SomeButton.Enabled = AnotherButton.Enabled = (ABoolean || (BBoolean && CBoolean));

编译器会针对布尔赋值进行优化吗？

3 个答案: