关键词搜索

源码搜索 ×
×

C#编写的Socket基于通道的服务端

发布2018-01-08浏览1075次

详情内容

本文是继C#编写的Socket客户端通道发送队列的续集。有客户端还需要服务端，服务端也要采用通道的方式来创建。

 连接服务类基类

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Net.Sockets;
  6. using System.Net;
  7. using SQ.Base;
  8.  
  9. namespace Network
  10. {
  11.     /// <summary>
  12.     /// 连接服务类基类
  13.     /// </summary>
  14.     public abstract class Server
  15.     {
  16.         #region 属性
  17.         /// <summary>
  18.         /// 通道连接事件
  19.         /// </summary>
  20.         public virtual event EventChannelConnect ChannelConnect;
  21.         /// <summary>
  22.         /// 通道断开事件
  23.         /// </summary>
  24.         public virtual event EventChannelDispose ChannelDispose;
  25.         /// <summary>
  26.         /// 通道错误事件
  27.         /// </summary>
  28.         public virtual event EventChannelError ChannelError;
  29.         /// <summary>
  30.         /// 获取本地套接字
  31.         /// </summary>
  32.         public Socket LocalSocket { get; protected set; }
  33.         /// <summary>
  34.         /// 获取服务器本地监听IP地址
  35.         /// </summary>
  36.         public string LocalHost { get; protected set; }
  37.         /// <summary>
  38.         /// 获取服务器本地绑定或监听端口
  39.         /// </summary>
  40.         public int LocalPort { get; protected set; }
  41.         /// <summary>
  42.         /// 获取连接客户端管理实例
  43.         /// </summary>
  44.         public ListLocker<Channel> Channels { get; protected set; }
  45.         /// <summary>
  46.         /// 用户标识对象
  47.         /// </summary>
  48.         public object Tag { get; set; }
  49.         #endregion
  50.  
  51.         #region 事件处理
  52.         /// <summary>
  53.         /// 通道连接事件处理
  54.         /// </summary>
  55.         /// <param name="sender"></param>
  56.         /// <param name="arg"></param>
  57.         protected virtual void OnChannelConnect(object sender, ChannelConnectArg arg)
  58.         {
  59. #if FUNCINLOG
  60. 			Log.WriteLog4("TCPServer.OnChannelConnect(sender, arg) in.", LOGTYPE.DEBUG);
  61. #endif
  62.             if (ChannelConnect != null)
  63.             {
  64.                 try
  65.                 {
  66.                     ChannelConnect(sender, arg);
  67.                 }
  68.                 catch (Exception ex)
  69.                 {
  70.                     Log.WriteLog4Ex("Network Server event error", ex);
  71.                     if (ex.Message == "等待连接超时！")
  72.                     {
  73.                         arg.SocketError = SocketError.SocketError;
  74.                     }
  75.                 }
  76.             }
  77.  
  78.             if (arg.SocketError == SocketError.Success)
  79.             {
  80.                 try
  81.                 {
  82.                     Channels.Enter();
  83.                     Channels.Add(arg.Channel);
  84.                 }
  85.                 finally
  86.                 {
  87.                     Channels.Exit();
  88.                 }
  89.             }
  90. #if FUNCOUTLOG
  91. 			Log.WriteLog4("TCPServer.OnChannelConnect(sender, arg) out.", LOGTYPE.DEBUG);
  92. #endif
  93.         }
  94.  
  95.         /// <summary>
  96.         /// 通道释放事件处理
  97.         /// </summary>
  98.         /// <param name="sender"></param>
  99.         /// <param name="arg"></param>
  100.         protected virtual void OnChannelDispose(object sender, ChannelDisposeArg arg)
  101.         {
  102. #if FUNCINLOG
  103. 			Log.WriteLog4("TCPServer.OnChannelDispose(sender, arg) in.", LOGTYPE.DEBUG);
  104. #endif
  105.             if (ChannelDispose != null)
  106.             {
  107.                 try
  108.                 {
  109.                     ChannelDispose(this, arg);
  110.                 }
  111.                 catch (Exception ex)
  112.                 {
  113.                     Log.WriteLog4Ex("Network Server event error", ex);
  114.                 }
  115.             }
  116.             try
  117.             {
  118.                 Channels.Enter();
  119.                 Channels.Remove(arg.Channel);
  120.             }
  121.             finally
  122.             {
  123.                 Channels.Exit();
  124.             }
  125. #if FUNCOUTLOG
  126. 			Log.WriteLog4("TCPServer.OnChannelDispose(sender, arg) out.", LOGTYPE.DEBUG);
  127. #endif
  128.         }
  129.  
  130.         /// <summary>
  131.         /// 通道异常事件处理
  132.         /// </summary>
  133.         /// <param name="sender"></param>
  134.         /// <param name="arg"></param>
  135.         protected virtual void OnChannelError(object sender, ChannelErrorArg arg)
  136.         {
  137. #if FUNCINLOG
  138. 			Log.WriteLog4("TCPServer.OnChannelError(sender, arg) in.", LOGTYPE.DEBUG);
  139. #endif
  140.             if (ChannelError != null)
  141.             {
  142.                 try
  143.                 {
  144.                     ChannelError(this, arg);
  145.                 }
  146.                 catch (Exception ex)
  147.                 {
  148.                     Log.WriteLog4Ex("Network Server event error", ex);
  149.                 }
  150.             }
  151.             try
  152.             {
  153.                 Channels.Enter();
  154.                 Channels.Remove(arg.Channel);
  155.             }
  156.             finally
  157.             {
  158.                 Channels.Exit();
  159.             }
  160. #if FUNCOUTLOG
  161. 			Log.WriteLog4("TCPServer.OnChannelError(sender, arg) out.", LOGTYPE.DEBUG);
  162. #endif
  163.         }
  164.         #endregion
  165.  
  166.         #region 公共方法
  167.         /// <summary>
  168.         /// 构造方法
  169.         /// </summary>
  170.         public Server()
  171.         {
  172.             Channels = new ListLocker<Channel>();
  173.             LocalSocket = null;
  174.         }
  175.  
  176.         /// <summary>
  177.         /// 开启服务器
  178.         /// </summary>
  179.         /// <returns>成功返回true,否则返回false</returns>
  180.         public virtual bool Start()
  181.         {
  182.             return true;
  183.         }
  184.  
  185.         /// <summary>
  186.         /// 停止服务器
  187.         /// </summary>
  188.         public virtual void Stop()
  189.         {
  190.             Channel[] channels;
  191.             try
  192.             {
  193.                 Channels.Enter();
  194.                 channels = Channels.ToArray();
  195.                 Channels.Clear();
  196.             }
  197.             finally
  198.             {
  199.                 Channels.Exit();
  200.             }
  201.  
  202.             foreach (var channel in channels)
  203.             {
  204.                 channel.Close();
  205.             }
  206.         }
  207.         #endregion
  208.  
  209.         #region 内部方法
  210.         /// <summary>
  211.         /// 通过连接套接字创建通道
  212.         /// </summary>
  213.         /// <param name="socket">连接套接字</param>
  214.         /// <param name="channel">子类已创建通道.如果非空,则基类在现有通道实例上处理</param>
  215.         /// <returns>创建的通道实例.非空进创建成功,否则失败</returns>
  216.         protected virtual Channel CreateChannelBySocket(Socket socket, Channel channel = null)
  217.         {
  218.             if (channel == null)
  219.                 return null;
  220.             else
  221.             {
  222.                 channel.ChannelDispose += OnChannelDispose;
  223.                 channel.ChannelError += OnChannelError;
  224.                 return channel;
  225.             }
  226.         }
  227.         #endregion
  228.     }
  229. }

