System.Threading.Timer不会触发

Question

我是新来的...

我有一个问题，如果有人能帮助我。

它是关于定时器（System.Threading.Timer）。

我想打破不可避免的递归：我在datarow中有两列，它们是相互依赖的（price_without_VAT和price_with_VAT）。设置其中的一个肯定会导致StackOverflowException。因此，这里的想法：

bool flag = true; 
void Reset(object state) { flag = true; } 

现在，包裹方法改变其中一列的值：

{ 
    if(flag) 
    { 
     flag = false; 
     System.Threading.Timer tmr = new System.Threading.Timer(new System.Threading.TimerCallback(Reset), null, 10, System.Threading.Timeout.Infinite); 
     datarow.other_column = value; 
    } 
} 

datarow.other_column.value线将立即触发上面的方法，但会有没有递归，因为标志是错误的。 在10 ms标志应该回到真，并且一切恢复正常。

现在，当我按照DEBUGGER中的代码，一切工作正常，但是当我启动应用程序NORMALLY复位功能根本不会触发，标志永远被卡住为假，一切都假分开。我玩due_time参数，但似乎没有任何帮助。

任何想法？

Answer 1

我不会这样做。你将遇到计时问题。如果您试图快速连续设置“标记”值，会发生什么情况？这最多会导致奇怪的调试，最糟糕的是导致无效的数据被保存。

您可以将标记设置为全局，将其设置为一个属性，然后在另一个属性中进行检查。设置标志，更改该值，然后在完成后再设置标志。或者，让获取者执行基础计算，并且不允许明确设置其中一个值。

Answer 2

听起来像你有各种讨厌的比赛在这里进行。你真的需要解决你的底层问题

Answer 3

看来你真正的问题是StackOverflow异常，由于非终止递归 - 你应该修复，然后不需要使用这样的定时器。

Answer 4

我不会在这里使用计时器。什么时候我有这样的问题（这是不经常）我通常做的，就是沿着这些路线的东西：

bool _isSettingAOrB; 
private int _a; 
private void SetA(int value) 
{ 
    _a = value; 

    if (_isSettingAOrB) 
    { 
     return; 
    } 

    _isSettingAOrB = true; 

    try 
    { 
     SetB(_a - 10); 
    } 
    finally 
    { 
     _isSettingAOrB = false; 
    } 
} 

private int _b; 
private void SetB(int value) 
{ 
    _b = value; 

    if (_isSettingAOrB) 
    { 
     return; 
    } 

    _isSettingAOrB = true; 

    try 
    { 

     SetA(_b + 10); 
    } 
    finally 
    { 
     _isSettingAOrB = false; 
    } 
} 

如果你不喜欢重复的图案（如上面的代码），你可以包裹调用结构成代替一个单独的方法：

bool _isSettingAOrB; 
private int _a; 
public void SetA(int value) 
{ 
    SetInterdependentValues(() => _a = value,() => SetB(_a - 10)); 
} 

private int _b; 
public void SetB(int value) 
{ 
    SetInterdependentValues(() => _b = value,() => SetA(_b + 10)); 
} 

private void SetInterdependentValues(Action primary, Action secondary) 
{ 
    primary(); 

    if (_isSettingAOrB) 
    { 
     return; 
    } 
    _isSettingAOrB = true; 
    try 
    { 
     secondary(); 
    } 
    finally 
    { 
     _isSettingAOrB = false; 
    } 
} 

代码的简单说明：

SetInterdependentValues(() => _a = value,() => SetB(_a - 10)); 

这是一个方法调用采用两个参数。这两个参数是() => _a = value和() => SetB(_a - 10)。简而言之，这些是lambda表达式，将转换为代表，其中每种方法的主体位于=>右侧。因此，第一个参数是一个将value指定为_a的方法，第二个参数将调用方法SetB，传递参数_a - 10。

SetInterdependentValues将执行第一种方法，但只有在_isSettingAOrB为false时才执行第二种方法。但是，在拨打电话之前，它会将_isSettingAOrB设置为true。这将防止发生无限递归。最后一部分是在try-finally块中完成的，以保证如果被调用的方法抛出异常，该标志也会被重置。

Answer 5

使用lock而不是标志来确保更新一次仅在一个线程中发生。

// class member 
private object syncObject = new object(); 

// then, in your code... 
lock(syncObject) { 
    System.Threading.Timer tmr = new System.Threading.Timer(new System.Threading.TimerCallback(Reset), null, 10, System.Threading.Timeout.Infinite); 
    datarow.other_column = value; 
} 

Answer 6

而我将与那些谁说，你应该找到另一种方式来防止无限递归同意，原因您的定时器不火，可能是因为它被优化掉。最近我遇到了这个问题。

比方说，你想有一个周期定时器：

void SomeMethod() 
{ 
    Timer MyTimer = new Timer(MyTimerProc, null, 3000, 3000); 
    // other stuff goes here 
} 

现在，您运行在调试模式下，一切工作。但是当你在释放模式下运行它时，定时器不会启动。这是因为它正在被优化。你需要做的是要么保持它活着（使用GC.KeepAlive）或using：

using (Timer MyTimer = new Timer(MyTimerProc, null, 3000, 3000)) 
{ 
    // other stuff here 
}