


C# network programming series of articles (2) Socket realizes synchronization of TCP server
Introduction to this article
As I said in the previous blog, I will introduce the use of Socket, TcpListener and UdpClient in c# to implement various synchronous and asynchronous TCP and UDP server, I spent many days summarizing these myself. In this way, I believe that friends who are new to c# network programming will not look for information and debug everywhere like me before. This time I introduce the synchronous TCP server implemented using Socket. The difference between the synchronous TCP server and the asynchronous TCP server introduced in the first article is whether it will block when Socket calls Accept.
When a synchronous TCP server receives a request from a client, it usually starts a thread to handle the communication with the client. This method is not The good thing is that it consumes a lot of resources, but if you use a thread pool and allocate a certain number of threads in advance, the performance is still good.
But the main purpose of giving out many ways to implement the server is to test which situation has better performance. For now, the asynchronous mode Compared with NICE, there is actually another IOCP mode with the best performance. . .
Socket synchronization TCP server
Server code
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Net.Sockets; using System.Net; using System.Threading; namespace NetFrame.Net.TCP.Sock.Synchronous { /// <summary> /// 基于socket实现的同步TCP服务器 /// </summary> public class SocketTCPServer { #region Fields /// <summary> /// 服务器程序允许的最大客户端连接数 /// </summary> private int _maxClient; /// <summary> /// 当前的连接的客户端数 /// </summary> private int _clientCount; /// <summary> /// 服务器使用的异步socket /// </summary> private Socket _serverSock; /// <summary> /// 客户端会话列表 /// </summary> private List<SocketClientHandle> _clients; private bool disposed = false; #endregion #region Properties /// <summary> /// 服务器是否正在运行 /// </summary> public bool IsRunning { get; private set; } /// <summary> /// 监听的IP地址 /// </summary> public IPAddress Address { get; private set; } /// <summary> /// 监听的端口 /// </summary> public int Port { get; private set; } /// <summary> /// 通信使用的编码 /// </summary> public Encoding Encoding { get; set; } #endregion #region 构造函数 /// <summary> /// 同步Socket TCP服务器 /// </summary> /// <param name="listenPort">监听的端口</param> public SocketTCPServer(int listenPort) : this(IPAddress.Any, listenPort, 1024) { } /// <summary> /// 同步Socket TCP服务器 /// </summary> /// <param name="localEP">监听的终结点</param> public SocketTCPServer(IPEndPoint localEP) : this(localEP.Address, localEP.Port, 1024) { } /// <summary> /// 同步Socket TCP服务器 /// </summary> /// <param name="localIPAddress">监听的IP地址</param> /// <param name="listenPort">监听的端口</param> /// <param name="maxClient">最大客户端数量</param> public SocketTCPServer(IPAddress localIPAddress, int listenPort, int maxClient) { this.Address = localIPAddress; this.Port = listenPort; this.Encoding = Encoding.Default; _maxClient = maxClient; _clients = new List<SocketClientHandle>(); _serverSock = new Socket(localIPAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp); } #endregion #region Method /// <summary> /// 启动服务器 /// </summary> public void Start() { if (!IsRunning) { IsRunning = true; _serverSock.Bind(new IPEndPoint(this.Address, this.Port)); Thread thread = new Thread(StartListen); thread.Start(); } } /// <summary> /// 开始进行监听 /// </summary> private void StartListen() { _serverSock.Listen(1024); SocketClientHandle handle; while (IsRunning) { if (_clientCount >= _maxClient) { //TODO 客户端过多异常 RaiseOtherException(null); } else { Socket clientSock = _serverSock.Accept(); _clientCount++; //TODO 创建一个处理客户端的线程并启动 handle = new SocketClientHandle(clientSock); _clients.Add(handle); //使用线程池来操作 ThreadPool.QueueUserWorkItem(new WaitCallback(handle.RecevieData)); //Thread pthread; //pthread = new Thread(new ThreadStart(client.RecevieData)); //pthread.Start(); //这里应该使用线程池来进行 } } } /// <summary> /// 停止服务器 /// </summary> public void Stop() { if (IsRunning) { IsRunning = false; _serverSock.Close(); //TODO 关闭对所有客户端的连接 } } /// <summary> /// 发送函数 /// </summary> public void Send(string msg, SocketClientHandle client) { //TODO } /// <summary> /// 关闭一个与客户端之间的会话 /// </summary> /// <param name="handle">需要关闭的客户端会话对象</param> public void Close(SocketClientHandle handle) { if (handle != null) { _clients.Remove(handle); handle.Dispose(); _clientCount--; //TODO 触发关闭事件 } } /// <summary> /// 关闭所有的客户端会话,与所有的客户端连接会断开 /// </summary> public void CloseAllClient() { foreach (SocketClientHandle handle in _clients) { Close(handle); } _clientCount = 0; _clients.Clear(); } #endregion #region 事件 /// <summary> /// 与客户端的连接已建立事件 /// </summary> public event EventHandler<SocketEventArgs> ClientConnected; /// <summary> /// 与客户端的连接已断开事件 /// </summary> public event EventHandler<SocketEventArgs> ClientDisconnected; /// <summary> /// 触发客户端连接事件 /// </summary> /// <param name="state"></param> private void RaiseClientConnected(SocketClientHandle handle) { if (ClientConnected != null) { ClientConnected(this, new SocketEventArgs(handle)); } } /// <summary> /// 触发客户端连接断开事件 /// </summary> /// <param name="client"></param> private void RaiseClientDisconnected(Socket client) { if (ClientDisconnected != null) { ClientDisconnected(this, new SocketEventArgs("连接断开")); } } /// <summary> /// 接收到数据事件 /// </summary> public event EventHandler<SocketEventArgs> DataReceived; private void RaiseDataReceived(SocketClientHandle handle) { if (DataReceived != null) { DataReceived(this, new SocketEventArgs(handle)); } } /// <summary> /// 数据发送事件 /// </summary> public event EventHandler<SocketEventArgs> CompletedSend; /// <summary> /// 触发数据发送事件 /// </summary> /// <param name="state"></param> private void RaiseCompletedSend(SocketClientHandle handle) { if (CompletedSend != null) { CompletedSend(this, new SocketEventArgs(handle)); } } /// <summary> /// 网络错误事件 /// </summary> public event EventHandler<SocketEventArgs> NetError; /// <summary> /// 触发网络错误事件 /// </summary> /// <param name="state"></param> private void RaiseNetError(SocketClientHandle handle) { if (NetError != null) { NetError(this, new SocketEventArgs(handle)); } } /// <summary> /// 异常事件 /// </summary> public event EventHandler<SocketEventArgs> OtherException; /// <summary> /// 触发异常事件 /// </summary> /// <param name="state"></param> private void RaiseOtherException(SocketClientHandle handle, string descrip) { if (OtherException != null) { OtherException(this, new SocketEventArgs(descrip, handle)); } } private void RaiseOtherException(SocketClientHandle handle) { RaiseOtherException(handle, ""); } #endregion #region Close 未实现 #endregion #region 释放 /// <summary> /// Performs application-defined tasks associated with freeing, /// releasing, or resetting unmanaged resources. /// </summary> public void Dispose() { Dispose(true); GC.SuppressFinalize(this); } /// <summary> /// Releases unmanaged and - optionally - managed resources /// </summary> /// <param name="disposing"><c>true</c> to release /// both managed and unmanaged resources; <c>false</c> /// to release only unmanaged resources.</param> protected virtual void Dispose(bool disposing) { if (!this.disposed) { if (disposing) { try { Stop(); if (_serverSock != null) { _serverSock = null; } } catch (SocketException) { //TODO 异常 } } disposed = true; } } #endregion } }
Handle class that encapsulates client operations
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Net.Sockets; namespace NetFrame.Net.TCP.Sock.Synchronous { /// <summary> /// Socket 服务器用于处理客户端连接封装的客户端处理类 /// </summary> public class SocketClientHandle:IDisposable { /// <summary> /// 与客户端相关联的socket /// </summary> private Socket _client; /// <summary> /// 标识是否与客户端相连接 /// </summary> private bool _is_connect; public bool IsConnect { get { return _is_connect; } set { _is_connect = value; } } /// <summary> /// 数据接受缓冲区 /// </summary> private byte[] _recvBuffer; public SocketClientHandle(Socket client) { this._client = client; _is_connect = true; _recvBuffer = new byte[1024 * 1024 * 2]; } #region Method /// <summary> /// 接受来自客户端发来的数据 /// </summary> public void RecevieData(Object state) { int len = -1; while (_is_connect) { try { len = _client.Receive(_recvBuffer); } catch (Exception) { //TODO } } } /// <summary> /// 向客户端发送数据 /// </summary> public void SendData(string msg) { byte[] data = Encoding.Default.GetBytes(msg); try { //有一种比较好的写法 _client.Send(data); } catch (Exception) { //TODO 处理异常 } } #endregion #region 事件 //TODO 消息发送事件 //TODO 数据收到事件 //TODO 异常处理事件 #endregion #region 释放 /// <summary> /// Performs application-defined tasks associated with freeing, /// releasing, or resetting unmanaged resources. /// </summary> public void Dispose() { _is_connect = false; if (_client != null) { _client.Close(); _client = null; } GC.SuppressFinalize(this); } #endregion } }
The time parameter class of Socket synchronizing TCP server
using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace NetFrame.Net.TCP.Sock.Synchronous { /// <summary> /// 同步Socket TCP服务器事件类 /// </summary> public class SocketEventArgs : EventArgs { /// <summary> /// 提示信息 /// </summary> public string _msg; /// <summary> /// 客户端状态封装类 /// </summary> public SocketClientHandle _handle; /// <summary> /// 是否已经处理过了 /// </summary> public bool IsHandled { get; set; } public SocketEventArgs(string msg) { this._msg = msg; IsHandled = false; } public SocketEventArgs(SocketClientHandle handle) { this._handle = handle; IsHandled = false; } public SocketEventArgs(string msg, SocketClientHandle handle) { this._msg = msg; this._handle = handle; IsHandled = false; } } }
The above is the content of Socket synchronizing TCP server in the C# network programming series article (2). For more related content, please pay attention to the PHP Chinese website (www.php.cn) !
##

The combination of C# and .NET provides developers with a powerful programming environment. 1) C# supports polymorphism and asynchronous programming, 2) .NET provides cross-platform capabilities and concurrent processing mechanisms, which makes them widely used in desktop, web and mobile application development.

.NETFramework is a software framework, and C# is a programming language. 1..NETFramework provides libraries and services, supporting desktop, web and mobile application development. 2.C# is designed for .NETFramework and supports modern programming functions. 3..NETFramework manages code execution through CLR, and the C# code is compiled into IL and runs by CLR. 4. Use .NETFramework to quickly develop applications, and C# provides advanced functions such as LINQ. 5. Common errors include type conversion and asynchronous programming deadlocks. VisualStudio tools are required for debugging.

C# is a modern, object-oriented programming language developed by Microsoft, and .NET is a development framework provided by Microsoft. C# combines the performance of C and the simplicity of Java, and is suitable for building various applications. The .NET framework supports multiple languages, provides garbage collection mechanisms, and simplifies memory management.

C# and .NET runtime work closely together to empower developers to efficient, powerful and cross-platform development capabilities. 1) C# is a type-safe and object-oriented programming language designed to integrate seamlessly with the .NET framework. 2) The .NET runtime manages the execution of C# code, provides garbage collection, type safety and other services, and ensures efficient and cross-platform operation.

To start C#.NET development, you need to: 1. Understand the basic knowledge of C# and the core concepts of the .NET framework; 2. Master the basic concepts of variables, data types, control structures, functions and classes; 3. Learn advanced features of C#, such as LINQ and asynchronous programming; 4. Be familiar with debugging techniques and performance optimization methods for common errors. With these steps, you can gradually penetrate the world of C#.NET and write efficient applications.

The relationship between C# and .NET is inseparable, but they are not the same thing. C# is a programming language, while .NET is a development platform. C# is used to write code, compile into .NET's intermediate language (IL), and executed by the .NET runtime (CLR).

C#.NET is still important because it provides powerful tools and libraries that support multiple application development. 1) C# combines .NET framework to make development efficient and convenient. 2) C#'s type safety and garbage collection mechanism enhance its advantages. 3) .NET provides a cross-platform running environment and rich APIs, improving development flexibility.

C#.NETisversatileforbothwebanddesktopdevelopment.1)Forweb,useASP.NETfordynamicapplications.2)Fordesktop,employWindowsFormsorWPFforrichinterfaces.3)UseXamarinforcross-platformdevelopment,enablingcodesharingacrossWindows,macOS,Linux,andmobiledevices.


Hot AI Tools

Undresser.AI Undress
AI-powered app for creating realistic nude photos

AI Clothes Remover
Online AI tool for removing clothes from photos.

Undress AI Tool
Undress images for free

Clothoff.io
AI clothes remover

Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Article

Hot Tools

MantisBT
Mantis is an easy-to-deploy web-based defect tracking tool designed to aid in product defect tracking. It requires PHP, MySQL and a web server. Check out our demo and hosting services.

Dreamweaver Mac version
Visual web development tools

SublimeText3 Mac version
God-level code editing software (SublimeText3)

PhpStorm Mac version
The latest (2018.2.1) professional PHP integrated development tool

WebStorm Mac version
Useful JavaScript development tools