简单 Socket 通信

MSDN 上也有个关于 Socket 通信的简单例子。我这是从那上面搬过来的。不过改来改去就变得跟原来的差得不少了。我觉得比 MSDN 上的例子会更好一点。因为可以自己定义要传送的数据类型，只要要传送的数据是可以序列化的。

我把程序分成两大块：PostOffice，Package。PostOffice 实现收发功能，相当于邮局。Package 包含了这个包的类型和包里面要传送的数据。

Package 类的定义：

using System;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;

namespace TalkDemo.Core
{
    [Serializable]
    public class Package
    {
        private PackageType packageType;

        public PackageType PackageType
        {
            get { return packageType; }
        }

        private IPEndPoint sourceEP;

        public IPEndPoint SourceEP
        {
            get { return sourceEP; }
        }

        private IPEndPoint destEP;

        public IPEndPoint DestEP
        {
            get { return destEP; }
        }

        private object[] data;

        public object[] Data
        {
            get { return data; }
        }

        public Package(PackageType packageType, IPEndPoint sourceEP, IPEndPoint destEP,
            params object[] data)
        {
            this.packageType = packageType;
            this.sourceEP = sourceEP;
            this.destEP = destEP;
            this.data = data;
        }

        public static void Serialize(Stream stream, Package package)
        {
            if (package == null) return;
            if (stream == null) return;

            BinaryFormatter binFormatter = new BinaryFormatter();
            binFormatter.Serialize(stream, package);
        }

        public static Package Deserialize(Stream stream)
        {
            if (stream == null) return null;

            BinaryFormatter binFormatter = new BinaryFormatter();
            Package package;
            try
            {
                package = binFormatter.Deserialize(stream) as Package;
            }
            catch
            {
                return null;
            }

            return package;
        }
    }
}

PackageType 枚举的定义：

namespace TalkDemo.Core
{
    public enum PackageType
    {
        Data,
        ExitSignal,
    }
}

using System;
using System.Collections.Generic;
using System.Text;

namespace TalkDemo.Core
{
    public class PackageReceivedEventArgs
        : EventArgs
    {
        private Package package;

        public Package Package
        {
            get { return package; }
        }

        public PackageReceivedEventArgs(Package package)
        {
            this.package = package;
        }
    }
}

namespace TalkDemo.Core
{
    public delegate void PackageReceivedEventhandler(object sender, PackageReceivedEventArgs e);
}

PostOffice 的定义：

using System;
using System.Collections.Generic;
using System.Text;
using System.Net.Sockets;
using System.IO;
using System.Net;
using System.Threading;

namespace TalkDemo.Core
{
    public sealed class PostOffice
    {
        Fields#region Fields

        public const int ClientPort = 5000;
        public const int ServerPort = 5001;
        private IPEndPoint localClientEP;
        private IPEndPoint localServerEP;
        private ManualResetEvent clientListeningDone = new ManualResetEvent(false);
        private ManualResetEvent serverListeningDone = new ManualResetEvent(false);
        private static readonly PostOffice instance = new PostOffice();
        private Buffoon_CRC_CCITT buffoon = new Buffoon_CRC_CCITT();
        private const int maxTryTimes = 16;

        #endregion

        Properties#region Properties

        public IPEndPoint LocalClientEP
        {
            get { return localClientEP; }
        }

        public IPEndPoint LocalServerEP
        {
            get { return localServerEP; }
        }

        public static PostOffice Instance
        {
            get { return instance; }
        }

        #endregion

        Methods#region Methods

        private PostOffice()
        {
            IPHostEntry localEntry = Dns.GetHostEntry(Dns.GetHostName());
            localClientEP = new IPEndPoint(localEntry.AddressList[0], ClientPort);
            localServerEP = new IPEndPoint(localEntry.AddressList[0], ServerPort);
        }

        public void Send(Package package)
        {
            if (package == null) return;

            MemoryStream memStream = new MemoryStream();
            Package.Serialize(memStream, package);
            byte[] buffer = memStream.ToArray();

            Socket socket = new Socket(AddressFamily.InterNetwork,
                    SocketType.Stream,
                    ProtocolType.Tcp);
            socket.Connect(package.DestEP);

            socket.Send(buffer);

            socket.Shutdown(SocketShutdown.Both);
            socket.Close();
        }

        public void BeginListen(ListenAs role)
        {
            switch (role)
            {
                case ListenAs.Server:
                    serverListeningDone.Reset();
                    break;

                case ListenAs.Client:
                    clientListeningDone.Reset();
                    break;
            }

            Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream,
                ProtocolType.Tcp);

            switch (role)
            {
                case ListenAs.Server:
                    socket.Bind(localServerEP);
                    break;

                case ListenAs.Client:
                    socket.Bind(localClientEP);
                    break;
            }
            socket.Listen(100);

