【WCF实践】编写最基础的公共聊天服务

学习了一段时间的WCF之后，应该开始写一些实用的工程来锻炼应用能力了。本文介绍了如何使用WCF编写最简单的公共聊天服务，当然，这只是开始，在未来，该工程将得到扩展。

在上一篇关于WCF的文章中介绍了编写Duplex通讯方式的服务，在该聊天服务中我将利用到Duplex。

首先还是新建一个空的解决方案，叫做WCFChat，按照惯常的手法添加2个C#类库项目，一个用于定义服务契约，一个用于服务契约的实现。

在服务契约项目WCFChatContract中定义了2个接口，第一个接口是要通过宿主开放的操作，第二个接口定义了客户端回调的方法集合。

using System.ServiceModel;

namespace Kwan.WCFChat.WCFChatContract
{
    #region Server Interface

    /// <summary>
    /// 用于聊天服务的服务契约，使用Duplex模式
    /// </summary>
    [ServiceContract(CallbackContract=typeof(IChatClientCallback))]
    public interface IChatServer
    {
        /// <summary>
        /// 用户登录
        /// </summary>
        /// <param name="userName">用户名</param>
        [OperationContract(IsOneWay=true)]
        void LogonUser(String userName);

        /// <summary>
        /// 广播用户消息
        /// </summary>
        /// <param name="userName">用户名</param>
        /// <param name="message">消息</param>
        [OperationContract(IsOneWay = true)]
        void PublishChat(String userName, String message);
    }

    #endregion

    #region Client Callback Interface

    /// <summary>
    /// 客户端回调接口
    /// </summary>
    public interface IChatClientCallback
    {
        /// <summary>
        /// 用户登录的客户端回调接口
        /// </summary>
        /// <param name="userName">用户名</param>
        [OperationContract(IsOneWay = true)]
        void OnUserLogon(String userName);

        /// <summary>
        /// 广播用户消息的客户端回调接口
        /// </summary>
        /// <param name="userName">用户名</param>
        /// <param name="message">消息</param>
        [OperationContract(IsOneWay = true)]
        void OnChatPublish(String userName, String message);
    }

    #endregion
}

然后在WCFChatLibrary中实现服务接口。

using Kwan.WCFChat.WCFChatContract;

namespace Kwan.WCFChat.WCFChatLibrary
{
    /// <summary>
    /// 服务接口实现
    /// </summary>
    /// 对每个会话使用一个服务对象实例进行处理
    [ServiceBehavior(InstanceContextMode = InstanceContextMode.PerSession)]
    public class ChatServer : IChatServer
    {
        private const String CONFIG_SERVER_NAME = "WCF Chat Server";
        private const String FORMAT_USER_REGISTERED = "{0} has registered.";
        private const String ERROR_USER_ALREADY_EXISTS = "User already registered.";

        /// <summary>
        /// 记录所有的客户端回调
        /// </summary>
        static Dictionary<String, IChatClientCallback> _callbacks =
            new Dictionary<String, IChatClientCallback>();
       
        /// <summary>
        /// 当前调用的客户端回调
        /// </summary>
        private IChatClientCallback _currentCallback;

        #region IChatServer Members

        public void LogonUser(String userName)
        {
            // 获取当前调用的客户端回调
            _currentCallback =
        OperationContext.Current.GetCallbackChannel<IChatClientCallback>();

            if (!_callbacks.ContainsKey(userName))
            {
                _callbacks.Add(userName, _currentCallback);
                _currentCallback.OnUserLogon(userName);

                // 广播新用户登录的消息
                foreach (String userKey in _callbacks.Keys)
                {
                    // 从泛型Dictionary中查找
                    _currentCallback = _callbacks[userKey];
                    _currentCallback.OnChatPublish(CONFIG_SERVER_NAME,
            String.Format(FORMAT_USER_REGISTERED, userName));
                }
            }
            else
            {
                throw new Exception(ERROR_USER_ALREADY_EXISTS);
            }
        }

        public void PublishChat(String userName, String message)
        {
            // 广播某用户发送的消息
            foreach (String userKey in _callbacks.Keys)
            {
                _currentCallback = _callbacks[userKey];
                _currentCallback.OnChatPublish(userName, message);
            }
        }

        #endregion
    }
}

在服务接口的实现中我使用了一个泛型Dictionary来记录所有的客户端回调。在后面的客户端的代码中可以看到，这样其实是记录了所有和服务器通讯的客户端。

WCFChatHost是一个Windows工程，作为WCF服务宿主，下面仅给出配置文件。

<?xml version="1.0" encoding="utf-8" ?>
<configuration>

  <system.serviceModel>
    <services>
      <service name="Kwan.WCFChat.WCFChatLibrary.ChatServer"               
                      behaviorConfiguration="ChatBehaviorConfig">
        <host>
          <baseAddresses>
            <add baseAddress="net.tcp://localhost:8000/WCFChat"/>
            <add baseAddress="http://localhost:8080/WCFChat"/>
          </baseAddresses>
        </host>
       
        <endpoint address="tcpmex"
                  binding="mexHttpBinding"
                  contract="IMetadataExchange"/>
        <endpoint address=""
                  binding="wsDualHttpBinding"                                                                       
                  contract="Kwan.WCFChat.WCFChatContract.IChatServer"/>
      </service>
    </services>

    <behaviors>
      <serviceBehaviors>
        <behavior name="ChatBehaviorConfig">
          <serviceMetadata httpGetEnabled="true" httpGetUrl=""/>
        </behavior>
      </serviceBehaviors>
    </behaviors>
   
  </system.serviceModel>
 
</configuration>

相对于上一篇文章中的配置，这里进行了简化，去掉了NamedPipe，并且开放了Http。Http的Binding使用wsDualHttpBinding，以满足Duplex的需要。

最后的工作便是写一个客户端来测试我们的服务是否正确。新建Windows工程WCFChatClient。启动Host，为Client添加服务引用，改名为ChatService。

让主窗口直接实现客户端回调接口，即

public partial class MainForm : Form, ChatService.IChatServerCallback
{
    #region IChatServerCallback Members

    public void OnUserLogon(string userName)
    {
        MessageBox.Show(userName + " log on the server successfully");
    }

    public void OnChatPublish(string userName, string message)
    {
        listBox1.Items.Add(String.Format("{0} say:{1}",userName,message));
    }

    #endregion
}

用MessageBox提示登录成功，用ListBox来显示消息。然后为2个按钮添加事件处理代码，调用服务。

public partial class MainForm : Form, ChatService.IChatServerCallback
{
    ChatService.ChatServerClient _client;
   
    private void MainForm_Load(object sender, EventArgs e)
    {
        InstanceContext ic = new InstanceContext(this);
        _client = new WCFChatClient.ChatService.ChatServerClient(ic);
    }

    private void button1_Click(object sender, EventArgs e)
    {
        _userName = textBox2.Text;
        _client.LogonUser(_userName);
    }

    private void button2_Click(object sender, EventArgs e)
    {
        _client.PublishChat(_userName, textBox1.Text);
    }
}

OK，代码的编写到此为止，我们已经实现了一个公共聊天服务，现在来测试一下。启动2个客户端，测试登录。
以kwan为用户名登录服务，如下图所示，登录成功。



客户端显示来自服务的广播，说kwan已经成功注册



打个招呼（没有其他人，和服务器说话吧）。



下面在第二个客户端上用joshua登录



然后开始公共聊天。



三个看看。



看来我们成功了。

该范例仅仅展示了WCF的基本应用，若要将该服务扩展成为实用服务，则需要在服务端和客户端编写更多的代码来实现复杂的逻辑。