C#Socket完整实例代码

解释说明
001ServerConsole 服务器开启端口
002ClientConsole 客户端和服务器建立连接
003ClientSendAndServerAccept 客户端发送字符串，服务器接收字符串
004ClientSendManyAndServerAcceptMany 客户端发送多条字符串，服务器接收多条字符串
005ClientSendManySelfAndServerAcceptManySelf 客户端发送多条自定义字符串，服务器接收多条自定义字符串
006ClientSendSQLAndServerAcceptSQL 客户端从数据库获取信息发送，服务器接收信息保存到数据库
007ServerSendAndClientAccept 服务端回传，客户端接收

001ServerConsole 服务器开启端口

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

using System.Net;
using System.Net.Sockets;

namespace ServerConsole
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Server is running...");
            IPAddress ip = IPAddress.Parse("127.0.0.1");//获取ip地址
            TcpListener listener = new TcpListener(ip, 8500);

            listener.Start();//开始监听
            Console.WriteLine("Start Listening...");

            Console.WriteLine("\n\n 输入 \"Q\"键退出。");
            ConsoleKey key;
            do
            {
                key = Console.ReadKey(true).Key;
            } while (key != ConsoleKey.Q);
        }
    }
}

002ClientConsole 客户端和服务器建立连接

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

using System.Net;
using System.Net.Sockets;
namespace ClientConsole
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Client Running...");
            TcpClient client = new TcpClient();
            try
            {
                client.Connect("localhost", 8500);//与服务器连接
            }
            catch (Exception ex){
                Console.WriteLine(ex.Message);
                return;
            }
            //打印连接到的服务器信息
            Console.WriteLine("Server Connected! {0}-->{1}", client.Client.LocalEndPoint, client.Client.RemoteEndPoint);

            //按Q退出
            Console.WriteLine("\n\n 输入 \"Q\"键退出。");
            ConsoleKey key;
            do
            {
                key = Console.ReadKey(true).Key;
            } while (key != ConsoleKey.Q);
        }
    }
}

003ClientSendAndServerAccept 客户端发送字符串，服务器接收字符串
客户端发送数据

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

using System.Net;
using System.Net.Sockets;
namespace Client
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Client Running...");
            TcpClient client = new TcpClient();
            try
            {
                client.Connect("localhost", 8500);//与服务器连接
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                return;
            }
            //打印连接到的服务器信息
            Console.WriteLine("Server Connected! {0}-->{1}", client.Client.LocalEndPoint, client.Client.RemoteEndPoint);

            //定义要传送的信息
            string msg = "\"欢迎连接到服务器！\"";
            NetworkStream streamToServer = client.GetStream();

            //发送信息
            byte[] buffer = Encoding.Unicode.GetBytes(msg);//获得缓存
            streamToServer.Write(buffer, 0, buffer.Length);//发往服务器
            Console.WriteLine("Sent:{0}", msg);

            //按Q退出
            Console.WriteLine("\n\n 输入 \"Q\"键退出。");
            ConsoleKey key;
            do
            {
                key = Console.ReadKey(true).Key;
            } while (key != ConsoleKey.Q);
        }
    }
}

服务器接收数据

namespace Server
{
    class Program
    {
        static void Main(string[] args)
        {
            const int BufferSize = 8192;//缓存大小，8192字节，可以保存4096个汉字和英文字符

            Console.WriteLine("Server is running ...");
            IPAddress ip = IPAddress.Parse("127.0.0.1");//获取ip地址
            TcpListener listener = new TcpListener(ip, 8500);

            listener.Start();//开始监听
            Console.WriteLine("Start Listening...");

            //获取一个连接，中断方法
            TcpClient remoteClient = listener.AcceptTcpClient();
            //打印连接到的客户端信息
            Console.WriteLine("Client Connected! {0}<--{1}", remoteClient.Client.LocalEndPoint, remoteClient.Client.RemoteEndPoint);

            //获取流，并写入buffer中
            NetworkStream streamToClient = remoteClient.GetStream();
            byte[] buffer = new byte[BufferSize];
            int bytesRead = streamToClient.Read(buffer, 0, BufferSize);//一直等待客户端传信息
            Console.WriteLine("Reading data,{0} bytes...", bytesRead);

            //获得请求的字符串
            string msg = Encoding.Unicode.GetString(buffer, 0, bytesRead);
            Console.WriteLine("Received:{0}", msg);

            //按Q退出
            Console.WriteLine("\n\n 输入 \"Q\"键退出。");
            ConsoleKey key;
            do
            {
                key = Console.ReadKey(true).Key;
            } while (key != ConsoleKey.Q);
        }
    }
}

