C # asynchronous operations are often used during development. In particular, many io-related accesses under Windows Phone and Silverlight are asynchronous.
Standard Asynchronous methods are usually a pair of methods for in [invoke] and end [invoke], so the usage is not much said.
I recently wrote httprequest operations that are commonly used in command mode and want to package the commands into asynchronous methods,
For a long time, I used the following method to package Asynchronization:
The first is the regular asynchronous call sequence:
Currently, two classes are used for packaging asynccallback, and one for packaging iasyncresult to package the time series.
The class code is as follows:
/// <Summary>
/// Asynchronous callback proxy
/// </Summary>
Public class asynccallbackdelegate
{
/// <Summary>
/// Asynchronous callback that requires proxy
/// </Summary>
Private readonly asynccallback;
/// <Summary>
/// Original call object
/// </Summary>
Public object delegate {Get; set ;}
Public asyncresultdelegate result {Get; set ;}
/// <Summary>
/// Construct an asynchronous callback proxy
/// </Summary>
/// <Param name = "asynccallback"> asynchronous callback for proxy </param>
Public asynccallbackdelegate (asynccallback)
{
This. asynccallback = asynccallback;
}
/// <Summary>
/// Asynchronous callback after Packaging
/// </Summary>
/// <Param name = "asyncresult"> </param>
Public void asynccallback (iasyncresult asyncresult)
{
// Use asyncresultdelegate to package asyncresult
VaR asyncresultdelegate = new asyncresultdelegate (asyncresult) {delegate = delegate };
Asynccallback (asyncresultdelegate); // call the original asynchronous callback
}
}
/// <Summary>
/// Asynchronous status proxy
/// </Summary>
Public class asyncresultdelegate: iasyncresult
{
/// <Summary>
/// Original asynchronous state
/// </Summary>
Private readonly iasyncresult asyncresult;
/// <Summary>
/// Original call object
/// </Summary>
Public object delegate {Get; set ;}
Public asyncresultdelegate (iasyncresult asyncresult)
{
This. asyncresult = asyncresult;
}
# Region decoration mode Packaging
Public object asyncstate
{
Get {return asyncresult. asyncstate ;}
}
Public System. Threading. waithandle asyncwaithandle
{
Get {return asyncresult. asyncwaithandle ;}
}
Public bool completedsynchronously
{
Get {return asyncresult. completedsynchronously ;}
}
Public bool iscompleted
{
Get {return asyncresult. iscompleted ;}
}
Public iasyncresult asyncresult
{
Get {return asyncresult ;}
}
# Endregion
}
Call Sequence After packaging:
The Demo code addcommand is used to asynchronously execute a + B to return results using proxy packaging.
Public class addcommand
{
Private readonly int;
Private readonly int B;
Public addcommand (int A, int B)
{
This. A =;
This. B = B;
}
Public iasyncresult begininvoke (asynccallback, object state)
{
Func <int, Int, int> addfunc = (x, y) => X + Y; // original asynchronous call object used for testing
Asynccallback callbackdelegate = asynccallback;
If (asynccallback! = NULL)
{
// Use asynccallbackdelegate to package asynccallback
VaR TMP = new asynccallbackdelegate (asynccallback) {delegate = addfunc };
Callbackdelegate = TMP. asynccallback;
}
VaR asyncresult = addfunc. begininvoke (a, B, callbackdelegate, State );
// Use asyncresultdelegate to package asyncresult
Return new asyncresultdelegate (asyncresult) {delegate = addfunc };
}
Public int endinovke (iasyncresult result)
{
VaR asyncresultdelegate = (asyncresultdelegate) result; // restore asyncresultdelegate
Func <int, Int, int> addfunc = (func <int, Int, int>) asyncresultdelegate. Delegate; // obtain the original object
Return addfunc. endinvoke (asyncresultdelegate. asyncresult); // input the original asyncresult
}
}
Two call methods are supported to call addcommand.
Class Program
{
Static void main (string [] ARGs)
{
// Call endinovke after the main thread waits
{
Addcommand invoker = new addcommand (1, 2 );
VaR async = invoker. begininvoke (null, null );
Async. asyncwaithandle. waitone ();
Int result = invoker. endinovke (async );
Console. writeline (result );
}
// Call endinovke by callback
{
Addcommand invoker = new addcommand (5, 9 );
VaR async = invoker. begininvoke (callback, invoker );
Async. asyncwaithandle. waitone ();
}
Console. Readline ();
}
Static void callback (iasyncresult asyncresult)
{
Addcommand invoker = asyncresult. asyncstate as addcommand;
Int result = invoker. endinovke (asyncresult );
Console. writeline (result );
}
}
Varcolor: # 0000ff;
/Spanspan style =