与众不同 windows phone (30) - Communication（通信）之基于 Socket TCP 开发一个多人聊天室

原文:与众不同 windows phone (30) - Communication（通信）之基于 Socket TCP 开发一个多人聊天室

[索引页]
[源码下载]

与众不同 windows phone (30) - Communication（通信）之基于 Socket TCP 开发一个多人聊天室

作者：webabcd

介绍
与众不同 windows phone 7.5 (sdk 7.1) 之通信

• 实例 - 基于 Socket TCP 开发一个多人聊天室

示例
1、服务端
ClientSocketPacket.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace SocketServerTcp
{
    /// <summary>
    /// 对客户端 Socket 及其他相关信息做一个封装
    /// </summary>
    public class ClientSocketPacket
    {
        /// <summary>
        /// 客户端 Socket
        /// </summary>
        public System.Net.Sockets.Socket Socket { get; set; }
 
        private byte[] _buffer;
        /// <summary>
        /// 为该客户端 Socket 开辟的缓冲区
        /// </summary>
        public byte[] Buffer
        {
            get
            {
                if (_buffer == null)
                    _buffer = new byte[];
 
                return _buffer;
            }
        }
 
        private List<byte> _receivedByte;
        /// <summary>
        /// 客户端 Socket 发过来的信息的字节集合
        /// </summary>
        public List<byte> ReceivedByte
        {
            get
            {
                if (_receivedByte == null)
                    _receivedByte = new List<byte>();
 
                return _receivedByte;
            }
        }
    }
}

Main.cs

/*
 * Socket TCP 聊天室的服务端
 */
 
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
 
using System.Net.Sockets;
using System.Net;
using System.Threading;
using System.IO;
 
namespace SocketServerTcp
{
    public partial class Main : Form
    {
        SynchronizationContext _syncContext;
 
        System.Timers.Timer _timer;
 
        // 信息结束符，用于判断是否完整地读取了客户端发过来的信息，要与客户端的信息结束符相对应（本例只用于演示，实际项目中请用自定义协议）
        private string _endMarker = "^";
 
        // 服务端监听的 socket
        private Socket _listener;
 
        // 实例化 ManualResetEvent，设置其初始状态为无信号
        private ManualResetEvent _signal = new ManualResetEvent(false);
 
        // 客户端 Socket 列表
        private List<ClientSocketPacket> _clientList = new List<ClientSocketPacket>();
 
        public Main()
        {
            InitializeComponent();
 
            // UI 线程
            _syncContext = SynchronizationContext.Current;
 
            // 启动后台线程去运行 Socket 服务
            Thread thread = new Thread(new ThreadStart(LaunchSocketServer));
            thread.IsBackground = true;
            thread.Start();
        }
 
        private void LaunchSocketServer()
        {
            // 每 10 秒运行一次计时器所指定的方法，群发信息
            _timer = new System.Timers.Timer();
            _timer.Interval = 10000d;
            _timer.Elapsed += new System.Timers.ElapsedEventHandler(_timer_Elapsed);
            _timer.Start();
 
            // TCP 方式监听 3366 端口
            _listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            _listener.Bind(new IPEndPoint(IPAddress.Any, ));
            // 指定等待连接队列中允许的最大数
            _listener.Listen();
 
            while (true)
            {
                // 设置为无信号
                _signal.Reset();
 
                // 开始接受客户端传入的连接
                _listener.BeginAccept(new AsyncCallback(OnClientConnect), null);
 
                // 阻塞当前线程，直至有信号为止
                _signal.WaitOne();
            }
        }
 
        private void _timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            // 每 10 秒给所有连入的客户端发送一次消息
            SendData(string.Format("webabcd 对所有人说：大家好！ 【信息来自服务端 {0}】", DateTime.Now.ToString("hh:mm:ss")));
        }
 
