Socket 服务端

最新推荐文章于 2019-06-09 22:46:57 发布
置顶 最新推荐文章于 2019-06-09 22:46:57 发布
阅读量344 收藏
点赞数 2
分类专栏： 经验分享 c# 编程学习文档（个人首发） Socke 文章标签： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luckystart0/article/details/89852198
版权

        以前写过一个Socket服务端程序，但在写4G模块项目的时候，遇到了一个问题，就是在服务端断开Socket客户端连接后，客户端收不到断开的状态，而且使用异步时，明明服务端停止服务了，但是客户端的连接依然还在，只不过不接收数据了，但客户端和服务端的连接照样还是在进行，所以花费了一天时间，继续研究Socket机制，写了一个服务端程序，这个程序不仅可以统计客户端数量，而且可以对收到的消息，发送的消息，断开的连接，接收的客户端做出事件，供外部访问，本来想做成COM控件，但想来没有什么用，没做，下面是代码，分享给大家，如果有更好的意见或建议，欢迎留言：

事件类：

using System;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.Net.Sockets;

namespace TcpLibrary
{
    public sealed class AcceptClient
    {
        /// <summary>
        /// 连接的客户端
        /// </summary>
        public Socket Client
        { get; set; }
        /// <summary>
        /// 连接地址
        /// </summary>
        public string Address
        { get; set; }
        /// <summary>
        /// 连接端口号
        /// </summary>
        public int Port
        { get; set; }
        /// <summary>
        /// SocketID
        /// </summary>
        public IntPtr ClientID
        { get; set; }
    }
    /// <summary>
    /// 接收客户端事件
    /// </summary>
    public sealed class AcceptClientEventArgs : EventArgs
    {
        /// <summary>
        /// 收到的客户端
        /// </summary>
        public Socket Client
        { get; set; }
        /// <summary>
        /// 收到的客户端
        /// </summary>
        public IPEndPoint EndPointRemote
        { get; set; }
        /// <summary>
        /// 收到的地址
        /// </summary>
        public IPAddress IPAddressRemote
        { get; set; }
        /// <summary>
        /// 收到客户端连接的端口号
        /// </summary>
        public int Port
        { get; set; }
    }
    /// <summary>
    /// 收到客户端发送过来的数据
    /// </summary>
    public sealed class ReceivedBufferEventArgs : EventArgs
    {
        /// <summary>
        /// 客户端来源
        /// </summary>
        public IPEndPoint EndPointRemote
        { get; set; }
        /// <summary>
        /// 来源客户端连接
        /// </summary>
        public Socket Client
        { get; set; }
        /// <summary>
        /// 收到的客户数据
        /// </summary>
        public byte[] Buffer
        { get; set; }
    }

    public sealed class HostDisconnectEventArgs : EventArgs
    {
        /// <summary>
        /// 客户端来源
        /// </summary>
        public IPEndPoint EndPointRemote
        { get; set; }
        /// <summary>
        /// 客户端来源地址
        /// </summary>
        public string Address
        { get; set; }
        /// <summary>
        /// 客户端来源端口号
        /// </summary>
        public int Port
        { get; set; }
        /// <summary>
        /// 客户端来源句柄
        /// </summary>
        public IntPtr ClientID
        { get; set; }
        /// <summary>
        /// 来源客户端连接
        /// </summary>
        public Socket Client
        { get; set; }
    }
}
委托类：

using System;
using System.Collections.Generic;
using System.Text;

namespace TcpLibrary
{
    /// <summary>
    /// 接收客户端事件
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    public delegate void AcceptClientEvents(object sender, AcceptClientEventArgs e);
    /// <summary>
    /// 接收数据事件
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    public delegate void ReceiveBufferEvents(object sender, ReceivedBufferEventArgs e);
    /// <summary>
    /// 断开客户端连接事件
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    public delegate void HostDisconnectionEvents(object sender, HostDisconnectEventArgs e);
}
数据接收类：

using System;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.Net.Sockets;

namespace TcpLibrary
{
    /// <summary>
    /// Socket数据接收类
    /// </summary>
    public sealed class TcpReceive
    {
        private byte[] _Buffer = new byte[2048];
        /// <summary>
        /// 获取或设置接收的数据信息
        /// </summary>
        public byte[] Buffer
        {
            get { return _Buffer; }
            set { _Buffer = value; }
        }
        private Socket _Client;
        /// <summary>
        /// 获取或设置连接的客户端
        /// </summary>
        public Socket Client
        {
            get { return _Client; }
            set { _Client = value; }
        }
    }
}
服务端监听类：

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

namespace TcpLibrary
{
    /// <summary>
    /// 监听类
    /// </summary>
    public sealed class TCPListener
    {
        