004ClientSendManyAndServerAcceptMany 客户端发送多条字符串，服务器接收多条字符串
客户端发送多条字符串

namespace ClientMany
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Client Running...");
            TcpClient client;
            //启动多个客户端
            for (int i = 0; i < 5; i++)
            {
                try
                {
                    client = new TcpClient();
                    client.Connect("localhost", 8500);//与服务器连接
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                    return;
                }

                //打印连接到的服务器信息
                Console.WriteLine("Server Connected! {0}-->{1}", client.Client.LocalEndPoint, client.Client.RemoteEndPoint);

                //定义要传送的信息
                string msg = "\"欢迎连接到服务器！\"";
                NetworkStream streamToServer = client.GetStream();

                //发送信息
                byte[] buffer = Encoding.Unicode.GetBytes(msg);//获得缓存
                streamToServer.Write(buffer, 0, buffer.Length);//发往服务器
                Console.WriteLine("Sent:{0}", msg);
            }
            //按Q退出
            Console.WriteLine("\n\n 输入 \"Q\"键退出。");
            ConsoleKey key;
            do
            {
                key = Console.ReadKey(true).Key;
            } while (key != ConsoleKey.Q);
        }

服务器接收多条字符串

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

using System.Net;
using System.Net.Sockets;
namespace ServerMany
{
    class Program
    {
        static void Main(string[] args)
        {
            const int BufferSize = 8192;//缓存大小，8192字节，可以保存4096个汉字和英文字符

            Console.WriteLine("Server is running ...");
            IPAddress ip = IPAddress.Parse("127.0.0.1");//获取ip地址
            TcpListener listener = new TcpListener(ip, 8500);

            listener.Start();//开始监听
            Console.WriteLine("Start Listening...");

            do
            {
                //获取一个连接，中断方法
                TcpClient remoteClient = listener.AcceptTcpClient();
                //打印连接到的客户端信息
                Console.WriteLine("Client Connected! {0}<--{1}", remoteClient.Client.LocalEndPoint, remoteClient.Client.RemoteEndPoint);

                //获取流，并写入buffer中
                NetworkStream streamToClient = remoteClient.GetStream();
                byte[] buffer = new byte[BufferSize];
                int bytesRead = streamToClient.Read(buffer, 0, BufferSize);//一直等待客户端传信息
                Console.WriteLine("Reading data,{0} bytes...", bytesRead);

                //获得请求的字符串
                string msg = Encoding.Unicode.GetString(buffer, 0, bytesRead);
                Console.WriteLine("Received:{0}", msg);
            } while (true);
            //按Q退出
            Console.WriteLine("\n\n 输入 \"Q\"键退出。");
            ConsoleKey key;
            do
            {
                key = Console.ReadKey(true).Key;
            } while (key != ConsoleKey.Q);
        }
    }
}

005ClientSendManySelfAndServerAcceptManySelf 客户端发送多条自定义字符串，服务器接收多条自定义字符串
客户端发送多条自定义字符串

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

using System.Net;
using System.Net.Sockets;
namespace ClientManySelf
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Client Running...");
            TcpClient client;
            //启动多个服务器
            for (int i = 0; i < 5; i++)
            {
                try
                {
                    client = new TcpClient();
                    client.Connect("localhost", 8500);//与服务器连接
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                    return;
                }

                //打印连接到的服务器信息
                Console.WriteLine("Server Connected! {0}-->{1}", client.Client.LocalEndPoint, client.Client.RemoteEndPoint);

                NetworkStream streamToServer = client.GetStream();

                ConsoleKey key;
                Console.WriteLine("Menu:S-Send,X-Exit");
                do
                {
                    key = Console.ReadKey(true).Key;
                    if (key == ConsoleKey.S)
                    {
                        //获取输入的字符串
                        Console.Write("输入信息：");
                        string msg = Console.ReadLine();

                        //发送信息
                        byte[] buffer = Encoding.Unicode.GetBytes(msg);//获得缓存
                        streamToServer.Write(buffer, 0, buffer.Length);//发往服务器
                        Console.WriteLine("Sent:{0}", msg);
                    }
                } while (key != ConsoleKey.X);
            }

        }
    }
}

