Uso de asincronismo con tipos dinámicos en C#.

Programa.cs

using System;
using System.Dynamic;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;
using ImpromptuInterface;

namespace R5._9OperadorAwaitConDynamic
{
    class Programa
    {
        /// <summary>
        /// Inicia la ejecución de la aplicación.
        /// </summary>
        static void Main()
        {
            Task nuevaTarea = ProcesamientoAsincronico();

            nuevaTarea.Wait();
        }

        /// <summary>
        /// Inicia el procesamiento asincrónica de una tarea.
        /// </summary>
        /// <returns>Tarea</returns>
        async static Task ProcesamientoAsincronico()
        {
            string resultado = await ObtenerObjetoAwaitDinamico(true);
            Console.WriteLine(resultado);

            resultado = await ObtenerObjetoAwaitDinamico(false);
            Console.WriteLine(resultado);
        }

        /// <summary>
        /// Obtiene un objeto dinámico a partir de la ejecución sincrónica o asincrónica de una tarea que 
        /// a de completarse después un segundo.
        /// </summary>
        /// <param name="completarConSincronismo">Determina si la tarea se ejecuta sincrónica o asincrónicamente.</param>
        /// <returns>Objeto dinámico</returns>
        static dynamic ObtenerObjetoAwaitDinamico(bool completarConSincronismo)
        {
            dynamic resultado = new ExpandoObject();
            dynamic awaiter = new ExpandoObject();
            awaiter.Message = "Proceso completado sincrónicamente";
            awaiter.IsCompleted = completarConSincronismo;
            awaiter.GetResult = (Func<string>)(() => awaiter.Message);

            awaiter.OnCompleted = (Action<Action>)(callback =>
                ThreadPool.QueueUserWorkItem(state => {
                    Thread.Sleep(TimeSpan.FromSeconds(1));
                    awaiter.Message = ObtenerMensajes();

                    if (callback != null)
                    {
                        callback();
                    }
                })
            );

            IAwaiter<string> proxy = Impromptu.ActLike(awaiter);
            resultado.GetAwaiter = (Func<dynamic>)(() => proxy);
            return resultado;
        }

        /// <summary>
        /// Muestra la información actual del thread en ejecución.
        /// </summary>
        /// <returns>Información actual del thread en ejecución.</returns>
        static string ObtenerMensajes()
        {
            return string.Format("La tarea se está ejecutando en el thread con ID: {0}. ¿Thread en el pool de threads?: {1} ", Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.IsThreadPoolThread);
        }

        public interface IAwaiter<T> : INotifyCompletion
        {
            bool IsCompleted { get; }
            T GetResult();
        }
    }
}