Page History

    public class PrintMyActorRefActor extends ActorMyActor : ReceiveActor
    {
    override    defprivate receive:ILoggingAdapter Receivelog = Context.GetLogger();

        public MyActor()
        {
      case "printit"      Receive<string>(message => {
      val secondRef = context.actorOf(Props.empty, "second-actor") //자식의 생성에 대한 책임은 부모가 가진다. ( 생성하고 자식노드로 런타임 이동하는 형태의 방법 제한)  
          if (message == "createChild")
                {
                    Context.ActorOf<MyActor>("myChild");
                    printlnSender.Tell(s"Second: $secondRefCreate Child Succed:myChild");
          }
}

val firstRef = system.actorOf(Props[PrintMyActorRefActor], "first-actor")  // actorOf 는 Actor생성시 사용됩니다.
println(s"First : $firstRef")
firstRef ! "printit"   
// !는 스칼라에서 Input을 위한 키워드이며, c++의 cout >> 과 유사한 키워드 , 
//C#또는 JAVA에서는 명시적으로 firstRef.Tell("printit") 이렇게 사용하면 됩니다.


//액터 생성 순서   first-actor <= second-actor  가 parent <= child 관계가 된다.
First : Actor[akka://testSystem/user/first-actor#1053618476]
Second: Actor[akka://testSystem/user/first-actor/second-actor#-1544706041]

      }
                else
                {
                    Sender.Tell("RE:" + message);
                }
            });

            Receive<SomeMessage>(message => {
                Sender.Tell("RE:" + message.message);
            });
        }

    }


	IActorRef myActor = actorSystem.ActorOf<MyActor>("myactor");
	myActor.tell("createChild");


	

    public class StartStopActor1 extends Actor {
  override def preStart(): Unit =: ReceiveActor
    {
        private ILoggingAdapter log = Context.GetLogger();

        public StartStopActor1()
        {
            Receive<string>(message => {
                if (message == "stop")
                {
                    Context.Stop(Self);
                }                
            });            
        }

        protected override void PreStart()
        {
    println        log.Info("first started");
    context.actorOf(Props[StartStopActor2],         Context.ActorOf<StartStopActor2>("second");
        }

        protected override defvoid postStopPostStop(): Unit = println
        {
            log.Info("first stopped");
        }

    }

    public overrideclass defStartStopActor2 receive: ReceiveReceiveActor
   = {
    case "stop"    private ILoggingAdapter log => context.stop(self)
  }
}

class StartStopActor2 extends Actor {
  override def preStart(): Unit = printlnContext.GetLogger();

        public StartStopActor2()
        {
            Receive<string>(message => {                
            });            
        }

        protected override void PreStart()
        {
            log.Info("second started");

  override def postStop(): Unit = println("second stopped") }

  // Actor.emptyBehavior is a useful placeholder when we don't
  // want to handle any messages in the actor.
  override def receive: Receive = Actor.emptyBehavior
}

val first = system.actorOf(Props[StartStopActor1], "first")
first ! "stop"


      protected override void PostStop()
        {
            log.Info("second stopped");
        }

    }


	IActorRef myActor = actorSystem.ActorOf<StartStopActor1 >("myactor");
	myActor.Tell("stop");

//OutPut
//first started
//second started
//second stopped
//first stopped

var supervisor = BackoffSupervisor.Props(
                    Backoff.OnFailure(
                        childProps,
                        childName: "supervised-actor",
                        minBackoff: TimeSpan.FromSeconds(3),
                        maxBackoff: TimeSpan.FromSeconds(30),
                        randomFactor: 0.2)
                    );