我已经看到了一些关于这个习语的提及(包括SO):
// Deliberately empty subscriber
public event EventHandler AskQuestion = delegate {};
好处很明显 - 它避免了在提升事件之前检查null的必要性.
但是,我很想知道是否有任何缺点. 例如,它是否被广泛使用并且足够透明以至于不会引起维护问题？空事件用户呼叫是否有明显的性能影响？
我正在开发.NET中的类库,其他开发人员最终将使用它.该库使用一些工作线程,这些线程触发状态事件,这将导致在WinForms/WPF应用程序中更新一些UI控件.
通常,对于每次更新,您都需要检查WinForms上的.InvokeRequired属性或等效的WPF属性,并在主UI线程上调用此更新.这可能会很快变老,并且让最终开发人员做到这一点感觉不对,所以......
有没有办法我的库可以从主UI线程触发/调用事件/委托？
特别是...
UseThisThreadForEvents()在应用程序启动时调用某些(伪)方法,以便从该调用中获取目标线程吗？为了引发事件,我们使用OnEventName方法,如下所示:
protected virtual void OnSomethingHappened(EventArgs e)
{
EventHandler handler = SomethingHappened;
if (handler != null)
{
handler(this, e);
}
}
但这个有什么不同？
protected virtual void OnSomethingHappened(EventArgs e)
{
if (SomethingHappened!= null)
{
SomethingHappened(this, e);
}
}
显然第一个是线程安全的,但为什么以及如何？
没有必要开始一个新线程？
让我感到困惑的东西,但从来没有引起任何问题......推荐的事件发送方式如下:
public event EventHandler SomeEvent;
...
{
....
if(SomeEvent!=null)SomeEvent();
}
在多线程环境中,此代码如何保证另一个线程不会更改SomeEvent检查null和事件调用之间的调用列表？
我正在尝试在C#中创建线程安全属性,我想确保我在正确的路径上 - 这就是我所做的 -
private readonly object AvgBuyPriceLocker = new object();
private double _AvgBuyPrice;
private double AvgBuyPrice
{
get
{
lock (AvgBuyPriceLocker)
{
return _AvgBuyPrice;
}
}
set
{
lock (AvgBuyPriceLocker)
{
_AvgBuyPrice = value;
}
}
}
阅读这篇文章,似乎这不是正确的做法 -
但是,这篇文章似乎暗示,
http://www.codeproject.com/KB/cs/Synchronized.aspx
有没有人有更明确的答案？
编辑:
我想为此属性执行Getter/Setter的原因是b/c我实际上希望它在设置时触发事件 - 所以代码实际上就像这样 -
public class PLTracker
{
public PLEvents Events;
private readonly object AvgBuyPriceLocker = new object();
private double _AvgBuyPrice;
private double AvgBuyPrice
{
get
{
lock (AvgBuyPriceLocker)
{
return _AvgBuyPrice;
}
}
set …所以我已经阅读过,而不是直接调用事件
if (SomeEvent != null)
SomeEvent(this, null);
我应该这样做
SomeEventHandler temp = SomeEvent;
if (temp != null)
temp(this, null);
为什么会这样？第二个版本如何变得线程安全？什么是最佳做法？
目前" 避免检查空事件处理程序"是标题为C#隐藏功能的帖子的答案的顶部,它包含严重误导性信息.
虽然我理解Stack Overflow是一个"民主",并且答案因公众投票而上升到顶峰,我觉得很多投票给答案的人要么没有完全理解C#/ .NET或者没有花时间充分了解帖子中描述的做法的后果.
简而言之,该帖子主张使用以下构造来避免在调用事件时检查null.
public event EventHandler SomeEvent = delegate {};
// Later..
void DoSomething()
{
// Invoke SomeEvent without having to check for null reference
SomeEvent(this, EventArgs.Empty);
}
乍一看,这似乎是一个聪明的捷径,但它可能是大型应用程序中一些严重问题的原因,特别是如果涉及并发性.
在调用事件的委托之前,您必须检查空引用.仅仅因为您使用空委托初始化事件并不意味着您的类的用户不会在某些时候将其设置为null并破坏您的代码.
像这样的东西是典型的:
void DoSomething()
{
if(SomeEvent != null)
SomeEvent(this, EventArgs.Empty);
}
但即使在上面的例子中,也存在这样的可能性,即DoSomething()可能由一个线程运行,另一个可能会删除事件处理程序,并且可能会出现竞争条件.
假设这种情况:
Thread A. Thread B.
-------------------------------------------------------------------------
0: if(SomeEvent != null)
1: { // remove all handlers of SomeEvent
2: SomeEvent(this, EventArgs.Empty);
3: }
在引发事件的代码检查了委托以获取空引用之后,但在调用委托之前,线程B删除了SomeEvent事件的事件处理程序.当SomeEvent(this,EventArgs.Empty); 调用,SomeEvent为null并引发异常.
为了避免这种情况,提出事件的更好模式是:
void DoSomething()
{
EventHandler handler …我最近创建了这两个(不相关的)方法来替换我的winforms应用程序中的大量样板代码.据我所知,他们工作正常,但我需要一些保证/建议,以确定是否存在一些我可能会遗漏的问题.
(从记忆里)
static class SafeInvoker
{
//Utility to avoid boiler-plate InvokeRequired code
//Usage: SafeInvoker.Invoke(myCtrl, () => myCtrl.Enabled = false);
public static void Invoke(Control ctrl, Action cmd)
{
if (ctrl.InvokeRequired)
ctrl.BeginInvoke(new MethodInvoker(cmd));
else
cmd();
}
//Replaces OnMyEventRaised boiler-plate code
//Usage: SafeInvoker.RaiseEvent(this, MyEventRaised)
public static void RaiseEvent(object sender, EventHandler evnt)
{
var handler = evnt;
if (handler != null)
handler(sender, EventArgs.Empty);
}
}
编辑:请在此处查看相关问题
UPDATE
继死锁问题(在此问题中相关)之后,我已从Invoke切换到BeginInvoke(请参阅此处的解释).
另一个更新
关于第二个片段,我越来越倾向于使用'空委托'模式,通过使用空处理程序直接声明事件来解决"源"问题,如下所示:
event EventHandler MyEventRaised = delegate {};
我担心看似标准的前C#6模式的正确性可以解雇事件:
EventHandler localCopy = SomeEvent;
if (localCopy != null)
localCopy(this, args);
我已经阅读了Eric Lippert的事件和比赛,并且知道调用过时的事件处理程序还有一个问题,但我担心的是,是否允许编译器/ JITter优化掉本地副本,有效地将代码重写为
if (SomeEvent != null)
SomeEvent(this, args);
有可能NullReferenceException.
根据C#语言规范,§3.10,
必须保留这些副作用的顺序的关键执行点是对volatile字段(第10.5.3节),锁语句(第8.12节)以及线程创建和终止的引用.
- 所以在上述模式中没有关键执行点,优化器也不受此限制.
由于条件的原因,JIT不允许在第一部分中执行您正在讨论的优化.我知道这是作为一个幽灵提出的,但它无效.(我刚才和Joe Duffy或Vance Morrison一起检查过;我不记得是哪一个.)
- 但是评论引用了这篇博客文章(2008年):事件和线程(第4部分),它基本上说CLR 2.0的JITter(可能是后续版本？)不能引入读取或写入,所以一定没有问题在Microsoft .NET下.但这似乎与其他.NET实现没有任何关系.
[旁注:我没有看到不引入读取证明了所述模式的正确性.难道JITter只是看到一些SomeEvent其他局部变量的陈旧值并优化其中一个读取,而不是另一个？完全合法,对吗？]
此外,这篇MSDN文章(2012年):Igor Ostrovsky的理论与实践中的C#记忆模型陈述如下:
非重新排序优化某些编译器优化可能会引入或消除某些内存操作.例如,编译器可能用一次读取替换字段的重复读取.类似地,如果代码读取字段并将值存储在局部变量中然后重复读取变量,则编译器可以选择重复读取该字段.
因为ECMA C#规范不排除非重新排序的优化,所以它们可能是允许的.实际上,正如我将在第2部分中讨论的那样,JIT编译器确实执行了这些类型的优化.
这似乎与Jon Skeet的答案相矛盾.
由于现在C#不再是Windows语言,因此问题在于,模式的有效性是否是当前CLR实现中有限的JITter优化的结果,或者是语言的预期属性.
所以,问题是:从C#-the-language的角度来看,正在讨论的模式是否有效？(这意味着是否需要语言编译器/运行时来禁止某种优化.)
当然,欢迎就该主题提出规范性参考.
我正在阅读Essential C#3.0书籍,我想知道这是否是检查代表为空的好方法？:
class Thermostat
{
public delegate void TemperatureChangeHandler ( float newTemperature );
public TemperatureChangeHandler OnTemperatureChange { get; set; }
float currentTemperature;
public float CurrentTemperature
{
get { return this.currentTemperature; }
set
{
if ( currentTemperature != value )
{
currentTemperature = value;
TemperatureChangeHandler handler = OnTemperatureChange;
if ( handler != null )
{
handler ( value );
}
}
}
}
}
如果类型是不可变的,解决方案是否会更改？我认为可能具有不变性,你不会遇到这个线程问题.