Std :: bind equivalent in C # or VB.NET

Question

I am refactoring "synchronous" code (that is, using Windows events to wait for some other thread to finish doing something) with "asynchronous" code (using delegates to implement the callback mechanism).

In the synchronization code, I sometimes have local variables that I need to use after the wait is over. When such code runs asynchronously, these local variables are lost (the callback handler cannot access them). I can store them as attributes of a class, but it looks wasteful.

In C ++, I use std::bind to get around this. I simply add as many parameters as the local variables needed for the callback handler and bind them when I call the async method. For example, say that an asynchronous method callback receives an object of type CallbackParam , and the caller uses two local variables of type LocalA and LocalB .

 void AsyncClass::MethodWhichCallsAsyncMethod(){ LocalA localVarA; LocalB localVarB; // OnAsyncMethodDone will need localVarA and localVarB, so we bind them AsyncMethod( std::bind( &AsyncClass::OnAsyncMethodDone, this, std::placeholders::_1, localVarA, localVarB ) ); } void AsynClass::AsyncMethod( std::function<void(CallbackParam)> callback ){ CallbackParam result; //Compute result... if( callback ) callback( result ); } void AsyncClass::OnAsyncMethodDone( CallbackParam p, LocalA a, LocalB b ){ //Do whatever needs to be done } 

Is there any equivalent to this in C # and VB.NET? Using delegates or something else?

UPDATE . For completeness, here is the C # equivalent of my example, based on @lasseespeholt answer:

 using System; public class AsyncClass { public void MethodWhichCallsAsyncMethod() { var a = new LocalA(); var b = new LocalB(); //Anonymous callback handler (equivalent to AsyncClass::OnAsyncMethodDone) Action<CallbackParam> callback = result => { //Do what needs to be done; result, a and b can be accessed }; AsyncMethod( callback ); } private void AsyncMethod( Action<CallbackParam> callback ) { var result = new CallbackParam(); //Compute result... if( callback != null ) callback( result ); } } 

Answer 1

UPDATE: This will almost certainly not be used. Use async / wait keywords in C #

You can use closure as below:

 void MethodWhichCallsAsyncMethod() { int foo = 1; AsyncCallback callback = result => { Console.WriteLine(foo); // Access to foo }; AsyncMethod(callback); } void AsyncMethod(AsyncCallback callback) { IAsyncResult result = null; // Compute result callback(result); } 

The compiler generates a class that contains "foo", so you don’t save anything with this approach, but it is clean.