Socket原理及代码（服务器端，自记录）

已于 2023-05-22 11:22:01 修改
阅读量556 收藏 2
点赞数
文章标签： 网络 服务器 c# tcp/ip
于 2023-05-22 10:45:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gong56/article/details/130801904
版权


1.创建Socket对象

public Socket Socket
        {
            get;
            private set;
        }

2.绑定监听端口-Bind

public bool Start(string ipString, int port)
        {
            IPAddress address = null;
            IPAddress.TryParse(ipString, out address);
            if (address == null)
            {
                Loggers.Logger.Info("IP地址格式不正确！" + ipString);
                return false;
            }
            else
            {
                this.Bind(new IPEndPoint(address, port));
                return this.Start(); //函数体在3.监听           
            }
        }
 private void Bind(EndPoint local)
        {
            try
            {
                this.Socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                this.Socket.Bind(local);
            }
            catch (Exception ex)
            {
                Loggers.Logger.Info(ex.Message);
                return;
            }

        }

3.监听-Listen

public bool Start()
        {
            if (this.Socket == null)
            {
                Loggers.Logger.Error("Socket对象不能为空！");
                return false;
            }
            try
            {
                //监听队列
                this.Backlog = 10;
                this.Socket.Listen(this.Backlog);
                Loggers.Logger.Info("启动服务成功！" + this.Socket.LocalEndPoint.ToString());
                this.State = true;
                //循环接收客户端连接，启动线程池！
                ThreadPool.QueueUserWorkItem(new WaitCallback(Accept));
       
                this._SysTimer = new System.Timers.Timer();
                this._SysTimer.Interval = 30 * 60 * 1000;
                this._SysTimer.Elapsed += SysTimer_Elapsed;
                this._SysTimer.Start();

                return true;
            }
            catch (Exception ex)
            {
                Loggers.Logger.Error("启动服务异常：" + ex.ToString());
                return false;
            }
        }

4.循环等待客户端连接-Accpet （注意：开线程池 ↑）

public void Accept(object args)
        {
            while (this.State && this.Socket != null)
            {
                try
                {
                    Socket client = this.Socket.Accept();
                    lock (this._dicSessions)
                    {
                        string key = client.RemoteEndPoint.ToString();//Guid.NewGuid().ToString();
                        if (this._dicSessions.ContainsKey(key) == false)
                        {
                            SocketSession session = new SocketSession(key, client);
                            //接收信息处理函数
                            session.ReceiveEncoding = this.ReceiveEncoding;
                            session.RemoteClose += Session_RemoteClose;
                            session.ReceiveData += Session_ReceiveData;
                            this._dicSessions.Add(key, session);
                            if (this.RemoteConnect != null)
                                this.RemoteConnect(key);
                            //开始接收数据
                            session.StartReceive();
                        }
                    }
                }
                catch (Exception ex)
                {
                    Loggers.Logger.Error("接收客户端异常：" + ex.ToString());
                }
            }
        }

程序参考（仅包含服务端Bind、 Listen、 Accept相关代码，接收Receive代码请参考下面的代码）

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


namespace SMS_YBS.IOCPSockets
{
    //从 Start(string ipString, int port) 函数开始调用
    /// <summary>
    /// Tcp Server
    /// </summary>
    public class TcpSocketServer : IDisposable
    {
        public Socket Socket
        {
            get;
            private set;
        }
        public int Backlog
        {
            get; set;
        }
        public bool State
        {
            get;
            private set;
        }
        /// <summary>
        /// 本地服务器
        /// </summary>
        public EndPoint Local
        {
            get;
            private set;
        }   
        /// <summary>
        /// 接收数据编码格式
        /// </summary>
        public Encoding ReceiveEncoding
        {
            get; set;
        }
        /// <summary>
        /// 远程数据
        /// </summary>
        public event OnRemoteConnectHanlder RemoteConnect = null;
        /// <summary>
        /// 接收数据
        /// </summary>
        public event OnReceiveDataHanlder ReceiveData = null;
        
        /// <summary>
      	/// 关闭远程
    	/// </summary>
   	    public event OnRemoteCloseHanlder RemoteClose = null;//public event 委托 事件；

        private Dictionary<string, SocketSession> _dicSessions = new Dictionary<string, SocketSession>();
        /// <summary>
        /// 获取连接对象
        /// </summary>
        public Dictionary<string, SocketSession> Sessions
        {
            get { return new Dictionary<string, SocketSession>(this._dicSessions); }
        }
        private System.Timers.Timer _SysTimer = null;
        private BackgroundWorker _Worker = null;
        private DateTime _RunTime = DateTime.Now;
        
        /// <summary>
        /// 绑定地址-
        /// </summary>
        /// <param name="local"></param>
        private void Bind(EndPoint local)
        {
            try
            {
                this.Socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                this.Socket.Bind(local);
            }
            catch (Exception ex)
            {
                Loggers.Logger.Info(ex.Message);
                return;
            }

        }

        #region 开始绑定接收连接
        /// <summary>
        /// 开始绑定接收连接
        /// </summary>
        /// <param name="ipString"></param>
        /// <param name="port"></param>
        /// <returns></returns>
        public bool Start(string ipString, int port)
        {
            IPAddress address = null;
            IPAddress.TryParse(ipString, out address);
            if (address == null)
            {
                Loggers.Logger.Info("IP地址格式不正确！" + ipString);
                return false;
            }
            else
            {
                this.Bind(new IPEndPoint(address, port));//IP和端口的整合称为终结点endpoint
                return this.Start();
               
            }
        }
        /// <summary>
        /// 开始绑定接收连接
        /// </summary>
        /// <param name="local"></param>
        /// <returns></returns>
        //public bool Start(EndPoint local)
        //{
        //    this.Bind(local);

        //    return this.Start();
        //}
        /// <summary>
        /// 开始绑定接收连接
        /// </summary>
        /// <returns></returns>
        public bool Start()
        {
            if (this.Socket == null)
            {
                Loggers.Logger.Error("Socket对象不能为空！");
                return false;
            }
            try
            {
                this.Backlog = 10;
                this.Socket.Listen(this.Backlog);
                Loggers.Logger.Info("启动服务成功！" + this.Socket.LocalEndPoint.ToString());
                this.State = true;

                ThreadPool.QueueUserWorkItem(new WaitCallback(Accept));
                //
                this._SysTimer = new System.Timers.Timer();
                this._SysTimer.Interval = 30 * 60 * 1000;//30分钟检查一次
                this._SysTimer.Elapsed += SysTimer_Elapsed;
                this._SysTimer.Start();

                return true;
            }
            catch (Exception ex)
            {
                Loggers.Logger.Error("启动服务异常：" + ex.ToString());
                return false;
            }
        }

        private void SysTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            if (this._Worker != null && this._Worker.IsBusy)
            {
                Loggers.Logger.Info("检查线程正在运行!");
                TimeSpan timeSpan = DateTime.Now - this._RunTime;
                if (timeSpan.TotalMinutes < 60)
                    return;

                Loggers.Logger.Info("检查线程超：" + timeSpan.TotalMinutes + "运行中，需要停止重新启动...");
                this.CheckClient();
            }
        }

        private void CheckClient()
        {
            this._RunTime = DateTime.Now;
            string[] keys = this._dicSessions.Keys.ToArray();
            foreach (var item in keys)
            {
                try
                {
                    int result = this._dicSessions[item].GetState();
                    Loggers.Logger.Info("返回结果：" + result);
                }
                catch (Exception ex)
                {
                    Loggers.Logger.Error("获取状态异常：" + ex.ToString());
                    this._dicSessions.Remove(item);
                }
            }
        }

        public void Accept(object args)
        {
            while (this.State && this.Socket != null)
            {
                try
                {
                    Socket client = this.Socket.Accept();
                    lock (this._dicSessions)
                    {
                        string key = client.RemoteEndPoint.ToString();//Guid.NewGuid().ToString();
                        if (this._dicSessions.ContainsKey(key) == false)
                        {
                            SocketSession session = new SocketSession(key, client);
                            session.ReceiveEncoding = this.ReceiveEncoding;
                            session.RemoteClose += Session_RemoteClose;
                            session.ReceiveData += Session_ReceiveData;
                            this._dicSessions.Add(key, session);
                            if (this.RemoteConnect != null)
                                this.RemoteConnect(key);

                            //开始接收数据
                            session.StartReceive();
                        }
                    }
                }
                catch (Exception ex)
                {
                    Loggers.Logger.Error("接收客户端异常：" + ex.ToString());
                }
            }
        }

