Question

C＃中是否有办法让方法在不同的调用中保留变量？例如：

private void foo()
{
    int j; //declare this so as it isn't destroyed with the stack frame.
    int i = calculateSomeValue() + j;
    j = i;
}

我这样做的正常方法是使用这样的成员变量：

private int j = 0;
private void foo()
{
    int i = calculateSomeValue() + j;
    j = i;
}

我不喜欢在类的所有其他方法中如何访问变量j。另外，它只是似乎凌乱这样：定义一个成员变量，当它只在一个方法中用于跟踪上次调用该方法时i的值。

这可能是一个很好/干净的方式吗？或者我应该只使用成员变量方式而忘记它？

Answer 1

您可以使用一个小的嵌套类来封装它，沿着以下几行：

public class Test
{
    private int foo()
    {
        return nested.foo();
    }

    private int calculateSomeValue()
    {
        return 42;
    }

    readonly Nested nested = new Nested();

    private class Nested
    {
        private int j;

        public int foo()
        {
            int i = calculateSomeValue() + j;
            j = i;
        }
    }
}

外部类中的方法只能访问Nested的公共成员，因此他们只能访问此示例中的foo() - j无法访问。但请注意，Nested中的方法可以访问外部类的所有私有成员。

Answer 2

我不认为还有另一种方式可以提供您所要求的范围。在这种情况下，其他方法可以访问j作为成员变量的事实是您正在使用封装持有者对象内的成员的OOP概念的直接结果。

所以我会继续使用成员变量，并且不用担心其他方法可以访问它。如果由于某种原因你必须避免访问变量的其他方法，也许你应该考虑在自己的类型中进行重构，尽管可能给出的例子是不合理的。

希望这有帮助。

Answer 3

在C中，这可以使用静态局部变量

void foo()
{
     static int j;
     int i = calculateSomeValue() + j;
     j = i;
}

在C＃中，故意不包含此功能。

您有几个选项，这取决于j的预期生命周期。如果您只需要连续通话，并且由于某些原因不想使用循环，您可以采用递归方法

private void foo()
{
    foo(0);
}

private void foo(int j)
{
    int i = calculateSomeValue() + j;
    foo(j);
}

如果您想要更多控制或更长的生命周期，那么面向对象的方法是将此功能推送到一个类，该类可以是普通类或私有类，并嵌套在现有类中。

public class ParentClass()
{
    FooClass bar = new FooClass();

    private class FooClass()
    {
        private int j = 0;
        public void foo()
        {
            int i = calculateSomeValue() + j;
            j = i;
        }

        private int calculateSomeValue()
        {
            //
        }
    }

    private void DoStuff()
    {
        bar.foo();
    }
}

另外，我建议重新称重是否值得保护变量。

Answer 4

使用闭包有一种令人讨厌的方法。但这意味着您必须将方法定义为匿名函数，并将它们包含在定义它们的某个全局方法中。认为这更像是一项学术活动，绝对不是一种生产解决方案。对于现实生活中的解决方案，一定要考虑单独的课程。

setCustomValidity()

保留方法调用的局部变量

4 个答案: