C# 服务端与客户端示例（Socket通信）

最新推荐文章于 2024-03-22 18:19:52 发布
最新推荐文章于 2024-03-22 18:19:52 发布
阅读量2.4w 收藏 64
点赞数 14
分类专栏： C# 服务端与客户端示例 文章标签： C# 服务端与客户端示例 Socket通信
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/scimence/article/details/52957829
版权

服务器、客户端示例.exe下载 

http://scimence.cn/soft/MessageServer/MessageServer_EXE.zip

 

服务器端源码：

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace MessageServer
{
    static class Program
    {
        /// <summary>
        /// 应用程序的主入口点。
        /// </summary>
        [STAThread]
        static void Main(String[] args)
        {
            if (args.Length > 1)    // 通过命令行参数启动服务,如： call "%~dp0MessageServer.exe" 127.0.0.1 37280
            {
                new Server(null, args[0], args[1]).start();
            }
            else
            {   // 通过windows窗体启动服务
                Application.EnableVisualStyles();
                Application.SetCompatibleTextRenderingDefault(false);
                Application.Run(new MessageServer());
            }
        }
    }
}

namespace MessageServer
{
    using System;
    using System.Collections.Generic;
    using System.Net;
    using System.Net.Sockets;
    using System.Runtime.CompilerServices;
    using System.Runtime.InteropServices;
    using System.Text;
    using System.Threading;

    public class Server
    {
        public string ipString = "127.0.0.1";   // 服务器端ip
        public int port = 37280;                // 服务器端口
        
        public Socket socket;
        public Print print;                     // 运行时的信息输出方法

        public Dictionary<string, Socket> clients = new Dictionary<string, Socket>();   // 存储连接到服务器的客户端信息
        public bool started = false;            // 标识当前是否启动了服务

        public Server(Print print = null, string ipString = null, int port = -1)
        {
            this.print = print;
            if (ipString != null) this.ipString = ipString;
            if (port >= 0)this.port = port;
        }

        public Server(Print print = null, string ipString = null, string port = "-1")
        {
            this.print = print;
            if (ipString != null) this.ipString = ipString;

            int port_int = Int32.Parse(port);
            if (port_int >= 0) this.port = port_int;
        }

        /// <summary>
        /// Print用于输出Server的输出信息
        /// </summary>
        public delegate void Print(string info);

        /// <summary>
        /// 启动服务
        /// </summary>
        public void start()
        {
            try
            {
                IPAddress address = IPAddress.Parse(ipString);
                socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                socket.Bind(new IPEndPoint(address, port));   
                socket.Listen(10000);

                if (print != null)
                {
                    try { print("启动服务【" + socket.LocalEndPoint.ToString() + "】成功"); }
                    catch { print = null; }
                }
                started = true;

                new Thread(listenClientConnect).Start(socket);  // 在新的线程中监听客户端连接
            }
            catch (Exception exception)
            {
                if (print != null)
                {
                    print("启动服务失败 " + exception.ToString());
                }
                started = false;
            }
        }

        /// <summary>
        /// 监听客户端的连接
        /// </summary>
        private void listenClientConnect(object obj)
        {
            Socket socket = (Socket) obj;
            while (true)
            {
                Socket clientScoket = socket.Accept();
                if (print != null)
                {
                    print("客户端" + clientScoket.RemoteEndPoint.ToString() + "已连接");
                }
                new Thread(receiveData).Start(clientScoket);   // 在新的线程中接收客户端信息

                Thread.Sleep(1000);                            // 延时1秒后，接收连接请求
                if (!started) return;
            }
        }

        /// <summary>
        /// 发送信息
        /// </summary>
        public void Send(string info, string id)
        {
            if (clients.ContainsKey(id))
            {
                Socket socket = clients[id];

                try 
                { 
                    Send(socket, info); 
                }
                catch(Exception ex)
                {
                    clients.Remove(id);
                    if (print != null) print("客户端已断开，【" + id + "】");
                }
            }
        }

        /// <summary>
        /// 通过socket发送数据data
        /// </summary>
        private void Send(Socket socket, string data)
        {
            if (socket != null && data != null && !data.Equals(""))
            {
                byte[] bytes = Encoding.UTF8.GetBytes(data);   // 将data转化为byte数组
                socket.Send(bytes);                            // 
            }
        }

        private string clientIp = "";
        /// <summary>
        /// 输出Server的输出信息到客户端
        /// </summary>
        public void PrintOnClient(string info)
        {
            Send(info, clientIp);
        }

        /// <summary>
        /// 接收通过socket发送过来的数据
        /// </summary>
        private void receiveData(object obj)
        {
            Socket socket = (Socket) obj;

            string clientIp = socket.RemoteEndPoint.ToString();                 // 获取客户端标识 ip和端口
            if (!clients.ContainsKey(clientIp)) clients.Add(clientIp, socket);  // 将连接的客户端socket添加到clients中保存
            else clients[clientIp] = socket;

            while (true)
            {
                try
                {
                    string str = Receive(socket);
                    if (!str.Equals(""))
                    {
                        if (str.Equals("[.Echo]"))
                        {
                            this.clientIp = clientIp;
                            print = new Print(PrintOnClient);     // 在客户端显示服务器输出信息
                        }
                        if (print != null) print("【" + clientIp + "】" + str);

                        if (str.Equals("[.Shutdown]")) Environment.Exit(0); // 服务器退出
                        else if (str.StartsWith("[.RunCmd]")) runCMD(str);  // 执行cmd命令
                    }
                }
                catch (Exception exception)
                {
                    if (print != null) print("连接已自动断开，【" + clientIp + "】" + exception.Message);

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

                    if (clients.ContainsKey(clientIp)) clients.Remove(clientIp);
                    return;
                }

                if (!started) return;
                Thread.Sleep(200);      // 延时0.2秒后再接收客户端发送的消息
            }
        }

        /// <summary>
        /// 执行cmd命令
        /// </summary>
        private void runCMD(string cmd)
        {
            new Thread(runCMD_0).Start(cmd);
        }

        /// <summary>
        /// 执行cmd命令
        /// </summary>
        private void runCMD_0(object obj)
        {
            string cmd = (string)obj;
            string START = "[.RunCmd]";
            if (cmd.StartsWith(START))
            {
                cmd = cmd.Substring(START.Length);  // 获取cmd信息
                Cmd.Run(cmd, print);                // 执行cmd，输出执行结果到print
            }
        }

        /// <summary>
        /// 从socket接收数据
        /// </summary>
        private string Receive(Socket socket)
        {
            string data = "";

            byte[] bytes = null;
            int len = socket.Available;
            if (len > 0)
            {
                bytes = new byte[len];
                int receiveNumber = socket.Receive(bytes);
                data = Encoding.UTF8.GetString(bytes, 0, receiveNumber);
            }

            return data;
        }

