《通过C#学Proto.Actor模型》之Behaviors

behaviors就是actor接收到消息后可以改变处理的方法，相同的actor，每次调用，转到不同的actor内方法执行，非常适合按流程进行的场景。behaviors就通过在actor内部实例化一个behavior对象，然后通过这个对象的become来切换执行的方法的。

 码友看码：

 1 using proto;
 2 using system;
 3 using system.threading.tasks;
 4 
 5 namespace p007_behaviors
 6 {
 7     class program
 8     {
 9         static void main(string[] args)
10         {
11             var props = actor.fromproducer(() => new lightbulb());
12             var pid = actor.spawn(props);
13             while (true)
14             {
15                 console.writeline("----------------------------");
16                 console.writeline("按开关");
17                 console.readline();
18                 var message = pid.requestasync<string>(new pressswitch()).result;
19                 console.writeline(message);
20 
21                 message = pid.requestasync<string>(new touch()).result;
22                 console.writeline(message);
23             }
24         }
25     }
26 
27     public class lightbulb : iactor
28     {
29         private readonly behavior _behavior;
30 
31         public lightbulb()
32         {
33             _behavior = new behavior();
34             //把off方法放入栈
35             _behavior.becomestacked(off);
36         }
37         public task receiveasync(icontext context)
38         {
39             //切换到behavior指定的方法,来充当receiveasync
40             return _behavior.receiveasync(context);
41         }
42         /// <summary>
43         /// 关
44         /// </summary>
45         /// <param name="context"></param>
46         /// <returns></returns>
47         private task off(icontext context)
48         {
49             switch (context.message)
50             {
51                 case pressswitch _:
52                     context.respond("打开");
53                     _behavior.become(on);
54                     break;
55                 case touch _:
56                     context.respond("凉的");
57                     break;
58             }
59             return actor.done;
60         }
61         /// <summary>
62         /// 开
63         /// </summary>
64         /// <param name="context"></param>
65         /// <returns></returns>
66         private task on(icontext context)
67         {
68             switch (context.message)
69             {
70                 case pressswitch _:
71                     context.respond("关闭");
72                     _behavior.become(off);
73                     break;
74                 case touch _:
75                     context.respond("烫手");
76                     break;
77             }
78             return actor.done;
79         }
80     }
81     class pressswitch
82     { }
83     class touch
84     { }
85 
86 }

几个要点，在actor构造中把off放入方法栈，在receive中调用behavior的receive，同时可以按自己业务逻辑切换方法，这样在一定程度上增加了actor的灵活性，让一个actor可以按设定流程实现不同行为。

behavior提供了三个切换方法相关的方法：

• become只需将传递的receive方法设置为当前方法，替换默认方法。
• becomestacked将传递的receive方法推送到方法堆栈，但保留以前的方法。
• unbecomestacked 恢复到以前使用的方法。

看结果：