一个更好一点的主线程与子线程之间通信的做法

  1 using System;
  2 using System.Threading;
  3 using System.Collections.Generic;
  4 
  5 namespace RemoteConsole
  6 {
  7     public delegate void RemoteConsoleMessageDelegate(object sender, RemoteConsoleMessageEventArgs e);
  8 
  9     public class TRemoteConsole
 10     {//我们定义了一系列的事件
 11         public event RemoteConsoleMessageDelegate ServerKeyCharEvent;
 12         public event RemoteConsoleMessageDelegate ServerShutdownEvent;
 13         public event RemoteConsoleMessageDelegate CloseClientEvent;
 14         public event RemoteConsoleMessageDelegate PauseClientEvent;
 15         public event RemoteConsoleMessageDelegate ListClientEvent;
 16 
 17         public List<TClientWaiter> clientGroup = new List<TClientWaiter>();
 18 
 19         public TClientWaiter AcceptNewClient()
 20         {
 21             //我们接受了一个client，并且把自身传递给过去，便于client引用
 22             TClientWaiter client = new TClientWaiter(this);
 23 
 24             //订阅了clientJoinEvent事件，注意这个事件是在TClientWaiter中定义的
 25             client.clientJoinEvent += ClientJoin;
 26 
 27             //我们用一个List包含了所有的client引用
 28             this.clientGroup.Add(client);
 29 
 30             Thread t = new Thread(new ThreadStart(client.connectionCreated));
 31             t.Name = String.Format("子线程{0}", clientGroup.Count);
 32             t.Start();
 33 
 34             return client;
 35         }
 36 
 37         //在上面，我们订阅了 clientJoinEvent 事件
 38         //所以一旦发生了 clientJoinEvent 事件，我们就能知道并且可以采取相应的行动
 39         public void ClientJoin(object sender, RemoteConsoleMessageEventArgs e)
 40         {
 41             Console.WriteLine("{0}进入", ((TClientWaiter)sender).currentThread.Name);
 42         }
 43 
 44         //以下几个都是触发事件的方法
 45         public void ServerKeyChar()
 46         {
 47             //注意，如果事件没有在任何一个地方被订阅的话，那么它等于null
 48             //触发一个等于null的事件会抛出异常，所以我们要先判断一下。
 49             if (this.ServerKeyCharEvent != null) {
 50                 this.ServerKeyCharEvent(this, new RemoteConsoleMessageEventArgs("Server key char event"));
 51             } else {
 52                 Console.WriteLine("警告:没有定义任何处理 ServerKeyCharEvent 事件的方法");
 53             }
 54         }
 55 
 56         public void Shutdown()
 57         {
 58             if (this.ServerShutdownEvent != null) {
 59                 this.ServerShutdownEvent(this, new RemoteConsoleMessageEventArgs("Server will shutdown after 10 minutes."));
 60             } else {
 61                 Console.WriteLine("警告:没有定义任何处理 ServerShutdownEvent 事件的方法");
 62             }
 63         }
 64 
 65         //这个是关闭所有client（子线程）的方法
 66         //我们可以通过迭代clientGroup这个List对象来取得所有client的引用来做
 67         //也可以利用事件机制向所有client线程发送消息来做到
 68         public void CloseCient()
 69         {
 70             if (this.CloseClientEvent != null) {
 71                 this.CloseClientEvent(this, new RemoteConsoleMessageEventArgs("Close client connection."));
 72             } else {
 73                 Console.WriteLine("警告:没有定义任何处理 CloseClientEvent 事件的方法");
 74             }
 75         }
 76 
 77         public void PauseClient()
 78         {
 79             if (this.PauseClientEvent != null) {
 80                 this.PauseClientEvent(this, new RemoteConsoleMessageEventArgs("Pause client thread."));
 81             } else {
 82                 Console.WriteLine("警告:没有定义任何处理 PauseClientEvent 事件的方法");
 83             }
 84         }
 85 
 86         public void ListClient()
 87         {
 88             if (this.ListClientEvent != null) {
 89                 this.ListClientEvent(this, new RemoteConsoleMessageEventArgs("List client status."));
 90             } else {
 91                 Console.WriteLine("警告:没有定义任何处理 ListClientEvent 事件的方法");
 92             }
 93         }
 94 
 95         private static void Main()
 96         {
 97             TRemoteConsole RServer = new TRemoteConsole();
 98 
 99             //新进来了两个client
             TClientWaiter c1 = RServer.AcceptNewClient();
             TClientWaiter c2 = RServer.AcceptNewClient();
 
             while(true)
             {
                 ConsoleKeyInfo k = Console.ReadKey(true);
 
                 //我们按下了键盘，触发了 ServerKeyCharEvent 事件
                 RServer.ServerKeyChar();
 
                 if (k.KeyChar == 'k') {
                     //按下k，触发了 CloseCientEvent
                     RServer.CloseCient();
                 }
                 if (k.KeyChar == ' ') {
                     //按下空格，触发了 PauseClientEvent 事件
                     RServer.PauseClient();
                 }
                 if (k.KeyChar == 'l') {
                     //按下l，触发了 ListClientEvent 事件
                     RServer.ListClient();
                 }
                 if (k.KeyChar == 'x') {
                     //按下x，触发了 ServerShutdownEvent 事件
                     RServer.Shutdown();
                     break;
                 }
             }
         }
 
         private void onClientJoin(object sender, RemoteConsoleMessageEventArgs e)
         {
             Console.WriteLine("创建时间:{0}, 消息:{1}", ((TClientWaiter)sender).JoinDateTime, e.MessageText);
         }
     }
 
     public class TClientWaiter
     {
         public DateTime JoinDateTime;
         public bool running = true;
 
         //我们在client中也声明了一个事件（当然可以更多）
         public RemoteConsoleMessageDelegate clientJoinEvent;
 
         public Thread currentThread;
 
         public TClientWaiter()
         {
             JoinDateTime = DateTime.Now;
         }
 
         public TClientWaiter(TRemoteConsole server)
         {
             JoinDateTime = DateTime.Now;
 
             //在这里我们订阅了一系列的事件
             //所以上面的Server对象一旦有任何风吹草动，client都能知道
             server.ServerKeyCharEvent += this.onServerKeyChar;
             server.ServerShutdownEvent += this.onServerShutdown;
             server.CloseClientEvent += this.onCloseClient;
             server.PauseClientEvent += this.onPauseClient;
             server.ListClientEvent += this.onListClient;
         }
 
         //订阅了 ServerShutdown 事件，如果服务器要shutdown的话，我们有必要采取一些措施
         public void onServerShutdown(object sender, RemoteConsoleMessageEventArgs e)
         {
             Console.WriteLine("Server will shutdown");
         }
 
         //在上面说了，我们可以在Server端迭代List对象来关闭所有子线程
         //也可以通过事件机制来达到目的
         public void onCloseClient(object sender, RemoteConsoleMessageEventArgs e)
         {
             //这里我们就用事件来达到目的
             //一旦接收到 CloseClientEvent 事件(这是Server端发出的事件)，所有的client线程退出
             try {
                 currentThread.Abort();
             } catch {}
             Console.WriteLine("{0}已退出，目前状态:{1}", currentThread.Name, currentThread.IsAlive);
         }
 
         public void onPauseClient(object sender, RemoteConsoleMessageEventArgs e)
         {
             this.running = !this.running;
             Console.WriteLine(this.running ? "继续" : "暂停");
         }
 
         public void onListClient(object sender, RemoteConsoleMessageEventArgs e)
         {
             Console.WriteLine("{0}状态:{1}", currentThread.Name, currentThread.IsAlive);
         }
 
         public void onServerKeyChar(object sender, RemoteConsoleMessageEventArgs e)
         {
             Console.WriteLine("从主程序传递过来的消息：{0}", e.MessageText);
         }
 
         public void connectionCreated()
         {
             currentThread = Thread.CurrentThread;
             
             //在这里我们触发了 clientJoinEvent 事件，在上面的 TRemoteConsole 对象中马上就能知道
             //依然要注意判断事件是否等于null
             if (this.clientJoinEvent != null) {
                 this.clientJoinEvent(this, new RemoteConsoleMessageEventArgs("新的连接已建立"));
             } else {
                 Console.WriteLine("警告:没有定义任何处理 clientJoinEvent 事件的方法");
             }
             while(true)
             {
                 if (this.running)
                 {
                     Thread.Sleep(1000);
                     Console.WriteLine("{0}->{1}", currentThread.Name, DateTime.Now);
                 }
             }
         }
     }
 
     //自定义事件参数
     public class RemoteConsoleMessageEventArgs : EventArgs
     {
         private string message;
 
         public string MessageText
         {
             get {return message;}
         }
 
         public RemoteConsoleMessageEventArgs(string _msg)
         {
             message = _msg;
         }
     }
 }