Bieżący SynchronizationContext nie może być używany jako TaskScheduler

Używam zadań do uruchamiania długotrwałych wywołań serwera w moim ViewModel, a wyniki są kierowane z powrotem przy Dispatcherużyciu TaskScheduler.FromSyncronizationContext(). Na przykład:

var context = TaskScheduler.FromCurrentSynchronizationContext();
this.Message = "Loading...";
Task task = Task.Factory.StartNew(() => { ... })
            .ContinueWith(x => this.Message = "Completed"
                          , context);

Działa to dobrze, gdy uruchamiam aplikację. Ale kiedy uruchamiam NUnittesty Resharper, otrzymuję komunikat o błędzie w połączeniu z FromCurrentSynchronizationContext:

Bieżący SynchronizationContext nie może być używany jako TaskScheduler.

Wydaje mi się, że dzieje się tak, ponieważ testy są uruchamiane na wątkach roboczych. Jak mogę upewnić się, że testy są uruchamiane w głównym wątku? Wszelkie inne sugestie są mile widziane.

Musisz podać SynchronizationContext. Oto jak sobie z tym radzę:

[SetUp]
public void TestSetUp()
{
  SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
}

Rozwiązanie Ritcha Meltona nie działało dla mnie. Dzieje się tak, ponieważ moja TestInitializefunkcja jest asynchroniczna, podobnie jak moje testy, więc z każdym awaitprądem SynchronizationContextjest tracony. Dzieje się tak, ponieważ, jak wskazuje MSDN, SynchronizationContextklasa jest „głupia” i po prostu kolejkuje całą pracę do puli wątków.

To, co mi zadziałało, to po prostu pomijanie FromCurrentSynchronizationContextwywołania, gdy nie ma znaku SynchronizationContext(to znaczy, jeśli bieżący kontekst ma wartość null ). Jeśli nie ma wątku interfejsu użytkownika, w pierwszej kolejności nie muszę się z nim synchronizować.

TaskScheduler syncContextScheduler;
if (SynchronizationContext.Current != null)
{
    syncContextScheduler = TaskScheduler.FromCurrentSynchronizationContext();
}
else
{
    // If there is no SyncContext for this thread (e.g. we are in a unit test
    // or console scenario instead of running in an app), then just use the
    // default scheduler because there is no UI thread to sync with.
    syncContextScheduler = TaskScheduler.Current;
}

To rozwiązanie okazało się prostsze niż alternatywy, w których:

• Przekaż TaskSchedulerdo ViewModel (przez iniekcję zależności)
• Utwórz test SynchronizationContexti „fałszywy” wątek interfejsu użytkownika, aby testy działały dalej - dla mnie o wiele więcej kłopotu, niż jest to warte

Tracę część niuansów wątków, ale nie testuję jawnie, czy moje wywołania zwrotne OnPropertyChanged wyzwalają w określonym wątku, więc nie przeszkadza mi to. Inne odpowiedzi new SynchronizationContext()nie są tak naprawdę lepsze dla tego celu.

Połączyłem wiele rozwiązań, aby mieć gwarancję działania SynchronizationContext:

using System;
using System.Threading;
using System.Threading.Tasks;

public class CustomSynchronizationContext : SynchronizationContext
{
    public override void Post(SendOrPostCallback action, object state)
    {
        SendOrPostCallback actionWrap = (object state2) =>
        {
            SynchronizationContext.SetSynchronizationContext(new CustomSynchronizationContext());
            action.Invoke(state2);
        };
        var callback = new WaitCallback(actionWrap.Invoke);
        ThreadPool.QueueUserWorkItem(callback, state);
    }
    public override SynchronizationContext CreateCopy()
    {
        return new CustomSynchronizationContext();
    }
    public override void Send(SendOrPostCallback d, object state)
    {
        base.Send(d, state);
    }
    public override void OperationStarted()
    {
        base.OperationStarted();
    }
    public override void OperationCompleted()
    {
        base.OperationCompleted();
    }

    public static TaskScheduler GetSynchronizationContext() {
      TaskScheduler taskScheduler = null;

      try
      {
        taskScheduler = TaskScheduler.FromCurrentSynchronizationContext();
      } catch {}

      if (taskScheduler == null) {
        try
        {
          taskScheduler = TaskScheduler.Current;
        } catch {}
      }

      if (taskScheduler == null) {
        try
        {
          var context = new CustomSynchronizationContext();
          SynchronizationContext.SetSynchronizationContext(context);
          taskScheduler = TaskScheduler.FromCurrentSynchronizationContext();
        } catch {}
      }

      return taskScheduler;
    }
}

Stosowanie:

var context = CustomSynchronizationContext.GetSynchronizationContext();

if (context != null) 
{
    Task.Factory
      .StartNew(() => { ... })
      .ContinueWith(x => { ... }, context);
}
else 
{
    Task.Factory
      .StartNew(() => { ... })
      .ContinueWith(x => { ... });
}