In diesem Artikel vorgestellt
In .Net bietet der System.Net.Sockets-Namespace eine verwaltete Implementierung der Windows Sockets (Winsock)-Schnittstelle für Entwickler, die den Netzwerkzugriff streng kontrollieren müssen. Alle anderen Netzwerkzugriffsklassen im System.Net-Namespace basieren auf dieser Socket-Implementierung. Die Klassen TCPClient, TCPListener und UDPClient kapseln detaillierte Informationen zum Erstellen von TCP- und UDP-Verbindungen zum Internet Zugriff, Socket kann in vielen gängigen Internetdiensten wie Telnet, HTTP, E-Mail, Echo usw. gesehen werden. Obwohl diese Dienste unterschiedliche Definitionen von Kommunikationsprotokollen haben, verwendet ihre grundlegende Übertragung Socket.
Tatsächlich kann Socket als Datenkanal wie ein Stream betrachtet werden. Dieser Kanal wird zwischen der Anwendung (Client) und dem Remote-Server eingerichtet. Dann erfolgt das Lesen (Empfangen) und Schreiben (Senden) von Daten über diesen Kanal .
Es ist ersichtlich, dass Sie nach dem Erstellen eines Socket-Objekts auf der Anwendungs- oder Serverseite die Send/SentTo-Methode verwenden können, um Daten an den verbundenen Socket zu senden, oder die Receive/ReceiveFrom-Methode verwenden können, um Daten vom verbundenen Socket zu empfangen Socket;
Für die Socket-Programmierung ist die Socket-Klasse des .NET Framework eine verwaltete Codeversion des Socket-Dienstes, der von der Winsock32-API bereitgestellt wird. Für die Implementierung der Netzwerkprogrammierung stehen eine Reihe von Methoden zur Verfügung. In den meisten Fällen leiten die Methoden der Socket-Klasse die Daten lediglich an ihre nativen Win32-Kopien weiter und führen alle erforderlichen Sicherheitsüberprüfungen durch. Wenn Sie mit den Winsock-API-Funktionen vertraut sind, wird es sehr einfach sein, die Socket-Klasse zum Schreiben von Netzwerkprogrammen zu verwenden. Wenn Sie noch nie damit in Berührung gekommen sind, wird es Ihnen natürlich nicht allzu schwer fallen Finden Sie heraus, dass die Verwendung der Socket-Klasse zum Entwickeln von Windows-Netzwerkanwendungen tatsächlich vorhanden ist Es gibt Regeln, die in den meisten Fällen ungefähr den gleichen Schritten folgen.
In diesem Abschnitt wird die Verwendung von Socket zum Implementieren eines synchronen UDP-Servers vorgestellt.
Socket-Synchronisation UDP-Server
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.UDP.Sock.Synchronous
{
/// <summary>
/// Socket 实现同步UDP服务器
/// </summary>
public class SocketUDPServer
{
#region Fields
/// <summary>
/// 服务器程序允许的最大客户端连接数
/// </summary>
private int _maxClient;
/// <summary>
/// 当前的连接的客户端数
/// </summary>
private int _clientCount;
/// <summary>
/// 服务器使用的同步socket
/// </summary>
private Socket _serverSock;
/// <summary>
/// 客户端会话列表
/// </summary>
private List<SocketUDPState> _clients;
private bool disposed = false;
/// <summary>
/// 数据接受缓冲区
/// </summary>
private byte[] _recvBuffer;
#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 UDP服务器
/// </summary>
/// <param name="listenPort">监听的端口</param>
public SocketUDPServer(int listenPort)
: this(IPAddress.Any, listenPort,1024)
{
}
/// <summary>
/// 异步Socket UDP服务器
/// </summary>
/// <param name="localEP">监听的终结点</param>
public SocketUDPServer(IPEndPoint localEP)
: this(localEP.Address, localEP.Port,1024)
{
}
/// <summary>
/// 异步Socket UDP服务器
/// </summary>
/// <param name="localIPAddress">监听的IP地址</param>
/// <param name="listenPort">监听的端口</param>
/// <param name="maxClient">最大客户端数量</param>
public SocketUDPServer(IPAddress localIPAddress, int listenPort, int maxClient)
{
this.Address = localIPAddress;
this.Port = listenPort;
this.Encoding = Encoding.Default;
_maxClient = maxClient;
_clients = new List<SocketUDPState>();
_serverSock = new Socket(localIPAddress.AddressFamily, SocketType.Dgram, ProtocolType.Udp);
_recvBuffer=new byte[_serverSock.ReceiveBufferSize];
}
#endregion
#region Method
/// <summary>
/// 启动服务器
/// </summary>
/// <returns>异步TCP服务器</returns>
public void Start()
{
if (!IsRunning)
{
IsRunning = true;
_serverSock.Bind(new IPEndPoint(this.Address, this.Port));
//启动一个线程监听数据
new Thread(ReceiveData).Start();
}
}
/// <summary>
/// 停止服务器
/// </summary>
public void Stop()
{
if (IsRunning)
{
IsRunning = false;
_serverSock.Close();
//TODO 关闭对所有客户端的连接
CloseAllClient();
}
}
/// <summary>
/// 同步数据接收方法
/// </summary>
private void ReceiveData()
{
int len = -1;
EndPoint remote = null;
while (true)
{
try
{
len = _serverSock.ReceiveFrom(_recvBuffer, ref remote);
//if (!_clients.Contains(remote))
//{
// _clients.Add(remote);
//}
}
catch (Exception)
{
//TODO 异常处理操作
RaiseOtherException(null);
}
}
}
/// <summary>
/// 同步发送数据
/// </summary>
public void Send(string msg, EndPoint clientip)
{
byte[] data = Encoding.Default.GetBytes(msg);
try
{
_serverSock.SendTo(data, clientip);
//数据发送完成事件
RaiseCompletedSend(null);
}
catch (Exception)
{
//TODO 异常处理
RaiseOtherException(null);
}
}
#endregion
#region 事件
/// <summary>
/// 接收到数据事件
/// </summary>
public event EventHandler<SocketUDPEventArgs> DataReceived;
private void RaiseDataReceived(SocketUDPState state)
{
if (DataReceived != null)
{
DataReceived(this, new SocketUDPEventArgs(state));
}
}
/// <summary>
/// 数据发送完毕事件
/// </summary>
public event EventHandler<SocketUDPEventArgs> CompletedSend;
/// <summary>
/// 触发数据发送完毕的事件
/// </summary>
/// <param name="state"></param>
private void RaiseCompletedSend(SocketUDPState state)
{
if (CompletedSend != null)
{
CompletedSend(this, new SocketUDPEventArgs(state));
}
}
/// <summary>
/// 网络错误事件
/// </summary>
public event EventHandler<SocketUDPEventArgs> NetError;
/// <summary>
/// 触发网络错误事件
/// </summary>
/// <param name="state"></param>
private void RaiseNetError(SocketUDPState state)
{
if (NetError != null)
{
NetError(this, new SocketUDPEventArgs(state));
}
}
/// <summary>
/// 异常事件
/// </summary>
public event EventHandler<SocketUDPEventArgs> OtherException;
/// <summary>
/// 触发异常事件
/// </summary>
/// <param name="state"></param>
private void RaiseOtherException(SocketUDPState state, string descrip)
{
if (OtherException != null)
{
OtherException(this, new SocketUDPEventArgs(descrip, state));
}
}
private void RaiseOtherException(SocketUDPState state)
{
RaiseOtherException(state, "");
}
#endregion
#region Close
/// <summary>
/// 关闭一个与客户端之间的会话
/// </summary>
/// <param name="state">需要关闭的客户端会话对象</param>
public void Close(SocketUDPState state)
{
if (state != null)
{
_clients.Remove(state);
_clientCount--;
//TODO 触发关闭事件
}
}
/// <summary>
/// 关闭所有的客户端会话,与所有的客户端连接会断开
/// </summary>
public void CloseAllClient()
{
foreach (SocketUDPState client in _clients)
{
Close(client);
}
_clientCount = 0;
_clients.Clear();
}
#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
RaiseOtherException(null);
}
}
disposed = true;
}
}
#endregion
}
}Nach dem Login kopieren
Client-Status-Kapselungsklasse
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net.Sockets;
using System.Net;
namespace NetFrame.Net.UDP.Sock.Synchronous
{
public class SocketUDPState
{
// Client socket.
public Socket workSocket = null;
// Size of receive buffer.
public const int BufferSize = 1024;
// Receive buffer.
public byte[] buffer = new byte[BufferSize];
// Received data string.
public StringBuilder sb = new StringBuilder();
public EndPoint remote = new IPEndPoint(IPAddress.Any, 0);
}
}Nach dem Login kopieren
Server-Ereignisparameterklasse
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace NetFrame.Net.UDP.Sock.Synchronous
{
/// <summary>
/// Socket实现同步UDP服务器
/// </summary>
public class SocketUDPEventArgs:EventArgs
{
/// <summary>
/// 提示信息
/// </summary>
public string _msg;
/// <summary>
/// 客户端状态封装类
/// </summary>
public SocketUDPState _state;
/// <summary>
/// 是否已经处理过了
/// </summary>
public bool IsHandled { get; set; }
public SocketUDPEventArgs(string msg)
{
this._msg = msg;
IsHandled = false;
}
public SocketUDPEventArgs(SocketUDPState state)
{
this._state = state;
IsHandled = false;
}
public SocketUDPEventArgs(string msg, SocketUDPState state)
{
this._msg = msg;
this._state = state;
IsHandled = false;
}
}
}Nach dem Login kopieren
Das Obige ist der Inhalt von Socket zum Synchronisieren des UDP-Servers im Artikel (6) der C#-Netzwerkprogrammierungsreihe. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn)!
