WPF

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...

fjparisIII wrote:

So the real question is, why doesn't BitmapEncoder.Save() have the actual image data to work with?

Mark Salsbery
Microsoft MVP - Visual C++

fjparisIII wrote:

the next step of passing some source code to you via email and giving you my running application (which you'll be able to get from the Office Live site)

Mark Salsbery
Microsoft MVP - Visual C++

fjparisIII wrote:

I just hope you don't run out of patience with me

fjparisIII wrote:

how to do basic things like extending the namespace of XAML

xmlns:local="clr-namespace:WPFTester"

    <code>// Note you can use BackgroundWorker or WPFSTABackgroundWorker - they both work the same</code>

    WPFSTABackgroundWorker bw = new WPFSTABackgroundWorker();
    bw.WorkerReportsProgress = true;
    bw.DoWork += new DoWorkEventHandler(bw_DoWork);
    bw.ProgressChanged += new ProgressChangedEventHandler(bw_ProgressChanged);
    bw.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bw_RunWorkerCompleted);
    bw.RunWorkerAsync();

...

        private void bw_DoWork(object sender, DoWorkEventArgs e)
        {
            <code>// Called on background thread - CANNOT access UI objects directly here!</code>

            WPFSTABackgroundWorker bw = sender as WPFSTABackgroundWorker;

            for (int i = 0; i < 10; i++)
            {
                bw.ReportProgress(i * 10);
                Thread.Sleep(500);
            }
        }

        void bw_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            <code>// Called on UI thread - CAN access UI objects directly here!</code>

            progrssBar.Value = e.ProgressPercentage;
        }

        void bw_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            <code>// Called on UI thread - CAN access UI objects directly here!</code>

            MyScaleButton.Content = "Thread completed!";
        }

Mark Salsbery
Microsoft MVP - Visual C++