C# ComponentModel.AsyncOperation类代码示例

 public IrcClient(string Server, int Port, string ServerPassword)
 {
     ops = AsyncOperationManager.CreateOperation(null);
     _server = Server;
     _port = Port;
     _serverPass = ServerPassword;
 }

        public void CalculateAsync()
        {
            if (task_id != Guid.Empty)
            {
                throw new InvalidOperationException();
            }

            task_id = Guid.NewGuid();
            async_operation = AsyncOperationManager.CreateOperation(task_id);
            Action calc = () =>
            {
                Exception error = null;
                try
                {
                    CalculatePrimeNumbers();
                }
                catch (Exception ex)
                {
                    error = ex;
                }
                bool cancelled = IsTaskCanceled;
                bool lock_taken = false;
                spin_lock_task_id.Enter(ref lock_taken);
                task_id = Guid.Empty;
                spin_lock_task_id.Exit(false);
                async_operation.PostOperationCompleted((arg) =>
                {
                    if (CalculateCompleted != null)
                    {
                        CalculateCompleted(this, arg as AsyncCompletedEventArgs);
                    }
                }, new AsyncCompletedEventArgs(error, cancelled, async_operation.UserSuppliedState));
            };
            this.AsyncResult = calc.BeginInvoke(null, null);
        }

		public MessageMarkService([NotNull] IServiceProvider provider)
		{
			if (provider == null)
				throw new ArgumentNullException(nameof(provider));

			_provider = provider;
			_uiAsyncOperation = _provider.GetRequiredService<IUIShell>().CreateUIAsyncOperation();
		}

 public void Run2()
 {
     somethingHappened += SynchronizationDemo_somethingHappened;
     operation = AsyncOperationManager.CreateOperation(null);
     Thread workerThread = new Thread(new ThreadStart(DoWork));
     workerThread.Start();
     Thread.Sleep(2000);
     Output("Call end");
 }

        private void loading(object obj, AsyncOperation asyncOperation)
        {
            string[] flist = (string[])obj;

            //loading
            string res = "ok";

            asyncOperation.PostOperationCompleted(new SendOrPostCallback(OnComplete), res);
        }

		public UIShell(Func<IWin32Window> parentWindowGetter, [NotNull] Action<bool> uiFreezer)
		{
			if (parentWindowGetter == null)
				throw new ArgumentNullException(nameof(parentWindowGetter));
			if (uiFreezer == null) throw new ArgumentNullException(nameof(uiFreezer));
			_parentWindowGetter = parentWindowGetter;
			_uiFreezer = uiFreezer;
			_ctorAsyncOperation = AsyncHelper.CreateOperation();
		}

        public GemixCompiler()
        {
            _Thread = new Thread(new ParameterizedThreadStart(gemix_compiler));
            _Thread.Priority = ThreadPriority.Normal;
            _Thread.IsBackground = true;

            _OutputCallBack = new SendOrPostCallback(OutputCallBack);

            _AsyncOperation = AsyncOperationManager.CreateOperation(null);
        }

 /// <summary>
 /// 初始化CommentInput类的新实例。
 /// </summary>
 protected CommentInput()
 {
     operation = AsyncOperationManager.CreateOperation(Guid.NewGuid());
     onComment = new SendOrPostCallback(o =>
         {
             if (Comment != null)
                 Comment(this, new CommentEventArgs((string)o));
         }
     );
 }

        internal Navigator([NotNull] IServiceProvider serviceProvider)
        {
            if (serviceProvider == null)
                throw new ArgumentNullException("serviceProvider");

            _serviceProvider = serviceProvider;

            _uiAsyncOperation = _serviceProvider.GetRequiredService<IUIShell>().CreateUIAsyncOperation();
            _form = new NavigationDummyForm(_serviceProvider);
            _serviceProvider.GetRequiredService<DockManager>().RegisterPersistablePane(_form);
        }

        private void CompletionMethod(string output, Exception ex, bool cancelled, AsyncOperation asyncOp)
        {
            lock (userStateDictionary)
            {
                userStateDictionary.Remove(asyncOp.UserSuppliedState);
            }

            // results of the operation
            asyncOp.PostOperationCompleted(onCompletedDelegate,
                new LongTaskCompletedEventArgs(output, ex, cancelled, asyncOp.UserSuppliedState));
        }

 public AsyncGuessState(
     string phrase,
     NetworkSetting networkSetting,
     AsyncOperation asyncOperation,
     EventHandler<GuessCompletedEventArgs> guessCompletedHandler)
 {
     this.asyncOperation = asyncOperation;
     this.phrase = phrase;
     this.networkSetting = networkSetting;
     GuessCompleted += guessCompletedHandler;
 }

 public SyncGroupHelper(string groupName, object userState, AsyncOperation asyncOp, SendOrPostCallback progressReporterDelegate)
 {
     if (groupName == null)
     {
         throw new ArgumentNullException("groupName");
     }
     this.groupName = groupName;
     this.userState = userState;
     this.asyncOperation = asyncOp;
     this.progressReporter = progressReporterDelegate;
 }

		public void TestInit()
		{
			ManualResetEvent waitHandle = new ManualResetEvent(false);
			ThreadPool.QueueUserWorkItem(o =>
			{
				operation = AsyncOperationManager.CreateOperation(null);
				InputProviderManager = new InputProviderManager_Accessor(new Provider());
				waitHandle.Set();
				Application.Run();
			});
			waitHandle.WaitOne();
		}

 private void DispatchCompleting(MessageData responsemsg, Exception ex, bool canceled, AsyncOperation asyncOper)
 {
     if (!canceled)
     {
         lock (_userStateToLifetime.SyncRoot)
         {
             _userStateToLifetime.Remove(asyncOper.UserSuppliedState);
         }
     }
     TransmitCompletedEventArgs eventArgs = new TransmitCompletedEventArgs(responsemsg, ex, canceled, asyncOper.UserSuppliedState);
     asyncOper.PostOperationCompleted(onCompletedDelegate, eventArgs);
 }

 protected override Bitmap Process(Bitmap bitmap, AsyncOperation asyncOp)
 {
     Bitmap newBitmap = new Bitmap(bitmap);
     Graphics g = Graphics.FromImage(newBitmap);
     g.SmoothingMode = SmoothingMode.HighQuality;
     g.TextRenderingHint = TextRenderingHint.AntiAliasGridFit;
     SizeF textSize = g.MeasureString(ImageAddTextPluginContext.Text, ImageAddTextPluginContext.Font);
     PointF p = new Point();
     switch (ImageAddTextPluginContext.Position)
     {
         case ContentAlignment.TopLeft:
             p.X = 0.0f;
             p.Y = 0.0f;
             break;
         case ContentAlignment.TopCenter:
             p.X = (newBitmap.Width - textSize.Width) / 2;
             p.Y = 0.0f;
             break;
         case ContentAlignment.TopRight:
             p.X = newBitmap.Width - textSize.Width;
             p.Y = 0.0f;
             break;
         case ContentAlignment.MiddleLeft:
             p.X = 0.0f;
             p.Y = (newBitmap.Height - textSize.Height) / 2;
             break;
         case ContentAlignment.MiddleCenter:
             p.X = (newBitmap.Width - textSize.Width) / 2;
             p.Y = (newBitmap.Height - textSize.Height) / 2;
             break;
         case ContentAlignment.MiddleRight:
             p.X = newBitmap.Width - textSize.Width;
             p.Y = (newBitmap.Height - textSize.Height) / 2;
             break;
         case ContentAlignment.BottomLeft:
             p.X = 0.0f;
             p.Y = newBitmap.Height - textSize.Height;
             break;
         case ContentAlignment.BottomCenter:
             p.X = (newBitmap.Width - textSize.Width) / 2;
             p.Y = newBitmap.Height - textSize.Height;
             break;
         case ContentAlignment.BottomRight:
             p.X = newBitmap.Width - textSize.Width;
             p.Y = newBitmap.Height - textSize.Height;
             break;
     }
     p.X += ImageAddTextPluginContext.XOffset;
     p.Y += ImageAddTextPluginContext.YOffset;
     g.DrawString(ImageAddTextPluginContext.Text, ImageAddTextPluginContext.Font, new SolidBrush(ImageAddTextPluginContext.Color), p);
     g.Dispose();
     return newBitmap;
 }