            Thread t = new Thread(new ParameterizedThreadStart(AcceptCallback));
            t.Start(new AcceptCallArgs(socket, role));
        }

        private void AcceptCallback(object o)
        {
            AcceptCallArgs arg = o as AcceptCallArgs;
            Socket socket = arg.Socket;
            ListenAs role = arg.Role;

            while (true)
            {
                Socket handler = socket.Accept();

                List<byte> bytes = new List<byte>();

                byte[] buffer = new byte[1024];
                int bytesRecved = handler.Receive(buffer);
                while (bytesRecved > 0)
                {
                    bytes.AddRange(buffer);
                    bytesRecved = handler.Receive(buffer);
                }

                MemoryStream ms = new MemoryStream(bytes.ToArray());

                Package package = null;
                try
                {
                    package = Package.Deserialize(ms);
                }
                catch
                {
                    if (BadDataReceived != null) BadDataReceived(this, null);
                }

                if (package != null && package.PackageType == PackageType.ExitSignal)
                {
                    handler.Shutdown(SocketShutdown.Both);
                    handler.Close();

                    break;
                }

                if (package != null && package.PackageType == PackageType.Data && PackageReceived != null)
                {
                    PackageReceived(this, new PackageReceivedEventArgs(package));
                }

                handler.Shutdown(SocketShutdown.Both);
                handler.Close();
            }

            socket.Close();

            switch (role)
            {
                case ListenAs.Server:
                    serverListeningDone.Set();
                    break;

                case ListenAs.Client:
                    clientListeningDone.Set();
                    break;
            }
        }

        public void EndListen(ListenAs role)
        {
            IPEndPoint localEP = null;
            switch (role)
            {
                case ListenAs.Server:
                    localEP = localServerEP;
                    break;

                case ListenAs.Client:
                    localEP = localClientEP;
                    break;
            }

            Package package = new Package(PackageType.ExitSignal, localEP, localEP);
            Send(package);

            switch (role)
            {
                case ListenAs.Server:
                    serverListeningDone.WaitOne();
                    break;

                case ListenAs.Client:
                    clientListeningDone.WaitOne();
                    break;
            }
        }

        #endregion

        Enumerations#region Enumerations

        public enum ListenAs
        {
            Server, Client
        }

        #endregion

        Events#region Events

        public event PackageReceivedEventhandler PackageReceived = null;
        public event PackageReceivedEventhandler BadDataReceived = null;

        #endregion

        private class AcceptCallArgs
        {
            private Socket socket;

            public Socket Socket
            {
                get { return socket; }
            }

            private ListenAs role;

            public ListenAs Role
            {
                get { return role; }
            }

            public AcceptCallArgs(Socket socket, ListenAs role)
            {
                this.socket = socket;
                this.role = role;
            }
        }
    }
}

可以看出来，这里发送是同步的，但接收是异步的。这个程序也算是个怪胎了！@#@#￥#，不过全当练习了。

有了这个通信的核心，就可以做个简单的双向通信程序了。

using System;
using System.Collections.Generic;
using System.Text;
using TalkDemo.Core;
using System.Net;

namespace TalkTest.Ui
{
    class Program
    {
        static void Main(string[] args)
        {
            PostOffice postOffice = PostOffice.Instance;
            try
            {
                Console.Write("Target ip: ");
                string targetIp = Console.ReadLine();

                IPHostEntry targetEntry = Dns.GetHostEntry(targetIp);
                IPEndPoint targetEP = new IPEndPoint(targetEntry.AddressList[0], PostOffice.ClientPort);

                postOffice.PackageReceived += new PackageReceivedEventhandler(postOffice_PackageReceived);
                postOffice.BeginListen(PostOffice.ListenAs.Client);

                Console.Write("Talk Demo> ");
                string input = Console.ReadLine();
                while (!input.ToLower().Equals("exit"))
                {
                    Package p = new Package(PackageType.Data, postOffice.LocalClientEP, targetEP, input);

                    try
                    {
                        postOffice.Send(p);
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine(ex.Message);
                    }

                    Console.Write("Talk Demo> ");
                    input = Console.ReadLine();
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            finally
            {
                postOffice.EndListen(PostOffice.ListenAs.Client);
            }

            Console.WriteLine("Press any key to continue");
            Console.ReadKey(true);
        }

        static void postOffice_PackageReceived(object sender, PackageReceivedEventArgs e)
        {
            if (e.Package.PackageType == PackageType.Data)
            {
                Console.WriteLine("\r\nFrom [" + e.Package.SourceEP.Address.ToString() + "]> " + e.Package.Data[0].ToString());
                Console.Write("Talk Demo> ");
            }
        }
    }
}