Le SynchronizationContext actuel ne peut pas être utilisé comme un TaskScheduler

J'utilise des tâches pour exécuter des appels de serveur de longue durée dans mon ViewModel et les résultats sont rassemblés lors de l' Dispatcherutilisation TaskScheduler.FromSyncronizationContext(). Par exemple:

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

Cela fonctionne bien lorsque j'exécute l'application. Mais quand j'exécute mes NUnittests, Resharperj'obtiens le message d'erreur sur l'appel à FromCurrentSynchronizationContextcomme:

Le SynchronizationContext actuel ne peut pas être utilisé comme un TaskScheduler.

Je suppose que c'est parce que les tests sont exécutés sur des threads de travail. Comment puis-je m'assurer que les tests sont exécutés sur le thread principal? N'importe quelles autres suggestions sont les bienvenues.

Vous devez fournir un SynchronizationContext. Voici comment je le gère:

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

La solution de Ritch Melton n'a pas fonctionné pour moi. C'est parce que ma TestInitializefonction est asynchrone, tout comme mes tests, donc à chaque fois que awaitle courant SynchronizationContextest perdu. Cela est dû au fait que, comme MSDN le souligne, la SynchronizationContextclasse est «stupide» et met tout simplement en file d'attente tous les travaux dans le pool de threads.

Ce qui a fonctionné pour moi, c'est simplement sauter l' FromCurrentSynchronizationContextappel quand il n'y a pas de SynchronizationContext(c'est-à-dire si le contexte actuel est nul ). S'il n'y a pas de thread d'interface utilisateur, je n'ai pas besoin de me synchroniser avec lui en premier lieu.

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

J'ai trouvé cette solution plus simple que les alternatives, qui où:

• Passer un TaskSchedulerà ViewModel (via l'injection de dépendances)
• Créez un test SynchronizationContextet un "faux" fil d'interface utilisateur pour les tests à exécuter - beaucoup plus de problèmes pour moi que cela en vaut la peine

Je perds une partie de la nuance de thread, mais je ne teste pas explicitement que mes rappels OnPropertyChanged se déclenchent sur un thread spécifique, donc je suis d'accord avec cela. Les autres réponses utilisant new SynchronizationContext()ne font pas vraiment mieux pour cet objectif de toute façon.

J'ai combiné plusieurs solutions pour avoir la garantie de fonctionner 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;
    }
}

Usage:

var context = CustomSynchronizationContext.GetSynchronizationContext();

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