        private void Session_ReceiveData(IPEndPoint remote, byte[] buffer, int count)
        {
            if (this.ReceiveData != null)
                this.ReceiveData(remote, buffer, count);
        }

        private void Session_RemoteClose(string key)
        {
            if (this._dicSessions.ContainsKey(key))
                this._dicSessions.Remove(key);

            if (this.RemoteClose != null)
                this.RemoteClose(key);
        }
        #endregion

        #region 向远程客户端发送信息
        /// <summary>
        /// 向远程客户端发送信息
        /// </summary>
        /// <param name="ipString"></param>
        /// <param name="port"></param>
        /// <param name="data"></param>
        /// <returns></returns>
        public int SendTo(string key, byte[] data)
        {
            if (this._dicSessions.ContainsKey(key) == false)
            {
                Loggers.Logger.Info("未能找到远程连接：" + key);
                return -1;
            }
            var session = this._dicSessions[key];
            return session.Send(data);
        }
        /// <summary>
        /// 向远程客户端发送信息
        /// </summary>
        /// <param name="ipString"></param>
        /// <param name="port"></param>
        /// <param name="data"></param>
        /// <returns></returns>
        public int SendTo(SocketSession session, byte[] data)
        {
            return session.Send(data);
        }
        /// <summary>
        /// 向远程客户端发送信息
        /// </summary>
        /// <param name="remote"></param>
        /// <param name="data"></param>
        /// <returns></returns>
        public Dictionary<string, string> SendTo(byte[] data)
        {
            Dictionary<string, string> list = new Dictionary<string, string>();
            if (this._dicSessions.Count <= 0)
            {
                Loggers.Logger.Info("未能找到远程连接!");
                return list;
            }
            bool success = true;
            string[] keys = this._dicSessions.Keys.ToArray();
            foreach (var item in keys)
            {
                try
                {
                    this._dicSessions[item].Send(data);
                }
                catch (Exception ex)
                {
                    success = false;
                    Loggers.Logger.Error("发送数据异常：" + ex.ToString());
                    this._dicSessions.Remove(item);//移除发送失败的远程连接
                }
            }
            //存在发送失败的远程
            if (success == false)
            {
                if (this.RemoteClose != null)
                    this.RemoteClose(null);
            }
            return list;
        }

        /// <summary>
        /// 向远程客户端发送信息
        /// </summary>
        /// <param name="remote"></param>
        /// <param name="data"></param>
        /// <returns></returns>
        public Task<int> SendToAsync(string key, byte[] data)
        {
            return new Task<int>(() => this.SendTo(key, data));
        }
        /// <summary>
        /// 向远程客户端发送信息
        /// </summary>
        /// <param name="remote"></param>
        /// <param name="data"></param>
        /// <returns></returns>
        public Task<Dictionary<string, string>> SendToAsync(byte[] data)
        {
            return Task.Factory.StartNew<Dictionary<string, string>>(() => {
                return this.SendTo(data);
            });
        }


        #endregion
        /// <summary>
        /// 停止监听
        /// </summary>
        public void Close()
        {
            this.ClientClose();

            if (this.Socket != null)
            {
                //由于套接字没有连接并且(当使用一个 sendto 调用发送数据报套接字时)没有提供地址，发送或接收数据的请求没有被接受。
                //this.Socket.Disconnect(true);

                this.Socket.Close(3);
                this.Socket.Dispose();
                this.Socket = null;
            }
        }

