WPF

fjparisIII wrote:

I'm using the the BackgroundWorker class to run my worker thread. In looking through MSDN, I don't see any way of getting the thread object of the background worker before it starts

fjparisIII wrote:

I would actually be shocked with disbelief if the BackgroundWorker thread doesn't automatically run with ApartmentState.STA

Mark Salsbery
Microsoft MVP - Visual C++

Mark Salsbery wrote:

I am sure curious if there is a threading problem with the encoder classes -
possibly COM related if those links are to be believed...

Mark Salsbery wrote:

fjparisIII wrote:
I would actually be shocked with disbelief if the BackgroundWorker thread doesn't automatically run with ApartmentState.STA


I'm not sure about that....I'll look it up after lunch...

fjparisIII wrote:

Do you know why this would prevent things like BitmapEncoder.Save() from executing correctly in an MTA thread?

Mark Salsbery
Microsoft MVP - Visual C++

Mark Salsbery wrote:

And your kludge sounds horrific - I would dump that

fjparisIII wrote:

massive re-invention of the wheel

Mark Salsbery
Microsoft MVP - Visual C++

fjparisIII wrote:

In the meantime I'm struggling with the prospect of writing a replacement class for BackgroundWorker, struggling because I've never written any threading code under .NET.

public class MyWPFBackgroundWorker
{
    private delegate void InvokerDelegate();

    public event DoWorkEventHandler DoWork;
    public event ProgressChangedEventHandler ProgressChanged;
    public event RunWorkerCompletedEventHandler RunWorkerCompleted;

    public void RunWorkerAsync()
    {
        RunWorkerAsync(null);
    }

    public void RunWorkerAsync(Object argument)
    {
        threadargument = argument;
        thread = new Thread(ThreadProc);
        thread.SetApartmentState(ApartmentState.STA);
        thread.Priority = ThreadPriority.Normal;
        thread.Start(this);
    }

    public void ReportProgress(int percentProgress)
    {
        ReportProgress(percentProgress, null);
    }

    public void ReportProgress(int percentProgress, Object userState)
    {
        ProgressChangedEventHandler progresshandler = ProgressChanged;
        if (progresshandler != null)
        {
            Application.Current.Dispatcher.BeginInvoke(System.Windows.Threading.DispatcherPriority.Normal, (InvokerDelegate)delegate
            {
                progresshandler(this, new ProgressChangedEventArgs(percentProgress, userState));
            });
        }
    }


    Thread thread;
    Object threadargument;

    static void ThreadProc(object context)
    {
        MyWPFBackgroundWorker worker = context as MyWPFBackgroundWorker;

        DoWorkEventHandler workhandler = worker.DoWork;
        if (workhandler != null)
        {
            workhandler(worker, new DoWorkEventArgs(worker.threadargument));
        }

        RunWorkerCompletedEventHandler completedhandler = worker.RunWorkerCompleted;
        if (completedhandler != null)
        {
            Application.Current.Dispatcher.BeginInvoke(System.Windows.Threading.DispatcherPriority.Normal, (InvokerDelegate)delegate
            {
                completedhandler(worker, new RunWorkerCompletedEventArgs(null, null, false));
            });
        }
    }
}

Mark Salsbery
Microsoft MVP - Visual C++

fjparisIII wrote:

BackgroundWorker has 17 methods, 9 properties, and 4 events.

Mark Salsbery
Microsoft MVP - Visual C++

fjparisIII wrote:

there's probably just some feature you're using that I'm not aware of.

Mark Salsbery
Microsoft MVP - Visual C++

fjparisIII wrote:

If you've got some canned code I can just pick up and shove into my app

Mark Salsbery
Microsoft MVP - Visual C++

//<code>*edit* added synchronization to CancellationPending (maybe overkill)</code>

public class WPFSTABackgroundWorker
{
    private delegate void InvokerDelegate();

    public event DoWorkEventHandler DoWork;
    public event ProgressChangedEventHandler ProgressChanged;
    public event RunWorkerCompletedEventHandler RunWorkerCompleted;

    public bool WorkerReportsProgress { get; set; }
    public bool IsBusy { get; protected set; }
    public bool WorkerSupportsCancellation { get; set; }
    private bool _cancellationPending;
    public bool CancellationPending
    {
        get
        {
            bool ret;
            lock (cancellock)
            {
                ret = _cancellationPending;
            }
            return ret;
        }
        protected set
        {
            lock (cancellock)
            {
                _cancellationPending = value;
            }
        }
    }


    public WPFSTABackgroundWorker()
    {
        IsBusy = false;
        WorkerReportsProgress = false;
        WorkerSupportsCancellation = false;
        CancellationPending = false;
    }

    public void RunWorkerAsync()
    {
        RunWorkerAsync(null);
    }

    public void RunWorkerAsync(Object argument)
    {
        IsBusy = true;
        threadargument = argument;
        thread = new Thread(ThreadProc);
        thread.SetApartmentState(ApartmentState.STA);
        thread.Priority = ThreadPriority.Normal;
        thread.Start(this);
    }

    public void CancelAsync()
    {
        if (!WorkerSupportsCancellation)
            throw new InvalidOperationException("Attempted to CancelAsync when WorkerSupportsCancellation is false.");

        CancellationPending = true;
    }

    public void ReportProgress(int percentProgress)
    {
        ReportProgress(percentProgress, null);
    }

    public void ReportProgress(int percentProgress, Object userState)
    {
        if (!WorkerReportsProgress)
            throw new InvalidOperationException("Attempted to ReportProgress when WorkerReportsProgress is false.");

        ProgressChangedEventHandler progresshandler = ProgressChanged;
        if (progresshandler != null)
        {
            Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Normal, (InvokerDelegate)delegate
            {
                progresshandler(this, new ProgressChangedEventArgs(percentProgress, userState));
            });
        }
    }


    Thread thread;
    Object threadargument;

    static void ThreadProc(object context)
    {
        WPFSTABackgroundWorker worker = context as WPFSTABackgroundWorker;

        DoWorkEventHandler workhandler = worker.DoWork;
        if (workhandler != null)
        {
            workhandler(worker, new DoWorkEventArgs(worker.threadargument));
        }

        RunWorkerCompletedEventHandler completedhandler = worker.RunWorkerCompleted;
        if (completedhandler != null)
        {
            Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Normal, (InvokerDelegate)delegate
            {
                completedhandler(worker, new RunWorkerCompletedEventArgs(null, null, worker.CancellationPending));
            });
        }

        worker.IsBusy = false;
    }
}

Mark Salsbery
Microsoft MVP - Visual C++

fjparisIII wrote:

when I copy and paste your code into mine, it all comes out in one line. Do you know how I can get a copy of your code that is properly formatted?

Mark Salsbery
Microsoft MVP - Visual C++

fjparisIII wrote:

I think this conclusively proves that whether BackgroundWorker runs as STA or MTA has nothing to do with my problem

Mark Salsbery
Microsoft MVP - Visual C++

Mark Salsbery wrote:

your very first post had this:
"The code that I have developed based on the above thread works 100%
of the time if it is executed inside of the WPF main application thread.
But it fails 100% of the time if it is executed inside of a worker thread.
The code fails on BitmapEncoder.Save(), throwing a "Cannot write to the
stream" exception. But I have to execute this code inside of a worker
thread because I have to display a progress bar: I'm updating the Copyright
metadata in a batch operation for thousands of images!"

That's what I was addressing...