TCP 连接服务类

TCPServer 继承自Server类：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Net.Sockets;
  6. using System.Net;
  7. using SQ.Base;
  8.  
  9. namespace Network
  10. {
  11. 	/// <summary>
  12. 	/// TCP通道服务
  13. 	/// </summary>
  14. 	/// <remarks>内部方法注释请参照基类</remarks>
  15. 	public class TCPServer : Server
  16. 	{
  17. 		#region 公共方法
  18. 		/// <summary>
  19. 		/// TCP通道服务构造函数
  20. 		/// </summary>
  21. 		/// <param name="localHost">本地绑定网卡地址</param>
  22. 		/// <param name="localPort">本地端口号</param>
  23. 		public TCPServer(string localHost, int localPort)
  24. 		{
  25. 			LocalHost = localHost;
  26. 			LocalPort = localPort;
  27. 		}
  28.  
  29. 		/// <summary>
  30. 		/// 开启服务器
  31. 		/// </summary>
  32. 		/// <returns>成功返回true,否则返回false</returns>
  33. 		public override bool Start()
  34. 		{
  35. 			try
  36. 			{
  37. 				if (LocalSocket == null)
  38. 				{
  39. 					LocalSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
  40. 					LocalSocket.Bind(new IPEndPoint(IPAddress.Parse(LocalHost), LocalPort));
  41. 					LocalSocket.Listen(64);
  42.  
  43. 					SocketAsyncEventArgs e = Managers.SocketArgManager.Allocate(false);
  44. 					e.Completed += IO_Completed;
  45. 					if (LocalSocket != null && !LocalSocket.AcceptAsync(e))
  46. 					{
  47. 						OnConnect(e);
  48. 					}
  49. 					return base.Start();
  50. 				}
  51. 				else
  52. 					return false;
  53. 			}
  54. 			catch (Exception ex)
  55. 			{
  56. 				Log.WriteLog4Ex("Server启动失败", ex);
  57. 				return false;
  58. 			}
  59. 		}
  60.  
  61. 		/// <summary>
  62. 		/// 停止服务器
  63. 		/// </summary>
  64. 		public override void Stop()
  65. 		{
  66. 			try
  67. 			{
  68. 				if (LocalSocket != null)
  69. 				{
  70. 					LocalSocket.Close();
  71. 					LocalSocket.Dispose();
  72. 					LocalSocket = null;
  73.  
  74. 					base.Stop();
  75. 				}
  76. 				else
  77. 					Log.WriteLog4("Server停止失败.服务已停止.", LOGTYPE.WARN);
  78. 			}
  79. 			catch (Exception ex)
  80. 			{
  81. 				Log.WriteLog4Ex("Server停止失败", ex);
  82. 			}
  83. 		}
  84. 		#endregion
  85.  
  86. 		#region 异步请求结果处理
  87. 		/// <summary>
  88. 		/// 通道连接IO完成时调用
  89. 		/// </summary>
  90. 		/// <param name="e"></param>
  91. 		private void OnConnect(SocketAsyncEventArgs e)
  92. 		{
  93. #if FUNCINLOG
  94. 			Log.WriteLog4("TCPServer.OnConnect(e) in.", LOGTYPE.DEBUG);
  95. #endif
  96. 			Channel channel = null;
  97. 			if (e.SocketError == SocketError.Success)
  98. 				channel = CreateChannelBySocket(e.AcceptSocket);
  99. 			e.AcceptSocket = null;
  100. 			OnChannelConnect(this, new ChannelConnectArg(channel, e.SocketError));
  101.  
  102. 			while (LocalSocket != null && !LocalSocket.AcceptAsync(e))
  103. 			{
  104. 				channel = null;
  105. 				if (e.SocketError == SocketError.Success)
  106. 					channel = CreateChannelBySocket(e.AcceptSocket);
  107. 				e.AcceptSocket = null;
  108. 				OnChannelConnect(this, new ChannelConnectArg(channel, e.SocketError));
  109. 			}
  110. #if FUNCOUTLOG
  111. 			Log.WriteLog4("TCPServer.OnConnect(e) out.", LOGTYPE.DEBUG);
  112. #endif
  113. 		}
  114. 		#endregion
  115.  
  116. 		#region 内部方法
  117. 		/// <summary>
  118. 		/// 异步请求回调处理方法
  119. 		/// </summary>
  120. 		/// <param name="sender"></param>
  121. 		/// <param name="e"></param>
  122. 		private void IO_Completed(object sender, SocketAsyncEventArgs e)
  123. 		{
  124. #if FUNCINLOG
  125. 			Log.WriteLog4("TCPServer.IO_Completed(sender, e) in.", LOGTYPE.DEBUG);
  126. #endif
  127. 			try
  128. 			{
  129. 				switch (e.LastOperation)
  130. 				{
  131. 					case SocketAsyncOperation.Accept:
  132. 						OnConnect(e);
  133. 						break;
  134. 				}
  135. 			}
  136. 			catch (Exception ex)
  137. 			{
  138. 				Log.WriteLog4Ex("TCPServer.IO_Completed(sender, e) error", ex);
  139. 			}
  140. #if FUNCOUTLOG
  141. 			Log.WriteLog4("TCPServer.IO_Completed(sender, e) out.", LOGTYPE.DEBUG);
  142. #endif
  143. 		}
  144.  
  145. 		/// <summary>
  146. 		/// 通过连接套接字创建通道
  147. 		/// </summary>
  148. 		/// <param name="socket">连接套接字</param>
  149. 		/// <param name="channel">子类已创建通道.如果非空,则基类在现有通道实例上处理</param>
  150. 		/// <returns>创建的通道实例.非空进创建成功,否则失败</returns>
  151. 		protected override Channel CreateChannelBySocket(Socket socket, Channel channel = null)
  152. 		{
  153. #if FUNCINLOG
  154. 			Log.WriteLog4("TCPServer.CreateChannelBySocket(socket) in.", LOGTYPE.DEBUG);
  155. #endif
  156. 			if (channel == null)
  157. 				channel = new TCPChannel(socket);
  158. #if FUNCOUTLOG
  159. 			Log.WriteLog4("TCPServer.CreateChannelBySocket(socket) out.", LOGTYPE.DEBUG);
  160. #endif
  161. 			return base.CreateChannelBySocket(socket, channel);
  162. 		}
  163. 		#endregion
  164. 	}
  165. }

如何使用初始化服务端

建立一个本地服务端连接：

 Network.TCPServer ser = new Network.TCPServer("0.0.0.0", 9999);

启动Socket连接： 

  1.  ser.ChannelConnect += new Network.EventChannelConnect(ser_ChannelConnect);
  2.  ser.ChannelDispose += new Network.EventChannelDispose(ser_ChannelDispose);
  3.  ser.Start();

要保证服务端不出问题，还需要实现通道的连接事件和释放事件方法，此处不提。



相关技术文章

最新源码

下载排行榜
点击QQ咨询
开通会员
返回顶部
×
微信扫码支付 元
微信扫码支付
确定支付下载
请使用微信描二维码支付
×

提示信息

×

选择支付方式

  • 微信支付
  • 支付宝付款
确定支付下载