WCF 聊天室程序代码详细讲解教程

解决方案

ChatService 服务端主要的三个文件：App.config，ChatService.cs，Program.cs

FormChatClient 客户端主要二个文件：App.config，ChatForm.cs

以下为这五个文件的全部代码及讲解，因为打算放在一篇文章里，所以本文会很长。发由本教程目的并不仅仅让初学者了解怎么开发一个聊天室。而是要通过这个例子

加深对C#及WCF一些实用特性的了解。

1 Service App.config

1. <xml version="1.0" encoding="utf-8" >
2. <configuration>
3.   <appSettings>
4.     <!--提供服务的通信协议、地址、端口、目录-->
5.     <!--通信协议：net.tcp 、http 、-->
6.     <add key="addr" value="net.tcp://localhost:22222/chatservice" />
7.   </appSettings>
8.   <system.serviceModel>
9.     <services>
10.       <!--服务名 = <命名空间>.<程序集名称>-->
11.       <!--behaviorConfiguration 性能配置自定一个名称，<serviceBehaviors> 下的项对应此名称-->
12.       <service name="NikeSoftChat.ChatService" behaviorConfiguration="MyBehavior">
14.         <!--终节点-->
15.         <!--binding 绑定类型,NetTcpBinding、WSDualHttpBinding、WSHttpBindingBase、BasicHttpBinding、NetNamedPipeBinding、NetPeerTcpBinding、MsmqBindingBase、NetPeerTcpBinding、WebHttpBinding、MailBindingBase、CustomBinding-->
16.         <!--DuplexBinding 双工-->
17.         <!--使用契约：<命名空间>.<接口名称>-->
18.         <endpoint address=""
19.                   binding="netTcpBinding"
20.                   bindingConfiguration="DuplexBinding"
21.                   contract="NikeSoftChat.IChat" />
22.       </service>
23.     </services>
25.     <behaviors>
26.       <serviceBehaviors>
27.         <behavior  name="MyBehavior">
28.           <!--会话最大数量-->
29.           <serviceThrottling maxConcurrentSessions="10000" />
30.         </behavior>
31.       </serviceBehaviors>
32.     </behaviors>
34.     <bindings>
35.       <netTcpBinding>
36.         <!--双工，超时设置-->
37.         <binding name="DuplexBinding" sendTimeout="00:00:01">
38.           <!--可靠会话-->
39.           <reliableSession enabled="true" />
40.           <!--安全模式-->
41.           <security mode="None" />
42.         </binding>
43.       </netTcpBinding>
44.     </bindings>
45.   </system.serviceModel>
46. </configuration>

复制代码

2 Service ChatService.cs

