private static async void Test()
{
            var tcs = new TaskCompletionSource<int>();
            var task = Task.Factory.StartNew(() =>
            {
                Thread.Sleep(1000);
                tcs.SetResult(10);
                Console.WriteLine("here3");
            });

            await tcs.Task; //1
            task.Wait(); //1
            //await tcs.Task.ContinueWith(t => task.Wait());//2


            Console.WriteLine("here1");
}

S>private static async void Test()
S>{
S>            var tcs = new TaskCompletionSource<int>();
S>            var task = Task.Factory.StartNew(() =>
S>            {
S>                Thread.Sleep(1000);
S>                tcs.SetResult(10);
S>                Console.WriteLine("here3");
S>            });

S>            await tcs.Task; //1
S>            task.Wait(); //1
S>            //await tcs.Task.ContinueWith(t => task.Wait());//2


S>            Console.WriteLine("here1");
S>}
S>

var task = Task.Factory.StartNew(() =>
            {
                Thread.Sleep(1000);
                Task.Factory.StartNew(() => tcs.SetResult(10));
                Console.WriteLine("here3");
            });

private static async void Test()
{
    var tcs = new TaskCompletionSource<int>();
    var task = Task.Factory.StartNew(() =>
    {
        Thread.Sleep(1000);
                tcs.SetResult(10);
                Console.WriteLine("here3");
    });

    await tcs.Task; //1
    await task;

    //task.Wait(); //1
    //await tcs.Task.ContinueWith(t => task.Wait());//2


    Console.WriteLine("here1");
}

    Form f = new Form();
    Test();
    Application.Run(f);

async void Test()
{
    var tcs = new TaskCompletionSource<int>();
    var task = Task.Factory.StartNew(() =>
    {
        Thread.Sleep(1000);
        tcs.SetResult(10); // Таска (из task completion source) завершилась и синхронно запустился сontinuation (1)
        // task ждет завершения continuation (1) (deadlock)
        Console.WriteLine("here3");
    });


    // await tcs.Task раскроется во что-то типа
    tcs.Task.GetAwaiter().OnCompleted(() => /* (1) continuation */
    {
        // continuation ждет завершения task (deadlock)
        task.Wait();
    });
}

// Если написать
var tcs = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);
// То continuation будет запускаться на другом потоке и дедлока не будет

private static void Main( string[] args )
        {
            Test();
            Thread.Sleep( 3500 );
        }

        private static async void Test()
        {
            Console.WriteLine( "T{0} run test", Thread.CurrentThread.ManagedThreadId );
            var tcs = new TaskCompletionSource<int>( TaskContinuationOptions.RunContinuationsAsynchronously );
            var task = Task.Factory.StartNew( () =>
            {
                Console.WriteLine( "T{0} processing task..", Thread.CurrentThread.ManagedThreadId );
                Thread.Sleep( 100 );
                tcs.SetResult( 10 );
                Console.WriteLine( "T{0} task done", Thread.CurrentThread.ManagedThreadId );

            });
            Console.WriteLine( "T{0} task started, awaiting", Thread.CurrentThread.ManagedThreadId );

            await tcs.Task; 
            Console.WriteLine( "T{0} cont, before Wait", Thread.CurrentThread.ManagedThreadId );
            task.Wait(); 
            Console.WriteLine( "T{0} cont, after Wait", Thread.CurrentThread.ManagedThreadId );
        }

F>private static void Main( string[] args )
F>        {
F>            Test();
F>            Thread.Sleep( 3500 );
F>        }

F>        private static async void Test()
F>        {
F>            // Тут у тебя вызывается перегрузка 
F>            // public TaskCompletionSource(object state), т.е. new TaskCompletionSource<int>((object)TaskContinuationOptions.RunContinuationsAsynchronously)
F>            // нужно TaskCreationOptions использовать, а не TaskContinuationOptions. :)
F>            var tcs = new TaskCompletionSource<int>(TaskContinuationOptions.RunContinuationsAsynchronously); 
F>        }