精华内容
下载资源
问答
  • 如果是新手,建议先看下前面的C#Socket客户端和服务器端的编写再来看这,会更容易些。 https://blog.csdn.net/qq_31157943/article/details/93379827 在实际发送请求时经常需要的对发送的数据进行分别的处理,比如...

    如果是新手,建议先看下前面的C#Socket客户端和服务器端的编写再来看这,会更容易些。

    https://blog.csdn.net/qq_31157943/article/details/93379827

    在实际发送请求时经常需要的对发送的数据进行分别的处理,比如说客户端向服务器端发送一个登录请求,那么就需要把客户端输入的账号和密码发送给服务器端,这时服务器端就需要对这两个数据进行处理,那么如何从服务器端socket收到的byte数组中获取到账号和密码呢?(当然最麻烦的方法是你分别发送,但那样当请求多了以后,代码比较乱,不容易修改,通用性比较差,或者你也可以对byte数组存的东西进行指定,比如说索引0存请求编码,用于区分请求,索引1存账号,索引2存密码,但通用性太差,你在未来可能会遇到每个请求我都要这么指定一遍索引,数据多了后就是一种噩梦),那有没有方便快捷通用性强的方法呢?

    个人推荐一种还算比较实用的方法就是:先把要发送的数据封装为一个客户端和服务端通用的类,然后新建这个类的对象,在通过关键的一步Xml序列化,把这个实例转为一个Xml字符串,然后直接发送这个字符串,服务器端收到后在进行Xml反序列化转为对应的实例,然后从实例中获取数据,直白的说就是发送对象------>接收对象 ------- > 对对象数据进行处理, 但是发送的内容因为是字符串所以数据量又比较小,不会太影响传输速度。

    /*对账号和密码的对象xml序列化后得到的xml字符创*/
    
    <?xml version="1.0" encoding="utf-16"?>
    <UserInfo xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
      <username>小明</username>
      <password>hkklp123123</password>
    </UserInfo>

    客户端和服务器端用到的共有工具类

    XmlHandler(对指定类型的序列化和和反序列化的处理)

    UserInfo(指定的用于记录用户账号的密码的类,这里只是个示例,可以根据自己的功能进行编写)

    需要用到的命名空间

    using System.IO;
    using System.Xml.Serialization;
    

    UserInfo.cs(客户端和服务器端都要有,负责对指定数据的封装,这里是账号和密码)

    using System;
    using System.Collections;
    using System.Collections.Generic;
    
    
    public class UserInfo
    {
        public string username;
    
        public string password;
        
        public void SetUserInfo(string username,string password)
        {
            this.username = username;
            this.password = password;
        }
    
    }

    XmlHandler.cs(客户端和服务器端都要有,序列化和反序列化的处理在这里)

    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.IO;
    using System.Xml.Serialization;
    
    public class XmlHandler {
    
        /// <summary>
        /// 把指定对象转化weiXml字符串
        /// </summary>
        /// <param name="type"></param>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public static string GetXmlContent<T> (T type) {
            string xmlString = "";
            using (StringWriter sw = new StringWriter ()) {
                XmlSerializer serializer = new XmlSerializer (typeof (T));
                serializer.Serialize (sw, type);
                sw.Close ();
                xmlString = sw.ToString ();
            }
            return xmlString;
        }
    
        /// <summary>
        /// 把xml字符串转化为指定的类型的对象
        /// </summary>
        /// <param name="xmlString"></param>
        /// <returns></returns>
        public static T GetDataByXml<T> (string xmlString) {
            T data;
            using (StringReader sr = new StringReader (xmlString)) {
                XmlSerializer serializer = new XmlSerializer (typeof (T));
                data = (T) serializer.Deserialize (sr);
                sr.Close ();
            }
            return data;
        }
    
    }

    以上方法的使用例子

    1.xml序列化

    UserInfo user = new UserInfo ();
    user.SetUserInfo ("小明", "hkklp123123");
    string xmlString = XmlHandler.GetXmlContent (user);
    Console.WriteLine(xmlString);

    2.xml反序列化

    //反序列化获得指定类型的实例
    UserInfo user_2 = XmlHandler.GetDataByXml<UserInfo>(xmlString);
    Console.WriteLine(user_2.username + "," + user_2.password);

    最后的结果

    xml序列化后的字符串

    xml反序列化后获得的对象的数据

    以上就是对发送内容的区分处理的办法,如果你有更好的方法,麻烦告诉我一下,在此谢谢了。

     

     

    展开全文
  • 最近在做个多人游戏的demo,试试自己编写服务器端,在写之前,就不介绍Tcp和Udp的区别了,网上资料很多,在看socket编程之前最好先去看看基础的Tcp和Udp的理论内容,再去看Socket编程会好很多。 C#的socket编程主要...

    最近在做个多人游戏的demo,试试自己编写服务器端,在写之前,就不介绍Tcp和Udp的区别了,网上资料很多,在看socket编程之前最好先去看看基础的Tcp和Udp的理论内容,再去看Socket编程会好很多。

    C#的socket编程主要用到一下命名空间:

    1. System.Net;//socket的重要基础
    2.  System.Net.Sockets;//socket的重要基础
    3. System.Text;//因为socket只能发送byte数组,也只能接收byte数组,需要把接收到的byte数组转化为字符串
    4. System.Threading;//主要用来开启一个负责监听和接收消息的线程

    socket的常用类和方法

      相关类:

    1.    IPAddress:包含了一个IP地址
    2.    IPEndPoint:包含了一对IP地址和端口号

    相关方法 

    1.    Socket():创建一个Socket
    2.    Bind():绑定一个本地的IP和端口号(IPEndPoint)
    3.    Listen():让Socket侦听传入的连接吃那个病,并指定侦听队列容量
    4.    Connect():初始化与另一个Socket的连接
    5.    Accept():接收连接并返回一个新的Socket
    6.    Send():输出数据到Socket,只能发送一个byte数组
    7.    Receive():从Socket中读取数据,返回接收到的数据的长度
    8.    Close():关闭Socket,销毁连接

     客户端和服务器端结构如图

    客户端与服务器结构图

           

     

    通过上图,我们可以看出,首先服务器会创建一个负责监听的socket,然后客户端通过socket连接到服务器指定端口,最后服务器端负责监听的socket,监听到客户端有连接过来了,就创建一个负责和客户端通信的socket。

    下面我们来看下Socket更具体的通信过程:

    Socket的通讯过程

      服务器端:

        01,申请一个socket

        02,绑定到一个IP地址和一个端口上

        03,开启侦听,等待接收连接

      客户端:

        01,申请一个socket

       02,连接服务器(指明IP地址和端口号)

       服务器端接收到连接请求后,产生一个新的socket(端口大于1024)与客户端建立连接并进行通信,原监听socket继续监听。

      注意:负责通信的Socket不能无限创建,创建的数量和操作系统有关。

    Socket的构造函数

        Public Socket(AddressFamily addressFamily,SocketType  socketType,ProtocolType  protocolTYpe)

        AddressFamily:指定Socket用来解析地址的寻址方案。例如:InterNetWork指示当Socket使用一个IP版本4地址连接

       SocketType:定义要打开的Socket的类型

       Socket类使用ProtocolType枚举向Windows  Sockets  API通知所请求的协议

    示例

    IPAddress addr = IPAddress.Parse("127.0.0.1");

    /*

    注意如果addr是指定ip地址,那么就只能在同一个ip下进行通信,如果作为服务器端的话addr必须是IpAddress.any,

    表示任意ip都可以在指定端口下访问服务器

    */

    IPEndPoint endp = new IPEndPoint(addr,,9000);

             服务端先绑定:serverWelcomeSocket.Bind(endp)

             客户端再连接:clientSocket.Connect(endp)

    注意

       1,一个Socket一次只能连接一台主机

       2,Socket关闭后无法再次使用

       3,每个Socket对象只能与一台远程主机连接。如果你想连接到多台远程主机,你必须创建多个Socket对象。

     

    服务器端代码

    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Net;
    using System.Net.Sockets;
    using System.Text;
    using System.Threading;
    
    namespace Server {
        class Program {
    
            //记录通信用的scoket的字典
            static Dictionary<string, Socket> sockets = new Dictionary<string, Socket> ();
            static void Main (string[] args) {
                //设置ip和端口
                IPAddress ipAddress = IPAddress.Any;
                int port = 30001;
                //绑定本机的IP和端口
                IPEndPoint endPoint = new IPEndPoint (ipAddress, port);
                //新建socket
                Socket socket = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    
                //绑定服务器的监听Socket
                try {
                    socket.Bind (endPoint);
                    //设置最大连接数
                    socket.Listen (10); //如果是0表示不限制连接数
                    ShowMessage ("开始监听");
    
                    // 后台线程用于监听来连接上来的客户端
                    Thread t = new Thread (AcceptInfo);
                    t.IsBackground = true;
                    t.Start (socket);
    
                } catch (Exception e) {
                    // 打印错误信息
                    ShowMessage (e.Message);
                }
    
                Console.ReadKey ();
            }
    
            //打印信息
            static void ShowMessage (string msg) {
                Console.WriteLine (msg);
            }
    
            //创建链接成功后用于通信的Socket
            static void AcceptInfo (Object o) {
                Socket socket = o as Socket;
    
                while (true) {
    
                    try {
                        //通信用的socket,根据连接过来的scoket返回一个新的用于通信的socket
                        Socket tSocket = socket.Accept ();
                        string point = tSocket.RemoteEndPoint.ToString ();
                        //把通信socket加入字典
                        sockets.Add (point, tSocket);
                        ShowMessage (point + " 连接成功");
                        //接收客户端的信息
                        Thread t = new Thread (ReceiveMsg);
                        t.IsBackground = true;
                        t.Start (tSocket);
    
                    } catch (Exception e) {
                        ShowMessage (e.Message);
                        break;
                    }
                }
    
            }
    
            static void ReceiveMsg (Object o) {
                Socket client = o as Socket;
    
                while (true) {
                    try {
                        byte[] buffer = new byte[1024 * 1024];
                        // 获得实际接受的数据的长度
                        int n = client.Receive (buffer);
                        // 如果是一个有内容的请求
                        if (n > 0) {
                            GetRequestByCode (buffer[0], buffer, n);
                        }
                        // string words = Encoding.UTF8.GetString(buffer,0,n);
                        // ShowMessage(client.RemoteEndPoint.ToString() + ":" + words);    
    
                    } catch (Exception e) {
                        ShowMessage (e.Message);
                        break;
                    }
    
                }
            }
    
            /// <summary>
            /// 根据请求的code来获得对应的请求,即buffer[0] = code
            /// </summary>
            /// <param name="code">请求的code</param>
            /// <param name="buffer">请求的内容</param>
            /// <param name="length">实际请求内容的长度</param>
            static void GetRequestByCode (byte code, byte[] buffer, int length) {
                switch (code) {
                    case 0:
                        GetRequestContent (buffer, length);
                        break;
                    case 1:
                        GetRequestContent (buffer, length);
                        break;
                    default:
                        break;
                }
            }
    
            /// <summary>
            /// 负责获取请求的内容
            /// </summary>
            /// <param name="buffer"></param>
            /// <param name="length"></param>
            static void GetRequestContent (byte[] buffer, int length) {
                //因为指定了buffer[0]是请求的code区分是哪个请求,请求内容从1开始
                string words = Encoding.UTF8.GetString (buffer, 1, length);
                Console.WriteLine (words);
            }
    
        }
    }

    客户端代码

    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Net;
    using System.Net.Sockets;
    using System.Text;
    
    namespace Client {
        class Program {
            static Socket client = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            static void Main (string[] args) {
                IPAddress ip = IPAddress.Parse ("39.107.234.74");
                IPEndPoint point = new IPEndPoint (ip, 30001);
    
                //开始连接到服务器
                try {
                    client.Connect (point);
                    ShowMessage ("服务器" + client.RemoteEndPoint.ToString ());
                    ShowMessage ("客户端" + client.LocalEndPoint.ToString ());
                    SendMessage (client, 0, "我是" + client.LocalEndPoint.ToString () + "请求0过来了");
                    // SendMessage(client,1,"我是" + client.LocalEndPoint.ToString() + "请求1过来了");
                } catch (Exception e) {
                    ShowMessage (e.Message);
                }
    
                Console.ReadKey ();
            }
    
            static void ShowMessage (string msg) {
                Console.WriteLine (msg);
            }
    
            /// <summary>
            /// 发送请求(code存在byte[]的0,content存在byte[]0后面的空间里)
            /// </summary>
            /// <param name="client">发送请求的socket</param>
            /// <param name="requestCode">请求的编码</param>
            /// <param name="context">请求的内容</param>
            static void SendMessage (Socket client, byte requestCode, string context) {
                if (client != null && client.Connected) {
                    try {
                        byte[] buffer = Encoding.UTF8.GetBytes (context);
                        //新的请求格式buffer[0]是请求的编码,buffe后面的内容是请求的内容
                        List<byte> list = new List<byte> ();
                        list.Add (requestCode);
                        list.AddRange (buffer);
                        byte[] newbuffer = list.ToArray ();
                        client.Send (newbuffer);
                    } catch (Exception e) {
    
                        ShowMessage (e.Message);
                    }
                }
            }
        }
    }

    至此结束。

     

     

     

    展开全文
  • (一)TCPSocket 服务端编写 —— 一个服务端对应多个客户端(超详细) 文章目录 客户端的一些API 客户端源码(超详细) 效果终极演示 客户端的一些API socket:创建套接字 connect:与服务端建立连接 send/...

    前文链接:
    (一)TCPSocket 服务端编写 —— 一个服务端对应多个客户端(超详细)


    文章目录


    客户端的一些API

    在这里插入图片描述

    • socket:创建套接字
    • connect:与服务端建立连接
    • send/recv:发送数据 / 接收数据
    • close:关闭套按字

    客户端编写顺序与上面函数顺序一样


    客户端源码(超详细)

    每行代码都加以详细的注释(看不懂你来砍我)~

    #pragma comment(lib, "ws2_32.lib")	// 网络编程需要的链接库
    
    #include <WinSock2.h>
    #include <stdio.h>
    #include <stdlib.h>
    
    void main()
    {
        WSADATA 		wsaData;	// 用于初始启动信息
        SOCKET		s;		// 客户端的套接字
        SOCKADDR_IN		ServerAddr;	// 服务端地址
        int			Port = 5150;	// 服务端端口号
        int 		Ret;		// 用于判断 
        char		buf[1024];	// 用来发送数据
        
        // 开始启动信息,2.2版本
        if((Ret = WSAStartup(MAKEWORD(2, 2), &wsaData)) != 0)
        {
            printf("WSAStartup failed with error %d\n", Ret);
            return;
        }
        
        // 创建套接字,并判断是否成功
        if((s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == INVALID_SOCKET)
        {
            printf("socket failed with error %d\n"), WSAGetLastError());
            WSACleanup();
            return;
        }
    
        // 初始化服务端地址信息
        ServerAddr.sin_family = AF_INET;	// 使用ip4
        ServerAddr.sin_port = htons(Port);	// 字节转型,前文有介绍
        // 因为没有其它电脑,也没有安装虚拟机,所有只有使用本机的ip地址
        ServerAddr.sin_addr.S_un.S_ddr = inet_addr("172.0.0.1");	// 将本机ip转为32位无符号整形
        
        // 提示信息
        printf("We are trying to connect to %s:%d...\n", inet_ntoa(ServerAddr.sin_addr), htons(ServerAddr.sin_port));
    
        // 建立链接(链接服务端),并判断是否成功
        if(connect(s, (SOCKADDR*)&ServerAddr, sizeof(ServerAddr)) == SOCKET_ERROR)
        {
            printf("connect failed with error %d\n", WSAGetLastError());
            closesocket(s);	// 释放套接字
            WSACleanup();	// 清空启动信息
            return;
        }
    
        // 链接成功提示信息
        printf("Our connection succeeded.\n");
        printf("We will with hello send.\n");
        
        while(1)	// 可以一直发信息
        {
            printf("The data you send is:\n");
            scanf("%s", buf);	// 输入需要发送的数据
            
            // 发送数据,并判断是否失败,返回的是发送了多少数据
            if((Ret = send(s, buf, strlen(buf), 0)) == SOCKET_ERROR)
            {
                printf("send failed with error %d\n", WSAGetLastError());
                closesocket(s);
       	    WSACleanup();
       	    return;
            }
    
            // 提示发送了多少数据
            printf("We successfully sent %d bytes.\n\n", Ret);
        }
        
        printf("We are closing the connection.\n");
        closesocket(s);
        WSACleanup();
    
        system("pause");	
    }

    效果终极演示

    先将服务端开启,然后再运行客户端

    在这里插入图片描述


    作者:浪子花梦
    Time:2020.02.15
    学海无涯苦作舟,加油!

    展开全文
  • WebSocket区分不同客户端两种方法(HttpSession和@PathParam)
  • c# Socket(客户端)异步通讯

    千次阅读 2018-10-09 12:15:25
    实现功能,能够随时发送数据,并且能够随时接收服务端发送过来的数据,能够判断服务端或端口网络的连接状态,随时查看与服务器通讯是否通畅。... 在写Socket客户端之前,要知道Socket客户端接收数据,使用 的线程循...

            实现功能,能够随时发送数据,并且能够随时接收服务端发送过来的数据,能够判断服务端或端口网络的连接状态,随时查看与服务器通讯是否通畅。

            可以使用VS创建一个用户控件或创建一个类,来控制Socket通讯,代码成熟,建议做成用户控件,这样可以随时拖拽控件,写事件什么的都方便。

            在写Socket客户端之前,要知道Socket客户端接收数据,使用 的线程循环的方式,有数据接收到的时候,触发消息事件,在断开事件处理时,能够触发断开连接事件,这时要定义几个委托,承载事件的触发。

            public delegate void ReceiveBuffer(byte[] buffer);//收到消息时,传递消息Buffer的事件。

            public delegate void HostDisconnectionEvent();//断开连接时,触发的事件。

            我在使用的时候,习惯将委托单独放在一个.cs文件当,定义为委托事件类:DelegateEvent.cs

            还要考虑到,在Socket接收消息时,需要使用线程,那么在触发收到消息的事件后,如果需要修改界面上的参数或值,需要做控件的异步调用处理,这样处理起来太麻烦,而且处理不好,到时会有一堆的Bug,这是我在使用过程当中遇到的。那么有一没有办法不使用线程,让客户端循环接收消息呢?这时我想到了使用异步,最后又增加了一个异步收消息的委托:

            public delegate void AsyncReceivedClient(object sender);//异步收到消息时的委托,如果整个类当中只有一个客户端连接,可以不带参数。

            这时,委托类基本建完了,那么,这时需要定义代码了:

        创建一个TCPClient类,当然,这个类和System.Net.Sockets下的类不同,为了区分,我定义的命名空间为:System.Net.Securate.TCP,下面是定义的事件和参数:

            /// <summary>
            /// 收到消息事件
            /// </summary>
            public ReceiveBuffer ReceiveComtemplate;
            /// <summary>
            /// 主机断开连接事件
            /// </summary>
            public HostDisconnectionEvent HostDisconnectedComtelplate;
            private string _Address;
            /// <summary>
            /// 获取或设置连接地址
            /// </summary>
            public string Address
            {
                get { return _Address; }
                set { _Address = value; }
            }
            private int _Port;
            /// <summary>
            /// 获取或设置端口号
            /// </summary>
            public int Port
            {
                get { return _Port; }
                set { _Port = value; }
            }
            private Socket tcpClient;
            /// <summary>
            /// 获取连接状态
            /// </summary>
            public bool IsConnected
            {
                get {
                    if (tcpClient == null)
                        return false;
                    return tcpClient.Connected;
                }
            }

            创建连接的启动事件,我写两种启动方式,一种是不带参的,一种是带参的,如下:

            /// <summary>
            /// 打开连接
            /// </summary>
            /// <returns></returns>
            public bool Start()
            {
                return Start(_Address, _Port);
            }
            /// <summary>
            /// 打开连接
            /// </summary>
            /// <param name="ip">连接地址</param>
            /// <param name="port">连接端口号</param>
            /// <returns></returns>
            public bool Start(string ip, int port)
            {
                try
                {
                    _Address = ip;
                    _Port = port;
                    tcpClient = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                    IPAddress ipaddress = IPAddress.Parse(_Address);
                    tcpClient.Connect(ipaddress, port);
                    if (tcpClient.Connected)
                    {
                        AsyncReceivedClient rc = new AsyncReceivedClient(Receive);
                        rc.BeginInvoke(tcpClient, null, null);
                    }
                    return tcpClient.Connected;
                }
                catch (Exception ex)
                {
                    return false;
                }
            }

            需要注意的是:

            AsyncReceivedClient rc = new AsyncReceivedClient(Receive);
            rc.BeginInvoke(tcpClient, null, null);

            这两行,实现的是异步委托带参的调用,实现随时接收服务端发送过来的消息。

          在客户端收消息时,需要判断服务端连接是否断开,在网上的介绍上,说使用socket.Poll(1, SelectMode.SelectRead)和socket.Available= 0来判断网络是否断开,但在实际上的使用当中,我使用第三方的服务端,使用这种方式,根本不能判断断开,后来我想,能不能开一个SocketCient,来判断服务端口是否正常,相当于telnet命令,在实际使用当中,还没遇到问题:

            /// <summary>
            /// 接收消息
            /// </summary>
            /// <returns></returns>
            public void Receive(object o)
            {
                Socket s = o as Socket;
                bool IsConnected = true;
                while (s.Connected)
                {
                    try
                    {
                        int res = s.Available;
                        if (res > 0)
                        {
                            byte[] xxxx = new byte[res];
                            int nRead = s.Receive(xxxx);
                            byte[] buffer = new byte[nRead];
                            Array.Copy(xxxx, 0, buffer, 0, nRead);
                            if (ReceiveComtemplate != null)
                                ReceiveComtemplate(buffer);
                        }
                        else
                        {
                            try
                            {
                                Socket testSocket =
                                    new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                                testSocket.Connect(s.RemoteEndPoint);
                                if (!testSocket.Connected)
                                {
                                    Stop();
                                    IsConnected = false;
                                    goto EndReceive;
                                }
                                else
                                {
                                    testSocket.Shutdown(SocketShutdown.Both);
                                    testSocket.Close();
                                }
                            }
                            catch (Exception ex)
                            {
                                Stop();
                                IsConnected = false;
                                goto EndReceive;
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        Stop();
                        IsConnected = false;
                        goto EndReceive;
                    }
                    Thread.Sleep(100);
                }
                EndReceive:
                if (!IsConnected)
                {
                    if (HostDisconnectedComtelplate != null)
                        HostDisconnectedComtelplate();
                }
            }

            最后就是一个发送,一个停止,这个部分,基本和msdn上介绍的一样,没有什么特殊的处理:

            /// <summary>
            /// 发送消息
            /// </summary>
            /// <param name="buffer">发送的数据</param>
            public void Send(byte[] buffer)
            {
                try
                {
                    if (tcpClient.Connected)
                    {
                        tcpClient.Send(buffer);
                    }
                }
                catch { }
            }
            /// <summary>
            /// 停止
            /// </summary>
            public void Stop()
            {
                try
                {
                    //tcpClient.Client.Shutdown(SocketShutdown.Both);
                    //tcpClient.Close();
                    tcpClient.Shutdown(SocketShutdown.Both);
                    tcpClient.Close();
                }
                catch (Exception ex)
                { }
            }

            到这里基本上已经完成,完整代码如下,如果有不同看法或有更好的意见,欢迎在线留言:

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

    namespace System.Net.Securate.TCP
    {
        public sealed class TCPClient
        {
            /// <summary>
            /// 收到消息事件
            /// </summary>
            public ReceiveBuffer ReceiveComtemplate;
            /// <summary>
            /// 主机断开连接事件
            /// </summary>
            public HostDisconnectionEvent HostDisconnectedComtelplate;
            private string _Address;
            /// <summary>
            /// 获取或设置连接地址
            /// </summary>
            public string Address
            {
                get { return _Address; }
                set { _Address = value; }
            }
            private int _Port;
            /// <summary>
            /// 获取或设置端口号
            /// </summary>
            public int Port
            {
                get { return _Port; }
                set { _Port = value; }
            }
            private Socket tcpClient;
            /// <summary>
            /// 获取连接状态
            /// </summary>
            public bool IsConnected
            {
                get {
                    if (tcpClient == null)
                        return false;
                    return tcpClient.Connected;
                }
            }
            /// <summary>
            /// 打开连接
            /// </summary>
            /// <returns></returns>
            public bool Start()
            {
                return Start(_Address, _Port);
            }
            /// <summary>
            /// 打开连接
            /// </summary>
            /// <param name="ip">连接地址</param>
            /// <param name="port">连接端口号</param>
            /// <returns></returns>
            public bool Start(string ip, int port)
            {
                try
                {
                    _Address = ip;
                    _Port = port;
                    tcpClient = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                    IPAddress ipaddress = IPAddress.Parse(_Address);
                    tcpClient.Connect(ipaddress, port);
                    if (tcpClient.Connected)
                    {
                        AsyncReceivedClient rc = new AsyncReceivedClient(Receive);
                        rc.BeginInvoke(tcpClient, null, null);
                    }
                    return tcpClient.Connected;
                }
                catch (Exception ex)
                {
                    return false;
                }
            }
            /// <summary>
            /// 接收消息
            /// </summary>
            /// <returns></returns>
            public void Receive(object o)
            {
                Socket s = o as Socket;
                bool IsConnected = true;
                while (s.Connected)
                {
                    try
                    {
                        int res = s.Available;
                        if (res > 0)
                        {
                            byte[] xxxx = new byte[res];
                            int nRead = s.Receive(xxxx);
                            byte[] buffer = new byte[nRead];
                            Array.Copy(xxxx, 0, buffer, 0, nRead);
                            if (ReceiveComtemplate != null)
                                ReceiveComtemplate(buffer);
                        }
                        else
                        {
                            try
                            {
                                Socket testSocket =
                                    new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                                testSocket.Connect(s.RemoteEndPoint);
                                if (!testSocket.Connected)
                                {
                                    Stop();
                                    IsConnected = false;
                                    goto EndReceive;
                                }
                                else
                                {
                                    testSocket.Shutdown(SocketShutdown.Both);
                                    testSocket.Close();
                                }
                            }
                            catch (Exception ex)
                            {
                                Stop();
                                IsConnected = false;
                                goto EndReceive;
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        Stop();
                        IsConnected = false;
                        goto EndReceive;
                    }
                    Thread.Sleep(100);
                }
                EndReceive:
                if (!IsConnected)
                {
                    if (HostDisconnectedComtelplate != null)
                        HostDisconnectedComtelplate();
                }
            }
            /// <summary>
            /// 发送消息
            /// </summary>
            /// <param name="buffer">发送的数据</param>
            public void Send(byte[] buffer)
            {
                try
                {
                    if (tcpClient.Connected)
                    {
                        tcpClient.Send(buffer);
                    }
                }
                catch { }
            }
            /// <summary>
            /// 停止
            /// </summary>
            public void Stop()
            {
                try
                {
                    //tcpClient.Client.Shutdown(SocketShutdown.Both);
                    //tcpClient.Close();
                    tcpClient.Shutdown(SocketShutdown.Both);
                    tcpClient.Close();
                }
                catch (Exception ex)
                { }
            }
        }
    }
     

    展开全文
  • 当服务端接收到客户端的访问请求时,会建立一个Socket来代表该客户端,通过该Socket进行输入输出操作。 客户端与服务端建立连接后,也会有一个Socket,用于输入输出操作。 3. 代码示例 首先建立一个服务端,在10000...
  • C++ Socket客户端和服务器通信

    万次阅读 热门讨论 2017-05-05 10:33:03
    关于Socket通信主要采用了C++编程,实现多线程通信,多个客户端同时和服务器通信,并支持服务器以广播的形式向所有客户端发送消息,该历程未加界面。具体的细节和源码见下分析 2 执行流程 服务器端 运行程序后...
  • C# 开发的 Socket 通信程序 能够开启一个服务器端和多个客户端 客户端选择要通信的其他客户端进行交流
  • 通过服务器,客户端之间可以互相通信,既可以群发,也可单独发送
  • php简单socket服务器客户端代码实例

    千次阅读 2017-05-11 10:19:11
    这篇文章主要介绍了php简单socket服务器客户端代码实例,本文给出了两个版本的服务器端口,对代码的问题和改进做了说明,并给出了使用这个socket服务器的客户端代码,需要的朋友可以参考下 本篇文章分享一个简单的...
  • socket bind在客户端和服务器端使用的区别_cuishumao的专栏-CSDN博客 socket 客户端也可以使用 bind_BlackNight168的博客-CSDN博客 客户端Client bind (1)bind端口 由进程选择一个端口去连服务器,(如果默认...
  • socket客户端通讯

    2020-07-02 17:27:07
    一个服务端,4个客户端 1、服务端接收道客户端1发来消息 2、服务端将消息转发给客户端2、3、4 3、客户端2、3、4回复服务端消息 ...注:最好服务端可以通过IP区分客户端1、2、3、4分别是那个IP。
  • netty之Socket客户端连接

    千次阅读 2018-01-13 16:18:05
    netty 聊天客户端 import io .netty .bootstrap .Bootstrap ; import io .netty .channel .Channel ; import io .netty .channel .EventLoopGroup ; import io .netty .channel .nio .NioEventLoopGroup ; ...
  • Socket简介及客户端服务器连接实例

    万次阅读 2016-12-08 19:27:30
    Socket简介及客户端服务器连接实例
  • socket C# 服务器和客户端 图形界面
  • 本期带给大家分享的是基于SuperSocket的项目实战,阿笨在实际工作中遇到的真实业务场景,请跟随阿笨的视角去如何实现打通B/S与C/S网络通讯,如果您对本期的《基于开源SuperSocket实现客户端和服务端通信项目实战》...
  • 大致了解了如何socket通信是如何操作的,并且初步实现了客户端和服务端的通信。也仅仅是是接受和返回简单的字符串。部分代码如下 public void run(){ try{ serverSocket=new ServerSocket(SERVER_PORT_ONE)...
  • socket通信中;服务端瞬间write了3次;客户端只read了1次;如何在客户端区分这三个数据;已经接受的数据如何区分
  • socket bind listen accept 服务器端需要知道端口号,自己的ip(IP也可以不用,可以使用 INADDR_ANY,即绑定本机的任意IP)。 使用INADDR_ANY的好处是,当更改了服务器装置的IP地址时,服务器程序不用再更改IP了...
  • Socket聊天程序(一个服务端,多个客户端

    千次下载 热门讨论 2011-07-26 17:47:35
    Socket聊天程序(一个服务端,多个客户端) 可通过设置IP地址,进行局域网聊天,互联网聊天。。详细配置可以看下我blog的文章。 blog中搜索:Socket聊天程序
  • 网络编程,简单的理解,就是通讯,这里说服务器和客户端的通讯。服务器一直监听着,看是不是有客户来访问。 服务器:相当于一个家,或者一个定点买东西的地方,肯定是需要地址的,不然别人找不到地方对吧。 JAVA ...
  • Java的Socket类(客户端和服务端都可以使用)提供了前4个操作的方法。后面3个操作仅服务器需要,即等待客户端的连接,这些操作由ServerSocket类实现。Socket的基本方法基本构造函数Socket构造函数
  • 主要介绍了Java编程Socket实现多个客户端连接同一个服务端代码,具有一定参考价值,需要的朋友可以了解下。
  • 对于Socket编程,网上资料、博文一抓一大把,不过大多数都是简单讲解单客户端和服务端通信的实例,这里主要给大家展现一下在.net平台上用窗体程序实现的过程,不过比较有特点的是会告诉大家如何实现不同客户端之间的...
  • 1.服务端welcoming socket :开始监听端口(负责监听客户端连接信息) 。 2.客户端client socket :连接服务端指定端口(负责接收和发送服务端消息) 。 3.服务端welcoming socket :监听到客户端连接,创建connection...
  • 一般是用来判断对方(设备,进程或其它网元)是否正常动行,一般采用定时发送简单的通讯包,如果在指定时间段内未收到对方响应,则判断对方...基本原因是服务器端不能有效的判断客户端是否在线也就是说,服务器无法区
  • 对于Socket编程,网上资料、博文一抓一大把,不过大多数都是简单讲解单客户端和服务端通信的实例,这里主要给大家展现一下在.net平台上用窗体程序实现的过程,不过比较有特点的是会告诉大家如何实现不同客户端之间的...
  • 基于UDP的Socket多个客户端之间的简单通信 本案例包括一个UDPServer.java服务器端类,两个客户端UDPClient.java、UDPClient2.java类,两个线程类,分别为UDPServerRunnable.java和UDPClientThread 下面直接贴代码 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 48,537
精华内容 19,414
关键字:

如何区分socket客户端