public static BackgroundWorker WithHandlers(this BackgroundWorker bw, DoWorkDelegate doWorkDelegate, ProgressChangedDelegate progressChangedDelegate, RunWorkerCompletedDelegate runWorkerCompletedDelegate)
 {
     bw.DoWork += new DoWorkEventHandler((sender, dwe) => { doWorkDelegate(dwe); });
     bw.ProgressChanged += new ProgressChangedEventHandler((sender, pce) => { progressChangedDelegate(pce); });
     bw.RunWorkerCompleted += new RunWorkerCompletedEventHandler((sender, rwce) => { runWorkerCompletedDelegate(rwce); });
     return bw;
 }
        private void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            // Do not access the form's BackgroundWorker reference directly.
            // Instead, use the reference provided by the sender parameter.
            BackgroundWorker bw = (BackgroundWorker)sender;

            try
            {
                if (!doWorkAdded)
                {
                    doWorkDelegate += backgroundWork.DoBackgroundWork;
                    doWorkAdded     = true;
                }
                doWorkDelegate();
            }
            catch (WorkerCanceledException)
            {
                // This exception is throw only to stop the execution of the method delegated to doWorkDelegate
            }
            finally
            {
                // If the operation was canceled by the user,
                // set the DoWorkEventArgs.Cancel property to true.
                if (bw.CancellationPending)
                {
                    e.Cancel = true;
                }
            }
        }
Exemple #3
0
        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();
        }
Exemple #4
0
        private void SendFileRun(String filePath)
        {
            DisableStartButtons();
            DoWorkDelegate worker = new DoWorkDelegate(SendFile);

            worker.BeginInvoke(filePath, new AsyncCallback(DoWorkComplete), worker);
        }
Exemple #5
0
        private void DoWorkComplete(IAsyncResult workID)
        {
            EnableStartButtons();
            DoWorkDelegate worker = workID.AsyncState as DoWorkDelegate;

            worker.EndInvoke(workID);
        }
        /// <summary>
        /// Выполняет операцию в фоновом потоке, не блокируя UI элементы формы. Может быть вызван сколько угодно раз подряд
        /// </summary>
        /// <param name="args">Начальные аргументы для потока</param>
        /// <param name="action">Метод, выполняемый в фоновом потоке</param>
        /// <param name="progress">Метод, выполняемый в фоновом потоке, позволяющий откликаться в основной поток</param>
        /// <param name="completed">Метод, выполняемый после окончания фонового потока</param>
        /// <param name="cancellationToken">Токен для воркеров с возможностью остановки</param>
        public static void RunAsync(object args, DoWorkDelegate action, ProgressDelegate progress, CompletedDelegate completed, CancellationTokenSource cancellationToken = null)
        {
            Worker w = new Worker(args, action, completed, progress, progress != null, cancellationToken);

            w.Complited += new EventHandler(w_Complited);
            Count++;
        }
        private void ActButton_Click(object sender, RoutedEventArgs e)
        {
            DoWorkDelegate d = new DoWorkDelegate(DoSlowWork);

            DoSlowWork();
            Output.Content = "Changed!";
        }
        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);
        }
Exemple #9
0
        //---------------------------------------------------
        public static void DoWork(DoWorkDelegate funcToCall)
        {
            CFormWaiting frm = new CFormWaiting();

            frm.m_funcToCall = funcToCall;
            frm.ShowDialog();
        }
        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();
        }
 public LoadBalancingBroker(LoadBalancingSettings settings, DoWorkDelegate doWork)
 {
     LoadBalancingSettings = settings;
     InitializeWorkerList(doWork);
     LoadBalancingSettings.LoadBalancer = InstantiateLoadBalancer();
     ((AbstractLoadBalancer)LoadBalancingSettings.LoadBalancer).SetWorkers(new LinkedList <IWorker>(this));
 }
Exemple #12
0
        public void Start()
        {
            Console.WriteLine("Started.");
            DoWorkDelegate d = FindThemClones;

            d.BeginInvoke(CodeText, WhenDoneCallback, d);
        }
        /// <summary>
        /// Выполняет операцию в фоновом потоке, не блокируя UI элементы формы. Может быть вызван сколько угодно раз подряд
        /// </summary>
        /// <param name="args">Начальные аргументы для потока</param>
        /// <param name="action">Метод, выполняемый в фоновом потоке</param>
        /// <param name="cancellationToken">Токен для воркеров с возможностью остановки</param>
        public static void RunAsync(object args, DoWorkDelegate action, CancellationTokenSource cancellationToken = null)
        {
            Worker w = new Worker(args, action, null, null, false, cancellationToken);

            w.Complited += new EventHandler(w_Complited);
            Count++;
        }
Exemple #14
0
        private void WhenDoneCallback(IAsyncResult ar)
        {
            DoWorkDelegate d          = (DoWorkDelegate)ar.AsyncState;
            ScanResult     scanResult = d.EndInvoke(ar);

            InvokeJobDone(scanResult);
        }
        private void ActButton_Click(object sender, RoutedEventArgs e)
        {
            DoWorkDelegate d = new DoWorkDelegate(DoSlowWork);

            DoSlowWork();
            Output.Content = "Changed!";
        }
Exemple #16
0
 public CancellableTask(DoWorkDelegate doWork, TaskCompletedDelegate completed)
     : this(new BackgroundWorker())
 {
     this._doWork = doWork;
     this._completed = completed;
     this._worker.DoWork += new DoWorkEventHandler(this._doWork);
     this._worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(this._completed);
 }
        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();
        }
