public void Start()
{
Console.WriteLine("Started.");
DoWorkDelegate d = FindThemClones;
d.BeginInvoke(CodeText, WhenDoneCallback, d);
}
private void SendFileRun(String filePath)
{
DisableStartButtons();
DoWorkDelegate worker = new DoWorkDelegate(SendFile);
worker.BeginInvoke(filePath, new AsyncCallback(DoWorkComplete), worker);
}
private IAsyncResult BeginLoadSlowContent(Object src, EventArgs args, AsyncCallback cb, Object state)
{
System.Diagnostics.Trace.WriteLine("BeginLoadSlowContent " + Thread.CurrentThread.ManagedThreadId);
_doWork = LoadProductList;
return _doWork.BeginInvoke(cb, state);
}
public void Demo01()
{
Debug.WriteLine($"Current executing thread ID of Demo01 unit test method is: {Thread.CurrentThread.ManagedThreadId.ToString()}");
// With a delegate instead of calling DoWork directly
//DoWork();
// We can do this
DoWorkDelegate doWorkDelegate = new DoWorkDelegate(DoWork);
// The delegate keyword behind the scene is generating a whole class
//doWorkDelegate(); // or doWorkDelegate.Invoke();
// So doWorkDelegate is actually an object that has methods in it
// With this we can introduce asynchronous code like the begin/end pattern
AsyncCallback asyncCallback = new AsyncCallback(TheCallback);
IAsyncResult ar = doWorkDelegate.BeginInvoke(asyncCallback, doWorkDelegate);
// do more work
var result = 1 + 2;
Debug.WriteLine($"Result is {result}");
ar.AsyncWaitHandle.WaitOne();
}
static void Main()
{
DoWorkDelegate del = DoWork;
// Note: У вас есть два способа получить уведомление об окончании метода:
// Note: 1) Через метод обратного вызова
IAsyncResult asyncResult = del.BeginInvoke(100000000,
stateObject => Console.WriteLine("Computation done"), // Фактически никакое состояние передано не было
null);
for (int i = 0; i < 5; i++)
{
Console.WriteLine("Doing other work...{0}", i);
Thread.Sleep(1000);
}
// Note: 2) С помощью EndInvoke
double sum = del.EndInvoke(asyncResult); // Дождаться окончания
Console.WriteLine("Sum: {0}", sum);
Console.ReadKey();
}
public void CheckDelegateAsyncOperation()
{
Debug.WriteLine($"Demo One Thread: {Thread.CurrentThread.ManagedThreadId}");
var doWork = new DoWorkDelegate(DoWork);
var asyncCallback = new AsyncCallback(TheCallBack);
var asyncResult = doWork.BeginInvoke(asyncCallback, doWork);
asyncResult.AsyncWaitHandle.WaitOne();
}
public void Demo01()
{
Debug.WriteLine(System.Threading.Thread.CurrentThread.ManagedThreadId.ToString());
DoWorkDelegate m = new DoWorkDelegate(DoWork);
AsyncCallback callback = new AsyncCallback(TheCallback);
IAsyncResult ar = m.BeginInvoke(callback, m);
// do more
ar.AsyncWaitHandle.WaitOne();
}
public void Demo1()
{
Debug.WriteLine(System.Threading.Thread.CurrentThread.ManagedThreadId.ToString());
DoWorkDelegate m = new DoWorkDelegate(DoWork);
AsyncCallback callback = new AsyncCallback(TheCallback);
// The Begin - End Pattern for Asyncronous Processing
IAsyncResult ar = m.BeginInvoke(callback, m);
//Do Work
ar.AsyncWaitHandle.WaitOne();
}
/// <summary>
/// Start asyncronous check.
/// </summary>
public void Start()
{
try
{
DoWorkDelegate WorkerThread = new DoWorkDelegate(DoWork);
WorkerThread.BeginInvoke(m_ComponentIndex, new AsyncCallback(DoWorkComplete), WorkerThread);
}
catch (Exception ex)
{
OnError(ex, "ASynchCheckBase.Start");
}
}
public void TestBeginEndPatternWithCallbackAbortException()
{
Debug.WriteLine($"Hello from TestBeginEndPatternWithCallbackAbortException() (Thread ID: {Thread.CurrentThread.ManagedThreadId})");
var doWork = new DoWorkDelegate(DoHardWork);
var callback = new AsyncCallback(Callback);
IAsyncResult ar = doWork.BeginInvoke(callback, doWork);
Debug.WriteLine($"End of main thread (Thread ID: {Thread.CurrentThread.ManagedThreadId})");
// Will rise ThreadAbortException on the second thread.
}
public void doWorkDelegateAsyncTest()
{
Debug.WriteLine(System.Threading.Thread.CurrentThread.ManagedThreadId.ToString());
DoWorkDelegate doingwork = new DoWorkDelegate(doWork);
// BeginInvoke will execute method in different thread
AsyncCallback asyncCallback = new AsyncCallback(callback);
IAsyncResult ar = doingwork.BeginInvoke(asyncCallback, doingwork);
// Do work in main thread here
//doingwork.EndInvoke(ar);
}
public void TestBeginEndPatternWithCallback()
{
Debug.WriteLine($"Hello from TestBeginEndPatternWithCallback() (Thread ID: {Thread.CurrentThread.ManagedThreadId})");
var doWork = new DoWorkDelegate(DoHardWork);
var callback = new AsyncCallback(Callback);
IAsyncResult ar = doWork.BeginInvoke(callback, doWork);
// The callback is made on a ThreadPool thread. ThreadPool threads
// are background threads, which do not keep the application running
// if the main thread ends.
Thread.Sleep(2000);
Debug.WriteLine($"End of main thread (Thread ID: {Thread.CurrentThread.ManagedThreadId})");
}
public static void TestCallMethodWithoutWaitingForReturn()
{
DoWorkDelegate del = DoWork;
//two ways to be notified of when method ends:
// 1. callback method
// 2. call EndInvoke
IAsyncResult res = del.BeginInvoke(100000000, DoWorkDone, null);
for (int i = 0; i < 5; i++)
{
Console.WriteLine("Doing other work...{0}", i);
Thread.Sleep(1000);
}
//wait for end
double sum = del.EndInvoke(res);
Console.WriteLine("Sum: {0}", sum);
}
public void TestBeginEndPatternWithWaitHandle()
{
Debug.WriteLine($"Hello from TestSimpleBeginEndPattern() (Thread ID: {Thread.CurrentThread.ManagedThreadId})");
// Create the delegate.
var caller = new DoWorkDelegate(DoHardWork);
IAsyncResult result = caller.BeginInvoke(null, null);
// Wait for the WaitHandle to become signaled.
result.AsyncWaitHandle.WaitOne();
caller.EndInvoke(result);
// Close the wait handle.
result.AsyncWaitHandle.Close();
Debug.WriteLine($"End of main thread (Thread ID: {Thread.CurrentThread.ManagedThreadId})");
}
public void TestBeginEndPatternWithPolling()
{
Debug.WriteLine($"Hello from TestBeginEndPatternWithPolling() (Thread ID: {Thread.CurrentThread.ManagedThreadId})");
// Create the delegate.
var caller = new DoWorkDelegate(DoHardWork);
IAsyncResult result = caller.BeginInvoke(null, null);
// Poll while simulating work.
while (result.IsCompleted == false)
{
Debug.WriteLine($"Hello again from TestBeginEndPatternWithPolling() (Thread ID: {Thread.CurrentThread.ManagedThreadId})");
Thread.Sleep(250); // Attention! Bad code
}
caller.EndInvoke(result);
Debug.WriteLine($"End of main thread (Thread ID: {Thread.CurrentThread.ManagedThreadId})");
}
public void TestBeginEndPatternSimple()
{
Debug.WriteLine($"Hello from TestSimpleBeginEndPattern() (Thread ID: {Thread.CurrentThread.ManagedThreadId})");
// Create the delegate.
var caller = new DoWorkDelegate(DoSimpleWork);
// The BeginInvoke method initiates the asynchronous call.
// BeginInvoke returns an IAsyncResult, which can be used to monitor the progress of the asynchronous call.
IAsyncResult result = caller.BeginInvoke(null, null);
// Simulating some work in the main thread.
Thread.Sleep(0);
Debug.WriteLine($"Hello again from TestSimpleBeginEndPattern() (Thread ID: {Thread.CurrentThread.ManagedThreadId})");
// The EndInvoke method retrieves the results of the asynchronous call.
// It can be called any time after BeginInvoke.
// If the asynchronous call has not completed, EndInvoke blocks the calling thread until it completes.
caller.EndInvoke(result);
Debug.WriteLine($"End of main thread (Thread ID: {Thread.CurrentThread.ManagedThreadId})");
}