服务器接收多条自定义字符串

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

using System.Net;
using System.Net.Sockets;
namespace ServerManySelf
{
    class Program
    {
        static void Main(string[] args)
        {
            const int BufferSize = 8192;//缓存大小，8192字节，可以保存4096个汉字和英文字符

            Console.WriteLine("Server is running ...");
            IPAddress ip = IPAddress.Parse("127.0.0.1");//获取ip地址
            TcpListener listener = new TcpListener(ip, 8500);

            listener.Start();//开始监听
            Console.WriteLine("Start Listening...");

            //获取一个连接，中断方法
            TcpClient remoteClient = listener.AcceptTcpClient();
            //打印连接到的客户端信息
            Console.WriteLine("Client Connected! {0}<--{1}", remoteClient.Client.LocalEndPoint, remoteClient.Client.RemoteEndPoint);
            //获取流，并写入buffer中
            NetworkStream streamToClient = remoteClient.GetStream();

            do
            {
                byte[] buffer = new byte[BufferSize];
                int bytesRead = streamToClient.Read(buffer, 0, BufferSize);//一直等待客户端传信息
                Console.WriteLine("Reading data,{0} bytes...", bytesRead);

                //获得请求的字符串
                string msg = Encoding.Unicode.GetString(buffer, 0, bytesRead);
                Console.WriteLine("Received:{0}", msg);
            } while (true);
            //按Q退出
            Console.WriteLine("\n\n 输入 \"Q\"键退出。");
            ConsoleKey key;
            do
            {
                key = Console.ReadKey(true).Key;
            } while (key != ConsoleKey.Q);
        }
    }
}

006ClientSendSQLAndServerAcceptSQL 客户端从数据库获取信息发送，服务器接收信息保存到数据库
客户端从数据库获取信息发送

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

//数据库引用
using System.Data;
using System.Data.OleDb;

//Socket引用
using System.Net;
using System.Net.Sockets;

