C#中的socket编程入门实例

最新推荐文章于 2024-09-05 23:33:41 发布
最新推荐文章于 2024-09-05 23:33:41 发布
阅读量201 收藏 1
点赞数
分类专栏： Csharp

http://blog.csdn.net/mevicky/article/details/49000019

Socket主要是通过TCP或者UDP协议进行多台主机之间的通讯。由于项目中用到，所以今天就结合项目需求对socket编程的C#表示进行一步一步详细的介绍。 
TCP的详细过程我就不多介绍了，这个是网络基础，不明白的同学可以看TCP

开启服务端对端口的监听

我们都知道TCP服务端需要对某个端口进行连续监听，客户端才可以发起连接。所以我们先讲讲服务端如何打开端口进行监听。 
新建一个控制台应用程序ServerConsole，引用System.Net和System.Net.Sockets。 
代码如下：

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);
        }
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30

运行后，通过cmd netstat –a 可以查看已经开启8500端口监听： 
开启端口

客户端与服务器连接

服务端开启端口监听后，接下来就是客户端来发起连接了。 
创建一个新的控制台命令程序ClientConsole，代码如下：

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);
        }
    }
}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37

当我们同时运行服务端ServerConsole和客户端ClientConsole后，客户端程序效果： 
这里写图片描述

可以看到，客户端开启了55279端口和服务端成功建立连接。客户端使用的端口号是随机选取的，并不需要我们来设置，并且每次运行时，端口都不同。8500端口和客户端建立连接后，仍然处于监听状态，也就是说一个端口可以和多个远程端口进行通信。

服务端和客户端通信

连接已经成功建立了，接下来需要进行的就是通信了。 
由于这里只是入门介绍，所以不涉及到文件的传输，我们主要还是介绍字节流的传输过程。

客户端发送，服务端接收

我们先从一条数据开始循序渐进吧。 
服务端Server代码如下：

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

using System.Net;
using System.Net.Sockets;
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);
        }
    }
}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48

可以看到，我们利用服务端监听客户端传入字节流，将其放入缓存并输出。 
客户端代码如下：

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);
        }
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46

这里是NetworkStream 类型就是字节流传输的一个载体。我们将客户端程序中定义好的字符串“欢迎连接到服务器！”传输给服务端。

客户端效果如下： 
这里写图片描述

服务端效果如下： 
这里写图片描述

可以看到服务端成功接收客户端信息。

客户端发送多条，服务端接收多条

再来看看我们如何一次发送多个信息到服务器。 
服务端ServerMany代码如下：

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);
        }
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49

我们通过do while循环一直等待客户端传输信息。 
客户端ClientMany代码如下：

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

using System.Net;
using System.Net.Sockets;
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);
        }
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51

这里我们先通过一个for循环传输多条数据。 
客户端效果如下： 
这里写图片描述

服务端效果如下： 
这里写图片描述

客户端发送自定义信息，服务端接收自定义信息

前面的demo中我们发送的信息都是固定在程序中的。现在我们对其进行改进，使客户端可以发送自定义的信息。 
服务端ServerManySelf代码如下：

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);
        }
    }
}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50

服务端的代码基本没有什么变化，客户端ClientManySelf代码如下：

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);
            }

        }
    }
}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57

我们通过交互来完成客户端的输入，从而发送自定义的信息到服务端。 
客户端效果： 
这里写图片描述

服务端效果： 
这里写图片描述

服务端回发信息，客户端接收

TCP是双向通信的，前面一直介绍的是客户端发送信息到服务端，接下来介绍如何从服务端发送信息到客户端。 
服务端通过Read方法读信息，所以通过Write方法写信息。 
我们想象一个需求，就是服务端将客户端发送过来的字符串变为大写后再传输回客户端。 
服务端ServerSend代码如下:

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);
        }
    }
}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56

客户端同意通过Read方法来读，客户端ClientAccept代码如下：

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);
            }

        }
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66

客户端效果如下： 
这里写图片描述

服务端效果如下： 
这里写图片描述

服务端指定ID，客户端对数据库进行查询

双向通信也介绍了。最后以一个我在项目中需要用到的功能来收尾。我们通过服务端发送需要查询的ID，然后客户端通过ID对Access数据库进行查询，并将结果返回给服务端。 
服务端ServerSQL代码如下：

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);
        }
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75

客户端ClientSQL代码如下：

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);
        }
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135

Access数据库test中内容如下： 
这里写图片描述

服务端效果如下： 
这里写图片描述

客户端效果如下： 
这里写图片描述

成功将客户端指定数据传输至服务端。 
全部实例下载地址

