Jak przekazać obiekt WPF, który został utworzony w wątku X, do wątku Y?

Question

Tworzę plik SolidColorBrush w przypadku niektórych wątków innych niż GUI i chcę przekazać go do wątku GUI, aby go wyświetlić, ale otrzymuję InvalidOperationException: The calling thread cannot access this object because a different thread owns it. (nawet jeśli spróbuję uzyskać Freeze();). Jak przekazać obiekt utworzony w wątku X do wątku Y?

Wiem, że mogę utworzyć ten obiekt SolidColorBrush w wątku GUI z Dispatcher, ale to wszystko komplikuje ... Chcę go utworzyć w wątku roboczym.

---

Dodatkowe szczegóły:

zainicjować jakąś statyczną delegata w jakimś statycznym klasy, aby umożliwić wysyłanie wiadomości z warstwy biznesowej do 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); } 
} 

inicjalizacji (w wątku GUI):

Gui.InitializeGuiInterface(_messagesToUserHandler.PrintMessage); 

Następnie w innym wątku (bez GUI) używam go:

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

podczas GuiMessage jest:

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

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

Answer 1

Możesz utworzyć zasoby wpf w innym wątku, jeśli je freeze, po czym element może zostać przekazany do kolejnego wątku lub wątku GUI. Pamiętaj, że jednorazowy zamrożony obiekt można zmodyfikować tylko wykonując kopię i używając tej kopii. Nie można zamrażać obiektów powiązanych z powiązaniami lub animacjami.

Answer 2

Trzeba użyć delegatem na bezpieczne powołać się na kontrolę.

Zastosowanie

Control.Invoke

lub

Control.BeginInvoke

do tego celu.

Jeśli nie użyjesz delegata do bezpiecznego wywołania, otrzymasz wyjątek.

Sprawdź te linki:

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

enter link description here

Answer 3

Należy użyć Dispatcher.

Możesz utworzyć klasę, która pomieści dyspozytora utworzonego w głównym wątku i wstrzyknie go przez twój kontener do klasy wykonanej na wątku tła, który musi wejść w interakcję z głównym wątkiem.

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); 
    } 
} 

Utwórz instancję UiDispatcher w punkcie Twoje są pewni swojej są na wątku UI, na przykład podczas inicjalizacji aplikacji.Korzystając z kontenera wtryskowego zależności, upewnij się, że tylko jedna instancja tej klasy zostanie utworzona i wstrzyknięta do dowolnej innej klasy, która tego wymaga, i użyć go do utworzenia/manipulowania składnikami interfejsu użytkownika.

Wybrałem kod, aby sprawdzić, czy konstruktor UiDispatcher jest wykonany w głównym wątku z this answer.

Chodzi o to, że nie można używać w wątku UI czegoś stworzonego na innym wątku. Potrzebujesz więc wątku w tle, aby delegować do głównego wątku UI, co dotyczy elementów interfejsu użytkownika.