Main(1): Th= '8', TaskId= ''
fAsync(1): Th= '8', TaskId= ''
DONE
ff(1): Th= '9', TaskId= '1'
ff(2): Th= '9', TaskId= '1'
fAsync(2): Th= '9', TaskId= ''

Main(1): Th= '9', TaskId= ''
fAsync(1): Th= '9', TaskId= ''
ff(1): Th= '6', TaskId= '1'
DONE
ff(2): Th= '6', TaskId= '1'
fAsync(2): Th= '9', TaskId= ''

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Main(1): Th= '{0}', TaskId= '{1}'", Thread.CurrentThread.ManagedThreadId, Task.CurrentId);

            fAsync();

            Console.WriteLine("DONE");
            Console.ReadKey();
        }

        private static async void fAsync()
        {
            Console.WriteLine("fAsync(1): Th= '{0}', TaskId= '{1}'", Thread.CurrentThread.ManagedThreadId, Task.CurrentId);

            await ff();

            Console.WriteLine("fAsync(2): Th= '{0}', TaskId= '{1}'", Thread.CurrentThread.ManagedThreadId, Task.CurrentId);
        }

        private static Task ff()
        {
            Task t = new Task(() =>
            {
                Console.WriteLine("ff(1): Th= '{0}', TaskId= '{1}'", Thread.CurrentThread.ManagedThreadId, Task.CurrentId);
                Thread.Sleep(5000);
                Console.WriteLine("ff(2): Th= '{0}', TaskId= '{1}'", Thread.CurrentThread.ManagedThreadId, Task.CurrentId);
            });
            t.Start();

            return t;
        }
    }

        private void button1_Click(object sender, EventArgs e)
        {
            Debug.WriteLine("Main(1): Th= '{0}', TaskId= '{1}'", Thread.CurrentThread.ManagedThreadId, Task.CurrentId);

            fAsync();

            Debug.WriteLine("DONE");
        }

        private static async void fAsync()
        {
            Debug.WriteLine("fAsync(1): Th= '{0}', TaskId= '{1}'", Thread.CurrentThread.ManagedThreadId, Task.CurrentId);

            await ff();

            Debug.WriteLine("fAsync(2): Th= '{0}', TaskId= '{1}'", Thread.CurrentThread.ManagedThreadId, Task.CurrentId);
        }

        private static Task ff()
        {
            Task t = new Task(() =>
            {
                Debug.WriteLine("ff(1): Th= '{0}', TaskId= '{1}'", Thread.CurrentThread.ManagedThreadId, Task.CurrentId);
                Thread.Sleep(5000);
                Debug.WriteLine("ff(2): Th= '{0}', TaskId= '{1}'", Thread.CurrentThread.ManagedThreadId, Task.CurrentId);
            });
            t.Start();

            return t;
        }

await ff().ConfigureAwait(false); ;

А в WinForms-проекте вывод такой:

if (SynchronizationContext.Current == null)
            SynchronizationContext.SetSynchronizationContext(new WindowsFormsSynchronizationContext());
 
        Sc = SynchronizationContext.Current;

        private void Button_Click(object sender, RoutedEventArgs e)
        {
            RunAsync(() => button.Content = "x_X")
                .ContinueWith(t => MessageBox.Show("Completed:" + t.IsCompleted));
        }

        private async Task RunAsync(Action onNext)
        {
            await Task.Delay(1).ConfigureAwait(false);
            onNext();
        }

S>        private void Button_Click(object sender, RoutedEventArgs e)
S>        {
S>            RunAsync(() => button.Content = "x_X")
S>                .ContinueWith(t => MessageBox.Show("Completed:" + t.IsCompleted));
S>        }

S>        private async Task RunAsync(Action onNext)
S>        {
S>            await Task.Delay(1).ConfigureAwait(false);
S>            onNext();
S>        }
S>

private async Task Button_Click(object sender, RoutedEventArgs e)
        {
            await RunAsync().ConfigureAwait(true);
                        button.Content = "x_X";

            MessageBox.Show("Completed:" + t.IsCompleted));
        }

await Task.Delay(1);

ConfigureAwait(false);

            public void OnCompleted(Action continuation)
            {
                TaskAwaiter.OnCompletedInternal(m_task, continuation, m_continueOnCapturedContext, flowExecutionContext:true);
            }

S>А можно пример? Есть такое подозрение, что проблема там не в ConfigureAwait(), а в исчерпании потоков, доступных для запуска продолжений. Так это и с ConfigureAwait(false) можно устроить, дурное дело нехитрое

private async Task Button_Click(object sender, RoutedEventArgs e)
        {
            await RunAsync().Wait(); //1
            button.Content = "x_X";

            MessageBox.Show("Completed:" + t.IsCompleted));
        }

private async Task RunAsync()
      {
            await Task.Delay(1); //2 Получим классический дедлок
// Так как  await Task.Delay(1); возвращается в поток GUI но, await RunAsync() его ждет
 

        }

Клик по кнопке здесь приводит к дедлоку. UI поток стартует новый I/O поток на строке «2» и уходит в спящий режим на строке «1», ожидая завершения работы. После того как I/O поток заканчивает выполнение, оставшаяся часть метода RunAsync передается на выполнение вызывающему (UI) потоку. Но тот в это время находится в спящем режиме, ожидая завершения метода. Дедлок.

S>Спасиб

проблема там не в ConfigureAwait(), а в исчерпании потоков, доступных для запуска продолжений

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

namespace ConsoleApp3
{
    class Program
    {
        static void Main(string[] args)
        {
            ThreadPool.SetMinThreads(1, 1);
            ThreadPool.SetMaxThreads(8, 8);
            // ...
            RunAsync(10).Wait();
            Console.WriteLine(total);
        }

        private static volatile int total = 0;

        private static async Task RunAsync(int i)
        {
            if (i == 0)
                return;

            Console.WriteLine(i);
            await Task.Delay(1).ConfigureAwait(false);
            RunAsync(i - 1).Wait();
            Interlocked.Increment(ref total);
        }
    }
}

S>Скорее наоборот Цитато:

S>using System;
S>using System.Threading;
S>using System.Threading.Tasks;

S>namespace ConsoleApp3
S>{
S>    class Program
S>    {
S>        static void Main(string[] args)
S>        {
S>            ThreadPool.SetMinThreads(1, 1);
S>            ThreadPool.SetMaxThreads(8, 8);
S>            // ...
S>            RunAsync(10).Wait();
S>            Console.WriteLine(total);
S>        }

S>        private static volatile int total = 0;

S>        private static async Task RunAsync(int i)
S>        {
S>            if (i == 0)
S>                return;

S>            Console.WriteLine(i);
S>            await Task.Delay(1).ConfigureAwait(false);
S>            RunAsync(i - 1).Wait();
S>            Interlocked.Increment(ref total);
S>        }
S>    }
S>}
S>

S>Ну как, помог ConfigureAwait(false)?

await RunAsync(i - 1).Wait;

delegate void AddTextToTListBox(string text);

        void msg_OnSendChatMessage(string message)
        {
            
            if (listBox1.InvokeRequired)
            {
                AddTextToTextBox d = new AddTextToTextBox(msg_OnSendChatMessage);
                this.Invoke(d, new object[] { message });
            }
            else
            {
                listBox1.Text += message + "\r\n";
            }  
        }