此解决方案的限制

Question

我无法弄清楚如何构建它。

我的课程VehicleState的属性包括passengers：

public class VehicleState
{
    public int _temp_passengers;
    public int _passengers;
    public int passengers
    {
        set { _temp_passengers = value; }
        get { return _passengers; }
    }
    public void CommitState()
    {
        _passengers = _temp_passengers;
    }
}

每隔X秒就有一个循环。每辆车都会影响模拟中的另一辆车。

为了避免在每辆车影响他人时破坏性能，我将它们存放在温度场中，例如： _passengers。临时值将在循环结束时提交给常规值。

问题如下：

passengers = passengers - 1;
passengers += 1

变为：

_temp_passengers = _passengers - 1;

修改

为了进一步解释这个问题，想象10辆车辆会影响车辆A，乘客数量增加1.每位乘客都会离开车辆上车。

因此，操作passengers += 1将被调用10次，但就好像操作只被调用一次一样！

是否有设计模式可以解决这个问题？
我可以在类中包装这样的每个属性吗？
我可以在+=中添加-=和set{}条件吗？

有什么想法吗？谢谢！：）

Answer 1

只使用一种延迟执行

public class VehicleState
{
    List<Action> actionList = new List<Action>();

    public int passengers { get; set; }

    public void CommitState()
    {
        foreach (var action in actionList)
        {
            action();
        }
    }

    public void Execute(Action action)
    {
        actionList.Add(action);
    }
}

测试

    [TestMethod]
    public void MyTestMethod()
    {
        var vs = new VehicleState { passengers = 3 };
        vs.Execute(() => vs.passengers += 1);
        Assert.AreEqual(3, vs.passengers);
        vs.CommitState();
        Assert.AreEqual(4, vs.passengers);

    }

此解决方案的限制

此解决方案仅提供延迟执行。根据您的情况，这可能有用或无用。

var vs1 = new VehicleState { passengers = 3 };
var vs2 = new VehicleState { passengers = 3 };

vs1.Execute(() => vs1.passengers += vs2.passengers);
// vs2.Execute(() => vs2.passengers -= vs1.passengers); // does not work

// remember state before 
var beforeVs1passengers = vs1.passengers;
vs2.Execute(() => vs2.passengers -= beforeVs1passengers);  // that works

vs1.CommitState();  // order might be important, no common state, no stack
vs2.CommitState();
Assert.AreEqual(6, vs1.passengers);
Assert.AreEqual(0, vs2.passengers);

Answer 2

让我们试试

public class VehicleState
{
    public float _passengers;
    public float _CommitedPassengers;
    public float passengers
    {
        set { _passengers = value; }
        get { return _passengers; }
    }

    public float CommitedPassengers
    {
        get { return _CommitedPassengers; }
    }

    public void CommitState()
    {
        _CommitedPassengers = _passengers;

    }
}

我认为你需要的只是

Answer 3

作为对一个相当古老的问题的最新评论 - 我认为“覆盖属性”不适合这里。您试图将模型的两种不同状态混合到一个实例中。您已经报告了这带来的一些问题。此外，代码将难以理解和维护。

相反，请使用模型M的两个版本，表示两个迭代n和n+1的状态。您的计算以M[n]为输入，并生成/修改M[n+1]作为输出。

然后，您需要一种方法将新状态从nextModel复制到currentModel：

var currentModel = new Model();

for (var n in Enumerable.Range(0, 99))
{
    var nextModel = calculate(currentModel);

    currentModel.UpdateFrom(nextModel);
}

然而，Model我指的是所有车辆的全部内容以及模拟中的其他任何内容，而calculate我指的是在一次迭代中完成的所有计算。

这与你正在做的很接近，它只是收集你所有属性中的“保留两个状态并稍后复制”逻辑到一个名为UpdateFrom的地方。拥有模型的两个实例可以让您清楚地了解计算所基于的模型状态：

nextModel.Vehicles[0].passengers =
    nextModel.Vehicles[0].passengers + currentModel.Vehicles[1].passengers

一旦你有多个实例，你也可以选择更多地转向函数式编程风格，在每次迭代中生成一个新模型并抛弃旧状态（或者如果需要的话，保留它作为记录）：

var model = new Model[100];
model[0] = new Model();

for (var n in Enumerable.Range(0, 99))
{
    // either throw away old state and keep a reference to the new state only
    var currentModel = calculate(currentModel);

    // or keep all states
    model[n+1] = calculate(model[n]);
}

用临时属性覆盖对象属性？

3 个答案:

此解决方案的限制