        private void ClientClose()
        {
            string[] keys = this._dicSessions.Keys.ToArray();
            foreach (var item in keys)
            {
                try
                {
                    Loggers.Logger.Info("开始关闭：" + this._dicSessions[item].Client.RemoteEndPoint.ToString() + "...");
                    this._dicSessions[item].Close();
                    this._dicSessions.Remove(item);
                    Loggers.Logger.Info("关闭成功");
                }
                catch (Exception ex)
                {
                    Loggers.Logger.Error("关闭异常：" + ex.ToString());
                    this._dicSessions.Remove(item);
                }
            }
        }
        /// <summary>
        /// 释放资源
        /// </summary>
        public void Dispose()
        {
            this.Close();
        }
    }
}

5.接收客户端的消息-Receive （注意：开线程池 ，循环接收）

 public bool StartReceive()
        {
            if (this.Client == null)
            {
                Loggers.Logger.Error("远程对象不能为空！");
                return false;
            }
            try
            {
                this.State = true;
                ThreadPool.QueueUserWorkItem(new WaitCallback(ReceiveThread));
                Loggers.Logger.Info(this.Client.LocalEndPoint.ToString() + "启动接收数据成功！");
                return true;
            }
            catch (Exception ex)
            {
                Loggers.Logger.Error("服务端启动异常：" + ex.ToString());
                return false;
            }
        }
    
private void ReceiveThread(object state)
        {
            while (this.State && this.Client != null && this.Client.Connected)
            {
                try
                {
                    byte[] mBuffer = new byte[10 * 1024];
                    int count = 0;
                    if (this.Client.Poll(-1, SelectMode.SelectRead))
                    {
                        count = this.Client.Receive(mBuffer);
                        if (count <= 0)
                        {
                            //连接已断开
                            this.Close();
                            return;
                        }
                    }
                        if (this.ReceiveEncoding == null)
                        this.ReceiveEncoding = System.Text.Encoding.UTF8;
                    //引发事件
                    if (this.ReceiveData != null)
                        this.ReceiveData((IPEndPoint)this.Client.RemoteEndPoint, mBuffer, count);
                }
                catch (Exception ex)
                {
                    //this.State = false;
                    Loggers.Logger.Error("接收数据异常：" + this.Client.RemoteEndPoint + ex.ToString());
                    this.Close();
                    return;
                }
            }
        }
