using System;

using Akka.Actor;

using Akka.Configuration;

using Akka.Pattern;

public class Program

{

    public static void Main()

    {

        var akkaConfig = Akka.Configuration.ConfigurationFactory.Default();

        using (ActorSystem system = ActorSystem.Create("TestSystem", akkaConfig))

        {

            var childProps = Props.Create<ChildActor>();

            var supervisor = BackoffSupervisor.Props(

                                Backoff.OnStop(

                                    childProps,

                                    childName: "myChild",

                                    minBackoff: TimeSpan.FromSeconds(3),

                                    maxBackoff: TimeSpan.FromSeconds(30),

                                    randomFactor: 0.2,

                                    maxNrOfRetries: 2)).WithSupervisorStrategy(

                                        new OneForOneStrategy(

                                            maxNrOfRetries: 2,

                                            withinTimeRange: TimeSpan.FromSeconds(30),

                                            ex =>

                                            {

                                                Console.WriteLine($"{DateTime.Now} - Deciding strategy");

                                                if (ex is UnauthorizedAccessException)

                                                {

                                                    return Directive.Stop;

                                                }

                                                else if (ex is InvalidOperationException)

                                                {

                                                    return Directive.Restart;

                                                }

                                                return OneForOneStrategy.DefaultDecider.Decide(ex);

                                            }

                                            )

                                    );

            var actor = system.ActorOf(supervisor, "childSupervisor");

            actor.Tell(new DoSomethingBad());

        }

    }

}

​

​

​

class ChildActor : ReceiveActor

{

​

        protected override void PreRestart(Exception reason, object message)

        {

            Console.WriteLine($"{DateTime.Now} - Restarting");

            // put message back in mailbox for re-processing after restart

            Self.Tell(message);

        }

​

    public ChildActor()

    {

        this.Receive<DoSomethingBad>(m => {

            Console.WriteLine($"{DateTime.Now} - Trying to do something really dangerous");

            throw new InvalidOperationException();

        });

    }

}

​

class DoSomethingBad {

}