private IAsyncResult SendMessage(MailMessage message) { AsyncMethodCaller caller = new AsyncMethodCaller(SendMailInSeperateThread); AsyncCallback callbackHandler = new AsyncCallback(AsyncCallback); return(caller.BeginInvoke(message, callbackHandler, null)); }
public void SendEmail(SendEmailModel model) { AsyncMethodCaller caller = new AsyncMethodCaller(SendMailInSeperateThread); AsyncCallback callbackHandler = new AsyncCallback(AsyncCallback); caller.BeginInvoke(model, callbackHandler, null); }
static void Main() { int threadId; AsyncDemo ad = new AsyncDemo(); AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod); IAsyncResult result = caller.BeginInvoke(3000, out threadId, null, null); Thread.Sleep(0); Console.WriteLine("Main thread {0} does some work.", Thread.CurrentThread.ManagedThreadId); result.AsyncWaitHandle.WaitOne(); string returnValue = caller.EndInvoke(out threadId, result); result.AsyncWaitHandle.Close(); Console.WriteLine("The call executed on thread {0}, with return value \"{1}\".", threadId, returnValue); Console.ReadKey(true); }
static void Main(string[] args) { // Ініціалізація byte[][] b = new byte[10000][]; for (int i = 0; i < b.Length; i++) { b[i] = new byte[10000]; for (int j = 0; j < b[i].Length; j++) { b[i][j] = 1; } } int[] async_threadId = new int[b.Length]; for (int i = 0; i < b.Length; i++) { async_threadId[i] = i; } List <AsyncMethodCaller> async_caller = new List <AsyncMethodCaller>(); List <IAsyncResult> async_res = new List <IAsyncResult>(); Stopwatch stopWatch = new Stopwatch(); stopWatch.Start(); // Проходи масив по рядку for (int i = 0; i < b.Length; i++) { AsyncSum async_sum = new AsyncSum(); AsyncMethodCaller caller = new AsyncMethodCaller(async_sum.TestMethod); async_caller.Add(caller); async_res.Add(async_caller[i].BeginInvoke(b[i], out async_threadId[i], null, null)); } int returnValue; for (int i = 0; i < b.Length; i++) { async_res[i].AsyncWaitHandle.WaitOne(); returnValue = async_caller[i].EndInvoke(out async_threadId[i], async_res[i]); async_res[i].AsyncWaitHandle.Close(); Console.WriteLine("The call executed on thread {0}, with return value \"{1}\".", async_threadId[i], returnValue); } stopWatch.Stop(); TimeSpan ts = stopWatch.Elapsed; string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}", ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10); Console.WriteLine("RunTime " + elapsedTime); Console.ReadLine(); }
public static void VehiclesAsync() { AsyncMethodCaller caller = new AsyncMethodCaller(Vehicles); AsyncCallback callback = new AsyncCallback(AsyncCallback); caller.BeginInvoke(callback, null); }
static void Main() { // The asynchronous method puts the thread id here. int threadId; // Create an instance of the test class. AsyncDemo ad = new AsyncDemo(); // Create the delegate. AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod); // Initiate the asychronous call. IAsyncResult result = caller.BeginInvoke(3000, out threadId, null, null); Thread.Sleep(0); Console.WriteLine("Main thread {0} does some work.", Thread.CurrentThread.ManagedThreadId); // Wait for the WaitHandle to become signaled. result.AsyncWaitHandle.WaitOne(); // Perform additional processing here. // Call EndInvoke to retrieve the results. string returnValue = caller.EndInvoke(out threadId, result); // Close the wait handle. result.AsyncWaitHandle.Close(); Console.WriteLine("The call executed on thread {0}, with return value \"{1}\".", threadId, returnValue); }
public void SendThat(MailMessage message) { AsyncMethodCaller caller = new AsyncMethodCaller(SendMailInSeperateThread); AsyncCallback callbackHandler = new AsyncCallback(AsyncCallback); caller.BeginInvoke(message, callbackHandler, null); }
static void Main(string[] args) { // The asynchronous method puts the thread id here. int threadId; // Create the delegate. AsyncMethodCaller caller = new AsyncMethodCaller(TestMethod); // Initiate the asychronous call. IAsyncResult result = caller.BeginInvoke(3000, out threadId, null, null); //Thread.Sleep(0); Console.WriteLine("Main thread {0} does some work.", Thread.CurrentThread.ManagedThreadId); // Wait for the WaitHandle to become signaled. result.AsyncWaitHandle.WaitOne(); // Call EndInvoke to retrieve the results. string returnValue = caller.EndInvoke(out threadId, result); // Close the wait handle. result.AsyncWaitHandle.Close(); Console.WriteLine("The call executed on thread {0}, with return value \"{1}\".", threadId, returnValue); }
private static void BeginInvokeOnDelegateWithLambdaCallback_DiscardParam() { var caller = new AsyncMethodCaller(AsyncMethod); // here the "_" is actually an identifier, not a discard parameter caller.BeginInvoke("delegate", 1, (_) => { }, null); // Noncompliant }
public static void Demo4() { // Create the delegate. AsyncMethodCaller caller = new AsyncMethodCaller(TestMethod); // The threadId parameter of TestMethod is an out parameter, so // its input value is never used by TestMethod. Therefore, a dummy // variable can be passed to the BeginInvoke call. If the threadId // parameter were a ref parameter, it would have to be a class- // level field so that it could be passed to both BeginInvoke and // EndInvoke. int dummy = 0; // Initiate the asynchronous call, passing three seconds (3000 ms) // for the callDuration parameter of TestMethod; a dummy variable // for the out parameter (threadId); the callback delegate; and // state information that can be retrieved by the callback method. // In this case, the state information is a string that can be used // to format a console message. IAsyncResult result = caller.BeginInvoke(3000, out dummy, new AsyncCallback(CallbackMethod), "The call executed on thread {0}, with return value \"{1}\"."); Console.WriteLine("The main thread {0} continues to execute...", Thread.CurrentThread.ManagedThreadId); // 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. Comment out the next line to demonstrate // this. Thread.Sleep(4000); Console.WriteLine("The main thread ends."); }
static void Main() { int threadId; AsyncDemo ad = new AsyncDemo(); AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod); IAsyncResult result = caller.BeginInvoke(3000, out threadId, null, null); Thread.Sleep(0); Console.WriteLine("Main thread {0} does some work.", Thread.CurrentThread.ManagedThreadId); result.AsyncWaitHandle.WaitOne(); string returnValue = caller.EndInvoke(out threadId, result); result.AsyncWaitHandle.Close(); Console.WriteLine("The call executed on thread {0}, with return value \"{1}\".", threadId, returnValue); Console.ReadKey(true); }
static void Start() { // The asynchronous method puts the thread id here. int threadId; // Create an instance of the test class. var ad = new AsyncDemo(); // Create the delegate. var caller = new AsyncMethodCaller(ad.TestMethod); // Initiate the asychronous call. var result = caller.BeginInvoke(3000, out threadId, null, null); Thread.Sleep(0); Console.WriteLine("Main thread {0} does some work.", Thread.CurrentThread.ManagedThreadId); // Wait for the WaitHandle to become signaled. result.AsyncWaitHandle.WaitOne(); // Perform additional processing here. // Call EndInvoke to retrieve the results. var returnValue = caller.EndInvoke(out threadId, result); // Close the wait handle. result.AsyncWaitHandle.Close(); Console.WriteLine("The call executed on thread {0}, with return value \"{1}\".", threadId, returnValue); Console.ReadKey(); }
private static void BeginInvokeOnDelegateWithLambdaCallback2() { var caller = new AsyncMethodCaller(AsyncMethod); var callback = new AsyncCallback(result => { }); caller.BeginInvoke("delegate", callback, null); // Noncompliant }
static void Main(string[] args) { AsyncMethodCaller caller = new AsyncMethodCaller(DoThis); IAsyncResult result = caller.BeginInvoke(new AsyncCallback(CallBackMethod), null); result.AsyncWaitHandle.WaitOne(); }
public DataFrame EndReceive(IAsyncResult ar) { AsyncResult result = (AsyncResult)ar; AsyncMethodCaller caller = (AsyncMethodCaller)result.AsyncDelegate; return(caller.EndInvoke(result)); }
private static void BeginInvokeAndEndInvokeOnDelegateWithVariableCallback() { var caller = new AsyncMethodCaller(AsyncMethod); AsyncCallback callback = result => { caller.EndInvoke(result); }; caller.BeginInvoke("delegate", callback, null); // Compliant }
private static void BeginInvokeAndEndInvokeOnDelegateWithLambdaCallback2() { var caller = new AsyncMethodCaller(AsyncMethod); var callback = new AsyncCallback(result => caller.EndInvoke(result)); caller.BeginInvoke("delegate", callback, null); // Compliant, EndInvoke is called by wrapper.CallEndInvoke }
private static void BeginInvokeAndEndInvokeOnDelegateWithStaticCallback2() { var caller = new AsyncMethodCaller(AsyncMethod); var wrapper = new CallerWrapper(caller); caller.BeginInvoke("delegate", new AsyncCallback(StaticDoNothing), null); // Noncompliant }
private static void BeginInvokeAndEndInvokeOnDelegateWithStaticCallback1() { var caller = new AsyncMethodCaller(AsyncMethod); var callback = new AsyncCallback(StaticCallEndInvoke); caller.BeginInvoke("delegate", callback, null); // Compliant, EndInvoke is called by wrapper.CallEndInvoke }
static void Main(string[] args) { AsyncMethodCaller caller = new AsyncMethodCaller(TestMethodAsync); // caller 为委托函数 int threadid = 0; //开启异步操作 IAsyncResult result = caller.BeginInvoke(1000, out threadid, null, null); for (int i = 0; i < 10; i++) { Console.WriteLine("其它业务" + i.ToString()); } //调用EndInvoke,等待异步执行完成 Console.WriteLine("等待异步方法TestMethodAsync执行完成"); //等待异步执行完毕信号 //result.AsyncWaitHandle.WaitOne(); //Console.WriteLine("收到WaitHandle信号"); //通过循环不停的检查异步运行状态 while (result.IsCompleted == false) { Thread.Sleep(100); Console.WriteLine("异步方法,running........"); } //异步结束,拿到运行结果 string res = caller.EndInvoke(out threadid, result); //显示关闭句柄 result.AsyncWaitHandle.Close(); Console.WriteLine("关闭了WaitHandle句柄"); Console.Read(); }
public static void Main() { // The asynchronous method puts the thread id here. int threadId; // Create an instance of the test class. AsyncDemo ad = new AsyncDemo(); // Create the delegate. AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod); // Initiate the asychronous call. IAsyncResult result = caller.BeginInvoke(3000, out threadId, null, null); Thread.Sleep(0); Console.WriteLine("Main thread {0} does some work.", Thread.CurrentThread.ManagedThreadId); // Call EndInvoke to wait for the asynchronous call to complete, // and to retrieve the results. string returnValue = caller.EndInvoke(out threadId, result); Console.WriteLine("The call executed on thread {0}, with return value \"{1}\".", threadId, returnValue); }
static void Main() { // The asynchronous method puts the thread id here. int threadId; // Create an instance of the test class. AsyncDemo ad = new AsyncDemo(); // Create the delegate. AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod); // Initiate the asychronous call. IAsyncResult result = caller.BeginInvoke(3000, out threadId, null, null); // Poll while simulating work. while (result.IsCompleted == false) { Thread.Sleep(250); Console.Write("."); } // Call EndInvoke to retrieve the results. string returnValue = caller.EndInvoke(out threadId, result); Console.WriteLine("\nThe call executed on thread {0}, with return value \"{1}\".", threadId, returnValue); }
/// <summary> /// Executes a particular function in a module, according to the passed in parameters, acting as a slave server /// </summary> /// <param id="state">The server state object of the request</param> public static void ExecutionBegin(ServerState state) { //finally execute the function defined in the transfer AsyncMethodCaller execution = new AsyncMethodCaller(execute); execution.BeginInvoke(state, null, null); }
public object DoWork(MB.Util.AsynWorkThread workThread, DoWorkEventArgs e) { // The asynchronous method puts the thread id here. int threadId; // Create an instance of the test class. AsyncDemo ad = new AsyncDemo(); // Create the delegate. AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod); // Initiate the asychronous call. IAsyncResult result = caller.BeginInvoke(3000, out threadId, null, null); Thread.Sleep(0); workThread.ReportProgress(0, string.Format("Main thread {0} does some work.", Thread.CurrentThread.ManagedThreadId)); // Call EndInvoke to wait for the asynchronous call to complete, // and to retrieve the results. string returnValue = caller.EndInvoke(out threadId, result); workThread.ReportProgress(1, string.Format("The call executed on thread {0}, with return value \"{1}\".", threadId, returnValue)); e.Result = returnValue; return(returnValue); }
static void Main() { // The asynchronous method puts the thread id here. int threadId; // Create an instance of the test class. AsyncDemo ad = new AsyncDemo(); // Create the delegate. AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod); // Initiate the asychronous call. IAsyncResult result = caller.BeginInvoke(3000, out threadId, null, null); // Poll while simulating work. while (result.IsCompleted == false) { Thread.Sleep(250); Console.Write("."); } // Call EndInvoke to retrieve the results. string returnValue = caller.EndInvoke(out threadId, result); Console.WriteLine("\nThe call executed on thread {0}, with return value \"{1}\".", threadId, returnValue); }
private void button3_Click(object sender, EventArgs e) { var caller = new AsyncMethodCaller(AsyncMethod); MessageBox.Show("Task Created."); IAsyncResult result = caller.BeginInvoke(2000, CallbackMethod, null); MessageBox.Show("Task BeginInvoke."); }
protected void Page_Load(object sender, EventArgs e) { #region // The asynchronous method puts the thread id here. int threadId; // Create the delegate. AsyncMethodCaller caller = new AsyncMethodCaller(TestMethod); // Initiate the asychronous call. IAsyncResult result = caller.BeginInvoke(3000, out threadId, null, null); string returnValue = caller.EndInvoke(out threadId, result); #endregion #region //Async async = null; //async = new Async(o => // { // return "异步返回值"; // }); //r = async.BeginInvoke("异步测试", new AsyncCallback(Done), async); //r.AsyncWaitHandle.WaitOne(); #endregion }
//EndInvokeによるブロッキング static void BlockingEndInvoke() { // The asynchronous method puts the thread id here. int threadId; // Create an instance of the test class. AsyncDemo ad = new AsyncDemo(); // Create the delegate. AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod); // Initiate the asychronous call. // デリゲートを同じ引き数+コールバック関数+コールバック引数となります。 IAsyncResult result = caller.BeginInvoke(3000, out threadId, null, null); Thread.Sleep(0); Console.WriteLine("Main thread {0} does some work.", Thread.CurrentThread.ManagedThreadId); // Call EndInvoke to wait for the asynchronous call to complete, // and to retrieve the results. string returnValue = caller.EndInvoke(out threadId, result); Console.WriteLine("The call executed on thread {0}, with return value \"{1}\".", threadId, returnValue); }
// On "Connect" button clicked private void ConnectButton_Click(object sender, EventArgs e) { if (videoDevice != null) { if ((videoCapabilities != null) && (videoCapabilities.Length != 0)) { videoDevice.VideoResolution = videoCapabilities[videoResolutionsCombo.SelectedIndex]; } if ((snapshotCapabilities != null) && (snapshotCapabilities.Length != 0)) { videoDevice.ProvideSnapshots = true; videoDevice.SnapshotResolution = snapshotCapabilities[snapshotResolutionsCombo.SelectedIndex]; videoDevice.SnapshotFrame += new NewFrameEventHandler(VideoDevice_SnapshotFrame); } EnableConnectionControls(false); videoSourcePlayer.VideoSource = videoDevice; videoDevice.NewFrame += new NewFrameEventHandler(Video_NewFrame); caller = SaveVideo; videoSourcePlayer.Start( ); } }
string Execute_Update() { for (int i = 1; i <= numberofexchanges; i++) { //mk.UpdateExchange(i); int threadId; AsyncMethodCaller caller = new AsyncMethodCaller(CallMarkets); // Initiate the asychronous call. IAsyncResult result = caller.BeginInvoke(i, out threadId, Callback, null); hsnumberofthreads.Add(i, result); } /* * while (hsnumberofthreads.Count > 0) * { * * }*/ WaitHandle[] waitHandles = new WaitHandle[numberofexchanges]; foreach (DictionaryEntry entry in hsnumberofthreads) { IAsyncResult tempresult = (IAsyncResult)entry.Value; waitHandles[Convert.ToInt32(entry.Key) - 1] = tempresult.AsyncWaitHandle; } WaitHandle.WaitAll(waitHandles); hsnumberofthreads.Clear(); return(""); }
static void PrintResult(IAsyncResult result) { AsyncResult asyncResult = (AsyncResult)result; AsyncMethodCaller caller = (AsyncMethodCaller)asyncResult.AsyncDelegate; // Retreaving previously stored number. decimal number = (decimal)result.AsyncState; try { // Call EndInvoke to retrieve the results. bool isPrime = caller.EndInvoke(out double seconds, result); if (isPrime) { Console.ForegroundColor = ConsoleColor.Green; Console.WriteLine($"Number {number} is prime. Elapsed time {seconds} s."); Console.ForegroundColor = ConsoleColor.Gray; } else { Console.ForegroundColor = ConsoleColor.Yellow; Console.WriteLine($"Number {number} is composite. Elapsed time {seconds} s."); Console.ForegroundColor = ConsoleColor.Gray; } } catch (Exception ex) // Exceptions from async operations will appear here. { Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine(ex.Message); Console.ForegroundColor = ConsoleColor.Gray; return; } }
/// <summary> /// Envoyer Email (d'une manière asynchrone) avec un template dans le dossier du template (appsettings EmailTemplatesFolder dans le web.config) /// </summary> /// <param name="model">Le model de l'email</param> /// <param name="template">Le nom complet du template. Ne pas oublier de déployer le dossier du template avec l'application</param> public void SendEmail(EmailModelBase model, string template) { AsyncMethodCaller caller = new AsyncMethodCaller(SendMailInSeperateThread); AsyncCallback callbackHandler = new AsyncCallback(AsyncCallback); caller.BeginInvoke(model, template, callbackHandler, null); }
public static void ContactsAsync() { AsyncMethodCaller caller = new AsyncMethodCaller(Contacts); AsyncCallback callback = new AsyncCallback(AsyncCallback); caller.BeginInvoke(callback, null); }
private void GetResult(IAsyncResult result) { AsyncMethodCaller caller = (AsyncMethodCaller)((AsyncResult)result).AsyncDelegate; string returnstring = caller.EndInvoke(result); sc.Post(ShowState, returnstring); }
protected void Page_Load(object sender, EventArgs e) { Debug.WriteLine("Starting"); DateTime? a = new DateTime(2000, 12, 5); a = null; TheDelegate delegateDefinition = s => s; string theReturnValue = delegateDefinition("test"); AsyncDemo ad = new AsyncDemo(); AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod); int dummy = 0; IAsyncResult result = caller.BeginInvoke(3000, out dummy, new AsyncCallback(CallbackMethod), "The call executed on thread {0}, with return value \"{1}\"."); Debug.WriteLine(string.Format("The main thread {0} continues to execute...", Thread.CurrentThread.ManagedThreadId)); //Thread.Sleep(4000); Debug.WriteLine("The main thread ends."); }
private void CpuAPMExcution() { var sw = Stopwatch.StartNew(); // time the operation // The asynchronous method puts the thread id here. int threadId; // Create an instance of the test class. AsyncPiBlocking ad = new AsyncPiBlocking(); // Create the delegate. AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod); // Initiate the asychronous call. IAsyncResult result = caller.BeginInvoke(0, out threadId, null, null); Thread.Sleep(0); var test = DoWork(_digits.Value); _pi.AppendText(test); // Wait for the WaitHandle to become signaled. result.AsyncWaitHandle.WaitOne(); // Perform additional processing here. // Call EndInvoke to retrieve the results. string returnValue = caller.EndInvoke(out threadId, result); // Close the wait handle. result.AsyncWaitHandle.Close(); textBoxPerformance.Text = Convert.ToString(sw.Elapsed); _pi.AppendText($" (The call executed on thread {threadId}). "); }
public void Send(MailMessage message) { MailMessage msg = new MailMessage(); msg = message; AsyncMethodCaller caller = new AsyncMethodCaller(SendMailInSeperateThread); AsyncCallback callbackHandler = new AsyncCallback(AsyncCallback); caller.BeginInvoke(msg, callbackHandler, null); }
private static void BeginInvokeAndEndInvokeOnDelegateWithoutCallback() { Console.WriteLine("BeginInvokeAndEndInvokeOnDelegateWithoutCallback"); var caller = new AsyncMethodCaller(AsyncMethod); IAsyncResult result = caller.BeginInvoke("delegate", /* callback */ null, /* state */ null); // Compliant caller.EndInvoke(result); }
static void Main(string[] args) { // Ініціалізація byte[][] b = new byte[10000][]; for (int i = 0; i < b.Length; i++) { b[i] = new byte[10000]; for (int j = 0; j < b[i].Length; j++) { b[i][j] = 1; } } int[] async_threadId = new int[b.Length]; for (int i = 0; i < b.Length; i++) { async_threadId[i] = i; } List<AsyncMethodCaller> async_caller = new List<AsyncMethodCaller>(); List<IAsyncResult> async_res = new List<IAsyncResult>(); Stopwatch stopWatch = new Stopwatch(); stopWatch.Start(); // Проходи масив по рядку for (int i = 0; i < b.Length; i++) { AsyncSum async_sum = new AsyncSum(); AsyncMethodCaller caller = new AsyncMethodCaller(async_sum.TestMethod); async_caller.Add(caller); async_res.Add (async_caller[i].BeginInvoke( b[i], out async_threadId[i], null, null) ); } int returnValue; for (int i = 0; i < b.Length; i++) { async_res[i].AsyncWaitHandle.WaitOne(); returnValue = async_caller[i].EndInvoke(out async_threadId[i], async_res[i]); async_res[i].AsyncWaitHandle.Close(); Console.WriteLine("The call executed on thread {0}, with return value \"{1}\".", async_threadId[i], returnValue); } stopWatch.Stop(); TimeSpan ts = stopWatch.Elapsed; string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}", ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10); Console.WriteLine("RunTime " + elapsedTime); Console.ReadLine(); }
private void button2_Click(object sender, EventArgs e) { var caller = new AsyncMethodCaller(AsyncMethod); MessageBox.Show("Task Created."); IAsyncResult result = caller.BeginInvoke(2000, null ,null); MessageBox.Show("Task BeginInvoke."); Thread.Sleep(100); caller.EndInvoke(result); MessageBox.Show("Task EndInvoke."); }
public void BuyNumber(Int32 number, Action<NumberType> callback) { // no lock is needed here since just checking if a number is prime // and its a readonly operation. if (!_primes.ContainsKey(number)) { callback(NumberType.NotExist); } else { // Create the delegate. AsyncMethodCaller caller = new AsyncMethodCaller(BuyPrime); // Initiate the asychronous call. caller.BeginInvoke(number, callback, null, null); } }
public static void Main(string[] args) { // Create an instance of the test class. AsyncDemo ad = new AsyncDemo(); // Create the delegate. AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod); // The threadId parameter of TestMethod is an out parameter, so // its input value is never used by TestMethod. Therefore, a dummy // variable can be passed to the BeginInvoke call. If the threadId // parameter were a ref parameter, it would have to be a class- // level field so that it could be passed to both BeginInvoke and // EndInvoke. int dummy = 0; // Initiate the asynchronous call, passing three seconds (3000 ms) // for the callDuration parameter of TestMethod; a dummy variable // for the out parameter (threadId); the callback delegate; and // state information that can be retrieved by the callback method. // In this case, the state information is a string that can be used // to format a console message. IAsyncResult result = caller.BeginInvoke(3000, out dummy, new AsyncCallback(CallbackMethod), "The call executed on thread {0}, with return value \"{1}\"."); Console.WriteLine("The main thread {0} continues to execute...", Thread.CurrentThread.ManagedThreadId); // 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. Comment out the next line to demonstrate // this. Thread.Sleep(4000); Console.WriteLine("The main thread ends."); Console.ReadKey(); }
public ActionResult Index() { var client = new FlickrService.FlickrService(); AsyncMethodCaller caller = new AsyncMethodCaller(client.GetRecentPhotos); var result = caller.BeginInvoke(null, null); var photos = caller.EndInvoke(result); ViewData["flickrphotos"] = photos; List<string> urls = new List<string>(); foreach (var photo in photos) { urls.Add(photo.ImageUrl); } ViewData["photos"] = urls; return View(); }
static void Main() { AsyncDemo ad = new AsyncDemo(); AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod); int dummy = 0; IAsyncResult result = caller.BeginInvoke(3000, out dummy, new AsyncCallback(CallbackMethod), "The call executed on thread {0}, with return value \"{1}\"."); Console.WriteLine("The main thread {0} continues to execute...", Thread.CurrentThread.ManagedThreadId); Thread.Sleep(4000); Console.WriteLine("The main thread ends."); Console.ReadKey(true); }
static int Main(string[] args) { IAsyncResult result = null; AsyncMethodCaller caller = new AsyncMethodCaller(DelegateCommon.TestMethod); try { result = caller.BeginInvoke(123, null, null); } catch (PlatformNotSupportedException) { // Expected } catch (Exception ex) { Console.WriteLine("BeginInvoke resulted in unexpected exception: {0}", ex.ToString()); Console.WriteLine("FAILED!"); return -1; } try { caller.EndInvoke(result); } catch (PlatformNotSupportedException) { // Expected } catch (Exception ex) { Console.WriteLine("EndInvoke resulted in unexpected exception: {0}", ex.ToString()); Console.WriteLine("FAILED!"); return -1; } return 100; }
static void Main() { int threadId; AsyncDemo ad = new AsyncDemo(); AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod); IAsyncResult result = caller.BeginInvoke(3000, out threadId, null, null); while (result.IsCompleted == false) { Thread.Sleep(250); Console.Write("."); } string returnValue = caller.EndInvoke(out threadId, result); Console.WriteLine("\nThe call executed on thread {0}, with return value \"{1}\".", threadId, returnValue); Console.ReadKey(true); }
public void FoundWayAsync(Point startPosition, Point endPosition) { HasEnded = false; AsyncMethodCaller caller = new AsyncMethodCaller(FoundPath); caller.BeginInvoke(startPosition, endPosition, null, null); // Thread thread = new Thread(caller(startPosition, endPosition, out path, creature, improvedPathFinding, ignoreObstacles)}); }
private void btnBatchUpdateLocalAssembly_Click(object sender, EventArgs e) { tabMain.SelectedTab = tabPageMessage; if (Configuration.MasterConfig.BatchUpdateAssemblySettings.AutoUpdate) { AsyncMethodCaller caller = new AsyncMethodCaller(InitializeDropdowns); IAsyncResult result = caller.BeginInvoke( null, caller); caller.EndInvoke(result); for (int i = 0; i < cmbVersion.Items.Count; i++) { cmbVersion.SelectedIndex = i; for (int j = 1; j < cmbModule.Items.Count; j++) { cmbModule.SelectedIndex = j; foreach (String uri in Configuration.MasterConfig.BatchUpdateAssemblySettings.UpdateModuleNames) { if (uri.ToLower() == cmbModule.Text.ToLower()) { string updateUrl = textEndPointUri.Text.ToLower(); if (!updateUrls.Contains(updateUrl)) { updateUrls.Add(updateUrl); } } } } } } string[] updateVersions = Configuration.MasterConfig.BatchUpdateAssemblySettings.UpdateVersions; string[] updateModuleNames = Configuration.MasterConfig.BatchUpdateAssemblySettings.UpdateModuleNames; if (updateVersions != null && updateModuleNames != null) { for (int i = 0; i < updateVersions.Length; i++) { for (int j = 0; j < updateModuleNames.Length; j++) { string updateUrl = updateVersions[i] + updateModuleNames[j]; if (!updateUrls.Contains(updateUrl)) { updateUrls.Add(updateUrl); } } } } beginUpdateLocalAssembly = 0; finishedUpdateLocalAssembly = 0; btnBatchUpdateLocalAssembly.Enabled = false; foreach (string updateUrl in updateUrls) { beginUpdateLocalAssembly++; Wsdl wsdl1 = new Wsdl(); wsdl1.Paths.Add(updateUrl); AsyncMethodCaller caller1 = new AsyncMethodCaller(wsdl1.GenerateAndUpdateAssembly); caller1.BeginInvoke( new AsyncCallback(BatchUpdateLocalAssemblyCallBack), caller1); ShowMessage(this, MessageType.Begin, "Begin Create Local Assembly Use EndPointUri: " + updateUrl); } }
/// <summary> /// Main: Async operation beginning using WaitOne (waithandler) /// </summary> /// <param name="sender"></param> /// <param name="e"></param> /// <param name="cb"></param> /// <param name="state"></param> /// <returns></returns> IAsyncResult BeginAsyncOperation(object sender,EventArgs e,AsyncCallback cb,object state) { // The asynchronous method puts the thread id here. int threadId; // Create an instance of the test class. AsyncDemo ad = new AsyncDemo(); // Create the delegate. AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod); Thread.Sleep(0); Console.WriteLine("Main thread {0} does some work.", Thread.CurrentThread.ManagedThreadId); // Initiate the asychronous call. IAsyncResult result = caller.BeginInvoke(3000, out threadId, //null, null); new AsyncCallback(EndAsyncOperation), "The call executed on thread {0}, with return value \"{1}\"."); Trace.Write("BeginAsyncOperation", string.Format("Waiting for the WaitHandle to become signaled...\nThreadId={0} \tResultState = {1}\t Caller= {2}) ", threadId, result.AsyncState, caller)); result.AsyncWaitHandle.WaitOne(); // Perform additional processing here. // Call EndInvoke to retrieve the results. string returnValue = caller.EndInvoke(out threadId, result); Console.WriteLine("The call executed on thread {0}, with return value \"{1}\".", threadId, returnValue); Queue<int> threadIds = m_TaskIds;// Session["TaskIds"] as Queue<int>; if (threadIds != null) threadIds.Enqueue(threadId); IDictionary<int, IAsyncResult> asyncResult = m_AsyncResults;// Session["AsyncResults"] as Dictionary<int, IAsyncResult>; if (asyncResult != null) asyncResult.Add(new KeyValuePair<int, IAsyncResult>(threadId, result)); IDictionary<int, AsyncMethodCaller> asyncCallers = m_AsyncCallers;// Session["AsyncCallers"] as Dictionary<int, AsyncMethodCaller>; if (asyncCallers != null) asyncCallers.Add(new KeyValuePair<int, AsyncMethodCaller>(threadId, caller)); // Close the wait handle. result.AsyncWaitHandle.Close(); return result; }
/// <summary> /// The dependencies are injected. /// </summary> /// <param name="asyncMethodCaller">Use TestAsyncMethodCaller for tests, AsyncMethodCaller in production.</param> /// <param name="service">Inject the service for easier faking and faster tests.</param> public ViewModel(AsyncMethodCaller asyncMethodCaller, IServiceInterface service) { this.asyncMethodCaller = asyncMethodCaller; this.service = service; }
public void FoundWayAsync(Point startPosition, Point endPosition) { HasEnded = false; AsyncMethodCaller caller = new AsyncMethodCaller(FindPath); caller.BeginInvoke(startPosition, endPosition, null, null); }
static void Main() { // The asynchronous method puts the thread id here. int threadId; // Create an instance of the test class AsyncDemo ad = new AsyncDemo(); // Create the delegate. AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod); IAsyncResult result; #region Using Begin and End Invoke Console.WriteLine("Beginning solely end invoke method..."); // Initiate the asynchronous call. result = caller.BeginInvoke(1111, out threadId, null, null); Thread.Sleep(0); Console.WriteLine("Main thread {0} does some work.", Thread.CurrentThread.ManagedThreadId); // Call EndInvoke to wait for the asynchronous call to complete, // and to retrieve the results. string returnValue = caller.EndInvoke(out threadId, result); Console.WriteLine("The call executed on thread {0}, has completed using EndInvoke (blocking) with return value \"{1}\".", threadId, returnValue); Console.WriteLine(); #endregion ad = new AsyncDemo(); caller = new AsyncMethodCaller(ad.TestMethod); #region Using a Wait Handle Console.WriteLine("Beginning wait handle method..."); result = caller.BeginInvoke(1234, out threadId, null, null); Thread.Sleep(0); Console.WriteLine("Main thread {0} does some more work.", Thread.CurrentThread.ManagedThreadId); // Wait for the WaitHandle to become signalled. result.AsyncWaitHandle.WaitOne(); // Perform additional processing here. // Call EndInvoke to retrieve the results. returnValue = caller.EndInvoke(out threadId, result); // Close the wait handle. result.AsyncWaitHandle.Close(); Console.WriteLine("The called executed on thread {0}, has completed using a Wait Handle with return value \"{1}\".", threadId, returnValue); Console.WriteLine(); #endregion ad = new AsyncDemo(); caller = new AsyncMethodCaller(ad.TestMethod); #region Using Polling Console.WriteLine("Beginning polling method..."); result = caller.BeginInvoke(1010, out threadId, null, null); // Poll while simulating work. while (result.IsCompleted == false) { Thread.Sleep(250); Console.Write("."); } returnValue = caller.EndInvoke(out threadId, result); Console.WriteLine("\nThe call executed on thread {0}, has completed using polling with return value \"{1}\".", threadId, returnValue); Console.WriteLine(); #endregion ad = new AsyncDemo(); caller = new AsyncMethodCaller(ad.TestMethod); #region Using an AsyncCallBack method Console.WriteLine("Beginning asynchronous callback method..."); /* AsyncCallback callback = new AsyncCallback(ad.AsyncCallBackMethod); result = caller.BeginInvoke(1234, out threadId, callback, null); callback(result); */ result = caller.BeginInvoke(1234, out threadId, new AsyncCallback(ad.AsyncCallBackMethod), "The call executed on thread {0}, with return value \"{1}\"."); Console.WriteLine("The main thread {0} continues to execute...", Thread.CurrentThread.ManagedThreadId); // 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. Comment out the next line to demonstrate // this. Thread.Sleep(4000); Console.WriteLine("The main thread ends."); Console.WriteLine(); #endregion #region My own test Console.WriteLine("Running my own test..."); AsyncThingy thingy = new AsyncThingy(); thingy.DoAsyncStuff(); Console.WriteLine("Main thread {0} is back.", Thread.CurrentThread.ManagedThreadId); Console.WriteLine("The asynchronous method should write something shortly, or stuff will explode"); Thread.Sleep(6000); #endregion }
public AsyncThingy() { myAd = new AsyncDemo(); caller = new AsyncMethodCaller(myAd.TestMethod); }
private void button1_Click(object sender, EventArgs e) { if (txtParameters.Count > 0) { if (MessageBox.Show("请确认参数是否全部填写正确!", "系统提示", MessageBoxButtons.OKCancel, MessageBoxIcon.Question) == DialogResult.Cancel) return; } button1.Enabled = false; label5.Text = "正在调用服务,请稍候..."; label5.Refresh(); var jValue = new JObject(); if (txtParameters.Count > 0) { foreach (var p in txtParameters) { var text = p.Value.Text.Trim(); if (!string.IsNullOrEmpty(text)) { var info = p.Value.Tag as ParameterInfo; try { jValue[p.Key] = JToken.Parse(text); } catch { jValue[p.Key] = text; } } } } //提交的参数信息 string parameter = jValue.ToString(Newtonsoft.Json.Formatting.None); var message = new InvokeMessage { ServiceName = serviceName, MethodName = methodName, Parameters = parameter }; //启用线程进行数据填充 var caller = new AsyncMethodCaller(AsyncCaller); var ar = caller.BeginInvoke(message, AsyncComplete, caller); }
private void AsyncInitializeDropdowns() { btnPopulate.Enabled = false; cmbModule.Enabled = false; cmbVersion.Enabled = false; ServerCBox.Enabled = false; buttonGet.Enabled = false; AsyncMethodCaller caller = new AsyncMethodCaller(InitializeDropdowns); caller.BeginInvoke( new AsyncCallback(InitializeDropdownsCallBack), caller); }
/// <summary> /// Load a category of videos into this carousel. /// Everything calling the webservice and downloading of coverart is run in a background thread. /// </summary> /// <param name="category"></param> public void Add(string category) { AsyncMethodCaller caller = new AsyncMethodCaller(InternalAdd); IAsyncResult result = caller.BeginInvoke(category, null, null); }
private void RegenerateCache(string url) { var method = new AsyncMethodCaller(GenerateIndexesFor); method.BeginInvoke(url, null, null); }
void AsyncJobByDelegate() { AsyncMethodCaller caller = new AsyncMethodCaller(SleepJob); caller.BeginInvoke(GetResult, null); }
private void startSync() { AsyncMethodCaller caller = new AsyncMethodCaller(logic.syncFolderPair); while (lvTaskList.Items.Count > 0) { string taskName = lvTaskList.Items[0].SubItems[0].Text; lblTimer.Text = "Synchronizing folder pair in " + taskName; statusBar.Refresh(); string source = lvTaskList.Items[0].SubItems[1].Text; string target = lvTaskList.Items[0].SubItems[2].Text; //IAsyncResult result = caller.BeginInvoke(source, target, taskName, null, null); logic.syncFolderPair(source, target, taskName); plugSyncList.Remove(new SyncTask(taskName, source, target)); updateListView(); } }
private void DoTestAsyncOperation() { // The asynchronous method puts the thread id here. int threadId; // Create an instance of the test class. AsyncDemo ad = new AsyncDemo(HttpContext.Current.Session, HttpContext.Current.Trace); // Create the delegate. AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod); Thread.Sleep(0); Console.WriteLine("Main thread {0} does some work.", Thread.CurrentThread.ManagedThreadId); // Initiate the asychronous call. IAsyncResult result = caller.BeginInvoke(1000, out threadId, null, null); result.AsyncWaitHandle.WaitOne(); Trace.Write("BeginAsyncOperation", string.Format("Waiting for the WaitHandle to become signaled...\nThreadId={0} \tResultState = {1}\t Caller= {2}", threadId, result.AsyncState, caller)); // Perform additional processing here. // Call EndInvoke to retrieve the results. string returnValue = caller.EndInvoke(out threadId, result); Console.WriteLine("The call executed on thread {0}, with return value \"{1}\".", threadId, returnValue); Queue<int> threadIds = m_TaskIds;// Session["TaskIds"] as Queue<int>; if (threadIds != null) threadIds.Enqueue(threadId); if (m_AsyncResults != null) m_AsyncResults.Add(threadId, result); // Close the wait handle. result.AsyncWaitHandle.Close(); }