G鑫莹
关注
socket服务端代码实现
qq_52025506的博客
10-10 270
socket服务端
Socket客户端与服务器测试C#源代码
最新发布
07-25
实现测试代码：使用Socket编程接口，编写客户端和服务器端的测试代码。这些代码应包含测试用例中涉及的所有操作。 运行测试：启动客户端和服务器端程序，进行实际测试。可以通过手动或自动化方式发送测试数据，并...
socket服务端源码
08-14
代码由vs2008 mfc编写，服务端可与客户端互联，实现收发消息，并可实现十六进制和十进制两种显示方式，此外还包括两条发送指令，项目中用到
【Linux 内核网络协议栈源码剖析】socket 函数剖析
wenqian 'blog
07-01 7026
深度剖析网络协议栈中的 socket 函数，可以说是把前面介绍的串联起来，将网络协议栈各层关联起来。
socket代码
nextop88的专栏
01-24 564
The following Socket errors reported in Trace Log of config screen:   Socket error 10004 - Interrupted function call Socket error 10013 - Permission denied Socket error 10014 - Bad address Socket
socket 服务端简单代码（一）
qq_53022114的博客
02-18 287
#include<stdio.h> #include <sys/types.h> /* See NOTES */ #include <sys/socket.h> //#include <linux/in.h> #include <arpa/inet.h> #include <netinet/in.h> #include<stdlib.h> int main() { int s_fd; /
使用SOCKET制作的聊天工具服务器端。
07-01
本文将详细解析基于Socket创建的聊天工具服务器端的核心概念、原理以及相关技术。 标题"使用SOCKET制作的聊天工具服务器端"指的是利用Socket编程技术构建一个能够处理多客户端连接并进行实时通信的服务器应用。...
SOCKET服务器端程序C# vs2015
09-07
Socket服务器端程序是网络编程中的一个重要概念，它用于在服务器和客户端之间建立通信连接，进行数据传输。在C#编程语言中，我们可以利用System.Net命名空间下的Socket类来实现这样的功能。本教程主要针对初学者，...
socket群组聊天服务器端客户端源码
04-29
本文将深入解析“socket群组聊天服务器端客户端源码”的相关知识点，帮助读者理解如何利用Socket技术实现一个简单的群组多人聊天系统。 首先，我们来看“Socket”这个词。Socket在计算机网络中是一个接口，它允许...
C# 文件传输客户端和服务器端
02-07
一旦接收到连接，服务器端就会创建一个新的Socket用于与客户端进行数据交换。客户端则需要创建一个Socket，连接到服务器的特定IP地址和端口号。 客户端代码的关键部分包括： 1. 创建Socket实例。 2. 使用Connect...
socket服务端和客户端完整代码
10-23
socket分为socketserver和socketclient，socketserver是一个简单的建立长连接后等待接收数据，socketclient请求建立与服务端连接，连接建立以后通过servlet发起通信。 服务端直接用application执行； 客户端部署到服务器上，启动服务即与服务端建立长连接； 长连接建立以后用http://localhost:8080/socketclient/servlet/Test 发起请求与服务端通信
socket通信代码（C代码）
09-21
ARM开发板作为客户端，PC作为服务端，建立socket，完成通信
socket服务器代码
Swxctx
04-26 580
创建一个socket使用socket() 系统调用. 使用bind()系统调用套接字绑定到一个地址。对于互联网上的服务器套接字，地址包括主机的端口号。  使用listen()系统调用连接监听。 accept() 系统调用形式接受连接。此调用通常会阻塞，直到有客户端与服务器连接。 发送和接收数据，使用read() 和 write() 系统调用。 现在要把上面这些步骤
Socket服务器端的代码
u011736532的专栏
09-25 889
服务器端的简单的socket
socket编程实例（源码）
zeng622peng的专栏
04-28 3166
本实例使用面向连接协议的客户/服务器模式，其流程如图2.3所示： 图2.3 面向连接的应用程序流程图 服务器方程序： #include #include #define TRUE 1 main( ) { int sock, length; struct sockaddr_in server; struct sockaddr tcpaddr; int msgsock; char buf[1024];
完整的socket代码
夕阳帆的专栏
06-23 3047
socket代码2010-04-18 16:34:09#include <stdio.h><br /> #include <stdlib.h><br /> #include <unistd.h><br /> #include <errno.h><br /> #include <string.h><br /> #include <sys/types.h><br /> #include <sys/socket.h><br /> #include <netinet/in.h><br /> #inc
一个socket源码
zhou1xp的专栏
03-04 3234
VC编写服务器转发式的聊天室2009-9-11  本文参考了 Visual C++6.0完全自学手册 中的示例一 流程说明客户端客户端创建流式套接字调用Connection向服务器发送连接请求连接成功后使用创建与之关联的的CSocketFile对象和CArchive对象使用CArchive对象在客户端和服务器之间传送数据结束之后释放CSocketFile对象,CArchive对象,CSoc
Socket实例代码
xumingxsh的专栏
03-12 2896
最近在用Socket，不是很明白，但是总算是实现了socket传信息。现在把代码贴在这里：这是一段MFC中的代码：服务器端接受数据的代码：static DWORD WINAPI RunSocket(LPVOID lpvoid);int CSocketAppView::OnCreate(LPCREATESTRUCT lpCreateStruct) {    if (CView::On
java【网络编程TCP/IP Socket[类] 套接字 ServerSocket[类] C/S B/S】详细讲解
qq_43436117的博客
02-20 765
【网络编程】 1.网络编程入门 1.1软件结构 C/S结构 ：全称为Client/Server结构，是指客户端和服务器结构。常见程序有ＱＱ、迅雷等软件。 B/S结构 ：全称为Browser/Server结构，是指浏览器和服务器结构。常见浏览器有谷歌、火狐等。 两种架构各有优势，但是无论哪种架构，都离不开网络的支持。网络编程，就是在一定的协议下，实现两台计算机的通信的程序。 1.2 网络通信协议 **网络通信协议：**通过计算机网络可以使多台计算机实现连接，位于同一个网络中的计算机在进行连接和通信
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值