        private void OnClientConnect(IAsyncResult async)
        {
            ClientSocketPacket client = new ClientSocketPacket();
            // 完成接受客户端传入的连接的这个异步操作，并返回客户端连入的 socket
            client.Socket = _listener.EndAccept(async);
 
            // 将客户端连入的 Socket 放进客户端 Socket 列表
            _clientList.Add(client);
 
            OutputMessage(((IPEndPoint)client.Socket.LocalEndPoint).Address + " 连入了服务器");
            SendData("一个新的客户端已经成功连入服务器。。。 【信息来自服务端】");
 
            try
            {
                // 开始接收客户端传入的数据
                client.Socket.BeginReceive(client.Buffer, , client.Buffer.Length, SocketFlags.None, new AsyncCallback(OnDataReceived), client);
            }
            catch (SocketException ex)
            {
                // 处理异常
                HandleException(client, ex);
            }
 
            // 设置为有信号
            _signal.Set();
        }
 
        private void OnDataReceived(IAsyncResult async)
        {
            ClientSocketPacket client = async.AsyncState as ClientSocketPacket;
 
            int count = ;
 
            try
            {
                // 完成接收数据的这个异步操作，并返回接收的字节数
                if (client.Socket.Connected)
                    count = client.Socket.EndReceive(async);
            }
            catch (SocketException ex)
            {
                HandleException(client, ex);
            }
 
            // 把接收到的数据添加进收到的字节集合内
            // 本例采用 UTF8 编码，中文占用 3 字节，英文等字符与 ASCII 相同
            foreach (byte b in client.Buffer.Take(count))
            {
                if (b == ) continue; // 如果是空字节则不做处理（'\0'）
 
                client.ReceivedByte.Add(b);
            }
 
            // 把当前接收到的数据转换为字符串。用于判断是否包含自定义的结束符
            string receivedString = UTF8Encoding.UTF8.GetString(client.Buffer, , count);
 
            // 如果该 Socket 在网络缓冲区中没有排队的数据 并且 接收到的数据中有自定义的结束符时
            if (client.Socket.Connected && client.Socket.Available ==  && receivedString.Contains(_endMarker))
            {
                // 把收到的字节集合转换成字符串（去掉自定义结束符）
                // 然后清除掉字节集合中的内容，以准备接收用户发送的下一条信息
                string content = UTF8Encoding.UTF8.GetString(client.ReceivedByte.ToArray());
                content = content.Replace(_endMarker, "");
                client.ReceivedByte.Clear();
 
                // 发送数据到所有连入的客户端，并在服务端做记录
                SendData(content);
                OutputMessage(content);
            }
 
            try
            {
                // 继续开始接收客户端传入的数据
                if (client.Socket.Connected)
                    client.Socket.BeginReceive(client.Buffer, , client.Buffer.Length, , new AsyncCallback(OnDataReceived), client);
            }
            catch (SocketException ex)
            {
                HandleException(client, ex);
            }
        }
 
        /// <summary>
        /// 发送数据到所有连入的客户端
        /// </summary>
        /// <param name="data">需要发送的数据</param>
        private void SendData(string data)
        {
            byte[] byteData = UTF8Encoding.UTF8.GetBytes(data);
 
            foreach (ClientSocketPacket client in _clientList)
            {
                if (client.Socket.Connected)
                {
                    try
                    {
                        // 如果某客户端 Socket 是连接状态，则向其发送数据
                        client.Socket.BeginSend(byteData, , byteData.Length, SocketFlags.None, new AsyncCallback(OnDataSent), client);
                    }
                    catch (SocketException ex)
                    {
                        HandleException(client, ex);
                    }
                }
                else
                {
                    // 某 Socket 断开了连接的话则将其关闭，并将其清除出客户端 Socket 列表
                    // 也就是说每次向所有客户端发送消息的时候，都会从客户端 Socket 集合中清除掉已经关闭了连接的 Socket
                    client.Socket.Close();
                    _clientList.Remove(client);
                }
            }
        }
 
        private void OnDataSent(IAsyncResult async)
        {
            ClientSocketPacket client = async.AsyncState as ClientSocketPacket;
 
            try
            {
                // 完成将信息发送到客户端的这个异步操作
                int sentBytesCount = client.Socket.EndSend(async);
            }
            catch (SocketException ex)
            {
                HandleException(client, ex);
            }
        }
 
