C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Akka.Actor;
using Akka.Event;

public sealed class MyStopMessage{
	public static readonly MyStopMessage Instance = new MyStopMessage();
	private MyStopMessage(){}
}

public sealed class StartWork{
	public int WorkCount {get;}
	
	public StartWork(int workCount){
		WorkCount = workCount;
	}
}

public sealed class ActorA : ReceiveActor{
	private IActorRef _actorB;	
	
	private readonly ILoggingAdapter _log = Context.GetLogger();
	
	public ActorA(){
		Receive<StartWork>(w => {
			foreach(var i in Enumerable.Range(0, w.WorkCount)){
				_actorB.Tell(i);
			}
		});
		
		ReceiveAsync<MyStopMessage>(async _ => {
			_log.Info("Begin shutdown");
			
			// stop child actor B with the same custom message
			await _actorB.GracefulStop(TimeSpan.FromSeconds(10), _);
			
			// shut ourselves down after child is done
			Context.Stop(Self);
		});
	}
	
	protected override void PreStart(){
		_actorB = Context.ActorOf(Props.Create(() => new ActorB()), "b");
	}
}

public sealed class ActorB : ReceiveActor{
	private IActorRef _actorC;
	private IActorRef _actorD;
	
	private readonly ILoggingAdapter _log = Context.GetLogger();
	
	public ActorB(){
		Receive<int>(i => {
			_actorC.Tell(i);
			_actorD.Tell(i);
		});
		
		ReceiveAsync<MyStopMessage>(async _ => {
			
			_log.Info("Begin shutdown");
			
			// stop both actors in parallel
			var stopC = _actorC.GracefulStop(TimeSpan.FromSeconds(10));
			var stopD = _actorD.GracefulStop(TimeSpan.FromSeconds(10));
			
			// compose stop Tasks
			var bothStopped = Task.WhenAll(stopC, stopD);
			await bothStopped;
			
			// shut ourselves down immediately
			Context.Stop(Self);
		});
	}
	
	protected override void PreStart(){
		var workerProps = Props.Create(() => new WorkerActor());
		_actorC = Context.ActorOf(workerProps, "c");
		_actorD = Context.ActorOf(workerProps, "d");
	}
}

public sealed class WorkerActor : ReceiveActor {
	private readonly ILoggingAdapter _log = Context.GetLogger();
	
	public WorkerActor(){
		ReceiveAsync<int>(async i => {
			await Task.Delay(10);
			_log.Info("Received {0}", i);
		});
	}
}

public class Program
{
	public static async Task Main()
	{
		var actorSystem = ActorSystem.Create("test");
		
		var actorA = actorSystem.ActorOf(Props.Create(() => new ActorA()), "a");
		actorA.Tell(new StartWork(100));
		
		// equivalent to Tell + Context.Watch + Receive<Terminated>
		await actorA.GracefulStop(TimeSpan.FromSeconds(12), MyStopMessage.Instance);
	}
}

​x
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Akka.Actor;
using Akka.Event;
​
public sealed class MyStopMessage{
    public static readonly MyStopMessage Instance = new MyStopMessage();
    private MyStopMessage(){}
}
​
public sealed class StartWork{
    public int WorkCount {get;}
    
    public StartWork(int workCount){
        WorkCount = workCount;
    }
}
​
public sealed class ActorA : ReceiveActor{
    private IActorRef _actorB;  
    
    private readonly ILoggingAdapter _log = Context.GetLogger();
    
    public ActorA(){
        Receive<StartWork>(w => {
            foreach(var i in Enumerable.Range(0, w.WorkCount)){
                _actorB.Tell(i);
            }
        });
        
        ReceiveAsync<MyStopMessage>(async _ => {
            _log.Info("Begin shutdown");
            
            // stop child actor B with the same custom message
            await _actorB.GracefulStop(TimeSpan.FromSeconds(10), _);
            
            // shut ourselves down after child is done
            Context.Stop(Self);
        });
    }
    
    protected override void PreStart(){
        _actorB = Context.ActorOf(Props.Create(() => new ActorB()), "b");
    }
}
​
public sealed class ActorB : ReceiveActor{
    private IActorRef _actorC;
    private IActorRef _actorD;
    
    private readonly ILoggingAdapter _log = Context.GetLogger();
    
    public ActorB(){
        Receive<int>(i => {
            _actorC.Tell(i);
            _actorD.Tell(i);
        });
        
        ReceiveAsync<MyStopMessage>(async _ => {
            
            _log.Info("Begin shutdown");
            
            // stop both actors in parallel
            var stopC = _actorC.GracefulStop(TimeSpan.FromSeconds(10));
            var stopD = _actorD.GracefulStop(TimeSpan.FromSeconds(10));
            
            // compose stop Tasks
            var bothStopped = Task.WhenAll(stopC, stopD);
            await bothStopped;
            
            // shut ourselves down immediately
            Context.Stop(Self);
        });
    }
    
