WPF中的多线程使用C＃（与后台工作者）

Question

I have written code to save an image which is generated by the application. The size of the image is around 32-35 MB. While saving the image to a BMB file, it is taking a long time, around 3-5 secs. For this purpose, I have used a background worker but when running the background worker, it shows an error like..."can't access the object as it is created on different thread".

Following is the code:

 private void btnSaveDesign_Click(object sender, RoutedEventArgs e)
    {
        Microsoft.Win32.SaveFileDialog sfd = new Microsoft.Win32.SaveFileDialog();
        sfd.Title = "Save design as...";
        sfd.Filter = "BMP|*.bmp";
        if (sfd.ShowDialog() == true)
        {
            ww = new winWait();
            ww.Show();
            System.ComponentModel.BackgroundWorker bw = new System.ComponentModel.BackgroundWorker();
            bw.DoWork += new System.ComponentModel.DoWorkEventHandler(bw_DoWork);
            bw.RunWorkerCompleted += new System.ComponentModel.RunWorkerCompletedEventHandler(bw_RunWorkerCompleted);
            fName = sfd.FileName;
            cache = new CachedBitmap((BitmapSource)imgOut.Source, BitmapCreateOptions.None, BitmapCacheOption.OnLoad);

            bw.RunWorkerAsync();


        }  
    }

    void bw_RunWorkerCompleted(object sender, System.ComponentModel.RunWorkerCompletedEventArgs e)
    {
        ww.Close();
    }

    void bw_DoWork(object sender, System.ComponentModel.DoWorkEventArgs e)
    {
        BmpBitmapEncoder encoder = new BmpBitmapEncoder();
        encoder.Frames.Add(BitmapFrame.Create(cache)); //here... it says cant access...
        using (FileStream file = File.OpenWrite(fName))
        {
            encoder.Save(file);
        }
    }

I have declared "cache" as a global object. (A similar trick worked when I was programming in Windows Forms with VB.NET.)

ww is the wait window that I want to be displayed while the precess is being executed.

How to do this? Is there any other simple method for multi threading in WPF?

Answer 1

When WPF objects are created they are assigned to a Dispatcher object. This disallows any threads other than the creating thread to access the object. This can be circumvented by freezing the object by calling the freeze method. You would need to call Freeze on your bitmapsource object. Once you have frozen your object it becomes uneditable

Answer 2

Your problem comes about because you are accessing an object which is not created by the background worker thread. Normally this would happen if you access a UI control which is created in the main thread and accessed from different thread.

Use the code below.

Dispatcher.Invoke
(
    new Action(
        delegate()
        {
            BmpBitmapEncoder encoder = new BmpBitmapEncoder();
            encoder.Frames.Add(BitmapFrame.Create(cache));
            using (FileStream file = File.OpenWrite(fName))
            {
                encoder.Save(file);
            }
        }
    )
);

Answer 3

.NET framework provides a simple way to get started in threading with the BackgroundWorker component. This wraps much of the complexity and makes spawning a background thread relatively safe. In addition, it allows you to communicate between your background thread and your UI thread without doing any special coding. You can use this component with WinForms and WPF applications. The BackgroundWorker offers several features which include spawning a background thread, the ability to cancel the background process before it has completed, and the chance to report the progress back to your UI.

public BackgroudWorker()
            {
                InitializeComponent();
                backgroundWorker = ((BackgroundWorker)this.FindResource("backgroundWorker"));
            }

            private int DoSlowProcess(int iterations, BackgroundWorker worker, DoWorkEventArgs e)
            {            
                int result = 0;
                for (int i = 0; i <= iterations; i++)
                {
                    if (worker != null)
                    {
                        if (worker.CancellationPending)
                        {
                            e.Cancel = true;
                            return result;
                        }
                        if (worker.WorkerReportsProgress)
                        {
                            int percentComplete =
                            (int)((float)i / (float)iterations * 100);
                            worker.ReportProgress(percentComplete);
                        }
                    }
                    Thread.Sleep(100);
                    result = i;
                }
                return result;
            }

            private void startButton_Click(object sender, RoutedEventArgs e)
            {
                int iterations = 0;
                if (int.TryParse(inputBox.Text, out iterations))
                {
                    backgroundWorker.RunWorkerAsync(iterations);
                    startButton.IsEnabled = false;
                    cancelButton.IsEnabled = true;
                    outputBox.Text = "";
                }

            }

            private void cancelButton_Click(object sender, RoutedEventArgs e)
            {
                // TODO: Implement Cancel process
                this.backgroundWorker.CancelAsync();
            }

            private void BackgroundWorker_DoWork(object sender, DoWorkEventArgs e)
            {
               // e.Result = DoSlowProcess((int)e.Argument);

                var bgw = sender as BackgroundWorker;
                e.Result = DoSlowProcess((int)e.Argument, bgw, e);
            }

            private void BackgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
            {
                workerProgress.Value = e.ProgressPercentage;
            }

            private void BackgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
            {
                if (e.Error != null)
                {
                    MessageBox.Show(e.Error.Message);
                }
                else if (e.Cancelled)  
                {
                    outputBox.Text = "Canceled";
                    workerProgress.Value = 0;
                }
                else
                {
                    outputBox.Text = e.Result.ToString();
                    workerProgress.Value = 0; 
                }
                startButton.IsEnabled = true;
                cancelButton.IsEnabled = false;
            }

Answer 4

I think you have to pass cache as a parameter to the new thread:

bw.RunWorkerAsync(cache);

and get it from the DoWork method:

var cache=(CacheType) e.Argument;