TOPIC:

            ThreadHelper.JoinableTaskFactory.Run(async delegate
                {
                    await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
                    using (new AutomationScope(this.project.Site))
                    {
                        project.SetEditLabel(value);
                    }
                });

oStopwatch := System.Diagnostics.Stopwatch{}
oStopwatch:Start()
Task.Run( { => self:_ConnectA( cHostName, cUserName, cPassword, nPort, oConfig ) } )
while _lWorking
	System.Threading.Thread.Sleep( 10 )
	if oStopwatch:Elapsed:Seconds > _nTimeout
		_cErrorMessage			:= "Timeout " + _nTimeout:ToString()
		exit
	endif
end
_DebOut( "Waited " + oStopwatch:Elapsed:ToString() )

_DebOut( "Creating AsyncFtpClient" )
_oClient			:= AsyncFtpClient{ cHostName, cUserName, cPassword, nPort, oConfig }
_DebOut( "Creating Task Connect()" )
oTask				:= _oClient:Connect()
_DebOut( "Awaiting Task Connect()" )
await oTask
_DebOut( "Task Connect() finished" )

Waited 00:00:00.0029780
Client is null
Creating AsyncFtpClient
Creating Task Connect()
Awaiting Task Connect()
Task Connect() finished

Task.WhenAll( self:_ConnectA( cHostName, cUserName, cPassword, nPort, oConfig ) )

public static class AsyncHelpers
    {
        /// <summary>
        /// Executes an async Task<T> method which has a void return value synchronously
        /// </summary>
        /// <param name="task">Task<T> method to execute</param>
        public static void RunSync(Func<Task> task)
        {
            var oldContext = SynchronizationContext.Current;
            var synch = new ExclusiveSynchronizationContext();
            SynchronizationContext.SetSynchronizationContext(synch);
            synch.Post(async _ =>
            {
                try
                {
                    await task();
                }
                catch (Exception e)
                {
                    synch.InnerException = e;
                    throw;
                }
                finally
                {
                    synch.EndMessageLoop();
                }
            }, null);
            synch.BeginMessageLoop();

            SynchronizationContext.SetSynchronizationContext(oldContext);
        }

        /// <summary>
        /// Executes an async Task<T> method which has a T return type synchronously
        /// </summary>
        /// <typeparam name="T">Return Type</typeparam>
        /// <param name="task">Task<T> method to execute</param>
        /// <returns></returns>
        public static T RunSync<T>(Func<Task<T>> task)
        {
            var oldContext = SynchronizationContext.Current;
            var synch = new ExclusiveSynchronizationContext();
            SynchronizationContext.SetSynchronizationContext(synch);
            T ret = default(T);
            synch.Post(async _ =>
            {
                try
                {
                    ret = await task();
                }
                catch (Exception e)
                {
                    synch.InnerException = e;
                    throw;
                }
                finally
                {
                    synch.EndMessageLoop();
                }
            }, null);
            synch.BeginMessageLoop();
            SynchronizationContext.SetSynchronizationContext(oldContext);
            return ret;
        }

        private class ExclusiveSynchronizationContext : SynchronizationContext
        {
            private bool done;
            public Exception InnerException { get; set; }
            readonly AutoResetEvent workItemsWaiting = new AutoResetEvent(false);
            readonly Queue<Tuple<SendOrPostCallback, object>> items =
                new Queue<Tuple<SendOrPostCallback, object>>();

            public override void Send(SendOrPostCallback d, object state)
            {
                throw new NotSupportedException("We cannot send to our same thread");
            }

            public override void Post(SendOrPostCallback d, object state)
            {
                lock (items)
                {
                    items.Enqueue(Tuple.Create(d, state));
                }
                workItemsWaiting.Set();
            }

            public void EndMessageLoop()
            {
                Post(_ => done = true, null);
            }

            public void BeginMessageLoop()
            {
                while (!done)
                {
                    Tuple<SendOrPostCallback, object> task = null;
                    lock (items)
                    {
                        if (items.Count > 0)
                        {
                            task = items.Dequeue();
                        }
                    }
                    if (task != null)
                    {
                        task.Item1(task.Item2);
                        if (InnerException != null) // the method threw an exeption
                        {
                            throw new AggregateException("AsyncHelpers.Run method threw an exception.", InnerException);
                        }
                    }
                    else
                    {
                        workItemsWaiting.WaitOne();
                    }
                }
            }

            public override SynchronizationContext CreateCopy()
            {
                return this;
            }
        }
    }

oThread := System.Threading.Thread{ { => self:_ConnectA( cHostName, cUserName, cPassword, nPort, oConfig ) } }
oThread:Start()
while oThread:IsAlive
	System.Threading.Thread.Sleep( 10 )
end

Creating AsyncFtpClient
Creating Task Connect()
Awaiting Task Connect()
Task Connect() finished
Waited 00:00:00.2349512
Connected is True

synch.Post(async _ =>
            {
                try
                {
                    await task();
                }
                catch (Exception e)
                {
                    synch.InnerException = e;
                    throw;
                }
                finally
                {
                    synch.EndMessageLoop();
                }
            }, null);

Post(_ => done = true, null);

self:Post( { => self:done := true }, null )

error XS1593: Delegate 'System.Threading.SendOrPostCallback' does not take 0 arguments