1. // Copyright (C) 2006 by Nikola Paljetak
3. using System;
4. using System.Collections;
5. using System.Collections.Generic;
6. using System.ServiceModel;
8. namespace NikeSoftChat
9. {
10.     //服务契约
11.     // SessionMode.Required  允许Session会话
12.     // 双工协定时的回调协定类型为IChatCallback接口）
13.     [ServiceContract(SessionMode = SessionMode.Required, CallbackContract = typeof(IChatCallback))]
14.     interface IChat
15.     {
16.         //服务操作
17.         // IsOneWay = false      等待服务器完成对方法处理
18.         // IsInitiating = true  启动Session会话
19.         // IsTerminating = false 设置服务器发送回复后不关闭会话
20.         [OperationContract(IsOneWay = false, IsInitiating = true, IsTerminating = false)]
21.         string[] Join(string name);
23.         [OperationContract(IsOneWay = true, IsInitiating = false, IsTerminating = false)]
24.         void Say(string msg);
26.         [OperationContract(IsOneWay = true, IsInitiating = false, IsTerminating = false)]
27.         void Whisper(string to, string msg);
29.         //服务操作
30.         // IsOneWay = true      不等待服务器完成对方法处理
31.         // IsInitiating = false  不启动Session会话
32.         // IsTerminating = true  关闭会话，在服务器发送回复后
33.         [OperationContract(IsOneWay = true, IsInitiating = false, IsTerminating = true)]
34.         void Leave();
35.     }
37.     interface IChatCallback
38.     {
39.         [OperationContract(IsOneWay = true)]
40.         void Receive(string senderName, string message);
42.         [OperationContract(IsOneWay = true)]
43.         void ReceiveWhisper(string senderName, string message);
45.         [OperationContract(IsOneWay = true)]
46.         void UserEnter(string name);
48.         [OperationContract(IsOneWay = true)]
49.         void UserLeave(string name);
50.     }
52.     //定义一个客户端动作的枚举
53.     public enum MessageType { Receive, UserEnter, UserLeave, ReceiveWhisper };
55.     //定义一个本例的事件消息类
56.     public class ChatEventArgs : EventArgs
57.     {
58.         public MessageType msgType;
59.         public string name;
60.         public string message;
61.     }
64.     // InstanceContextMode.PerSession 服务器为每个客户会话创建一个新的上下文对象
65.     // ConcurrencyMode.Multiple      异步的多线程实例
66.     [ServiceBehavior(InstanceContextMode = InstanceContextMode.PerSession, ConcurrencyMode = ConcurrencyMode.Multiple)]
67.     public class ChatService : IChat //继承IChat接口或者说IChat的实现类
68.     {
69.         //定义一个静态对象用于线程部份代码块的锁定，用于lock操作
70.         private static Object syncObj = new Object();
72.         //创建一个IChatCallback 回调接口实例,接口成员始终是公共的，所有没有访问修饰符
73.         IChatCallback callback = null;
75.         //定义一个委托
76.         public delegate void ChatEventHandler(object sender, ChatEventArgs e);
77.         //定义一个静态的委托事件
78.         public static event ChatEventHandler ChatEvent;
80.         //创建一个静态Dictionary（表示键和值）集合(字典)，用于记录在线成员，Dictionary<(Of <(TKey, TValue>)>) 泛型类
81.         static Dictionary<string, ChatEventHandler> chatters = new Dictionary<string, ChatEventHandler>();
83.         //当用客户的昵称
84.         private string name;
85.         //创建委托（ChatEventHandler）的一个空实例
86.         private ChatEventHandler myEventHandler = null;
88.         //成员进入聊天室
89.         public string[] Join(string name)
90.         {
91.             bool userAdded = false;
92.             //用MyEventHandler方法，实例化委托（ChatEventHandler）
93.             myEventHandler = new ChatEventHandler(MyEventHandler);
95.             //锁定，保持lock块中的代码段始终只有一个线程在调用，原因是ConcurrencyMode.Multiple 为异步的多线程实例，存在并发竞争问题
96.             //如果不锁定，则静态成员字典chatters.ContainsKey(name) 的结果将会不确定，原因是每个线程都可以访问到它。以下凡是chatters 的操作匀加锁
97.             //使用lock多个线程同时请示时，没有操作权的将会在线程池中等待至有操作权的线程执完成。lock 方法存在影响吞吐量的问题
98.             lock (syncObj)
99.             {
100.                 //如果请求的昵称在成员字典中不存在并不空
101.                 if (!chatters.ContainsKey(name) && name != "" && name != null)
102.                 {
103.                     this.name = name; //记录当前线程昵称
104.                     chatters.Add(name, MyEventHandler);//加入到成员字典key 为当前昵称，MyEventHandler 当前的委托调用
105.                     userAdded = true;
106.                 }
107.             }
109.             if (userAdded)
110.             {
111.                 //获取当前操作客户端实例的通道给IChatCallback接口的实例callback,
112.                 //此通道是一个定义为IChatCallback类型的泛类型
113.                 //通道的类型是事先服务契约协定好的双工机制（见IChat前的ServiceContract）
114.                 callback = OperationContext.Current.GetCallbackChannel<IChatCallback>();
116.                 //实例化事件消息类ChatEventArgs，并对其赋值
117.                 ChatEventArgs e = new ChatEventArgs();
118.                 e.msgType = MessageType.UserEnter;
119.                 e.name = name;
121.                 //发送广播信息
122.                 BroadcastMessage(e);
123.                 //加入到多路广播委托的调用列表中,下面这条如果和上面一条位置互换，那么会收到自己进入聊天室的广播信息。
124.                 ChatEvent += myEventHandler;
126.                 //以下代码返回当前进入聊天室成员的称列表
127.                 string[] list = new string[chatters.Count];
128.                 lock (syncObj)
129.                 {
130.                     chatters.Keys.CopyTo(list, 0);//从成员字典索引0 开始复制chatters成员字典的key 值到list 字符串数组
131.                 }
132.                 return list;
133.             }
134.             else
135.             {
136.                 //当昵称重复或为空是，如果客户端做了为空检测，则可直接认为是名称重复，当前要在没有异常的情况下。
137.                 return null;
138.             }
139.         }
141.         //聊天室通信
142.         public void Say(string msg)
143.         {
144.             ChatEventArgs e = new ChatEventArgs();
145.             e.msgType = MessageType.Receive;
146.             e.name = this.name;
147.             e.message = msg;
148.             BroadcastMessage(e);
149.         }
151.         //私有对话
152.         public void Whisper(string to, string msg)
153.         {
154.             ChatEventArgs e = new ChatEventArgs();
155.             e.msgType = MessageType.ReceiveWhisper;
156.             e.name = this.name;
157.             e.message = msg;
158.             try
159.             {
160.                 //创建一个临时委托实例
161.                 ChatEventHandler chatterTo;
162.                 lock (syncObj)
163.                 {
164.                     //查找成员字典中，找到要接收者的委托调用
165.                     chatterTo = chatters[to];
166.                 }
167.                 //异步方式调用接收者的委托调用
168.                 chatterTo.BeginInvoke(this, e, new AsyncCallback(EndAsync), null);
169.             }
170.             catch (KeyNotFoundException)
171.             {
172.                 //访问集合中元素的键与集合中的任何键都不匹配时所引发的异常
173.             }
174.         }
176.         //成员离开聊天室
177.         public void Leave()
178.         {
179.             if (this.name == null)
180.                 return;
182.             //删除成员字典中的当前会话的成员，及删除多路广播委托的调用列表中的当前调用
183.             //name 和myEventHandler 的生存周期是在当前会话中一直存在的，参考Session 周期
184.             lock (syncObj)
185.             {
186.                 chatters.Remove(this.name);
187.             }
188.             ChatEvent -= myEventHandler;
189.             ChatEventArgs e = new ChatEventArgs();
190.             e.msgType = MessageType.UserLeave;
191.             e.name = this.name;
192.             this.name = null;
193.             BroadcastMessage(e);
194.         }
196.         //回调
197.         //根据客户端动作通知对应客户端执行对应的操作
198.         private void MyEventHandler(object sender, ChatEventArgs e)
199.         {
200.             try
201.             {
202.                 switch (e.msgType)
203.                 {
204.                     case MessageType.Receive:
205.                         callback.Receive(e.name, e.message);
206.                         break;
207.                     case MessageType.ReceiveWhisper:
208.                         callback.ReceiveWhisper(e.name, e.message);
209.                         break;
210.                     case MessageType.UserEnter:
211.                         callback.UserEnter(e.name);
212.                         break;
213.                     case MessageType.UserLeave:
214.                         callback.UserLeave(e.name);
215.                         break;
216.                 }
217.             }
218.             catch //异常退出，或超时，或session过期
219.             {
220.                 Leave();
221.             }
222.         }
224.         //发送广播信息
225.         //要点：根据上下文理解: 1 广播什么(what),2 为谁广播(who),3“谁”从哪来(where),4 如何来的(how)
226.         private void BroadcastMessage(ChatEventArgs e)
227.         {
228.             //创建回调委托事件实例ChatEvent的一个副本，之所以用副本是因为ChatEvent处于多线程并状态(？此处不知理解是否正确,因为我理解后面的handler 是一个引用，自相矛盾了)
229.             ChatEventHandler temp = ChatEvent;
231.             if (temp != null)
232.             {
233.                 //GetInvocationList方法，按照调用顺序返回“多路广播委托(MulticastDelegate)”的调用列表
234.                 foreach (ChatEventHandler handler in temp.GetInvocationList())
235.                 {
236.                     //异步方式调用多路广播委托的调用列表中的ChatEventHandler
237.                     //BeginInvoke方法异步调用，即不等等执行，详细说明则是：公共语言运行库(CLR) 将对请求进行排队并立即返回到调用方。将对来自线程池的线程调用该目标方法。
238.                     //EndAsync 为线程异步调用完成的回调方法，EndAsync 接收并操持着线程异步调用的操作状态,可通过此结果找到调用者，如此例handler，handler是一个委托实例的引用
239.                     //        此状态为调用者（委托）的事件声明类型此例为public event ChatEventHandler ChatEvent; 中的ChatEventHandler
240.                     //最后一个参数:包含的对象的状态信息，传递给委托;
241.                     handler.BeginInvoke(this, e,EndAsync, null);
242.                 }
243.             }
244.         }
246.         //广播中线程调用完成的回调方法
247.         //功能：清除异常多路广播委托的调用列表中异常对象（空对象）
248.         private void EndAsync(IAsyncResult ar)
249.         {
250.             ChatEventHandler d = null;
252.             try
253.             {
254.                 //封装异步委托上的异步操作结果
255.                 System.Runtime.Remoting.Messaging.AsyncResult asres = (System.Runtime.Remoting.Messaging.AsyncResult)ar;
257.                 //asres.AsyncDelegate 获取在异步调用asres 的委托对象，asres 来自对ar 的AsyncResult 封装，ar 来自线程异步调用的操作状态
258.                 d = ((ChatEventHandler)asres.AsyncDelegate);
260.                 //EndInvoke 返回由异步操作ar 生成的结果Object
261.                 d.EndInvoke(ar);
262.             }
263.             catch
264.             {
265.                 ChatEvent -= d;
266.             }
267.         }
269.     }
270. }

