private void SendAsync(bool showDlg) { if (IsSending) { throw new InvalidOperationException("ShowMailClient or Send has already been called."); } IsSending = true; var key = new object(); var asyncOp = AsyncOperationManager.CreateOperation(key); var t = new Thread(SendAsyncWorker); t.SetApartmentState(ApartmentState.STA); t.Start(new SendAsyncThreadArgs() { ShowDialog = showDlg, Operation = asyncOp }); }
public void MyTaskAsync() { MyTaskWorkerDelegate worker = new MyTaskWorkerDelegate(MyMouseWorker); AsyncCallback completedCallback = new AsyncCallback(MyTaskCompletedCallback); lock (_sync) { if (_myTaskIsRunning) { return; } //throw new InvalidOperationException("The control is currently busy."); AsyncOperation async = AsyncOperationManager.CreateOperation(null); worker.BeginInvoke(completedCallback, async); _myTaskIsRunning = true; } }
/// <summary> /// Starts this EnityPoller. /// </summary> /// <exception cref="System.InvalidOperationException">Already polling</exception> public void Start() { var worker = new AsyncWorker(Poll); var completed = new AsyncCallback(PollComplete); var onCompleted = new AsyncComplete(OnEntity); lock (_sync) { if (_polling) { throw new InvalidOperationException("Already polling"); } var operation = AsyncOperationManager.CreateOperation(onCompleted); worker.BeginInvoke(completed, operation); _polling = true; } }
/// <summary> /// Sends the service request async. /// </summary> /// <param name="context">The context.</param> /// <param name="state">The state.</param> public void SendServiceRequestAsync(IHttpCommand context, object state) { AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(state); lock (userStateToLifetime.SyncRoot) { if (userStateToLifetime.Contains(state)) { throw new ArgumentException("state must be unique for async operation", "state"); } userStateToLifetime[state] = asyncOp; } WorkerEventHandler workerDelegate = new WorkerEventHandler(SendServiceRequestAsyncWrapper); workerDelegate.BeginInvoke(context, asyncOp, null, null); }
public static void GetOddNumbersAsync(int min, int max, object userState) { AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(userState); lock (tasks.SyncRoot) { if (tasks.Contains(userState)) { throw new ArgumentException("The userState parameter must be unique!"); } tasks[userState] = asyncOp; } GetWorkerOddNumbersHandler oddHandler = new GetWorkerOddNumbersHandler(OddNumbersWorker); oddHandler.BeginInvoke(min, max, asyncOp, null, null); }
public virtual void GenerateAsync(GenerationParameter parameter, object taskId) { AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(taskId); lock (userStateToLifetime.SyncRoot) { if (userStateToLifetime.Contains(taskId)) { throw new ArgumentException("Task ID parameter must be unique", "taskId"); } userStateToLifetime[taskId] = asyncOp; } WorkerEventHandler workerDelegate = new WorkerEventHandler(GenerateWorker); workerDelegate.BeginInvoke(parameter, asyncOp, null, null); }
/// <summary> /// Asynchoronous version of the method /// </summary> /// <param name="message">just simple message to display</param> /// <param name="userState">Unique value to maintain the task</param> /// public void MathMulAsync(double[][] mat1, double[][] mat2, object userState) { AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(userState); //Multiple threads will access the task dictionary, so it must be locked to serialze access lock (tasks.SyncRoot) { if (tasks.Contains(userState)) { throw new ArgumentException("User state parameter must be unique", "userState"); } tasks[userState] = asyncOp; } WorkerEventHandler worker = new WorkerEventHandler(MathMulWorker); //Execute process Asynchronously worker.BeginInvoke(mat1, mat2, asyncOp, null, null); }
public void ListTasksAsync(object userTaskId) { AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(userTaskId); lock (taskListJobs.SyncRoot) { if (taskListJobs.Contains(userTaskId)) { throw new ArgumentException("Task ID parameter must be unique", "userTaskId"); } taskListJobs[userTaskId] = asyncOp; } // Start the asynchronous operation. listTasksWorkerEventHandler workerDelegate = new listTasksWorkerEventHandler(listTasksWorker); workerDelegate.BeginInvoke(asyncOp, null, null); }
public virtual void Run() { if (_operation != null) { throw new InvalidOperationException(); } _operation = AsyncOperationManager.CreateOperation(null); Success = true; if (AsyncRun) { System.Threading.ThreadPool.QueueUserWorkItem(_ => InnerRun()); } else { InnerRun(); } }
public ProcessesWatcher(RegionsManager regionsManager, SystemWindowsFactory windowsFactory, MoveWindowCommand moveWindowCommand) { _regionsManager = regionsManager; _windowsFactory = windowsFactory; _moveWindowCommand = moveWindowCommand; _asyncOperation = AsyncOperationManager.CreateOperation((object)null); _tickReporter = new SendOrPostCallback(SyncedTick); SyncWindowsSet(); _syncTimer = new Timer { Interval = 2000 }; _syncTimer.Elapsed += SyncTick; _syncTimer.AutoReset = true; _syncTimer.Enabled = true; }
/// <summary> /// 开始操作 /// </summary> void StartOperation() { if (WorkCallback == null && WorkCallbackAdvanced == null) { _completed = true; return; } if (AsyncWork) { _operation = AsyncOperationManager.CreateOperation(this); System.Threading.ThreadPool.QueueUserWorkItem(ThreadWorker); } else { ThreadWorker(null); } }
private void SendAsync(string hostNameOrAddress, int timeout, byte[] buffer, PingOptions options, object userToken) { if (string.IsNullOrEmpty(hostNameOrAddress)) { throw new ArgumentNullException("hostNameOrAddress"); } if (buffer == null) { throw new ArgumentNullException("buffer"); } if (buffer.Length > MaxBufferSize) { throw new ArgumentException(SR.net_invalidPingBufferSize, "buffer"); } if (timeout < 0) { throw new ArgumentOutOfRangeException("timeout"); } IPAddress address; if (IPAddress.TryParse(hostNameOrAddress, out address)) { SendAsync(address, timeout, buffer, options, userToken); return; } CheckStart(true); try { _cancelled = false; _asyncOp = AsyncOperationManager.CreateOperation(userToken); AsyncStateObject state = new AsyncStateObject(hostNameOrAddress, buffer, timeout, options, userToken); ThreadPool.QueueUserWorkItem(new WaitCallback(ContinueAsyncSend), state); } catch (Exception e) { Finish(true); throw new PingException(SR.net_ping, e); } }
public virtual void RequestStringAsync( EnumRequestMethod requestMethod, object taskId) { //HttpWebRequest requestObj = GetRequestObj(requestMethod); //RequestState requestState = new RequestState(); //requestState.request = requestObj; //requestState.RequestId = taskId; //requestState.IsRequestString = true; //requestState.Context = SynchronizationContext.Current; //if (requestMethod == EnumRequestMethod.POST) //{ // requestState.PostData = this.PostData; //} //requestState.RequestMethod = requestMethod; //this.BeginHttpReqeust(requestState); // Create an AsyncOperation for taskId. AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(taskId); // Multiple threads will access the task dictionary, // so it must be locked to serialize access. lock (userStateToLifetime.SyncRoot) { if (userStateToLifetime.Contains(taskId)) { throw new ArgumentException( "Task ID parameter must be unique", "taskId"); } userStateToLifetime[taskId] = asyncOp; } // Start the asynchronous operation. WorkerEventHandler workerDelegate = new WorkerEventHandler(RequestStringWorker); workerDelegate.BeginInvoke( requestMethod, asyncOp, null, null); }
/// <summary> /// Старт захвата параметров /// </summary> public void SensorStartLive() { //Если сейчас уже скан идет - остановим if (_flagIsScanning) { _flagIsScanning = false; } lock (this) { if (CountOfSensors == 0) { throw new ConsultException("Нет доступных сенсоров, Сначала добавьте сенсор"); } byte[] cmd = GetCommandToECU().ToArray(); try { _consult.SetClassState(ConsultClassState.ECU_STREAMING_MONITORS); //Отправляю команду _consult.SendCommand(cmd, ECUConst.ECU_REG_READ_CMD); //старт приема данных _consult.ECUFrameStart(); //Выставляем флаг начала сканирования _flagIsScanning = true; // Запускаем процедуру приема данных // чтобы из рабочего потока можно было "присоединиться" к текущему потоку. AsyncOperation ao = AsyncOperationManager.CreateOperation(null); // запустить рабочий поток new AsyncOperationInvoker(SensorLiveScanProcedure).BeginInvoke(ao, null, null); } catch (Exception ex) { _consult.ECUFrameStop(); _consult.SetClassState(ConsultClassState.ECU_IDLE); throw ex; } } }
/// <summary> /// Called to process the next queued work item. /// </summary> public void ProcessNextWorkRequest() { if (this.AllWorkersCompleted) { throw new AsyncWorkManagerException("Cannot restart an already completed queue manager."); } if (this.CancelRequested) { // Check to see that the cancelled request has not been processed if (!this.Cancelled) { lock (this._lockObject) { if (!this.Cancelled) { CheckAndSendCancellationNotice(); } } } } else if (this._workersQueue.Count > 0) { AsyncWorkRequest workRequest = this._workersQueue.Dequeue(); AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(workRequest.Id); workRequest.SetAsyncOperation(asyncOp); ThreadPool.QueueUserWorkItem(new WaitCallback( o => { asyncOp.SynchronizationContext.Post(new SendOrPostCallback(LaunchWorkerCallback), workRequest); })); } else { // No workers were found. End the session if no session is established or if a session has been // established and has completed. if (!this._sessionEnabled || (this._sessionEnabled && this._sessionCompleted)) { this.EndSession(); } } }
private void ViewOnShowLoggerBinImport(object sender, EventArgs eventArgs) { if (Project == null) { MessageBox.Show("Bitte zunächst ein Projekt erstellen oder öffnen."); return; } CommonOpenFileDialog loggerBinOpenFileDialog = new CommonOpenFileDialog { Multiselect = false }; loggerBinOpenFileDialog.Filters.Add( new CommonFileDialogFilter("e-obs Binärdatei v7.2", "*.bin" )); CommonFileDialogResult dr = loggerBinOpenFileDialog.ShowDialog(); if (dr != CommonFileDialogResult.Ok) { return; } const string DecoderBinaryFilename = "decoder_v7_2.exe"; Process proc = new Process { StartInfo = new ProcessStartInfo( Path.Combine(Path.GetDirectoryName(System.Reflection.Assembly.GetEntryAssembly().Location), DecoderBinaryFilename), $"-f {loggerBinOpenFileDialog.FileName} -c m") { CreateNoWindow = false, UseShellExecute = true, WindowStyle = ProcessWindowStyle.Normal, WorkingDirectory = Path.GetDirectoryName(loggerBinOpenFileDialog.FileName) }, EnableRaisingEvents = true }; proc.Exited += ProcOnExited; AsyncOp = AsyncOperationManager.CreateOperation(null); proc.Start(); }
public void character_CalculationsInvalidated(object sender, EventArgs e) { #if DEBUG DateTime start = DateTime.Now; #endif this.Cursor = Cursors.Wait; if (asyncCalculation != null) { CharacterCalculationsBase oldCalcs = referenceCalculation; referenceCalculation = null; oldCalcs.CancelAsynchronousCharacterDisplayCalculation(); asyncCalculation = null; } //_unsavedChanges = true; referenceCalculation = Calculations.GetCharacterCalculations(character, null, true, true, true); CalculationDisplay.SetCalculations(referenceCalculation.GetCharacterDisplayCalculationValues()); UpdateDisplayCalculationValues(referenceCalculation.GetCharacterDisplayCalculationValues(), referenceCalculation); if (Character.PrimaryProfession == Profession.Blacksmithing || Character.SecondaryProfession == Profession.Blacksmithing) { //HandBSCheck.IsChecked = true; //WristBSCheck.IsChecked = true; HandBSCheck.IsEnabled = true; WristBSCheck.IsEnabled = true; } else { HandBSCheck.IsChecked = false; WristBSCheck.IsChecked = false; HandBSCheck.IsEnabled = false; WristBSCheck.IsEnabled = false; } if (referenceCalculation.RequiresAsynchronousDisplayCalculation) { asyncCalculation = AsyncOperationManager.CreateOperation(null); ThreadPool.QueueUserWorkItem(delegate { AsyncCalculationStart(referenceCalculation, asyncCalculation); }); } this.Cursor = Cursors.Arrow; #if DEBUG System.Diagnostics.Debug.WriteLine(string.Format("Finished MainPage CalculationsInvalidated: {0}ms", DateTime.Now.Subtract(start).TotalMilliseconds)); #endif }
/// <summary> /// Called from the owner to start the worker /// </summary> /// <param name="asynchronous"> /// Specifies if the worker must run in asynchronous mode (True) or not (False) /// </param> /// <remarks></remarks> public void StartWorker(bool asynchronous) { _isAsynchonous = asynchronous; _cancelWorkerDoneEvent = false; if (_isAsynchonous) { //Asynchronous mode - we need to create a thread and start the worker using this thread _callingThreadAsyncOp = AsyncOperationManager.CreateOperation(null); _workerThread = new Thread(_worker.StartWorkerAsynchronous); _workerThread.IsBackground = true; _workerThread.Start(); } else { //Synchronous mode - simply call the worker's start method _worker.StartWorkerSynchronous(); } }
/// <summary> /// Download file asynchronously /// Performs DownloadFileCompleted callback /// </summary> public void DownloadFileAsync(Task task, string outputPath, object userTaskId) { AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(userTaskId); lock (downloadJobs.SyncRoot) { if (downloadJobs.Contains(userTaskId)) { throw new ArgumentException("Task ID parameter must be unique", "userTaskId"); } downloadJobs[userTaskId] = asyncOp; } // Start the asynchronous operation. downloadWorkerEventHandler workerDelegate = new downloadWorkerEventHandler(downloadFileWorker); workerDelegate.BeginInvoke(task, outputPath, asyncOp, null, null); }
private void MoveAsync(string name, string file, bool isBackup, Action <AsyncCompletedEventArgs> callback, object userState) { this.CheckInput(name, file, isBackup); AsyncOperation operation = AsyncOperationManager.CreateOperation(userState); SqlCommand command = this.CreateCommand(name, file, isBackup); command.BeginExecuteNonQuery((ar) => { Exception error = null; try { command.EndExecuteNonQuery(ar); } catch (Exception ex) { error = ex; } finally { this.Clean(command.Connection, command); operation.PostOperationCompleted((state) => callback(new AsyncCompletedEventArgs(error, false, state)), operation.UserSuppliedState); } }, null); }
public virtual void MatMulAsync(double[] mat1, double[] mat2, int size, object taskId) { AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(taskId); lock (tasks.SyncRoot) { if (tasks.Contains(taskId)) { throw new ArgumentException( "Task ID parameter must be unique", "taskId"); } tasks[taskId] = asyncOp; } WorkerEventHandler workerDelegate = new WorkerEventHandler(CalculateWorker); workerDelegate.BeginInvoke(mat1, mat2, size, asyncOp, null, null); }
public void DownloadAsync(object userState) { lock (asyncOpLock) { if (asyncOp != null) { throw new InvalidOperationException("Another async operation in progress."); } asyncOp = AsyncOperationManager.CreateOperation(userState); } Contract.Requires(cancellationTokenSource == null); cancellationTokenSource = new CancellationTokenSource(); cancellationToken = cancellationTokenSource.Token; IsBusy = true; // Is Task.Dispose() required? taskFactory.StartNew(DownloadTaskStart, asyncOp); }
private void MainForm_Load(object sender, EventArgs e) { MyTcpClient client = MyTcpClient.getInstance(); //保证回调函数是在创建他的上下文执行(一般是UI线程) client.AsyncOperation = AsyncOperationManager.CreateOperation(null); /* * client.Error += Client_Error; ; * client.Receive += Client_Receive; ; * client.Connected += Client_Connected; */ client.Connect(); comboDeadZone.Items.AddRange(Enum.GetNames(typeof(GamePadDeadZone))); comboDeadZone.SelectedItem = reporterState.DeadZone.ToString(); pollingWorker.RunWorkerAsync(); }
public void LongTaskAsync(string input, object taskId) { AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(taskId); lock (userStateDictionary) { if (userStateDictionary.ContainsKey(taskId)) { throw new ArgumentException("taskId must be unique", "taskId"); } userStateDictionary[taskId] = asyncOp; } LongTaskWorkHandler someLongTaskDelegate = DoLongTask; someLongTaskDelegate.BeginInvoke(input, asyncOp, null, null); }
private void AsynOperationCompleted(object args) { lock (statusChangeLockObject) { isWorking = false; if (!enabled) { isRunning = false; try { mainThreadOperation.OperationCompleted(); } catch { } } } OnRunWorkerCompleted((RunWorkerCompletedEventArgs)args); workThreadOperation = AsyncOperationManager.CreateOperation(null); workThreadOperation.PostOperationCompleted(completedCallback, null); }
/// <summary> /// 开始异步操作 /// </summary> /// <param name="taskId"></param> /// <returns></returns> protected AsyncOperation BeginAsync(object taskId) { // Create an AsyncOperation for taskId. AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(taskId); // Multiple threads will access the task dictionary, // so it must be locked to serialize access. lock (_taskIdToLifetime.SyncRoot) { if (_taskIdToLifetime.Contains(taskId)) { throw new ArgumentException( "Task ID parameter must be unique", "taskId"); } _taskIdToLifetime[taskId] = asyncOp; } return(asyncOp); }
/// <include file='doc\SoapClientProtocol.uex' path='docs/doc[@for="SoapClientProtocol.InvokeAsync1"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> protected void InvokeAsync(string methodName, object[] parameters, SendOrPostCallback callback, object userState) { if (userState == null) { userState = NullToken; } InvokeAsyncState invokeState = new InvokeAsyncState(methodName, parameters); AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(new UserToken(callback, userState)); WebClientAsyncResult asyncResult = new WebClientAsyncResult(this, invokeState, null, new AsyncCallback(InvokeAsyncCallback), asyncOp); try { AsyncInvokes.Add(userState, asyncResult); } catch (Exception e) { if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) { throw; } if (Tracing.On) { Tracing.ExceptionCatch(TraceEventType.Warning, this, "InvokeAsync", e); } Exception exception = new ArgumentException(Res.GetString(Res.AsyncDuplicateUserState), e); InvokeCompletedEventArgs eventArgs = new InvokeCompletedEventArgs(new object[] { null }, exception, false, userState); asyncOp.PostOperationCompleted(callback, eventArgs); return; } try { BeginSend(Uri, asyncResult, true); } catch (Exception e) { if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) { throw; } if (Tracing.On) { Tracing.ExceptionCatch(TraceEventType.Warning, this, "InvokeAsync", e); } OperationCompleted(userState, new object[] { null }, e, false); } }
/// <summary> /// Method to udpate Writeback status for a given WR. This method will be called by client asyncronously. Client needs to register the event WriteBackProcessCompleted to get the notification of method completion /// </summary> /// <param name="p_wrNumber">WR number</param> /// <param name="taskId"></param> public void UpdateWriteBack(string p_wrNumber, object taskId) { string sJobIdentifier = string.Empty; this.cc = new ConfirmComplete(); this.WriteBackProcessCompleted += WritebackClass_WriteBackProcessCompleted; this.cc.enableOK = false; this.cc.statusText = "Writing data to WMIS..."; this.cc.SetDesktopLocation(0, 0); this.cc.Show(m_oApp.ApplicationWindow); this.cc.TopMost = true; this.cc.Text = "WR# " + p_wrNumber; // When the cc form closes, dispose of it properly. this.cc.FormClosed += Cc_FormClosed; InitializeWriteBackDelegates(); AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(taskId); string sUserName = m_oApp.DataContext.DatabaseUserName; string sPasswordString = m_oApp.DataContext.ViewerConnectionString.Substring(m_oApp.DataContext.ViewerConnectionString.IndexOf("Password="******"Password="******"Task ID parameter must be unique", "taskId"); } userStateToLifetime[taskId] = asyncOp; } WorkerEventHandler workerDelegate = new WorkerEventHandler(UpdateWritebackStatusWorker); workerDelegate.BeginInvoke( p_wrNumber, asyncOp, sUserName, sPasswordString, null, null ); }
public void Execute(IServiceMethodUiBridge serviceMethodUiBridge) { m_ServiceMethodUiBridge = serviceMethodUiBridge; AsyncOperation asyncOperation = AsyncOperationManager.CreateOperation(m_AsyncKey); try { FeatureKey featureKey = BuildFeatureKey(serviceMethodUiBridge); UpdateFeatureStateRequest request = UpdateFeatureStateRequest.Create( MessageIdFactory.GenerateMessageId(), featureKey, serviceMethodUiBridge.FeatureStoreMethodArguments.State); IFeatureStoreServiceProxy featureStoreServiceProxy = new FeatureStoreServiceProxy(); featureStoreServiceProxy.BeginUpdateFeatureState( request, ar => { string rtfResults; try { UpdateFeatureStateResponse response = featureStoreServiceProxy.EndUpdateFeatureState(ar); rtfResults = BuildResultsRichText(request, response, GetType().Name); } catch (Exception e) { rtfResults = BuildExceptionRichText(e); } asyncOperation.PostOperationCompleted(HandleEndAsync, rtfResults); }, null); } catch (Exception e) { serviceMethodUiBridge.DisplayResults(BuildExceptionRichText(e)); } }
// WARNING: Any changes in the signature/name of the following method ctor must be applied to the // ClientClassGenerator.cs as well, otherwise the ClientClassGenerator would generate wrong code. protected void InvokeAsync(BeginOperationDelegate beginOperationDelegate, object[] inValues, EndOperationDelegate endOperationDelegate, SendOrPostCallback operationCompletedCallback, object userState) { if (beginOperationDelegate == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(beginOperationDelegate)); } if (endOperationDelegate == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(endOperationDelegate)); } AsyncOperation asyncOperation = AsyncOperationManager.CreateOperation(userState); AsyncOperationContext context = new AsyncOperationContext(asyncOperation, endOperationDelegate, operationCompletedCallback); Exception error = null; object[] results = null; IAsyncResult result = null; try { result = beginOperationDelegate(inValues, s_onAsyncCallCompleted, context); if (result.CompletedSynchronously) { results = endOperationDelegate(result); } } catch (Exception e) { if (Fx.IsFatal(e)) { throw; } error = e; } if (error != null || result.CompletedSynchronously) /* result cannot be null if error == null */ { CompleteAsyncCall(context, results, error); } }