C# 递增 ToString

Question

我在 C#/WPF 中添加了意外行为

    private void ButtonUp_Click(object sender, RoutedEventArgs e)
    {
        int quant;
        if( int.TryParse(Qnt.Text, out quant))
        {
            string s = ((quant++).ToString());
            Qnt.Text = s;
        }
    }

因此，如果我将 Quant 设为 1，Quant 将增加到 2。但是 s 字符串将为 1。这是优先级问题吗？

编辑：

我将其重写为：

            quant++;
            Qnt.Text = quant.ToString();

现在这按我的预期工作。

Answer 1

您正在使用post-增量运算符。这会计算出原始值，然后递增。要在一行中执行您想要的操作，您可以使用预增量运算符。

(++quant).ToString();

但更好的是避免所有这些陷阱并这样做：

quant++;
string s = quant.ToString();

对于第一个版本，您必须考虑事情发生的顺序。在第二个版本中不需要思考。始终更重视代码的清晰度而不是简洁性。

人们很容易相信单行版本在某种程度上更快，但事实并非如此。在 20 世纪 70 年代的 C 系统中，这可能是正确的，但即便如此，我对此表示怀疑。

Answer 2

问题是您使用的是后增量而不是前增量...但是为什么您要编写这段复杂的代码呢？只需将副作用（增量）和 ToString 调用分开：

if (int.TryParse(Qnt.Text, out quant))
{
    quant++;
    Qnt.Text = quant.ToString();
}

或者甚至放弃实际的增量，因为您不会再次读取该值：

if (int.TryParse(Qnt.Text, out quant))
{
    Qnt.Text = (quant + 1).ToString();
}

在可能的情况下，避免em> 在其他表达式中间使用复合赋值。它通常会导致疼痛。

此外，感觉所有这些解析和格式化都隐藏了真实的模型，也就是说，某处应该有一个 int 属性，这可能反映在 UI 中。例如：

private void ButtonUp_Click(object sender, RoutedEventArgs e)
{
    // This is an int property
    Quantity++;
    // Now reflect the change in the UI. Ideally, do this through binding
    // instead.
    Qnt.Text = Quantity.ToString();
}

Answer 3

现在我会做一些不应该做的事情...我会尝试简化 Eric Lippert 在这里写的内容 i++ 和 ++i 之间有什么区别？ 我希望我没有写太多错误的东西:-)

现在...前自增和后自增运算符的作用是什么？简化并忽略中间完成的所有复制（并记住它们在多线程环境中不是原子运算符）：

它们都是表达式（例如i + 1< /code>）返回结果（如 i + 1），但有副作用（与 i + 1 不同）。副作用是它们增加了变量i。最大的问题是“一切按什么顺序发生？”答案很简单：

• i并返回i的新值
• 预增量++i：增量增量i++：增量i并返回i的旧值

现在...重要的部分是增量 i 总是首先发生。然后返回一个值（旧的或新的）。

让我们举一个例子（Lippert 的例子相当复杂。我会做一个不同的、更简单的例子，虽然不是那么完整，但足以检查我之前说的顺序是否正确）（技术上）我将举两个例子）

示例 1：

unchecked
{
    int i = Int32.MaxValue;
    Console.WriteLine("Hello! I'm trying to do my work here {0}", i++);
    Console.WriteLine("Work done {1}", i);
}

示例 2：

checked
{
    int i = Int32.MaxValue;
    Console.WriteLine("Hello! I'm trying to do my work here {0}", i++);
    Console.WriteLine("Work done {1}", i);
}

checked 表示如果存在溢出，将抛出异常 (OverflowException)。 unchecked 意味着相同的操作不会抛出异常。 Int32.MaxValue + 1 肯定会溢出。如果选中，则会出现异常，如果未选中，则i将变为-1。

让我们尝试运行第一个代码段。结果：

Hello! I'm trying to do my work here 2147483647
Work done -1

好的...i 增加了，但 Console.WriteLine 收到了旧值 (Int32.MaxValue == 2147483647)。从这个例子中我们无法确定后递增和调用Console.WriteLine的顺序。

让我们尝试运行第二个代码段。结果：

System.OverflowException: Arithmetic operation resulted in an overflow.

好的...很明显，首先执行了后置增量，引发了异常，然后显然 Console.WriteLine 没有执行（因为程序结束了）。

所以我们知道我说的顺序是正确的。

现在。你应该从这个例子中学到什么？这和我很多年前学到的一样。 C 和 C# 中的前后增量非常适合混淆代码竞赛。它们不适用于许多其他事情（但请注意，C++ 不同！）。从那次教训中我了解到，可以自由使用后自增的地方正好有两个，可以自由使用前自增的地方正好有零个。

“安全”后增量

for (int i = 0; i < x; i++)

和

i++; // Written alone. Nothing else on the same line but a comment if necessary.

“安全”前增量

(nothing)

Answer 4

在这种情况下，首先将调用 quant.ToString()，然后 quant 将递增。

如果您编写 ((++quant).ToString()) ，第一步将递增 quant，然后调用 quant.ToString() 。

Answer 5

string s = ((quant++).ToString());

可以分发为

在递增之前使用 quant 调用 toString() 方法，然后

执行赋值运算符，然后

增加 `quant'

尝试使用 ++quant。