3 Service Program.cs

1. // Copyright (C) 2006 by Nikola Paljetak
3. using System;
4. using System.Collections.Generic;
5. using System.Text;
6. using System.ServiceModel;
7. using System.Configuration;
9. namespace NikeSoftChat
10. {
11.     class Program
12.     {
13.         static void Main(string[] args)
14.         {
16.             Uri uri = new Uri(ConfigurationManager.AppSettings["addr"]);//获取配置
17.             ServiceHost host = new ServiceHost(typeof(NikeSoftChat.ChatService), uri);
18.             host.Open();
19.             Console.WriteLine("Chat service listen on endpoint {0}", uri.ToString());
20.             Console.WriteLine("Press ENTER to stop chat service...");
21.             Console.ReadLine();
22.             host.Abort();
23.             host.Close();
25.         }
27.      
28.     }
29. }

复制代码

4 Client  App.config

1. <xml version="1.0" encoding="utf-8">
2. <!--这里的说明可以完全参考 service 的 app.config -->
3. <configuration>
4.   <system.serviceModel>
5.     <client>
6.       <endpoint name=""
7.                 address="net.tcp://localhost:22222/chatservice"
8.                 binding="netTcpBinding"
9.                 bindingConfiguration="DuplexBinding"
10.                 contract="IChat" />
11.     </client>
12.     <bindings>
13.       <netTcpBinding>
14.         <!--这里的sendTimeout比服务端的要多出4秒，因为服务端不参入具体通信，它只是提供服务-->
15.         <binding name="DuplexBinding" sendTimeout="00:00:05" >
16.           <reliableSession enabled="true" />
17.           <security mode="None" />
18.         </binding>
19.       </netTcpBinding>
20.     </bindings>
21.   </system.serviceModel>
22. </configuration>

