服务端

    class Program

    {

        public static void Main(string[] arg)

        {

            IPAddress ip = IPAddress.Parse("192.168.0.103");

            int port = 5555;

            List<Socket> ReadSock = new List<Socket>();

            List<Socket> ErrorSock = new List<Socket>();

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

            ReadSock.Add(server);

            Dictionary<Socket, SockData> ClientRecvFile = new Dictionary<Socket, SockData>();

            server.Bind(new IPEndPoint(ip, port));

            server.Listen(10);

            while (true)

            {

                List<Socket> rs = new List<Socket>(ReadSock);

                List<Socket> es = new List<Socket>(ErrorSock);

                Socket.Select(rs, null, es, -1);

                foreach (Socket sk in rs)

                {

                    if (sk == server)

                    {

                        AcceptSock(ReadSock, ErrorSock, sk, ClientRecvFile);

                        continue;

                    }

                    if (sk.Available == 0)

                    {

                        CloseSock(ReadSock, ErrorSock, sk, ClientRecvFile);

                        continue;

                    }

                    ReceiveFile(sk, ClientRecvFile);

                }

                foreach (Socket sk in es)

                    CloseSock(ReadSock, ErrorSock, sk, ClientRecvFile);

            }

        }



        static void AcceptSock(List<Socket> readsock, List<Socket> errorsock, 

            Socket server, Dictionary<Socket,SockData> clientfs)

        {

            Socket client = server.Accept();

            readsock.Add(client);

            errorsock.Add(client);

            SockData sd = new SockData();

            sd.DataRecvLen = 4;

            sd.Buffer = new byte[4096];

            clientfs.Add(client, sd);

            Console.WriteLine("{0}建立连接", client.RemoteEndPoint);

        }



        static void ReceiveFile(Socket client, Dictionary<Socket,SockData> clientfs)

        {

            SockData sd = clientfs[client];

            if (sd.SockFile == null)

            {

                ReceiveData(client, sd);

                return;

            }

            int len = client.Receive(sd.Buffer);

            sd.SockFile.Write(sd.Buffer, 0, len);

            sd.FileRecvLen += len;

            Console.SetCursorPosition(0, Console.CursorTop);

            Console.Write("{0:P}", (double)sd.FileRecvLen / sd.FileLen);

            if (sd.FileRecvLen < sd.FileLen)

                return;

            sd.Clear();

            Console.WriteLine();

        }



        static void ReceiveData(Socket client, SockData sd)

        {

            int len2 = client.Receive(sd.Buffer, sd.OffSet, sd.DataRecvLen, SocketFlags.None);

            if (len2 != sd.DataRecvLen)

            {

                sd.SetBuffer(sd.OffSet + len2, sd.DataRecvLen - len2);

                return;

            }

            if (sd.OffSet < 4)

            {

                int datalen = BitConverter.ToInt32(sd.Buffer, 0);

                if (datalen <= 4)

                {

                    sd.SetBuffer(0, 4);

                    return;

                }

                sd.SetBuffer(4, datalen - 4);

                return;

            }

            DoSomething(client, sd);

        }



        static void DoSomething(Socket client, SockData sd)

        {

            string filename = sd.SetFileInfo();

            Console.WriteLine("开始接收文件{0}", filename);

        }



        static void CloseSock(List<Socket> readsock, List<Socket> errorsock, 

            Socket client, Dictionary<Socket, SockData> clientfs)

        {

            Console.WriteLine("{0}断开连接", client.RemoteEndPoint);

            client.Shutdown(SocketShutdown.Both);

            client.Close();

            readsock.Remove(client);

            errorsock.Remove(client);

            clientfs[client].Dispose();

            clientfs.Remove(client);

        }

    }



    class SockData : IDisposable

    {

        public int OffSet { get; set; }

        public int DataRecvLen { get; set; }

        public int FileLen { get; set; }

        public int FileRecvLen { get; set; }

        public FileStream SockFile { get; set; }

        public byte[] Buffer { get; set; }



        public void SetBuffer(int offset, int len)

        {

            OffSet = offset;

            DataRecvLen = len;

        }



        public string SetFileInfo()

        {

            FileLen = BitConverter.ToInt32(Buffer, 4);

            int filenamelen = BitConverter.ToInt32(Buffer, 8);

            string filename = Encoding.Unicode.GetString(Buffer, 12, filenamelen);

            SockFile = new FileStream(filename, FileMode.Create, FileAccess.Write);

            return filename;

        }



        public void Clear()

        {

            OffSet = 0;

            DataRecvLen = 4;

            FileLen = 0;

            FileRecvLen = 0;

            if (SockFile == null)

                return;

            SockFile.Close();

            SockFile = null;

        }



        public void Dispose()

        {

            if (SockFile != null)

                SockFile.Close();

            GC.SuppressFinalize(this);

        }



        ~SockData()

        {

            if (SockFile != null)

                SockFile.Close();

        }

    }