        /// <summary>
        /// 停止服务
        /// </summary>
        public void stop()
        {
            started = false;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace MessageServer
{
    /// <summary>
    /// 执行CMD命令，或以进程的形式打开应用程序（d:\*.exe）
    /// </summary>
    public class Cmd
    {
        /// <summary>
        /// 以后台进程的形式执行应用程序（d:\*.exe）
        /// </summary>
        public static Process newProcess(String exe)
        {
            Process P = new Process();
            P.StartInfo.CreateNoWindow = true;
            P.StartInfo.FileName = exe;
            P.StartInfo.UseShellExecute = false;
            P.StartInfo.RedirectStandardError = true;
            P.StartInfo.RedirectStandardInput = true;
            P.StartInfo.RedirectStandardOutput = true;
            //P.StartInfo.WorkingDirectory = @"C:\windows\system32";
            P.Start();
            return P;
        }

        /// <summary>
        /// 执行CMD命令
        /// </summary>
        public static string Run(string cmd)
        {
            Process P = newProcess("cmd.exe");
            P.StandardInput.WriteLine(cmd);
            P.StandardInput.WriteLine("exit");
            string outStr = P.StandardOutput.ReadToEnd();
            P.Close();
            return outStr;
        }

        /// <summary>
        /// 定义委托接口处理函数，用于实时处理cmd输出信息
        /// </summary>
        public delegate void Callback(String line);

        / <summary>
        / 此函数用于实时显示cmd输出信息, Callback示例
        / </summary>
        //private void Callback1(String line)
        //{
        //    textBox1.AppendText(line);
        //    textBox1.AppendText(Environment.NewLine);
        //    textBox1.ScrollToCaret();

        //    richTextBox1.SelectionColor = Color.Green;
        //    richTextBox1.AppendText(line);
        //    richTextBox1.AppendText(Environment.NewLine);
        //    richTextBox1.ScrollToCaret();
        //}


        /// <summary>
        /// 执行CMD语句,实时获取cmd输出结果，输出到call函数中
        /// </summary>
        /// <param name="cmd">要执行的CMD命令</param>
        public static string Run(string cmd, Server.Print call)
        {
            String CMD_FILE = "cmd.exe"; // 执行cmd命令

            Process P = newProcess(CMD_FILE);
            P.StandardInput.WriteLine(cmd);
            P.StandardInput.WriteLine("exit");

            string outStr = "";
            string line = "";
            string baseDir = System.AppDomain.CurrentDomain.BaseDirectory.TrimEnd('\\');

            try
            {
                for (int i = 0; i < 3; i++) P.StandardOutput.ReadLine();

                while ((line = P.StandardOutput.ReadLine()) != null || ((line = P.StandardError.ReadToEnd()) != null && !line.Trim().Equals("")))
                {
                    // cmd运行输出信息
                    if (!line.EndsWith(">exit") && !line.Equals(""))
                    {
                        if (line.StartsWith(baseDir + ">")) line = line.Replace(baseDir + ">", "cmd>\r\n"); // 识别的cmd命令行信息
                        line = ((line.Contains("[Fatal Error]") || line.Contains("ERROR:") || line.Contains("Exception")) ? "【E】 " : "") + line;
                        if (call != null) call(line);
                        outStr += line + "\r\n";
                    }
                }
            }
            catch (Exception ex)
            {
                if (call != null) call(ex.Message);
                //MessageBox.Show(ex.Message);
            }

            P.WaitForExit();
            P.Close();

            return outStr;
        }


        /// <summary>
        /// 以进程的形式打开应用程序（d:\*.exe）,并执行命令
        /// </summary>
        public static void RunProgram(string programName, string cmd)
        {
            Process P = newProcess(programName);
            if (cmd.Length != 0)
            {
                P.StandardInput.WriteLine(cmd);
            }
            P.Close();
        }


        /// <summary>
        /// 正常启动window应用程序（d:\*.exe）
        /// </summary>
        public static void Open(String exe)
        {
            System.Diagnostics.Process.Start(exe);
        }

        /// <summary>
        /// 正常启动window应用程序（d:\*.exe）,并传递初始命令参数
        /// </summary>
        public static void Open(String exe, String args)
        {
            System.Diagnostics.Process.Start(exe, args);
        }
    }
}

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace MessageServer
{
    public partial class MessageServer : Form
    {
        Server server;

        public MessageServer()
        {
            InitializeComponent();
        }

        // 启动服务
        private void button_start_Click(object sender, EventArgs e)
        {
            if (server == null) server = new Server(SeverPrint, textBox_Ip.Text, textBox_Port.Text);
            if (!server.started) server.start();
        }

        // 服务器端输出信息
        private void SeverPrint(string info)
        {
            if (textBox_showing.IsDisposed) server.print = null;
            else
            {
                if (textBox_showing.InvokeRequired)
                {
                    Server.Print F = new Server.Print(SeverPrint);
                    this.Invoke(F, new object[] { info });
                }
                else
                {
                    if (info != null)
                    {
                        textBox_showing.SelectionColor = Color.Green;
                        textBox_showing.AppendText(info);
                        textBox_showing.AppendText(Environment.NewLine);
                        textBox_showing.ScrollToCaret();
                    }
                }
            }
        }

        // 发送信息到客户端
        private void button_send_Click(object sender, EventArgs e)
        {
            if (server != null) server.Send(textBox_send.Text, comboBox_clients.Text);
        }

        private void MessageServer_FormClosed(object sender, FormClosedEventArgs e)
        {
            //if (server != null) server.stop();
        }

        // 选择客户端时，更新客户端列表信息
        private void comboBox_clients_DropDown(object sender, EventArgs e)
        {
            if (server != null)
            {
                List<string> clientList = server.clients.Keys.ToList<string>();
                comboBox_clients.DataSource = clientList;
            }
        }

    }
}

 

客户端源码：

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace MessageClient
{
    static class Program
    {
        /// <summary>
        /// 应用程序的主入口点。
        /// </summary>
        [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new MessageClient());
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace MessageClient
{
    class Client
    {
        public string ipString = "127.0.0.1";   // 服务器端ip
        public int port = 37280;                // 服务器端口
        public Socket socket;
        public Print print;                     // 运行时的信息输出方法
        public bool connected = false;          // 标识当前是否连接到服务器
        public string localIpPort = "";         // 记录本地ip端口信息

        public Client(Print print = null, string ipString = null, int port = -1)
        {
            this.print = print;
            if (ipString != null) this.ipString = ipString;
            if (port >= 0) this.port = port;
        }

        public Client(Print print = null, string ipString = null, string port = "-1")
        {
            this.print = print;
            if (ipString != null) this.ipString = ipString;

            int port_int = Int32.Parse(port);
            if (port_int >= 0) this.port = port_int;
        }


        /// <summary>
        /// Print用于输出Server的输出信息
        /// </summary>
        public delegate void Print(string info);

        /// <summary>
        /// 启动客户端，连接至服务器
        /// </summary>
        public void start()
        {
            //设定服务器IP地址  
            IPAddress ip = IPAddress.Parse(ipString);
            socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            try
            {
                socket.Connect(new IPEndPoint(ip, port));   // 连接服务器
                if (print != null) print("连接服务器【" + socket.RemoteEndPoint.ToString() + "】完成"); // 连接成功
                localIpPort = socket.LocalEndPoint.ToString();
                connected = true;

                Thread thread = new Thread(receiveData);
                thread.Start(socket);      // 在新的线程中接收服务器信息

            }
            catch (Exception ex)
            {
                if (print != null) print("连接服务器失败 " + ex.ToString()); // 连接失败
                connected = false;
            }
        }

        /// <summary>
        /// 结束客户端
        /// </summary>
        public void stop()
        {
            connected = false;
        }

        /// <summary>
        /// 发送信息
        /// </summary>
        public void Send(string info)
        {
            try
            {
                Send(socket, info);
            }
            catch (Exception ex)
            {
                if (print != null) print("服务器端已断开，【" + socket.RemoteEndPoint.ToString() + "】");
            }
        }

        /// <summary>
        /// 通过socket发送数据data
        /// </summary>
        private void Send(Socket socket, string data)
        {
            if (socket != null && data != null && !data.Equals(""))
            {
                byte[] bytes = Encoding.UTF8.GetBytes(data);   // 将data转化为byte数组
                socket.Send(bytes);                            // 
            }
        }

        /// <summary>
        /// 接收通过socket发送过来的数据
        /// </summary>
        private void receiveData(object socket)
        {
            Socket ortherSocket = (Socket)socket;

            while (true)
            {
                try
                {
                    String data = Receive(ortherSocket);       // 接收客户端发送的信息
                    if (!data.Equals(""))
                    {
                        //if (print != null) print("服务器" + ortherSocket.RemoteEndPoint.ToString() + "信息：\r\n" + data);
                        if (print != null) print(data);
                        if (data.Equals("[.Shutdown]")) System.Environment.Exit(0);
                    }
                }
                catch (Exception ex)
                {
                    if (print != null) print("连接已自动断开，" + ex.Message);
                    ortherSocket.Shutdown(SocketShutdown.Both);
                    ortherSocket.Close();
                    connected = false;
                    break;
                }

                if (!connected) break;
                Thread.Sleep(200);      // 延时0.2后处理接收到的信息
            }
        }

        /// <summary>
        /// 从socket接收数据
        /// </summary>
        private string Receive(Socket socket)
        {
            string data = "";

            byte[] bytes = null;
            int len = socket.Available;
            if (len > 0)
            {
                bytes = new byte[len];
                int receiveNumber = socket.Receive(bytes);
                data = Encoding.UTF8.GetString(bytes, 0, receiveNumber);
            }

            return data;
        }
    }
}

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace MessageClient
{
    public partial class MessageClient : Form
    {
        Client client;    // 客户端实例

        public MessageClient()
        {
            InitializeComponent();
        }

        // 连接服务器
        private void button_connect_Click(object sender, EventArgs e)
        {
            if (client == null) client = new Client(ClientPrint, textBox_Ip.Text, textBox_Port.Text);
            if (!client.connected) client.start();
            if (client != null) this.Text = "客户端 " + client.localIpPort;
        }

        // 客户端输出信息
        private void ClientPrint(string info)
        {
            if (textBox_showing.InvokeRequired)
            {
                Client.Print F = new Client.Print(ClientPrint);
                this.Invoke(F, new object[] { info });
            }
            else
            {
                if (info != null)
                {
                    textBox_showing.SelectionColor = Color.Green;
                    textBox_showing.AppendText(info);
                    textBox_showing.AppendText(Environment.NewLine);
                    textBox_showing.ScrollToCaret();
                }
            }
        }

        // 发送信息到服务器
        private void button_send_Click(object sender, EventArgs e)
        {
            if (client != null && client.connected)
            {
                string info = textBox_send.Text;
                if (checkBox_isCmd.Checked && !info.StartsWith("[.RunCmd]"))    // 添加cmd串头信息
                    info = "[.RunCmd]" + info;

                client.Send(info);
            }
        }

        // 关闭界面停止服务运行
        private void MessageClient_FormClosed(object sender, FormClosedEventArgs e)
        {
            if (client != null && client.connected)
                client.stop();
        }

        private void linkLabel_closeServer_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
        {
            if (client != null && client.connected)
                client.Send("[.Shutdown]");
        }

        private void linkLabel_Echo_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
        {
            if (client != null && client.connected)
                client.Send("[.Echo]");
        }
    }
}

 

安卓客户端Socket示例：https://blog.csdn.net/scimence/article/details/92832245

scimence
关注
  • 14
    点赞
  • 踩
  • 64
    收藏
    觉得还不错? 一键收藏
  • 11
    评论
专栏目录
WebSocket和Socket Client连共同Sever端并实现相互通信（C#、JS、C++）
09-19
PC端一般使用c++或c# socket收发信息，网页端只能使用websocket，手机端是java socket。需要将PC端、手机端和网页端，多端打通同时实现即时通讯，就是需要websocket和socket相互通信。
C#利用Socket实现客户端通信（包含：服务器和客户端通信，客户端通过服务器和客户端通信）
ba_wang_mao的专栏
07-21 7341
实验功能： 设计程序，分别构建通信的两端:服务器端和客户端应用程序,套接字类型为面向连接的Socket,自己构建双方的应答模式，实现双方的数据的发送和接收（S发给C，C发给S）。 服务端程序能响应单个或任意多个客户端连接请求；服务端能向单个客户发送消息，支持群发消息给所有客户端； 通信的双方具备异常响应功能，包括对方异常退出的处理。如果客户端退出，服务器有响应；反之亦然。 客户端之间直接通信，C与C之间直接通信（不是通过S传递）。 设计思路： 服务..
C#中Socket的简单使用
最新发布
qq_44625976的博客
03-22 432
当两台主机通信是,必须通过Socket连接,Socket则利用TCP/IP协议建立TCP连接.TCP连接则更依赖于底层的IP协议.Socket是控制层传输协议.Socket其实并不是一个协议,而是为了方便使用TCP或UDP而抽象出来的一层,是位于应用层和传输控制层之间的一组接口.第四步:客户端和服务端就建立起了双工同信,客户端与服务端就可以实现彼此发送消息。第三步:服务器接收连接请求后创建Socket连接,并维护这个连接队列。第二步:客户端向服务端地址和端口发起Socket请求。
C#.网络编程 Socket基础（二） 基于WinForm系统Socket TCP协议 实现端到端（服务器与客户端）图片传输
xpj8888的博客
10-27 2850
一、简介 本文主要参考相关网页，进行设计，实现简单的基于WinForm的Socket TCP协议 实现端到端（服务器与客户端）图片传输。相关网址为 https://www.cnblogs.com/wuzhang/p/wuzhang20141119.html https://blog.csdn.net/z5976749/article/details/40743487 本文知识的主要继承是来...
C# winform socket一个服务端和多个客户端进行通信
yueguanyun的专栏
04-21 2万+
 参看此链接http://blog.csdn.net/zdyueguanyun/article/details/51207727 在上述代码的基础上进行了修改，包括一些捕获异常以及按钮的应用，扩充了一个listbox确保服务端可以选择和不同的客户端进行通信 代码： using System; using System.Collections.Generic; using System.
C# 6 与 .NET Core 1.0 高级编程 - 39 章 Windows 服务（上）
weixin_34405332的博客
02-14 153
译文，个人原创，转载请注明出处（C# 6 与 .NET Core 1.0 高级编程 - 39 章 Windows 服务（上）），不对的地方欢迎指出与交流。 章节出自《Professional C# 6 and .NET Core 1.0》。水平有限，各位阅读时仔细分辨，唯望莫误人子弟。 附英文版原文：Professional C# 6 and .NET Core 1.0 - Chapte...
C# Socket案例（服务端与客户端）
qq_42203978的博客
05-31 1万+
服务端完整代码 using System; using System.Net; using System.Net.Sockets; using System.Text; using System.Threading; using System.Windows.Forms; namespace ServerSocket { public partial class Form1 : ...
C# Windows Sockets (Winsock) 接口
weixin_30826095的博客
03-30 147
在.Net中，System.Net.Sockets 命名空间为需要严密控制网络访问的开发人员提供了 Windows Sockets (Winsock) 接口的托管实现。System.Net 命名空间中的所有其他网络访问类都建立在该套接字Socket实现之上，如TCPClient、TCPListener 和 UDPClient 类封装有关创建到 Internet 的 TCP 和 UDP 连接的详细信...
C#使用Windows窗体应用实现Socket异步通讯
尽早点完技能点，升到顶级。
04-06 261
【代码】C#使用Windows窗体应用实现Socket异步通讯。
C# Socket网络编程入门（服务器与客户端通信，客户端与客户端通信）
黄瓜炒鸡蛋的博客
08-12 3689
C# Socket 入门
C#实现简单TCP服务器和客户端网络编程
book_dw5189的博客
08-23 4129
NetworkStream 类位于 System.Net.Sockets 命名空间中，用于在网络套接字上提供流式数据传输的功能。
C# 一对多远程屏幕监控 可用于多终端切屏投影
11-18
C# 一对多远程屏幕监控 可用于多终端切屏投影，一个管理端，一个客户端，需要在客户端设置好管理端IP地址，客户端上线下线管理端自动感知，管理端可随意切换要查看的屏幕，项目采用VS2012编写。 可用作学习屏幕录像、屏幕截图、网络发送、SOCKET编程的资料。 项目基本成熟，可用于生产环境，程序运行稳定
C#写的TCP客户端和服务端
09-18
C#写的TCP客户端和服务端互通源码，0分下载了
c#客户端服务端的通信示例
08-02
资源里面clientV1.0一个客户端对一个服务端的示例，可直接运行；clientV2.0一个服务端对多个客户端的示例，可以直接运行；client3.0多个客户端对多个服务端，还未完成；
C#使用Socket实现服务器与多个客户端通信(简单的聊天系统)
08-25
主要介绍了C#使用Socket实现服务器与多个客户端通信(简单的聊天系统)，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
详解C# Socket简单例子（服务器与客户端通信）
01-20
这个例子只是简单实现了如何使用 Socket 类实现面向连接的通信。 注意：此例子的目的只是为了说明用套接字写程序的大概思路，而不是实际项目中的使用程序。在这个例子中，实际上还有很多问题没有解决，如消息边界...
C#使用Socket实现心跳的方法示例
08-25
主要介绍了C#使用Socket实现心跳的方法示例，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
C#通信_TCPIP_基于C#的TCPip通信示例_服务器_
10-03
实现了tcpip通信协议的服务器和客户端
\u5b57\u7b26 字符转换 （Unicode字符与中文的相互转化）
热门推荐
scimence的专栏
09-20 3万+
\u55\u5b57\u7b26 U字符转换 Unicode字符与中文的相互转化
C# 服务端监听客户端连接
05-21
在 C# 中实现服务端监听客户端连接可以使用 Socket 类。以下是一个简单的示例代码： ```csharp using System; using System.Net; using System.Net.Sockets; namespace ServerExample { class Program { static void Main(string[] args) { // 创建一个 TCP/IP socket Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); // 获取本地 IP 地址 IPAddress ipAddress = IPAddress.Parse("127.0.0.1"); // 绑定 IP 地址和端口号 IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 8080); listener.Bind(localEndPoint); // 开始监听连接请求 listener.Listen(10); Console.WriteLine("等待客户端连接..."); while (true) { // 接受连接请求并创建一个新的 socket Socket handler = listener.Accept(); // 处理客户端请求 byte[] buffer = new byte[1024]; int bytesReceived = handler.Receive(buffer); string data = Encoding.ASCII.GetString(buffer, 0, bytesReceived); Console.WriteLine("接收到客户端数据：" + data); // 发送响应给客户端 byte[] response = Encoding.ASCII.GetBytes("已接收到您的请求"); handler.Send(response); // 关闭 socket handler.Shutdown(SocketShutdown.Both); handler.Close(); } } } } ``` 上述代码创建了一个服务端 socket，绑定了本地 IP 地址和端口号，并且开始监听连接请求。当有客户端连接请求时，接受连接请求并创建一个新的 socket，处理客户端请求并发送响应，最后关闭 socket。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值