    protected override void PreStart(){
        var workerProps = Props.Create(() => new WorkerActor());
        _actorC = Context.ActorOf(workerProps, "c");
        _actorD = Context.ActorOf(workerProps, "d");
    }
}
​
public sealed class WorkerActor : ReceiveActor {
    private readonly ILoggingAdapter _log = Context.GetLogger();
    
    public WorkerActor(){
        ReceiveAsync<int>(async i => {
            await Task.Delay(10);
            _log.Info("Received {0}", i);
        });
    }
}
​
public class Program
{
    public static async Task Main()
    {
        var actorSystem = ActorSystem.Create("test");
        
        var actorA = actorSystem.ActorOf(Props.Create(() => new ActorA()), "a");
        actorA.Tell(new StartWork(100));
        
        // equivalent to Tell + Context.Watch + Receive<Terminated>
        await actorA.GracefulStop(TimeSpan.FromSeconds(12), MyStopMessage.Instance);
    }
}

  Angle--------------------------------------

    angle1 = 90 Degrees
    angle2 = 0.5 Revolutions
    angle1 + angle2 = 270 Degrees
    angle2 - angle1 = 90 Degrees
    angle1 * 2 = 180 Degrees
    angle1 / 2 = 45 Degrees
    angle1 > angle2 = False
    angle1 == angle2 = False
    angle1 * 2 == angle2 = True
    angle1 != angle2 = True

  Length--------------------------------------

    length1 = 1 Meters
    length2 = 2 Yards
    length1 + length2 = 3.94 Yards
    length2 - length1 = 0.06000000000000005 Yards
    length1 * 2 = 2 Meters
    length1 / 2 = 0.5 Meters
    length1 > length2 = False
    length1 == length2 = False
    length1 * 2 == length2 = False
    length1 != length2 = True

  Mass--------------------------------------

    mass1 = 1 Grams
    mass2 = 2 Kilograms
    mass1 + mass2 = 2001 Grams
    mass2 - mass1 = 1999 Grams
    mass1 * 2 = 2 Grams
    mass1 / 2 = 0.5 Grams
    mass1 > mass2 = False
    mass1 == mass2 = False
    mass1 * 2 == mass2 = False
    mass1 != mass2 = True

  Time--------------------------------------

    time1 = 1 Seconds
    time2 = 2 Minutes
    time1 + time2 = 121 Seconds
    time2 - time1 = 119 Seconds
    time1 * 2 = 2 Seconds
    time1 / 2 = 0.5 Seconds
    time1 > time2 = False
    time1 == time2 = False
    time1 * 2 == time2 = False
    time1 != time2 = True

  Area--------------------------------------

    area1 = 1 Meters*Meters
    area2 = 2 Yards*Yards
    area1 + area2 = 5.7636 Yards*Yards
    area2 - area1 = -1.7635999999999998 Yards*Yards
    area1 * 2 = 2 Meters*Meters
    area1 / 2 = 0.5 Meters*Meters
    area1 > area2 = True
    area1 == area2 = False
    area1 * 2 == area2 = False
    area1 != area2 = True

  Volume--------------------------------------

    volume1 = 1 Meters*Meters*Meters
    volume2 = 2 Yards*Yards*Yards
    volume1 + volume2 = 9.301383999999999 Yards*Yards*Yards
    volume2 - volume1 = -5.301384 Yards*Yards*Yards
    volume1 * 2 = 2 Meters*Meters*Meters
    volume1 / 2 = 0.5 Meters*Meters*Meters
    volume1 > volume2 = True
    volume1 == volume2 = False
    volume1 * 2 == volume2 = False
    volume1 != volume2 = True
    volume1 / length1 = 1 Meters*Meters

  Speed--------------------------------------

    speed1 = 1 Meters/Seconds
    speed2 = 2 Inches/Milliseconds
    speed1 + speed2 = 2.03937 Inches/Milliseconds
    speed2 - speed1 = 1.96063 Inches/Milliseconds
    speed1 * 2 = 2 Meters/Seconds
    speed1 / 2 = 0.5 Meters/Seconds
    speed1 > speed2 = False
    speed1 == speed2 = False
    speed1 * 2 == speed2 = False
    speed1 != speed2 = True
    speed1 * time2 = 120 Meters
    speed3 = 6 NauticalMiles/Hours
    speed1 + speed3 = 4.086666666666666 Meters/Seconds

  Acceleration--------------------------------------

    acceleration1 = 5 Meters/(Seconds*Seconds)
    acceleration2 = 4 Inches/(Milliseconds*Milliseconds)
    acceleration1 + acceleration2 = 4.00019685 Inches/(Milliseconds*Milliseconds)
    acceleration2 - acceleration1 = 3.99980315 Inches/(Milliseconds*Milliseconds)
    acceleration1 * 2 = 10 Meters/(Seconds*Seconds)
    acceleration1 / 2 = 2.5 Meters/(Seconds*Seconds)
    acceleration1 > acceleration2 = False
    acceleration1 == acceleration2 = False
    acceleration1 * 2 == acceleration2 = False
    acceleration1 != acceleration2 = True
    acceleration1 * time2 = 600 Meters/Seconds

  Force--------------------------------------

    force1 = 1 Kilograms*Meters/Seconds/Seconds
    force2 = 2 Kilograms*Meters/Seconds/Seconds
    force1 + force2 = 3 Kilograms*Meters/Seconds/Seconds
    force2 - force1 = 1 Kilograms*Meters/Seconds/Seconds
    force1 * 2 = 2 Kilograms*Meters/Seconds/Seconds
    force1 / 2 = 0.5 Kilograms*Meters/Seconds/Seconds
    force1 > force2 = False
    force1 == force2 = False
    force1 * 2 == force2 = True
    force1 != force2 = True

  ElectricCurrent--------------------------------------

    electricCurrent1 = 5 Coulombs/Seconds
    electricCurrent2 = 4 Coulombs/Seconds
    electricCurrent1 + electricCurrent2 = 9 Coulombs/Seconds
    acceleration2 - electricCurrent1 = -1 Coulombs/Seconds
    electricCurrent1 * 2 = 10 Coulombs/Seconds
    electricCurrent1 / 2 = 2.5 Coulombs/Seconds
    electricCurrent1 > electricCurrent2 = True
    electricCurrent1 == electricCurrent2 = False
    electricCurrent1 * 2 == electricCurrent2 = False
    electricCurrent1 != electricCurrent2 = True

  AngularSpeed--------------------------------------

    angularSpeed1 = 10 Radians/Seconds
    angularSpeed2 = 2200 Degrees/Milliseconds
    angularSpeed1 + angularSpeed2 = 2200.5729577951306 Degrees/Milliseconds
    angularSpeed2 - angularSpeed1 = 2199.4270422048694 Degrees/Milliseconds
    angularSpeed1 * 2 = 20 Radians/Seconds
    angularSpeed1 / 2 = 5 Radians/Seconds
    angularSpeed1 > angularSpeed2 = False
    angularSpeed1 == angularSpeed2 = False
    angularSpeed1 * 2 == angularSpeed2 = False
    angularSpeed1 != angularSpeed2 = True
    angularSpeed1 * time2 = 1200 Radians

  AngularAcceleration--------------------------------------

    angularAcceleration1 = 5000 Radians/(Seconds*Seconds)
    angularAcceleration2 = 0.4 Degrees/(Milliseconds*Milliseconds)
    angularAcceleration1 + angularAcceleration2 = 0.6864788975654117 Degrees/(Milliseconds*Milliseconds)
    angularAcceleration2 - angularAcceleration1 = 0.1135211024345884 Degrees/(Milliseconds*Milliseconds)
    angularAcceleration1 * 2 = 10000 Radians/(Seconds*Seconds)
    angularAcceleration1 / 2 = 2500 Radians/(Seconds*Seconds)
    angularAcceleration1 > angularAcceleration2 = False
    angularAcceleration1 == angularAcceleration2 = False
    angularAcceleration1 * 2 == angularAcceleration2 = False
    angularAcceleration1 != angularAcceleration2 = True
    angularAcceleration1 * time2 = 600000 Radians/Seconds

  Density--------------------------------------

    density1 = 5 Kilograms/Meters/Meters/Meters
    density2 = 2000 Grams/Meters/Meters/Meters
    density1 + density2 = 7000 Grams/Meters/Meters/Meters
    density2 - density1 = -3000 Grams/Meters/Meters/Meters
    density1 * 2 = 10 Kilograms/Meters/Meters/Meters
    density1 / 2 = 2.5 Kilograms/Meters/Meters/Meters
    density1 > density2 = True
    density1 == density2 = False
    density1 * 2 == density2 = False
    density1 != density2 = True

Cached Result
Last Run:	8:14:59 pm
Compile:	0.237s
Execute:	0.25s
Memory:	24.97Mb
CPU:	0.487s

View IL Code