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;
 }

        protected void StartLongOperation(List<string> strings) {

            waitLongOperationCompleted = AsyncOperationManager.CreateOperation(null);
            var longOperation = new DevExpress.ExpressApp.Demos.LongOperation(DoWork) { CancellingTimeoutMilliSeconds = 2000 };
            longOperation.CancellingTimeoutExpired += LongOperation_CancellingTimeoutExpired;
            longOperation.Completed += LongOperation_Completed;

            ChangedProps = strings;
            progressControl = CreateProgressControl();
            progressControl.ShowProgress(longOperation);
            longOperation.StartAsync();
            OnOperationStarted();
        }

        private void IndexerThread(AsyncOperation operation, bool isCreateNewDbFile)
        {
            for (int i = 0; i < 100000; i++)
            {

            }

            SendOrPostCallback callUpdate = delegate(object o)
                                                {
                                                    _view.CloseView();
                                                };
            operation.Post(callUpdate, null); ;
        }

 public void SortAsync(int[] data)
 {
     if (IsTaskCanceled)
     {
         task_id = Guid.NewGuid();
         sort_async_operation = AsyncOperationManager.CreateOperation(task_id);
         sort_delegate.BeginInvoke(data, null, null);
     }
     else
     {
         throw new InvalidOperationException();
     }
 }

        private void InvokeOperationCompeted(AsyncOperation asyncOp, SendOrPostCallback callback, UploadFileCompletedEventArgs eventArgs)
        {
            if (this.m_IsExpired)
                eventArgs = new UploadFileCompletedEventArgs("", new Exception(Properties.Settings.Default.UploadExpired), false, this.m_AsyncOperation.UserSuppliedState);

            if (Interlocked.CompareExchange<AsyncOperation>(ref this.m_AsyncOperation, null, asyncOp) == asyncOp)
            {
                var _originalWebResponse = Interlocked.Exchange<WebResponse>(ref this.m_WebResponse, null);
                closeResponse(_originalWebResponse);
                this.completeUploadClientState();
                asyncOp.PostOperationCompleted(callback, eventArgs);
            }
        }

 protected override Bitmap Process(Bitmap bitmap, AsyncOperation asyncOp)
 {
     Bitmap newBitmap = new Bitmap(bitmap.Width, bitmap.Height);
     Graphics graphics = Graphics.FromImage(newBitmap);
     for (int y = 0; y < bitmap.Height; y += Size)
     {
         for (int x = 0; x < bitmap.Width; x += Size)
         {
             int a = 0, r = 0, g = 0, b = 0;
             int yb = y + Size;
             int xb = x + Size;
             for (int yt = y; yt < yb && yt < bitmap.Height; yt++)
             {
                 for (int xt = x; xt < xb && xt < bitmap.Width; xt++)
                 {
                     Color color = bitmap.GetPixel(xt, yt);
                     a += color.A;
                     r += color.R;
                     g += color.G;
                     b += color.B;
                 }
             }
             int wt, ht;
             if (x + Size > bitmap.Width)
             {
                 wt = bitmap.Width - x;
             }
             else
             {
                 wt = Size;
             }
             if (y + Size > bitmap.Height)
             {
                 ht = bitmap.Height - y;
             }
             else
             {
                 ht = Size;
             }
             double nt = wt * ht;
             Color newColor = Color.FromArgb((int)Math.Round(a / nt), (int)Math.Round(r / nt), (int)Math.Round(g / nt), (int)Math.Round(b / nt));
             graphics.FillRectangle(new SolidBrush(newColor), x, y, wt, ht);
         }
         if (y + Size < bitmap.Height)
         {
             this.DoProcessAsyncProgressChanged(asyncOp, new ProgressChangedEventArgs((int)Math.Round(100.0 * (y + Size) / bitmap.Height), asyncOp.UserSuppliedState));
         }
     }
     graphics.Dispose();
     return newBitmap;
 }