        public static ManualResetEvent allDone = new ManualResetEvent(false);
        private Socket tcpListener;
        /// <summary>
        /// 收到客户端事件
        /// </summary>
        public event AcceptClientEvents AcceptClientEvent;
        /// <summary>
        /// 收到消息事件
        /// </summary>
        public event ReceiveBufferEvents ReceivedBufferEvent;
        /// <summary>
        /// 断开连接事件
        /// </summary>
        public event HostDisconnectionEvents DisconnectionEvent;
        private List<Thread> listThread = new List<Thread>();
        private List<AcceptClient> listClient = new List<AcceptClient>();
        private object objClientList = new object();
        /// <summary>
        /// 获取连接的客户端集合
        /// </summary>
        public List<AcceptClient> Clients
        {
            get { return listClient; }
        }
        private int Port;
        /// <summary>
        /// 获取或设置接收超时时间(秒)
        /// </summary>
        public int? ReceiveTimeOut
        { get; set; }
        /// <summary>
        /// 获取或设置发送超时时间(秒)
        /// </summary>
        public int? SendTimeOut
        { get; set; }
        public TCPListener(int Port)
        {
            this.Port = Port;
        }

        private bool IsStartListener = false;

        public void Start()
        {
            tcpListener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            tcpListener.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
            IPEndPoint point = new IPEndPoint(IPAddress.Parse("0.0.0.0"), Port);
            tcpListener.Bind(point);
            tcpListener.Listen(2000);
            IsStartListener = true;
            Thread thread = new Thread(new ThreadStart(ClientAcceptAsync));
            thread.Start();
            listThread.Add(thread);
        }

        private void ClientAcceptAsync()
        {
            while (IsStartListener)
            {
                try
                {
                    TcpReceive receive = new TcpReceive();
                    receive.Client = tcpListener.Accept();
                    if (receive.Client.Connected)
                    {
                        //listClient.Add(receive.Client);
                        IPEndPoint point = receive.Client.RemoteEndPoint as IPEndPoint;
                        lock (objClientList)
                        {
                            AcceptClient ac = new AcceptClient();
                            ac.ClientID = receive.Client.Handle;
                            ac.Client = receive.Client;
                            ac.Address = point.Address.ToString();
                            ac.Port = point.Port;
                            listClient.Add(ac);
                        }
                        AcceptClientEventArgs e = new AcceptClientEventArgs();
                        e.Client = receive.Client;
                        e.EndPointRemote = point;
                        e.IPAddressRemote = e.EndPointRemote.Address;
                        e.Port = e.EndPointRemote.Port;
                        if (AcceptClientEvent != null)
                            AcceptClientEvent.Invoke(receive, e);
                        //receive.Client.BeginReceive(receive.Buffer, 0, receive.Buffer.Length, SocketFlags.None, new AsyncCallback(Receive), receive);
                        if(ReceiveTimeOut != null)
                            receive.Client.ReceiveTimeout = 1000 * Convert.ToInt32(ReceiveTimeOut);
                        if(SendTimeOut != null)
                            receive.Client.SendBufferSize = 1000 * Convert.ToInt32(SendTimeOut);
                        Thread thread = new Thread(new ParameterizedThreadStart(Receive));
                        thread.Start(receive);
                        listThread.Add(thread);
                    }
                    Thread.Sleep(100);
                }
                catch (Exception ex)
                {
                    break;
                }
            }
        }

        private void RemoveClient(AcceptClient ac)
        {
            for (int i = 0; i < listClient.Count; i++)
            {
                if (listClient[i].ClientID == ac.ClientID)
                {
                    try
                    {
                        listClient[i].Client.Shutdown(SocketShutdown.Both);
                    }
                    catch
                    { }
                    finally
                    {
                        listClient[i].Client.Close();
                    }
                    listClient.RemoveAt(i);
                    break;
                }
            }
        }