Exemple #18
0
 public LoadBalancingBroker(ILogger logger, string name, DoWorkDelegate doWork, LoadBalancingSettings settings)
 {
     _logger  = logger;
     Name     = name;
     Settings = settings;
     InitializeWorkerList(doWork);
     Settings.LoadBalancer = InstantiateLoadBalancer();
     ((AbstractLoadBalancer)Settings.LoadBalancer).SetWorkers(new LinkedList <IWorker>(this));
 }
Exemple #19
0
 private void InitializeWorkerList(DoWorkDelegate doWork)
 {
     AddRange(
         Enumerable.Range(0, Settings.NumberOfWorkers).Select(index =>
                                                              new Worker <TEntity>(index, Settings.BoundedCapacityByWorker, Settings.CancellationToken)
     {
         DoWork = doWork
     }).ToList());
 }
        public void TestDelegateInvoke()
        {
            Debug.WriteLine($"Hello from TestDelegateCall() (Thread ID: {Thread.CurrentThread.ManagedThreadId})");

            // Create the delegate.
            var caller = new DoWorkDelegate(DoSimpleWork);

            // Call the delegated method on the same thread.
            caller();
        }
 private void InitializeWorkerList(DoWorkDelegate doWork)
 {
     for (var index = 0; index < LoadBalancingSettings.NumberOfWorkers; index++)
     {
         var worker = new Worker <TEntity>(index, 100, LoadBalancingSettings.CancellationToken)
         {
             DoWork = doWork
         };
         Add(worker);
     }
 }
Exemple #22
0
        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();
        }
Exemple #23
0
 private void AppendSuccess(string msg)
 {
     if (this.InvokeRequired)
     {
         DoWorkDelegate dg = new DoWorkDelegate(AppendSuccess);
         this.Invoke(dg, new object[] { msg });
     }
     else
     {
         vsubdwnldr.Items.Insert(0, msg);
     }
 }
Exemple #24
0
        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();
        }
Exemple #25
0
 /// <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.
        }
Exemple #27
0
 private void Labelchange(int cnt, string Filename)
 {
     if (this.InvokeRequired)
     {
         DoWorkDelegate dg = new DoWorkDelegate(Labelchange);
         this.Invoke(dg, new object[] { cnt, Filename });
     }
     else
     {
         label4.Text = cnt + " Bhavcopy Downloaded";
         rCT1.Text  += Filename + " Fetched \n\n";
     }
 }
Exemple #28
0
        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);
        }
Exemple #29
0
 public Guid?Chat(string sender, string reciever)
 //Adds a chat session to reciever
 {
     try
     {
         DoWorkDelegate del = SendMessagesListToClient;
         return(OpenSession(sender, reciever, del));
     }
     catch (Exception e)
     {
         Report($"Could not open a chat with {reciever}", LogLevel.Exception);
         Report(e.Message, LogLevel.Exception);
         return(null);
     }
 }
Exemple #30
0
 public Guid?RequestNewGame(string sender, string reciever)
 {
     try
     {
         DoWorkDelegate del = SendGameToClient;
         Report($"Game request sent to {reciever}", LogLevel.Information);
         return(OpenSession(sender, reciever, del));
     }
     catch (Exception e)
     {
         Report($"Could not open a game with {reciever}", LogLevel.Exception);
         Report(e.Message, LogLevel.Exception);
         return(null);
     }
 }
        // What is a delegate
        // ==================
        // A delegate is a type that represents references to methods with a particular parameter list and return type.


        public void Main()
        {
            //Assigning an existing function
            DoWorkDelegate doWorkDelegate = DoWork;



            //Assigning to an anonymous method (C# 2.0)
            DoWorkDelegate anonymousFunctionDelegate = delegate()
            {
                Console.WriteLine("Work done from anonymous function !");
            };



            //Assigning to an anonymous method (C# 3.0)
            DoWorkDelegate lambdaDelegate = () => Console.WriteLine("Work done from lambda expression !");



            //Invoking a delegate's method
            doWorkDelegate.Invoke();
            anonymousFunctionDelegate.Invoke();
            lambdaDelegate.Invoke();



            //Method chaining
            Console.WriteLine();
            Console.WriteLine("Method chaining");
            Console.WriteLine("==================");
            doWorkDelegate += DoOtherWork;
            doWorkDelegate.Invoke();



            //Using a delegate with params and a return type

            Console.WriteLine();
            Console.WriteLine("Delegate with params and a return type");
            Console.WriteLine("==================");

            DoWorkAndReturnStuffDelegate delegateWithParamsAndReturnType = DoWorkAndReturnStuff;

            string result = delegateWithParamsAndReturnType.Invoke("Test input");

            Console.WriteLine($"Delegate invocation result: {result}");
        }
        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 Worker(object args, DoWorkDelegate action, CompletedDelegate completedAction, ProgressDelegate progressAction, bool canReport, CancellationTokenSource cancellationToken)
        {
            this.bWork = new BackgroundWorker();
            this.bWork.WorkerReportsProgress = canReport;
            this.Action               = action;
            this.CompletedAction      = completedAction;
            this.ProgressAction       = progressAction;
            bWork.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bWork_RunWorkerCompleted);
            bWork.DoWork             += new DoWorkEventHandler(bWork_DoWork);
            bWork.ProgressChanged    += new ProgressChangedEventHandler(bWork_ProgressChanged);

            if (cancellationToken != null)
            {
                bWork.WorkerSupportsCancellation = true;
            }
            bWork.RunWorkerAsync(args);
        }
Exemple #34
0
        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);
        }
 private void RunBackground(DoWorkDelegate doWork)
 {
     backgroundWorker1.RunWorkerAsync(doWork);
     ShowRunnerStatus();
 }