复制代码

5 Client ChatForm.cs

1. // Copyright (C) 2006 by Nikola Paljetak
3. using System;
4. using System.Collections.Generic;
5. using System.ComponentModel;
6. using System.Data;
7. using System.Drawing;
8. using System.Text;
9. using System.Windows.Forms;
10. using System.Runtime.InteropServices;
11. using System.ServiceModel;
14. namespace NikeSoftChat
15. {
16.     public partial class ChatForm : Form, IChatCallback
17.     {
18.         [DllImport("user32.dll")]
19.         private static extern int SendMessage(IntPtr hWnd, int msg, int wParam, IntPtr lParam);
20.         private const int WM_VSCROLL = 0x115;
21.         private const int SB_BOTTOM = 7;
23.         private int lastSelectedIndex = -1;
25.         private ChatProxy proxy;//代理
26.         private string myNick;  //当前我的昵称
28.         private PleaseWaitDialog pwDlg; //状态窗口（显示等待与错误提示）
29.         private delegate void HandleDelegate(string[] list);//委托
30.         private delegate void HandleErrorDelegate();//委托
32.         public ChatForm()
33.         {
34.             InitializeComponent();
35.             ShowConnectMenuItem(true);
36.         }
38.         private void connectToolStripMenuItem_Click(object sender, EventArgs e)
39.         {
40.             lstChatters.Items.Clear();
41.             NickDialog nickDlg = new NickDialog();
42.             if (nickDlg.ShowDialog() == DialogResult.OK)
43.             {
44.                 myNick = nickDlg.txtNick.Text;// 得到键入的当前昵称
45.                 nickDlg.Close();
46.             }
48.             txtMessage.Focus();
49.             Application.DoEvents(); //强制处理当前队列的所有windows 消息，以名影响后面的通信，winForm程序要注意一下UI 线程的问题
50.             //获取服务实例的上下文，为指定主机承载的服务初始化
51.             InstanceContext site = new InstanceContext(this);
52.             proxy = new ChatProxy(site); //初始服务实例
54.             //BeginJoin 是svcutil工具自动生成的(如果你用工具的话，当然你也可以自己写)，还有一个EndJoin 也是。
55.             //为什么会生成这两个我们并没有在服务契约中定义的接口呢？原因是服务契约中Join 接口定义了IsOneWay = false
56.             //IsOneWay = false 则我们在配置中绑定的是duplex 双工(双通道)，指操作返回应答信息。
57.             //duplex 双工并不会等待调用服务方法完成，而是立即返回。单工方式则为Request/Reply 本例中没有涉及
58.             //自动生成BeginJoin 会比我们的Join 多两个参数，一个用来当BeginJoin请求在服务方完成后本地回调的方法，另一个获取作为BeginInvoke 方法调用的最后一个参数而提供的对象。
59.             //BeginJoin 会请求服务方执行Join 方法。当Join代码执行完毕，触发回调方法OnEndJoin
60.             IAsyncResult iar = proxy.BeginJoin(myNick, new AsyncCallback(OnEndJoin),null);
61.             pwDlg = new PleaseWaitDialog();
62.             pwDlg.ShowDialog();
64.         }
66.         private void OnEndJoin(IAsyncResult iar)
67.         {
68.             try
69.             {
70.                 //EndJoin 请求服务方返回Join 执行后的返回值
71.                 //iar 异步调用的操作状态
72.                 //返回聊天室当前在线成员列表
73.                 string[] list = proxy.EndJoin(iar);
74.                 HandleEndJoin(list);
76.             }
77.             catch (Exception e)
78.             {
79.                 HandleEndJoinError();
80.             }
82.         }
84.         private void HandleEndJoinError()
85.         {
86.             //判断状态提示窗口是否在同一个线程内
87.             if (pwDlg.InvokeRequired)
88.                 //对当前线程调用目标方法,此例调用本身
89.                 pwDlg.Invoke(new HandleErrorDelegate(HandleEndJoinError));
90.             else
91.             {
92.                 pwDlg.ShowError("Error: Cannot connect to chat!");
93.                 ExitChatSession();
94.             }
95.         }
98.         //生成在线成员列表，当参数list为空时则表示当前昵称在在线成员列表中已存在
99.         private void HandleEndJoin(string[] list)
100.         {
101.             //状态提示窗口是否运行在同一个线程
102.             if (pwDlg.InvokeRequired)
103.                 pwDlg.Invoke(new HandleDelegate(HandleEndJoin), new object[] { list });
104.             else
105.             {
107.                 if (list == null)
108.                 {
109.                     pwDlg.ShowError("Error: Username already exist!");
110.                     ExitChatSession();
111.                 }
112.                 else
113.                 {
114.                     pwDlg.Close();
115.                     ShowConnectMenuItem(false);
116.                     foreach (string name in list)
117.                     {
118.                         lstChatters.Items.Add(name);
119.                     }
120.                     AppendText("Connected at " + DateTime.Now.ToString() + " with user name " + myNick + Environment.NewLine);
121.                 }
122.             }
123.         }
124.         //发送信息
125.         private void SayAndClear(string to, string msg, bool pvt)
126.         {
127.             if (msg != "")
128.             {
129.                 try
130.                 {
131.                     CommunicationState cs = proxy.State;
132.                     //pvt 公聊还是私聊
133.                     if (!pvt)
134.                         proxy.Say(msg); //发送信息
135.                     else
136.                         proxy.Whisper(to, msg);//对指定者发送信息
138.                     txtMessage.Text = "";
139.                 }
140.                 catch
141.                 {
142.                     AbortProxyAndUpdateUI();
143.                     AppendText("Disconnected at " + DateTime.Now.ToString() + Environment.NewLine);
144.                     Error("Error: Connection to chat server lost!");
145.                 }
146.             }
147.         }
150.         private void Error(string errMessage)
151.         {
152.             MessageBox.Show(errMessage, "Connection error", MessageBoxButtons.OK, MessageBoxIcon.Error);
153.             ExitChatSession();
154.         }
156.         private void btnSay_Click(object sender, EventArgs e)
157.         {
158.             SayAndClear("", txtMessage.Text, false);
159.             txtMessage.Focus();
160.         }
162.         private void btnWhisper_Click(object sender, EventArgs e)
163.         {
164.             if (txtMessage.Text == "")
165.                 return;
167.             object to = lstChatters.SelectedItem;
168.             if (to != null)
169.             {
170.                 string receiverName = (string)to;
171.                 AppendText("Whisper to " + receiverName + ": " + txtMessage.Text + Environment.NewLine);
172.                 SayAndClear(receiverName, txtMessage.Text, true);
173.                 txtMessage.Focus();
174.             }
175.         }
177.         private void disconnectToolStripMenuItem_Click(object sender, EventArgs e)
178.         {
179.             ExitChatSession();
180.             btnWhisper.Enabled = false;
181.             AppendText("Disconnected at " + DateTime.Now.ToString() + Environment.NewLine);
182.         }
184.         #region IChatCallback 实现接口成员
186.         //接收公聊时
187.         public void Receive(string senderName, string message)
188.         {
189.             AppendText(senderName + ": " + message + Environment.NewLine);
190.         }
191.         //接收私聊时
192.         public void ReceiveWhisper(string senderName, string message)
193.         {
194.             AppendText(senderName + " whisper: " + message + Environment.NewLine);
195.         }
196.         //其他人进入聊天室时
197.         public void UserEnter(string name)
198.         {
199.             AppendText("User " + name + " enter at " + DateTime.Now.ToString() + Environment.NewLine);
200.             lstChatters.Items.Add(name);
201.         }
202.         //其他人退出聊天室时
203.         public void UserLeave(string name)
204.         {
205.             AppendText("User " + name + " leave at " + DateTime.Now.ToString() + Environment.NewLine);
206.             lstChatters.Items.Remove(name);
207.             AdjustWhisperButton();
208.         }
210.         #endregion
212.         private void AppendText(string text)
213.         {
214.             txtChatText.Text += text;
215.             //txtChatText 滚动条始终定位于最下面
216.             SendMessage(txtChatText.Handle, WM_VSCROLL, SB_BOTTOM, new IntPtr(0));
217.         }
219.         //菜单项"连接"与"断开"的显/隐控制（）
220.         private void ShowConnectMenuItem(bool show)
221.         {
222.             connectToolStripMenuItem.Enabled = show;
223.             disconnectToolStripMenuItem.Enabled = btnSay.Enabled = !show;
224.         }
226.         private void txtMessage_KeyDown(object sender, KeyEventArgs e)
227.         {
228.             if (e.KeyData == Keys.Enter && btnSay.Enabled)
229.             {
230.                 SayAndClear("", txtMessage.Text, false);
231.             }
232.         }
234.         private void exitToolStripMenuItem_Click(object sender, EventArgs e)
235.         {
236.             ExitChatSession();
237.             ExitApplication();
238.         }
240.         private void ChatForm_FormClosed(object sender, FormClosedEventArgs e)
241.         {
242.             ExitChatSession();
243.             ExitApplication();
244.         }
246.         //退出聊天室会话
247.         private void ExitChatSession()
248.         {
249.             try
250.             {
251.                 //离开通知
252.                 proxy.Leave();
253.             }
254.             catch { }
255.             finally
256.             {             
257.                 AbortProxyAndUpdateUI();
258.             }
259.         }
261.         //中断代理并更新UI
262.         private void AbortProxyAndUpdateUI()
263.         {
264.             if (proxy != null)
265.             {
266.                 proxy.Abort();
267.                 proxy.Close();
268.                 proxy = null;
269.             }
270.             ShowConnectMenuItem(true);
271.         }
274.         private void ExitApplication()
275.         {
276.             Application.Exit();
277.         }
279.         private void txtMessage_KeyPress(object sender, KeyPressEventArgs e)
280.         {
281.             if (e.KeyChar == 13)
282.             {
283.                 e.Handled = true;
284.                 btnSay.PerformClick();
285.             }
286.         }
288.         private void lstChatters_SelectedIndexChanged(object sender, EventArgs e)
289.         {
290.             AdjustWhisperButton();
291.         }
293.         private void AdjustWhisperButton()
294.         {
295.             if (lstChatters.SelectedIndex == lastSelectedIndex)
296.             {
297.                 lstChatters.SelectedIndex = -1;
298.                 lastSelectedIndex = -1;
299.                 btnWhisper.Enabled = false;
300.             }
301.             else
302.             {
303.                 btnWhisper.Enabled = true;
304.                 lastSelectedIndex = lstChatters.SelectedIndex;
305.             }
306.             txtMessage.Focus();
307.         }
309.         private void ChatForm_Resize(object sender, EventArgs e)
310.         {
311.             //txtChatText 滚动条始终定位于最下面
312.             SendMessage(txtChatText.Handle, WM_VSCROLL, SB_BOTTOM, new IntPtr(0));
313.         }
316.     }
317. }