Wykrywanie, czy w wątku UI w WPF i Winforms

W WinForms normalnie używasz

if(control.InvokeRequired) 
{
 // Do non UI thread stuff
}

Dla WPF

if (!control.Dispatcher.CheckAccess())
{
  // Do non UI Thread stuff
}

Prawdopodobnie napisałbym małą metodę, która wykorzystuje ogólne Ograniczenie, aby określić, które z nich należy wywołać. np.

public static bool CurrentlyOnUiThread<T>(T control)
{ 
   if(T is System.Windows.Forms.Control)
   {
      System.Windows.Forms.Control c = control as System.Windows.Forms.Control;
      return !c.InvokeRequired;
   }
   else if(T is System.Windows.Controls.Control)
   {
      System.Windows.Controls.Control c = control as System.Windows.Control.Control;
      return c.Dispatcher.CheckAccess()
   }
}

Dla WPF:

// You are on WPF UI thread!
if (Thread.CurrentThread == System.Windows.Threading.Dispatcher.CurrentDispatcher.Thread)

Dla WinForms:

// You are NOT on WinForms UI thread for this control!
if (someControlOrWindow.InvokeRequired)

Do WPF używam:

public static void InvokeIfNecessary (Action action)
{
    if (Thread.CurrentThread == Application.Current.Dispatcher.Thread)
        action ();
    else {
        Application.Current.Dispatcher.Invoke(action);
    }
}

Klucz jest zamiast sprawdzania dyspozytora.CurrentDispatcher (który da ci dyspozytora dla bieżącego wątku), musisz sprawdzić, czy bieżący wątek pasuje do dyspozytora aplikacji lub innej kontroli.

Może Control.InvokeRequired (WinForms) i Dispatcher.CheckAccess (WPF) są dla Ciebie w porządku?

Wpychasz wiedzę o swoim interfejsie użytkownika do swojej logiki. To nie jest dobry projekt.

Twoja warstwa interfejsu powinna obsługiwać wątki, ponieważ zapewnienie, że wątek interfejsu nie jest nadużywany, jest w zasięgu interfejsu.

Pozwala to również na użycie IsInvokeRequired w winforms i Dispatcher.Wywołaj w WPF... i pozwala na wykorzystanie kodu w ramach synchronicznych i asynchronicznych asp.net prośby również...

Odkryłem w praktyce, że próbując poradzić sobie tworzenie wątków na niższym poziomie logiki aplikacji często zwiększa niepotrzebną złożoność. W rzeczywistości praktycznie cały framework jest napisany z tym punktem-prawie nic w frameworku nie jest bezpieczne. Jego do wywołujących (na wyższym poziomie) w celu zapewnienia bezpieczeństwa wątku.

Dla WPF:

Muszę wiedzieć, czy Dyspozytor na moim wątku jest rzeczywiście uruchomiony, czy nie. Ponieważ jeśli utworzysz jakąkolwiek klasę WPF w wątku, zaakceptowana odpowiedź stwierdzi, że dispatcher tam jest, nawet jeśli nigdy nie wykonasz Dispatcher.Run(). Skończyło się na refleksji:

public static class WpfDispatcherUtils
{
    private static readonly Type dispatcherType = typeof(Dispatcher);
    private static readonly FieldInfo frameDepthField = dispatcherType.GetField("_frameDepth", BindingFlags.Instance | BindingFlags.NonPublic);

    public static bool IsInsideDispatcher()
    {
        // get dispatcher for current thread
        Dispatcher currentThreadDispatcher = Dispatcher.FromThread(Thread.CurrentThread);

        if (currentThreadDispatcher == null)
        {
            // no dispatcher for current thread, we're definitely outside
            return false;
        }

        // get current dispatcher frame depth
        int currentFrameDepth = (int) frameDepthField.GetValue(currentThreadDispatcher);

        return currentFrameDepth != 0;
    }
}

Korzystanie z MVVM jest w rzeczywistości dość łatwe. To, co robię, to umieszczam coś w rodzaju następującego, powiedzmy, ViewModelBase...

protected readonly SynchronizationContext SyncContext = SynchronizationContext.Current;

Lub...

protected readonly TaskScheduler Scheduler = TaskScheduler.Current; 

Wtedy, gdy konkretny model widoku musi dotknąć czegokolwiek "obserwowalnego", możesz sprawdzić kontekst i odpowiednio zareagować...

public void RefreshData(object state = null /* for direct calls */)
{
    if (SyncContext != SynchronizationContext.Current)
    {
        SyncContext.Post(RefreshData, null); // SendOrPostCallback
        return;
    }
    // ...
}

Lub zrobić coś innego w tle przed powrotem do kontekstu ...

public void RefreshData()
{
    Task<MyData>.Factory.StartNew(() => GetData())
        .ContinueWith(t => {/* Do something with t.Result */}, Scheduler);
}

Zwykle, jeśli podążasz za MVVM (lub inną architekturą) w uporządkowany sposób, łatwo jest powiedzieć, gdzie odpowiedzialność za synchronizację UI będzie umiejscowiona. Ale możesz to zrobić w dowolnym miejscu, aby powrócić do kontekstu, w którym tworzone są obiekty. Jestem pewien, że łatwo byłoby stworzyć "osłonę", aby poradzić sobie z tym czysto i konsekwentnie w dużym i złożonym systemie.

Oto fragment kodu, którego używam w WPF do przechwytywania prób modyfikacji właściwości UI (które implementują INotifyPropertyChanged) z nie-UI wątku:

    public event PropertyChangedEventHandler PropertyChanged;

    private void NotifyPropertyChanged(String info)
    {
        // Uncomment this to catch attempts to modify UI properties from a non-UI thread
        //bool oopsie = false;
        //if (Thread.CurrentThread != Application.Current.Dispatcher.Thread)
        //{
        //    oopsie = true; // place to set a breakpt
        //}

        if (PropertyChanged != null)
        {
            PropertyChanged(this, new PropertyChangedEventArgs(info));
        }
    }

Thread.CurrentThread.ManagedThreadId == Dispatcher.Thread.ManagedThreadId

Is a better way to check this