        private void Receive(object sender)
        {
            TcpReceive receive = sender as TcpReceive;
            HostDisconnectEventArgs e = new HostDisconnectEventArgs();
            e.Client = receive.Client;
            e.ClientID = receive.Client.Handle;
            e.EndPointRemote = receive.Client.RemoteEndPoint as IPEndPoint;
            e.Address = e.EndPointRemote.Address.ToString();
            e.Port = e.EndPointRemote.Port;
            AcceptClient ac = new AcceptClient();
            ac.Client = receive.Client;
            ac.Address = e.EndPointRemote.Address.ToString();
            ac.Port = e.EndPointRemote.Port;
            ac.ClientID = receive.Client.Handle;
            while (IsStartListener)
            {
                try
                {
                    if (!receive.Client.Connected)
                    {
                        e.Client = receive.Client;
                        if (DisconnectionEvent != null)
                            DisconnectionEvent.Invoke(this, e);
                        RemoveClient(ac);
                        try
                        {
                            receive.Client.Shutdown(SocketShutdown.Both);
                        }
                        catch { }
                        finally
                        {
                            receive.Client.Close();
                        }
                        break;
                    }
                    int byteRead = receive.Client.Receive(receive.Buffer, 0, receive.Buffer.Length, SocketFlags.None);
                    if (byteRead > 0)
                    {
                        ReceivedBufferEventArgs re = new ReceivedBufferEventArgs();
                        re.Buffer = new byte[byteRead];
                        Array.Copy(receive.Buffer, re.Buffer, byteRead);
                        re.Client = receive.Client;
                        IPEndPoint point = receive.Client.RemoteEndPoint as IPEndPoint;
                        re.EndPointRemote = point;
                        if (ReceivedBufferEvent != null)
                            ReceivedBufferEvent.Invoke(receive, re);
                    }
                    else
                    {
                        e.Client = receive.Client;
                        if (DisconnectionEvent != null)
                            DisconnectionEvent.Invoke(receive, e);
                        RemoveClient(ac);
                        try
                        {
                            receive.Client.Shutdown(SocketShutdown.Both);
                        }
                        catch { }
                        finally
                        {
                            receive.Client.Close();
                        }
                        break;
                    }
                }
                catch
                {
                    try
                    {
                        receive.Client.Shutdown(SocketShutdown.Both);
                    }
                    catch { }
                    finally
                    {
                        receive.Client.Close();
                    }
                    RemoveClient(ac);
                    if (DisconnectionEvent != null)
                        DisconnectionEvent.Invoke(receive, e);
                    break;
                }
            }
        }

        public void Send(Socket Client, byte[] buffer)
        {
            if (!IsStartListener)
            {
                try
                {
                    Client.Shutdown(SocketShutdown.Both);
                }
                catch { }
                finally
                {
                    Client.Close();
                }
                return;
            }
            if(Client.Connected)
                Client.Send(buffer);
        }

        public void Stop()
        {
            IsStartListener = false;
            try
            {
                //tcpListener.Shutdown(SocketShutdown.Both);
                tcpListener.Close();
            }
            catch { }
            tcpListener = null;
            for (int i = 0; i < listClient.Count; i++)
            {
                try
                {
                    listClient[i].Client.Shutdown(SocketShutdown.Both);
                }
                catch { }
                finally
                {
                    listClient[i].Client.Close();
                }
            }
            for (int i = 0; i < listThread.Count; i++)
            {
                try
                {
                    listThread[i].Abort();
                    //while (!(listThread[i].ThreadState == ThreadState.Aborted) && !(listThread[i].ThreadState == ThreadState.Stopped))
                    //{
                    //    Thread thread = listThread[i];
                    //    thread.Abort();
                    //    if (thread.ThreadState == ThreadState.Aborted || thread.ThreadState == ThreadState.Stopped)
                    //    {
                    //        thread.Abort();
                    //        break ;
                    //    }
                    //}
                }
                catch { }
            }
            listClient.Clear();
            listThread.Clear();
        }
    }
}
以上是全部代码，留做记忆或大家写的时候，可以做一 个参考，不用再绕圈子。

