I have used the EventsHelper class to fire events asynchronical. I came across this class in the TechEd 2003 presentation C# Best Practices from Eric Gunnerson and Juval Löwy. Today I noticed a bug. The FireAsync() method uses the 'Fire and Forget' pattern incorrectly.
The 'Fire and Forget' pattern is used when the return value and returned parameters of the call are not required, and when there is no need to synchronize with the asynchronously executing method. In this case, the caller simply needs to call BeginInvoke, passing any normal and ref parameters, and null for the callback and asyncState.
This has been a commonly used pattern. However, there has been a documentation change in version 1.1 of the .NET Framework that has big ramifications for this technique of making async calls. The documentation now states that EndInvoke must be called for a corresponding BeginInvoke--otherwise Microsoft say they may now, or in the future, leak resources. It appears that no resources are leaked under version 1.0 of the framework; however, with this type of warning in place, it is recommended that a call to EndInvoke be made even if the return values of an async call are not required.
It is relatively straightforward to create a helper class that handles this for you--one example I found here.
 delegatevoid DynamicInvokeShimProc(Delegate d,object[]args);
 static DynamicInvokeShimProc dynamicInvokeShim=new
   DynamicInvokeShimProc(DynamicInvokeShim);
 static AsyncCallback dynamicInvokeDone=new
   AsyncCallback(DynamicInvokeDone);
 publicstaticvoid FireAndForget(Delegate d,paramsobject[]args){
   dynamicInvokeShim.BeginInvoke(d,args,dynamicInvokeDone,null);
 }
 staticvoid DynamicInvokeShim(Delegate d,object[]args){
   d.DynamicInvoke(args);
 }
 staticvoid DynamicInvokeDone(IAsyncResult ar){
   dynamicInvokeShim.EndInvoke(ar);
 }
}
My improved EventsHelper class now looks like this:
 publicstaticvoid FireAsync(Delegate del,paramsobject[]args){
   if(del==null){
     return;
   }
   Delegate[]delegates=del.GetInvocationList();
   AsyncFire asyncFire;
   foreach(Delegate sinkindelegates){
     asyncFire=new AsyncFire(InvokeDelegate);
     AsyncHelper.FireAndForget(asyncFire,sink,args);
   }
 }
 delegatevoid AsyncFire(Delegate del,object[]args);
 [OneWay]
 staticvoid InvokeDelegate(Delegate del,object[]args){
   del.DynamicInvoke(args);
 }
 publicstaticvoid Fire(Delegate del,paramsobject[]args){
   if(del==null){
     return;
   }
   Delegate[]delegates=del.GetInvocationList();
   foreach(Delegate sinkindelegates){
     try{
       sink.DynamicInvoke(args);
     }
     catch{}
   }
 }
}
All postings/content on this blog are provided "AS IS" with no warranties, and confer no rights. All entries in this blog are my opinion and don't necessarily reflect the opinion of my employer or sponsors. The content on this site is licensed under a Creative Commons Attribution By license.
Blog comments
0 responses