Intenté usar el método SwitchTo hoy para cambiar al subproceso de la GUI y descubrí que el ejemplo del que lo extraje no funciona, simplemente porque el método no está allí.

Entonces encontré esta propagandaaquí:

La razón por la que nos deshicimos de él fue porque era muy peligroso. La alternativa es agrupar su código dentro de TaskEx.Run ...

Mi pregunta es simplemente:Por qué era peligroso? ¿A qué peligros específicos llevaría su uso?

Tenga en cuenta que yohizo lea el resto de esa publicación, así que entiendo que hay limitaciones técnicas aquí. Mi pregunta sigue siendo, si soy consciente de esto, ¿por qué?peligroso?

Estoy considerando la reimplementación de métodos de ayuda para darme la funcionalidad especificada, pero si hay algo fundamentalmente roto, aparte de que alguien decidió que era peligroso, no lo haría.

Específicamente, muy ingenuamente, así es como consideraría implementar los métodos requeridos:

public static class ContextSwitcher
{
    public static ThreadPoolContextSwitcher SwitchToThreadPool()
    {
        return new ThreadPoolContextSwitcher();
    }

    public static SynchronizationContextSwitcher SwitchTo(this SynchronizationContext synchronizationContext)
    {
        return new SynchronizationContextSwitcher(synchronizationContext);
    }
}

public class SynchronizationContextSwitcher : INotifyCompletion
{
    private readonly SynchronizationContext _SynchronizationContext;

    public SynchronizationContextSwitcher(SynchronizationContext synchronizationContext)
    {
        _SynchronizationContext = synchronizationContext;
    }

    public SynchronizationContextSwitcher GetAwaiter()
    {
        return this;
    }

    public bool IsCompleted
    {
        get
        {
            return false;
        }
    }

    public void OnCompleted(Action action)
    {
        _SynchronizationContext.Post(_ => action(), null);
    }

    public void GetResult()
    {
    }
}

public class ThreadPoolContextSwitcher : INotifyCompletion
{
    public ThreadPoolContextSwitcher GetAwaiter()
    {
        return this;
    }

    public bool IsCompleted
    {
        get
        {
            return false;
        }
    }

    public void OnCompleted(Action action)
    {
        ThreadPool.QueueUserWorkItem(_ => action(), null);
    }

    public void GetResult()
    {
    }
}

Esto me permitiría escribir código como este:

public async void Test()
{
    await ContextSwitcher.SwitchToThreadPool(); // ensure we're not bogging down the UI thread
    // do some heavy processing
    await _UIContext.SwitchTo(); // presumably saved from the main thread
    // update UI with new data
}