namespace ClientSQL
{
    class Program
    {
        /// <summary>
        /// 数据库连接
        /// </summary>
        /// <returns>数据库连接对象</returns>
        public static OleDbConnection getConn() 
        {
            string connstr = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=G:\\users\\brizer\\documents\\visual studio 2010\\Projects\\socket\\test.mdb";
            OleDbConnection tempconn = new OleDbConnection(connstr);
            return tempconn;
        }
        /// <summary>
        /// 获取需要的信息
        /// </summary>
        /// <param name="id">通过参数查询</param>
        /// <returns>得到查询结果的字节流</returns>
        public static string getValueFromId(string id)
        {
            string tempValue = "";//定义返回值
            try
            {
                OleDbConnection conn = getConn();//得到连接对象
                string strCom = "Select * from testTable where id =" + id;
                OleDbCommand myCommand = new OleDbCommand(strCom, conn);
                conn.Open();
                OleDbDataReader reader;
                reader = myCommand.ExecuteReader();//执行命令并得到相应的DataReader
                //下面将得到的值赋给tempValue对象
                if (reader.Read())
                {
                    tempValue = "ID:" + reader["id"].ToString();
                    tempValue += "温度:" + reader["温度"].ToString();
                    tempValue += "长度:" + reader["长度"].ToString();
                }
                else
                {
                    tempValue = "没有该记录";
                }
            }
            catch (Exception e)
            {
 
            }
            return tempValue;
        }
        /// <summary>
        /// 将字节流传给服务端
        /// </summary>
        /// <param name="value">需要传送的内容</param>
        public static void sendToServer(string value)
        {
            const int BufferSize = 8192;//缓存大小，8192字节，可以保存4096个汉字和英文字符
             Console.WriteLine("Client Running...");
            TcpClient client = new TcpClient();
            try
            {
                client.Connect("localhost", 8500);//与服务器连接
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                return;
            }
            //打印连接到的服务器信息
            Console.WriteLine("Server Connected! {0}-->{1}", client.Client.LocalEndPoint, client.Client.RemoteEndPoint);

            //定义要传送的信息
            string msg = value;
            NetworkStream streamToServer = client.GetStream();

            //发送信息
            byte[] buffer = Encoding.Unicode.GetBytes(msg);//获得缓存
            streamToServer.Write(buffer, 0, buffer.Length);//发往服务器
            Console.WriteLine("Sent:{0}", msg);
            
            //接收信息
            do
            {
                buffer = new byte[BufferSize];
                int bytesRead = streamToServer.Read(buffer, 0, BufferSize);//一直等待客户端传信息
                Console.WriteLine("Reading data,{0} bytes...", bytesRead);

                //获得请求的字符串
                msg = Encoding.Unicode.GetString(buffer, 0, bytesRead);
                Console.WriteLine("Received:{0}", msg);
                string result = getValueFromId(msg);
                Console.WriteLine("结果:{0}", result);

                //将结果发送给服务端
                msg = result;
                byte[] bufferWrite = Encoding.Unicode.GetBytes(result);
                streamToServer.Write(bufferWrite, 0, bufferWrite.Length);//发往服务器

            } while (true);

            //按Q退出
            Console.WriteLine("\n\n 输入 \"Q\"键退出。");
            ConsoleKey key;
            do
            {
                key = Console.ReadKey(true).Key;
            } while (key != ConsoleKey.Q);
        }


        static void Main(string[] args)
        {

            //获取需要的数据信息
            string value;
            value = getValueFromId("2");
            //Console.WriteLine(value);
            //Console.ReadKey();
            
            //通过TCP传到服务端
            sendToServer(value);
        }
    }
}

服务器接收信息保存到数据库

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

using System.Net;
using System.Net.Sockets;
namespace ServerSQL
{
    class Program
    {
        static void Main(string[] args)
        {
            const int BufferSize = 8192;//缓存大小，8192字节，可以保存4096个汉字和英文字符

            Console.WriteLine("Server is running ...");
            IPAddress ip = IPAddress.Parse("127.0.0.1");//获取ip地址
            TcpListener listener = new TcpListener(ip, 8500);

            listener.Start();//开始监听
            Console.WriteLine("Start Listening...");

            //获取一个连接，中断方法
            TcpClient remoteClient = listener.AcceptTcpClient();
            //打印连接到的客户端信息
            Console.WriteLine("Client Connected! {0}<--{1}", remoteClient.Client.LocalEndPoint, remoteClient.Client.RemoteEndPoint);

            //获取流，并写入buffer中
            NetworkStream streamToClient = remoteClient.GetStream();
            byte[] buffer = new byte[BufferSize];
            int bytesRead = streamToClient.Read(buffer, 0, BufferSize);//一直等待客户端传信息
            Console.WriteLine("Reading data,{0} bytes...", bytesRead);

            //获得请求的字符串
            string msg = Encoding.Unicode.GetString(buffer, 0, bytesRead);
            Console.WriteLine("Received:{0}", msg);

            //发送信息
            ConsoleKey key;
            Console.WriteLine("Menu:S-Send,X-Exit");
            do
            {
                key = Console.ReadKey(true).Key;
                if (key == ConsoleKey.S)
                {
                    //获取输入的字符串
                    Console.Write("输入信息：");
                    msg = Console.ReadLine();

                    //发送信息
                    buffer = Encoding.Unicode.GetBytes(msg);//获得缓存
                    streamToClient.Write(buffer, 0, buffer.Length);//发往服务器
                    Console.WriteLine("Sent:{0}", msg);

                    //获取流，并写入buffer中
                    streamToClient = remoteClient.GetStream();
                    buffer = new byte[BufferSize];
                    bytesRead = streamToClient.Read(buffer, 0, BufferSize);//一直等待客户端传信息
                    Console.WriteLine("Reading data,{0} bytes...", bytesRead);

                    //获得请求的字符串
                    msg = Encoding.Unicode.GetString(buffer, 0, bytesRead);
                    Console.WriteLine("Received:{0}", msg);
                }
            } while (key != ConsoleKey.X);

            //按Q退出
            Console.WriteLine("\n\n 输入 \"Q\"键退出。");
            do
            {
                key = Console.ReadKey(true).Key;
            } while (key != ConsoleKey.Q);
        }
    }
}

