WPF Background Worker का उपयोग कैसे करें

Question

अपने आवेदन में मुझे इनिशियलाइज़ेशन चरणों की एक श्रृंखला करने की आवश्यकता है, इनको पूरा करने में 7-8 सेकंड लगते हैं, जिसके दौरान मेरा UI अनुत्तरदायी हो जाता है। इसे हल करने के लिए मैं एक अलग सूत्र में इनिशियलाइज़ेशन करता हूँ:

public void Initialization()
{
    Thread initThread = new Thread(new ThreadStart(InitializationThread));
    initThread.Start();
}

public void InitializationThread()
{
    outputMessage("Initializing...");
    //DO INITIALIZATION
    outputMessage("Initialization Complete");
}

मैंने इस बारे में कुछ लेख पढ़े हैं BackgroundWorkerऔर कैसे मुझे अपने आवेदन को बिना किसी थपेड़े के लिखने के लिए कभी-कभार लिखकर रखने की अनुमति देनी चाहिए, लेकिन मुझे इसे लागू करने में कोई सफलता नहीं मिली है, क्या कोई यह बता सकता है कि मैं कैसे करूँगा? यह प्रयोग कर रहा है BackgroundWorker?

Comments

मुझे यह ट्यूटोरियल उपयोगी लगा, इसके कई संक्षिप्त उदाहरण हैं: सुरुचिपूर्णकोड .2009

— 07

मुझे उस लिंक पर क्लिक करते समय गोपनीयता त्रुटि मिलती है।

— LittleBirdy

Answer 1

1. का उपयोग कर जोड़ें

using System.ComponentModel;

2. पृष्ठभूमि कार्यकर्ता घोषित करें :

private readonly BackgroundWorker worker = new BackgroundWorker();

3. घटनाओं की सदस्यता लें:

worker.DoWork += worker_DoWork;
worker.RunWorkerCompleted += worker_RunWorkerCompleted;

4. दो तरीकों को लागू करें:

private void worker_DoWork(object sender, DoWorkEventArgs e)
{
  // run all background tasks here
}

private void worker_RunWorkerCompleted(object sender, 
                                           RunWorkerCompletedEventArgs e)
{
  //update ui once worker complete his work
}

5. जब भी आपकी आवश्यकता के अनुसार वर्कर async चलाएँ।

worker.RunWorkerAsync();

6. ट्रैक प्रगति (वैकल्पिक, लेकिन अक्सर उपयोगी)

   एक) की सदस्यता ProgressChangedघटना और उपयोग ReportProgress(Int32)मेंDoWork

   बी) सेट worker.WorkerReportsProgress = true;(@ ज़ागी को क्रेडिट)

Comments

क्या उन तरीकों में DataContext तक पहुंचने का एक तरीका है?

— सुसीलू_

Answer 2

आप Taskपृष्ठभूमि के श्रमिकों के बजाय उपयोग में भी देखना चाहते हैं।

ऐसा करने का सबसे आसान तरीका आपके उदाहरण में है Task.Run(InitializationThread);।

पृष्ठभूमि के श्रमिकों के बजाय कार्यों का उपयोग करने के कई फायदे हैं। उदाहरण के लिए, Taskथ्रेडिंग के लिए .net 4.5 उपयोग में नए async / प्रतीक्षा सुविधाएँ । Https://docs.microsoft.com/en-us/dotnet/api/system.threading.tasks.task के बारे में कुछ दस्तावेज यहां दिए गए हैंTask

Comments

इस धागे का पता लगाने के लिए क्षमा करें, लेकिन .net 4.0 और 4.5 ने कुछ ऐसे कूल स्टफ जोड़े हैं, जो उपयोग करने के लिए आसान है BackgroundWorker। लोगों को इससे जोड़ने की उम्मीद है।

— ओवेन जॉनसन

अब जब कि यह उत्तर सुपर पुराना है, तो देखें asyncऔर await। ये अधिक एकीकृत तरीके से कार्यों का उपयोग करने के लिए भाषा एकीकृत तरीके हैं।

— ओवेन जॉनसन

Answer 3

using System;  
using System.ComponentModel;   
using System.Threading;    
namespace BackGroundWorkerExample  
{   
    class Program  
    {  
        private static BackgroundWorker backgroundWorker;  

        static void Main(string[] args)  
        {  
            backgroundWorker = new BackgroundWorker  
            {  
                WorkerReportsProgress = true,  
                WorkerSupportsCancellation = true  
            };  

            backgroundWorker.DoWork += backgroundWorker_DoWork;  
            //For the display of operation progress to UI.    
            backgroundWorker.ProgressChanged += backgroundWorker_ProgressChanged;  
            //After the completation of operation.    
            backgroundWorker.RunWorkerCompleted += backgroundWorker_RunWorkerCompleted;  
            backgroundWorker.RunWorkerAsync("Press Enter in the next 5 seconds to Cancel operation:");  

            Console.ReadLine();  

            if (backgroundWorker.IsBusy)  
            { 
                backgroundWorker.CancelAsync();  
                Console.ReadLine();  
            }  
        }  

        static void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)  
        {  
            for (int i = 0; i < 200; i++)  
            {  
                if (backgroundWorker.CancellationPending)  
                {  
                    e.Cancel = true;  
                    return;  
                }  

                backgroundWorker.ReportProgress(i);  
                Thread.Sleep(1000);  
                e.Result = 1000;  
            }  
        }  

        static void backgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)  
        {  
            Console.WriteLine("Completed" + e.ProgressPercentage + "%");  
        }  

        static void backgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)  
        {  

            if (e.Cancelled)  
            {  
                Console.WriteLine("Operation Cancelled");  
            }  
            else if (e.Error != null)  
            {  
                Console.WriteLine("Error in Process :" + e.Error);  
            }  
            else  
            {  
                Console.WriteLine("Operation Completed :" + e.Result);  
            }  
        }  
    }  
} 

इसके अलावा, नीचे दिए गए लिंक का संदर्भ लें, आप इन अवधारणाओं को समझेंगे Background:

http://www.c-sharpcorner.com/UploadFile/1c8574/threads-in-wpf/

Answer 4

मैंने इसे पाया ( WPF मल्टीथ्रेडिंग: बैकग्राउंडवॉकर का उपयोग करना और यूआई को प्रगति की रिपोर्ट करना। लिंक ) बाकी विवरणों को समाहित करने के लिए जो @ एंड्रयू के उत्तर से गायब हैं।

एक चीज जो मुझे बहुत उपयोगी लगी, वह यह थी कि वर्कर थ्रेड मेनविंडो के नियंत्रण (अपनी स्वयं की विधि में) तक पहुंच नहीं सकता था, हालांकि जब मुख्य विंडोज़ इवेंट हैंडलर के अंदर एक प्रतिनिधि का उपयोग करना संभव था।

worker.RunWorkerCompleted += delegate(object s, RunWorkerCompletedEventArgs args)
{
    pd.Close();
    // Get a result from the asynchronous worker
    T t = (t)args.Result
    this.ExampleControl.Text = t.BlaBla;
};