.net for TCP服务端 && 客户端
L.的博客
12-08 397
关键代码 详细代码请看示例代码 Service //创建套接字 IPEndPoint ipe = new IPEndPoint(IPAddress.Parse(ipaddress), port); //也可以使用IPAddress.Any，监听所有网络接口上的客户端活动 //https://docs.microsoft.com/en-us/dotnet/api/system.net.ipaddress.any?view=netframework-4.7.2 //一般来说，服务端套接字都是直接bind端口，
IPEndPoint(IPAddress.Any, 0)的意思
farmer_worker的专栏
03-01 2万+
IPEndPoint(IPAddress.Any, 0) If creates an IPEndpoint using any available IP address on the local computer, and any available port number. IPAddress.Any代表本机上的所有IP地址，MSDN上说是“一个 IP 地址，指示服务器应侦听所有网络接口
SOCKET服务端
网络知识精读
02-10 818
 Code:import java.io.*;  import java.net.*;  import java.util.*;    public class VerySimpleChatServer {        /**      * @param args      */      ArrayList clientOutputs
Socket 服务器短标示特定的客服
小王同学的博客
05-25 887
1、java   Socket客服 服务器代码。  该Demo 代码不多规范，仅供参考： 服务器段code import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.IOException; import java.io.InputStreamReader; import java.io.Ou
c#应用04-udp服务器端与客户端
zyhui65的专栏
11-08 692
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading;             //使用Thread类来创建和控制线程 using System.Net; using System.Net.Sockets; namespa
c# Socket(客户端)异步通讯
luckystart0的专栏
10-09 6280
        实现功能，能够随时发送数据，并且能够随时接收服务端发送过来的数据，能够判断服务端或端口网络的连接状态，随时查看与服务器通讯是否通畅。         可以使用VS创建一个用户控件或创建一个类，来控制Socket通讯，代码成熟，建议做成用户控件，这样可以随时拖拽控件，写事件什么的都方便。         在写Socket客户端之前，要知道Socket客户端接收数据，使用 的线程循...
javaweb启动时启动socket服务端代码实现
08-25
Java Web 启动时启动 Socket 服务端代码实现 Java Web 启动时启动 Socket 服务端代码实现是指在 Java Web 应用程序启动时，自动启动一个 Socket 服务端，以便接受客户端的连接请求并处理数据传输。本文将详细介绍...
基于netty编写的socket服务端
12-05
在基于Netty编写的socket服务端中，首先需要定义一个`ChannelHandler`，这个处理器负责处理接收到的网络事件，如连接建立、数据读取、连接关闭等。`ChannelHandlerContext`则是`ChannelHandler`和`ChannelPipeline`...
C#SuperSocket服务端与客户端通信实例
09-17
SuperSocket是一个轻量级且易于使用的.NET Socket服务端开发框架，它为开发者提供了构建自定义网络应用的便捷途径。 首先，我们来看服务端的搭建。使用SuperSocket，你可以快速创建一个Socket服务端，处理来自...
TCP socket服务端代码 C#
09-25
本文将详细解析使用C#语言编写的TCP socket服务端代码，特别是针对GPRS（General Packet Radio Service）环境的服务端测试程序。 首先，TCP是一种面向连接的、可靠的传输协议，它确保了数据的顺序传输和无丢失特性...
VB6.0 简单 Socket 服务端
12-04
在这个“VB6.0简单Socket服务端”项目中，开发者使用了Winsock控件来实现了一个基本的Socket服务器。下面将详细解释Socket、Winsock控件以及如何在VB6.0中构建Socket服务端。 Socket，也称为套接字，是网络编程中的...
IP地址127.0.0.1和0.0.0.0的区别
enzochan的博客
06-09 1万+
一直以来都以为 127.0.0.1 和 0.0.0.0 都是表示本机IP 地址，直至上一次在C# 中写一个UDP 通信的程序时遇到了问题。 先上代码： // 实名发送 IPEndPoint localIpep = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 25555); // 本机IP，指定的端口号 ...
设计IP地址屏蔽功能 c#
满地鸡毛
12-11 1977
出于安全考虑，几乎每个动态网站都具备IP地址屏蔽功能，而网上流传的很多关于该功能的教程大都采用字符串保存和验证IP地址，我认为这是不太科学的，我试图找到最佳的设计方案。    “IP地址的长度为32位，分为4段，每段8位，用十进制数字表示，每段数字范围为0～255，段与段之间用句点隔开。”    由此我们了解到，IP地址实际上是一个32位正整数，在C#中可以使用uint类型来表示，
运维发布服务时候设置"hostname":"0.0.0.0"
nobody
11-23 3094
以前没接触过运维，现在不免动手发布一些java服务，碰到绑定ip：端口问题。 What is the difference between 0.0.0.0, 127.0.0.1 and localhost 摘自：http://stackoverflow.com/questions/20778771/what-is-the-difference-between-0-0-0-0
ip地址0.0.0.0与127.0.0.1的区别
热门推荐
txx_laughing的博客
02-28 2万+
最近在项目开发中发现一个奇怪的问题，当服务器与客户端在同一台机器上时，用服务器ip（本地主机ip）192.168.1.xxx、127.0.0.1以及0.0.0.0都能登陆服务器，于是找点资料研究一下。 其实，最开始是发现服务器ip填0能登陆成功，后来知道了系统自动补全ip地址，什么意思呢，就是如果你填0或0.0或0.0.0，系统都会自动补全ip为0.0.0.0。下面就简要介绍一下这三种ip的区别。
ip地址0.0.0.0与127.0.0.1的区别（转载）
06-16 1709
原文链接：http://blog.csdn.net/ttx_laughing/article/details/58586907 最近在项目开发中发现一个奇怪的问题，当服务器与客户端在同一台机器上时，用服务器ip（本地主机ip）192.168.1.xxx、127.0.0.1以及0.0.0.0都能登陆服务器，于是找点资料研究一下。其实，最开始是发现服务器ip填0能登陆成功，后来知道了系统...
Java实现Socket服务端的深入探讨
标题和描述中提到了“java socket 服务端”和“sping”，而标签是“socket服务端 java”，这些信息指向了一个关于Java编程语言中使用Socket API创建服务端程序的主题。以下内容将详细介绍如何在Java中创建一个Socket...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值