Akka.net Nested ask async await issue example

gistfile1.txt

using System;
using Akka.Actor;

namespace AkkaAsyncAwait
{
    class Program
    {
        static void Main(string[] args)
        {
            var system = ActorSystem.Create("MySystem");

            var toplevelworker = system.ActorOf<TopLevelCoordinatorActor>(ActorPaths.TopLevelCoordinator.Name);
            var sublevelworker = system.ActorOf<WorkCoordinatorActor>(ActorPaths.WorkCoordinator.Name);

            Console.WriteLine("Asking work");
            var completed = toplevelworker.Ask<TopLevelWorkCompleted>(new TopLevelWork()).Result;

            Console.WriteLine("Work completed!");
            Console.ReadLine();
        }
    }

    public class ActorPaths
    {
        public static readonly ActorMetaData WorkCoordinator = new ActorMetaData("workcoordinator", "akka://MySystem/user/workcoordinator");
        public static readonly ActorMetaData TopLevelCoordinator = new ActorMetaData("toplevelcoordinator", "akka://MySystem/user/toplevelcoordinator");
        /// <summary>
        /// Meta-data class
        /// </summary>
        public class ActorMetaData
        {
            public ActorMetaData(string name, string path)
            {
                Name = name;
                Path = path;
            }

            public string Name { get; private set; }

            public string Path { get; private set; }
        }
    }

    public class TopLevelCoordinatorActor : ReceiveActor {
        public class DelegateToSubWorkCoordinator {}

        private IActorRef _parent;

        public TopLevelCoordinatorActor() {
            Receive<TopLevelWork>(work => {
                _parent = Sender;
                //important decisions being made
                //but we delegate it
                Context.Self.Tell(new DelegateToSubWorkCoordinator());
            });

            Receive<DelegateToSubWorkCoordinator>(async job => {
                await Context.ActorSelection(ActorPaths.WorkCoordinator.Path)
                           .Ask<WorkCoordinatorActor.WorkFinished>(new WorkCoordinatorActor.DoWork())
                           .ContinueWith(t => {
                               _parent.Tell(new TopLevelWorkCompleted());
                           });
            });
        }
    }

    public class WorkCoordinatorActor : ReceiveActor {
        public class DoWork {}
        public class WorkFinished{}

        private IActorRef _askSource;
        private IActorRef _childActor;

        public WorkCoordinatorActor() {
            Waiting();
        }

        private void Waiting() {
            Receive<DoWork>(subWork =>
            {
                _askSource = Sender;

                _childActor.Tell(new ChildActor.DoChildWork());

                BecomeStacked(Working);
            });
        }

        private void Working() {
            Receive<ChildActor.ChildCompleted>(work => {
                _askSource.Tell(new WorkFinished());
                UnbecomeStacked();
            });
        }

        protected override void PreStart() {
            _childActor = Context.ActorOf<ChildActor>();
            base.PreStart();
        }
    }

    public class ChildActor : ReceiveActor {
        public class DoChildWork { }
        public class ChildCompleted { }

        public ChildActor() {
            Receive<DoChildWork>(w => {
                
                //simulate some work


                Context.Parent.Tell(new ChildCompleted());
            });
        }
    }

    public class TopLevelWork {}
    public class TopLevelWorkCompleted {}

   
}