        /// <summary>
        /// 处理 SocketException 异常
        /// </summary>
        /// <param name="client">导致异常的 ClientSocketPacket</param>
        /// <param name="ex">SocketException</param>
        private void HandleException(ClientSocketPacket client, SocketException ex)
        {
            // 在服务端记录异常信息，关闭导致异常的 Socket，并将其清除出客户端 Socket 列表
            OutputMessage(client.Socket.RemoteEndPoint.ToString() + " - " + ex.Message);
            client.Socket.Close();
            _clientList.Remove(client);
        }
 
        // 在 UI 上输出指定信息
        private void OutputMessage(string data)
        {
            _syncContext.Post((p) => { txtMsg.Text += p.ToString() + "\r\n"; }, data);
        }
    }
}

2、客户端
TcpDemo.xaml

<phone:PhoneApplicationPage
    x:Class="Demo.Communication.SocketClient.TcpDemo"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:phone="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone"
    xmlns:shell="clr-namespace:Microsoft.Phone.Shell;assembly=Microsoft.Phone"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    FontFamily="{StaticResource PhoneFontFamilyNormal}"
    FontSize="{StaticResource PhoneFontSizeNormal}"
    Foreground="{StaticResource PhoneForegroundBrush}"
    SupportedOrientations="Portrait" Orientation="Portrait"
    mc:Ignorable="d" d:DesignHeight="768" d:DesignWidth="480"
    shell:SystemTray.IsVisible="True">
 
    <Grid x:Name="LayoutRoot" Background="Transparent">
        <StackPanel HorizontalAlignment="Left">
 
            <ScrollViewer x:Name="svChat" Height="400">
                <TextBlock x:Name="txtChat" TextWrapping="Wrap" />
            </ScrollViewer>
 
            <TextBox x:Name="txtName" />
            <TextBox x:Name="txtInput" KeyDown="txtInput_KeyDown" />
            <Button x:Name="btnSend" Content="发送" Click="btnSend_Click" />
 
        </StackPanel>
    </Grid>
 
</phone:PhoneApplicationPage>

TcpDemo.xaml.cs

/*
 * Socket TCP 聊天室的客户端
 */
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;
using Microsoft.Phone.Controls;
 
using System.Net.Sockets;
using System.Text;
 
// 此命名空间下有 Socket 的扩展方法 GetCurrentNetworkInterface()
using Microsoft.Phone.Net.NetworkInformation; 
 
namespace Demo.Communication.SocketClient
{
    public partial class TcpDemo : PhoneApplicationPage
    {
        // 信息结束符，用于判断是否完整地读取了服务端发过来的信息，要与服务端的信息结束符相对应（本例只用于演示，实际项目中请用自定义协议）
        private string _endMarker = "^";
 
        // 客户端 Socket
        private Socket _socket;
 
        // 用于发送数据到服务端的 Socket 异步操作对象
        private SocketAsyncEventArgs _socketAsyncSend;
 
        // 用于接收数据的 Socket 异步操作对象
        private SocketAsyncEventArgs _socketAsyncReceive;
 
        public TcpDemo()
        {
            InitializeComponent();
 
            this.Loaded += new RoutedEventHandler(TcpDemo_Loaded);
        }
 
        void TcpDemo_Loaded(object sender, RoutedEventArgs e)
        {
            // 初始化姓名和需要发送的默认文字
            txtName.Text = "匿名用户" + new Random().Next(, ).ToString().PadLeft(, '');
            txtInput.Text = "hi";
 
            // 实例化 Socket
            _socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
 
            // 设置 Socket 连接的首选网络类型 NetworkSelectionCharacteristics.Cellular 或 NetworkSelectionCharacteristics.NonCellular
            _socket.SetNetworkPreference(NetworkSelectionCharacteristics.NonCellular);
 
            // 强制 Socket 连接的网络类型 NetworkSelectionCharacteristics.Cellular 或 NetworkSelectionCharacteristics.NonCellular（不指定的话则均可）
            // 如果无法使用强制要求的网络类型，则在 OnSocketConnectCompleted 会收到 SocketError.NetworkDown
            _socket.SetNetworkRequirement(NetworkSelectionCharacteristics.NonCellular);
 
            // 实例化 SocketAsyncEventArgs ，用于对 Socket 做异步操作，很方便
            _socketAsyncReceive = new SocketAsyncEventArgs();
            // 服务器的 EndPoint
            _socketAsyncReceive.RemoteEndPoint = new DnsEndPoint("192.168.8.217", );
            // 异步操作完成后执行的事件
            _socketAsyncReceive.Completed += new EventHandler<SocketAsyncEventArgs>(OnSocketConnectCompleted);
 
            // 异步连接服务端
            _socket.ConnectAsync(_socketAsyncReceive);
        }
 