007ServerSendAndClientAccept 服务端回传，客户端接收
服务端回传

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

using System.Net;
using System.Net.Sockets;
namespace ServerSend
{
    class Program
    {
        static void Main(string[] args)
        {
            const int BufferSize = 8192;//缓存大小，8192字节，可以保存4096个汉字和英文字符

            Console.WriteLine("Server is running ...");
            IPAddress ip = IPAddress.Parse("127.0.0.1");//获取ip地址
            TcpListener listener = new TcpListener(ip, 8500);

            listener.Start();//开始监听
            Console.WriteLine("Start Listening...");

            //获取一个连接，中断方法
            TcpClient remoteClient = listener.AcceptTcpClient();
            //打印连接到的客户端信息
            Console.WriteLine("Client Connected! {0}<--{1}", remoteClient.Client.LocalEndPoint, remoteClient.Client.RemoteEndPoint);

            //获取流，并写入buffer中
            NetworkStream streamToClient = remoteClient.GetStream();
            byte[] buffer = new byte[BufferSize];
            int bytesRead = streamToClient.Read(buffer, 0, BufferSize);//一直等待客户端传信息
            Console.WriteLine("Reading data,{0} bytes...", bytesRead);

            //获得请求的字符串
            string msg = Encoding.Unicode.GetString(buffer, 0, bytesRead);
            Console.WriteLine("Received:{0}", msg);

            //转换成大写并发送
            msg = msg.ToUpper();
            buffer = Encoding.Unicode.GetBytes(msg);
            lock (streamToClient) {
                streamToClient.Write(buffer, 0, buffer.Length);
            }
            Console.WriteLine("Send:{0}", msg);

            //按Q退出
            Console.WriteLine("\n\n 输入 \"Q\"键退出。");
            ConsoleKey key;
            do
            {
                key = Console.ReadKey(true).Key;
            } while (key != ConsoleKey.Q);
        }
    }
}

客户端接收服务端回传

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

using System.Net;
using System.Net.Sockets;
namespace ClientAccept
{
    class Program
    {
        static void Main(string[] args)
        {
             const int BufferSize = 8192;//缓存大小，8192字节，可以保存4096个汉字和英文字符
            Console.WriteLine("Client Running...");
            TcpClient client;
            //启动多个服务器
            for (int i = 0; i < 5; i++)
            {
                try
                {
                    client = new TcpClient();
                    client.Connect("localhost", 8500);//与服务器连接
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                    return;
                }

                //打印连接到的服务器信息
                Console.WriteLine("Server Connected! {0}-->{1}", client.Client.LocalEndPoint, client.Client.RemoteEndPoint);

                NetworkStream streamToServer = client.GetStream();

                ConsoleKey key;
                Console.WriteLine("Menu:S-Send,X-Exit");
                do
                {
                    key = Console.ReadKey(true).Key;
                    if (key == ConsoleKey.S)
                    {
                        //获取输入的字符串
                        Console.Write("输入信息：");
                        string msg = Console.ReadLine();

                        //发送信息
                        byte[] buffer = Encoding.Unicode.GetBytes(msg);//获得缓存
                        streamToServer.Write(buffer, 0, buffer.Length);//发往服务器
                        Console.WriteLine("Sent:{0}", msg);

                        //获取信息
                        int bytesRead;
                        buffer = new byte[BufferSize];
                        lock (streamToServer) {
                            bytesRead = streamToServer.Read(buffer, 0, BufferSize);
                        }
                        msg = Encoding.Unicode.GetString(buffer, 0, bytesRead);
                        Console.WriteLine("Received:{0}", msg);
                    }
                } while (key != ConsoleKey.X);
            }

        }
    }
}