How do I pass a WPF object that was created in thread X, to thread Y?

Question

I create a SolidColorBrush on some non-GUI thread, and want to pass it to a GUI thread to display it, but I get InvalidOperationException: The calling thread cannot access this object because a different thread owns it. (even if I try to Freeze(); it). How do I pass object that was created in thread X to thread Y ?

I know I can create this SolidColorBrush object in the GUI thread with Dispatcher, but that would complicate everything... I want to create it in the worker thread.

---

Additional details:

I initialize some static delegate in some static class, to allow sending messages from business layer to GUI:

public static class Gui{
    private static PrintMethodDelegate _printMethod;
    public static void InitializeGuiInterface(PrintMethodDelegate printMethod){
        _printMethod = printMethod;
    }
    public static void Print(GuiMessage data) { _printMethod(data); }
}

Initialization (in the GUI thread):

Gui.InitializeGuiInterface(_messagesToUserHandler.PrintMessage);

Then in another (non-gui) thread, I use it:

Gui.Print(new GuiMessage(testDescription) { Foreground = new SolidColorBrush(someColor) });

while GuiMessage is:

public class GuiMessage {
    public string Msg { get; set; }

    private SolidColorBrush _foregroundBrush;
    public SolidColorBrush Foreground
    {
        get { return _foregroundBrush; }
        set { _foregroundBrush = value; }
    }
}

Answer 1

You can create wpf resources in another thread if you freeze them, after that the element can be passed to yet another thread or the gui thread. Remember that a once frozen object can only be modified by making a copy and using that copy. You can't freeze objects that have Bindings or animations attached to it.

Answer 2

You need to use a Delegate to safe invoke the control.

Use

Control.Invoke

or

Control.BeginInvoke

for this purpose.

private delegate void SetControlPropertyThreadSafeDelegate(Control control, string propertyName, object propertyValue);

public static void SetControlPropertyThreadSafe(Control control, string propertyName, object propertyValue)
{
  if (control.InvokeRequired)
  {
    control.Invoke(new SetControlPropertyThreadSafeDelegate(SetControlPropertyThreadSafe), new object[] { control, propertyName, propertyValue });
  }
  else
  {
    control.GetType().InvokeMember(propertyName, BindingFlags.SetProperty, null, control, new object[] { propertyValue });
  }
}

If you do not use the delegate to safe-invoke them, You will get the exception.

Check these links:

How to update the GUI from another thread in C#?enter link description here

enter link description here

Answer 3

You should use the Dispatcher.

You can create a class that will hold a dispatcher created on a the main thread and inject it via your container to whatever class executed on a background thread that needs to interact with your main thread.

public interface IUiDispatcher
{
    Dispatcher Dispatcher { get; }
}

public class UiDispatcher : IUiDispatcher
{
    public UiDispatcher()
    {
        if (Thread.CurrentThread.GetApartmentState() == ApartmentState.STA
            && !Thread.CurrentThread.IsBackground
            && !Thread.CurrentThread.IsThreadPoolThread)
        {
            this.Dispatcher = Dispatcher.CurrentDispatcher;
        }
        else
        {
            throw new InvalidOperationException("Ui Dispatcher must be created in UI thread");
        }
    }

    public Dispatcher Dispatcher { get; set; }
}

public class ExecutedOnABackgroundThread
{
    IUiDispatcher uidispatcher;

    public ExecutedOnABackgroundThread(IUiDispatcher uidispatcher)
    {
        this.uidispatcher = uidispatcher;
    }

    public void Method()
    {
        // Do something on the background thread...
        // ...

        // Now we need to do something on the UI
        this.uidispatcher.Dispatcher.BeginInvoke(new Action(delegate
        {
            // Do something
        }), null);
    }
}

Create the instance of UiDispatcher at a point your are sure your are on the UI thread, for example during the initialization of your application. Using your dependency injection container, ensure that only one instance of this class will be created and injected to any other class that requires it and use it to create/manipulate your UI components.

I picked the code to check if the constructor of UiDispatcher is executed in the main thread from this answer.

The thing is that you can't use on the UI thread something created on a different thread. So you need your background thread to delegate to the main UI thread whatever involves UI stuffs.