        private void OnSocketConnectCompleted(object sender, SocketAsyncEventArgs e)
        {
            if (e.SocketError != SocketError.Success)
            {
                OutputMessage("Socket 连接错误：" + e.SocketError.ToString());
                return;
            }
 
            // 设置数据缓冲区
            byte[] response = new byte[];
            e.SetBuffer(response, , response.Length);
 
            // 修改 SocketAsyncEventArgs 对象的异步操作完成后需要执行的事件
            e.Completed -= new EventHandler<SocketAsyncEventArgs>(OnSocketConnectCompleted);
            e.Completed += new EventHandler<SocketAsyncEventArgs>(OnSocketReceiveCompleted);
 
            // 异步地从服务端 Socket 接收数据
            _socket.ReceiveAsync(e);
 
            // 构造一个 SocketAsyncEventArgs 对象，用于用户向服务端发送消息
            _socketAsyncSend = new SocketAsyncEventArgs();
            _socketAsyncSend.RemoteEndPoint = e.RemoteEndPoint;
 
            if (_socket.Connected)
            {
                OutputMessage("成功地连接上了服务器。。。");
 
                // Socket 有一个扩展方法 GetCurrentNetworkInterface()，需要引用命名空间 Microsoft.Phone.Net.NetworkInformation
                // GetCurrentNetworkInterface() 会返回当前 Socket 连接的 NetworkInterfaceInfo 对象（NetworkInterfaceInfo 的详细说明参见：Device/Status/NetworkStatus.xaml.cs）
                NetworkInterfaceInfo nii = _socket.GetCurrentNetworkInterface();
                OutputMessage("网络接口的类型：" + nii.InterfaceType.ToString());
            }
            else
            {
                OutputMessage("无法连接到服务器。。。请刷新后再试。。。");
            }
        }
 
        private void OnSocketReceiveCompleted(object sender, SocketAsyncEventArgs e)
        {
            try
            {
                // 将接收到的数据转换为字符串
                string data = UTF8Encoding.UTF8.GetString(e.Buffer, e.Offset, e.BytesTransferred);
 
                OutputMessage(data);
            }
            catch (Exception ex)
            {
                OutputMessage(ex.ToString());
            }
 
            // 继续异步地从服务端接收数据
            _socket.ReceiveAsync(e);
        }
 
        private void OutputMessage(string data)
        {
            // 在聊天文本框中输出指定的信息，并将滚动条滚到底部
            this.Dispatcher.BeginInvoke(
                delegate
                {
                    txtChat.Text += data + "\r\n";
                    svChat.ScrollToVerticalOffset(txtChat.ActualHeight - svChat.Height);
                }
            );
        }
 
        private void SendData()
        {
            if (_socket.Connected)
            {
                // 设置需要发送的数据的缓冲区
                _socketAsyncSend.BufferList =
                    new List<ArraySegment<byte>>()
                    {
                        new ArraySegment<byte>(UTF8Encoding.UTF8.GetBytes(txtName.Text + "：" + txtInput.Text + _endMarker))
                    };
 
                // 异步地向服务端发送消息
                _socket.SendAsync(_socketAsyncSend);
            }
            else
            {
                txtChat.Text += "无法连接到服务器。。。请刷新后再试。。。\r\n";
                _socket.Close();
            }
 
            txtInput.Focus();
            txtInput.Text = "";
        }
 
        private void btnSend_Click(object sender, RoutedEventArgs e)
        {
            SendData();
        }
 
        private void txtInput_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.Key == Key.Enter)
            {
                SendData();
                this.Focus();
            }
        }
    }
}

OK
[源码下载]