qq_32444825
关注
专栏目录
用C#编写的Winform通信程序
12-10
本程序通过UDP协议和线程实现点对点通信，通过字节码的转换数据包（类）的发送与接收，希望能帮助大家
C# Socket编程（服务端、客户端）
qq1326702940的博客
05-30 8804
【代码】C# Socket编程基础。
高效稳定的C Socket通信类库：助力你的网络应用开发
最新发布
gitblog_09791的博客
09-05 390
高效稳定的C# Socket通信类库：助力你的网络应用开发 Wodsoft.Net.rar项目地址:https://gitcode.com/open-source-toolkit/01eba 项目介绍 在现代软件开发中，网络通信是不可或缺的一部分。无论是实时在线游戏、分布式系统，还是企业级应用的后台数据交互，高效的网络通信都是关键。为了帮助开发者快速实现稳定、高效的网络通信，我们推出了一个用C#...
C#教程 socket编程
qq_40793198的博客
11-26 5255
如何练成编程高手，编程需要恒心和毅力，最主要是要有信心，循序渐进地完成任务
入门级C# Socket编程实现
热门推荐
weixin_49959955的博客
03-29 3万+
文章简单介绍了Socket的概念和作用，并详细介绍了如何使用C#语言实现Socket编程，实现进程之间的数据传输，可以拓展成窗口功能，文章中包含了服务器端和客户端完整代码，以及非常详细的Socket对象方法介绍和示例以及完整的实现步骤，也很方便新手学习和复现。
C# Socket编程入门实例
10-09
本入门实例将带你走进C# Socket编程的世界，通过具体的代码示例，帮助你理解其核心概念和用法。 首先，Socket是网络通信中的一个接口（API），它允许应用程序通过网络发送和接收数据。在C#中，Socket类位于System...
C#socket编程从入门到精通
04-16
在探讨C# socket编程的过程中，我们首先需要了解的是如何操作IP地址，这是进行网络通信的基础。C#中的IPAddress类提供了方便的方法...对于希望从入门到精通C# socket编程的读者而言，这些内容是必须掌握的核心知识点。
c_socket编程入门
12-06
### C# Socket编程入门 #### 一、C# Socket编程概述 C# 是一种现代的、面向对象的编程语言，广泛应用于各种类型的软件开发中，包括网络应用开发。在网络编程领域，Socket 编程是非常核心的技术之一。在 .NET ...
Socket编程技术
jkinbor的博客
08-22 763
经过上述分析汇总，应该清楚了，在进行网络通信编程时，如果出现了跨平台、跨语言的场景，一定要注意字节序的影响，除此之外还要注意字符编码、通讯协议的实现、驱动程序等也会出现字节序的问题，影响开发调试进度。最近几年忙于云平台和架构的设计与研发，现在终于有时间来整理一下知识点了。一开始没有整理这篇文章的计划，搜了半天文章，感觉都不是很全面，为此就有了写此文的想法。
C#中简单Socket编程
weixin_45144862的博客
07-09 1686
TCP通信服务端的通信过程是：第一步调用Socket创建套接字。第二步：调用Bind()函数将套接字绑定到指定的IP地址和端口号。第三步：调用Listen()函数监听套接字。Socket分为面向连接的套接字(TCP套接字)和面向消息的套接字(UDP 套接字)。客户端套接字通信过程是：第一步:调用Socket类创建套接字。第一步：创建套接字。第一步：创建套接字。第二步：将套接字绑定到指定IP地址和端口号。UDP通信是面向消息的通信方式。接下来，我用C#语言来进行简单的TCP通信和UDP通信。
C#编写Socket服务器
m0_73500215的博客
04-15 3298
由Socket慨念，Socket一般应用模式，Socket的通讯过程，再逐步深入到项目界面设计，程序编码，叫你一步步实现用C#编写Socket服务器，代码全部都有注释。
使用C#编写Sockets
qq_35229383的博客
02-13 1920
C#可以用于编写简单、可扩展的Socket应用程序。主要流程包括创建、连接、发送/接收数据、断开连接、关闭并释放资源。上面是一个示例代码片段，它显示了如何使用C#编写socket应用程序。其他文章C#计算两线交点查看主页了解更多内容查看主页了解更多内容。
C# Socket 编程
flysh05的专栏
07-10 2930
C# Socket 创建服务器和客户端通信。
【深入解析】C#高级Socket工具类及其使用教程——服务端与客户端
ck23456的博客
11-11 2164
在.NET开发中，Socket编程是网络编程的基础，主要包括服务端和客户端的建立与通信。本文将介绍一个C# Socket工具类，包括服务端和客户端，并通过实例来详细说明如何使用。通过以上示例，我演示了如何使用我的Socket工具类进行服务端和客户端的建立与通信。希望这个教程能够帮助到你。以上就是我的分享，如有任何问题，欢迎在评论区留言，我将尽快为你解答。
C#网络编程（Socket编程）
dust__的博客
04-02 2万+
一、Socket网络编程 1.Socket是什么？ 在计算机通信领域，Socket被译为“套接字”。它是计算机之间进行通信的一种约定或一种方式。通过Socket这种约定可以接收到其他计算机的数据，也可以向其他计算机发送数据。 2.本质 是编程接口（API），对于TCP/IP的封装，TCP/IP也提供了可供程序员做网络开发所用的接口 3.作用 Socket的英文原意是“插座”,的意思，通常在计算机编...
在C#中使用Socket通信
仰望星空的博客
06-11 2963
文章按照 Socket 的 创建、连接、传输数据、释放资源的过程来写。给出方法、参数的详细信息。
Socket编程示例：C#服务端、客户端和心跳实现
weixin_48588665的博客
08-05 9769
本示例提供了使用C#编程语言实现Socket通信的完整示例代码。包括服务端和客户端的实现，服务端支持多个连接，并在客户端与服务端之间实现了心跳机制。心跳机制用于维持连接的活跃性和检测连接是否断开。服务端和客户端的代码都做了详细注释，方便阅读和理解。通过该示例，你将学习如何创建基本的服务端和客户端，并了解如何添加心跳功能以确保连接的稳定性。无论是初学者还是有经验的开发者，这个示例都将为你提供一个完整的Socket编程实现的参考。
C#语言编写Socket服务端程序
weixin_44818588的博客
08-28 446
【代码】C#语言编写Socket服务端程序。
C# Socket编程入门实例：服务端与接收消息
这份文档不仅提供了基础的Socket编程实例，还展示了如何在C#中管理Socket连接，确保资源的合理使用和线程安全。对于想要学习C#网络编程尤其是Socket编程的新手来说，这是一个很好的起点，能够帮助他们理解Socket通信...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值