2021-7-6 new tcpip

using System;

using System.Collections.Generic;

using System.Linq;

using System.Net;

using System.Net.Sockets;

using System.Text;

using System.Threading;

using System.Threading.Tasks;

namespace TcpIp

{

    public class SocketClient

    {

        byte[] buffer = new byte[2048];

        Socket socket;

        Thread thread;

        string ip, port;

        public bool connect(string ip, string port) {

            bool result = true;

            try {

                socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

                this.ip = ip;

                this.port = port;

                socket.Connect(new IPEndPoint(IPAddress.Parse(this.ip), int.Parse(this.port)));

                thread = new Thread(StartReceive);

                thread.IsBackground = true;

                thread.Start();

            }

            catch (Exception) {

                result = false;

            }

            return result;

        }

        private void StartReceive(object obj) {

            string str;

            while (true) {

                Socket receiveSocket = obj as Socket;

                try {

                    int result = receiveSocket.Receive(buffer);

                    if (result == 0) {

                        break;

                    }

                    else {

                        str = Encoding.Default.GetString(buffer);

                    }

                }

                catch (Exception) {

                    throw;

                }

            }

        }

        public bool close() {

            bool result = true;

            try {

                socket.Shutdown(SocketShutdown.Both);

                socket.Close();

                thread.Abort();

                socket = null;

                thread = null;

                GC.Collect();

            }

            catch (Exception) {

                result = false;

            }

            return result;

        }

        public void send(string str) {

            socket.Send(Encoding.Default.GetBytes(str));

        }

        public void sendbytes(byte[] buffer) {

            socket.Send(buffer);

        }

        public bool isConnection() {

            bool blockingState = socket.Blocking;

            try {

                if (!socket.Connected) {

                    try {

                        close();

                        connect(this.ip, this.port);

                    }

                    catch (Exception) {

                        return false;

                    }

                }

                byte[] tmp = new byte[1];

                socket.Blocking = false;

                socket.Send(tmp, 0, 0);

                socket.Blocking = blockingState;

                return true;

            }

            catch (Exception) {

                return false;

            }

        }

    }

    class SocketServer

    {

        private static Dictionary<string, Socket> socketList = new Dictionary<string, Socket>();

        public SocketServer(string ip, string port) {

            try {

                Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

                IPEndPoint IEP = new IPEndPoint(IPAddress.Parse(ip), int.Parse(port));

                socket.Bind(IEP);

                socket.Listen(20);

                Thread thread = new Thread(new ParameterizedThreadStart(StartServer));

                thread.IsBackground = true;

                thread.Start(socket);

            }

            catch (Exception) {

                throw;

            }

        }

        public void StartServer(object obj) {

            string str;

            while (true) {

                Socket recevicesSocket = ((Socket)obj).Accept();

                str = recevicesSocket.RemoteEndPoint.ToString();

                socketList.Add(str, recevicesSocket);

                Thread thread = new Thread(startReceive);

                thread.IsBackground = true;

                thread.Start(recevicesSocket);

            }

        }

        public void startReceive(object obj) {

            while (true) {

                try {

                    byte[] buffer = new byte[2048];

                    int count = ((Socket)obj).Receive(buffer);

                    if (count == 0) break;

                    string str = Encoding.Default.GetString(buffer, 0, count);

                    string ip = ((Socket)obj).RemoteEndPoint.ToString();

                }

                catch (Exception) {

                    throw;

                }

            }

        }

        private void send2Client(string ip, string str) {

            byte[] bytes = new byte[2048];

            bytes = Encoding.Default.GetBytes(str);

            if (socketList.ContainsKey(ip)) {

                try {

                    socketList[ip].Send(bytes);

                }

                catch (Exception) {

                    throw;

                }

            }

        }

    }

    class TcpClient

    {

        Socket m_client;

        byte[] buffer = new byte[3072 * 2048];

        bool isOpen = false;

        bool hasClient = false;

        bool check_client() {

            try {

                if (m_client == null) return false;

                bool isConnect = !(m_client.Poll(1000, SelectMode.SelectRead) && m_client.Available == 0) && m_client.Connected;

                return isConnect;

            }

            catch (Exception) {

                return false;

            }

        }

        void AcceptCallBack(IAsyncResult ar) {

            try {

                if (check_client()) {

                    m_client.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallBack), m_client);

                    hasClient = true;

                    while (hasClient) {

                        Thread.Sleep(500);

                        if (!check_client()) {

                            break;

                        }

                    }

                    hasClient = false;

                }

                if (isOpen) {

                    Open();

                }

            }

            catch (Exception) {

                throw;

            }

        }

        void ReceiveCallBack(IAsyncResult ar) {

            try {

                var client = ar.AsyncState as Socket;

                int length = client.EndReceive(ar);

                if (length>0) {

                    //执行文件传输方法

                    OnDataRecive?.Invoke(buffer.Take(length).ToArray());

                }

                client.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallBack), client);

            }

            catch (Exception) {

                throw;

            }

        }

        public event Action<byte[]> OnDataRecive;

        string m_ip;

        int m_port;

        public void Open(string ip, int port) {

            Close();

            IPEndPoint serverip = new IPEndPoint(IPAddress.Parse(ip), port);

            m_client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            m_client.BeginConnect(serverip, AcceptCallBack, m_client);

            isOpen = true;

            m_ip = ip;

            m_port = port;

        }

        public void Open() {

            Open(m_ip, m_port);

        }

        public void Close() {

            if (m_client != null) {

                if (m_client.Connected)

                    m_client.Shutdown(SocketShutdown.Both);

                m_client.Close();

                m_client = null;

            }

            hasClient = false;

            isOpen = false;

        }

        public bool IsOpen() {

            return isOpen;

        }

        public bool IsConnected(){

            return hasClient;

        }

        public void Send(byte[] data) {

            if (hasClient) {

                m_client.Send(data);

            }

        }

        public void Send(string str) {

            if (hasClient) {

                m_client.Send(Encoding.Default.GetBytes(str));

            }

        }

    }

    class TcpServer

    {

        Socket m_server;

        Socket m_client;

        byte[] buffer = new byte[1024];

        bool isOpen = false;

        bool hasClient = false;

        bool check_client() {

            try {

                if (m_client == null)

                    return false;

                bool isConnect = !(m_client.Poll(1000, SelectMode.SelectRead) && m_client.Available == 0) && m_client.Connected;

                return isConnect;

            }

            catch (Exception) {

                return false;

            }

        }

        void AcceptCallBack(IAsyncResult ar) {

            try {

                var server = ar.AsyncState as Socket;

                var client = server.EndAccept(ar);

                m_client = client;

                m_client.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallBack), m_client);

                hasClient = true;

                while (true) {

                    Thread.Sleep(100);

                    if (!check_client()) {

                        if (m_client.Connected) {

                            m_client.Shutdown(SocketShutdown.Both);

                        }

                        m_client.Close();

                        m_client = null;

                        break;

                    }

                }

                hasClient = false;

                if (m_server!=null) {

                    m_server.BeginAccept(new AsyncCallback(AcceptCallBack), m_server);

                }

            }

            catch (Exception) {

                throw;

            }

        }

        void ReceiveCallBack(IAsyncResult ar) {

            try {

                var client = ar.AsyncState as Socket;

                int length = client.EndReceive(ar);

                OnDataReceive?.Invoke(buffer.Take(length).ToArray());

                client.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new

 AsyncCallback(ReceiveCallBack), client);

            }

            catch (Exception) {

                throw;

            }

        }

        public event Action<byte[]> OnDataReceive;

        public void Open(string ip,int port) {

            Close();

            IPEndPoint serverip = new IPEndPoint(IPAddress.Parse(ip), port);

            m_server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            m_server.Bind(serverip);

            m_server.Listen(0);

            m_server.BeginAccept(new AsyncCallback(AcceptCallBack), m_server);

            isOpen = true;

        }

        public void Close() {

            hasClient = false;

            isOpen = false;

            if (m_server!=null) {

                if (m_server.Connected) {

                    m_server.Shutdown(SocketShutdown.Both);

                }

                m_server.Close();

                m_server = null;

            }

            if (m_client!=null) {

                if (m_client.Connected) {

                    m_client.Shutdown(SocketShutdown.Both);

                }

                m_client.Close();

                m_client = null;

            }

        }

        public bool IsOpen() {

            return isOpen;

        }

        public bool IsConnected() {

            return hasClient;

        }

        public void Send(byte[] data) {

            if (hasClient) {

                m_client.Send(data);

            }

        }

    }

}

using System;using System.Collections.Generic;using System.Linq;using System.Net;using System.Net.Sockets;using System.Text;using System.Threading;using System.Threading.Tasks;
namespace TcpIp{ public class SocketClient { byte[] buffer = new byte[2048]; Socket socket; Thread thread; string ip, port; public bool connect(string ip, string port) { bool result = true; try { socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); this.ip = ip; this.port = port; socket.Connect(new IPEndPoint(IPAddress.Parse(this.ip), int.Parse(this.port))); thread = new Thread(StartReceive); thread.IsBackground = true; thread.Start(); } catch (Exception) { result = false; } return result; } private void StartReceive(object obj) { string str; while (true) { Socket receiveSocket = obj as Socket; try { int result = receiveSocket.Receive(buffer); if (result == 0) { break; } else { str = Encoding.Default.GetString(buffer); } } catch (Exception) {
throw; } } } public bool close() { bool result = true; try { socket.Shutdown(SocketShutdown.Both); socket.Close(); thread.Abort(); socket = null; thread = null; GC.Collect(); } catch (Exception) {
result = false; } return result; } public void send(string str) { socket.Send(Encoding.Default.GetBytes(str)); } public void sendbytes(byte[] buffer) { socket.Send(buffer); } public bool isConnection() { bool blockingState = socket.Blocking; try { if (!socket.Connected) { try { close(); connect(this.ip, this.port); } catch (Exception) {
return false; } } byte[] tmp = new byte[1]; socket.Blocking = false; socket.Send(tmp, 0, 0); socket.Blocking = blockingState; return true; } catch (Exception) {
return false; } } } class SocketServer { private static Dictionary<string, Socket> socketList = new Dictionary<string, Socket>(); public SocketServer(string ip, string port) { try { Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); IPEndPoint IEP = new IPEndPoint(IPAddress.Parse(ip), int.Parse(port)); socket.Bind(IEP); socket.Listen(20); Thread thread = new Thread(new ParameterizedThreadStart(StartServer)); thread.IsBackground = true; thread.Start(socket); } catch (Exception) {
throw; } } public void StartServer(object obj) { string str; while (true) { Socket recevicesSocket = ((Socket)obj).Accept(); str = recevicesSocket.RemoteEndPoint.ToString(); socketList.Add(str, recevicesSocket); Thread thread = new Thread(startReceive); thread.IsBackground = true; thread.Start(recevicesSocket); } } public void startReceive(object obj) { while (true) { try { byte[] buffer = new byte[2048]; int count = ((Socket)obj).Receive(buffer); if (count == 0) break; string str = Encoding.Default.GetString(buffer, 0, count); string ip = ((Socket)obj).RemoteEndPoint.ToString(); } catch (Exception) {
throw; } } } private void send2Client(string ip, string str) { byte[] bytes = new byte[2048]; bytes = Encoding.Default.GetBytes(str); if (socketList.ContainsKey(ip)) { try { socketList[ip].Send(bytes); } catch (Exception) {
throw; } } } } class TcpClient { Socket m_client; byte[] buffer = new byte[3072 * 2048]; bool isOpen = false; bool hasClient = false; bool check_client() { try { if (m_client == null) return false; bool isConnect = !(m_client.Poll(1000, SelectMode.SelectRead) && m_client.Available == 0) && m_client.Connected; return isConnect; } catch (Exception) {
return false; } } void AcceptCallBack(IAsyncResult ar) { try { if (check_client()) { m_client.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallBack), m_client); hasClient = true; while (hasClient) { Thread.Sleep(500); if (!check_client()) { break; }
} hasClient = false; } if (isOpen) { Open(); } } catch (Exception) {
throw; } } void ReceiveCallBack(IAsyncResult ar) { try { var client = ar.AsyncState as Socket; int length = client.EndReceive(ar); if (length>0) { //执行文件传输方法 OnDataRecive?.Invoke(buffer.Take(length).ToArray()); } client.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallBack), client); } catch (Exception) {
throw; } } public event Action<byte[]> OnDataRecive; string m_ip; int m_port; public void Open(string ip, int port) { Close(); IPEndPoint serverip = new IPEndPoint(IPAddress.Parse(ip), port); m_client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); m_client.BeginConnect(serverip, AcceptCallBack, m_client); isOpen = true; m_ip = ip; m_port = port; } public void Open() { Open(m_ip, m_port); } public void Close() { if (m_client != null) { if (m_client.Connected) m_client.Shutdown(SocketShutdown.Both); m_client.Close(); m_client = null; } hasClient = false; isOpen = false; } public bool IsOpen() { return isOpen; } public bool IsConnected(){ return hasClient; } public void Send(byte[] data) { if (hasClient) { m_client.Send(data); } } public void Send(string str) { if (hasClient) { m_client.Send(Encoding.Default.GetBytes(str)); } } } class TcpServer { Socket m_server; Socket m_client; byte[] buffer = new byte[1024]; bool isOpen = false; bool hasClient = false; bool check_client() { try { if (m_client == null) return false; bool isConnect = !(m_client.Poll(1000, SelectMode.SelectRead) && m_client.Available == 0) && m_client.Connected; return isConnect; } catch (Exception) {
return false; } } void AcceptCallBack(IAsyncResult ar) { try { var server = ar.AsyncState as Socket; var client = server.EndAccept(ar); m_client = client; m_client.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallBack), m_client); hasClient = true; while (true) { Thread.Sleep(100); if (!check_client()) { if (m_client.Connected) { m_client.Shutdown(SocketShutdown.Both); } m_client.Close(); m_client = null; break; } } hasClient = false; if (m_server!=null) { m_server.BeginAccept(new AsyncCallback(AcceptCallBack), m_server); } } catch (Exception) {
throw; } } void ReceiveCallBack(IAsyncResult ar) { try { var client = ar.AsyncState as Socket; int length = client.EndReceive(ar); OnDataReceive?.Invoke(buffer.Take(length).ToArray()); client.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallBack), client); } catch (Exception) {
throw; } } public event Action<byte[]> OnDataReceive; public void Open(string ip,int port) { Close(); IPEndPoint serverip = new IPEndPoint(IPAddress.Parse(ip), port); m_server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); m_server.Bind(serverip); m_server.Listen(0); m_server.BeginAccept(new AsyncCallback(AcceptCallBack), m_server); isOpen = true; } public void Close() { hasClient = false; isOpen = false; if (m_server!=null) { if (m_server.Connected) { m_server.Shutdown(SocketShutdown.Both); } m_server.Close(); m_server = null; } if (m_client!=null) { if (m_client.Connected) { m_client.Shutdown(SocketShutdown.Both); } m_client.Close(); m_client = null; } } public bool IsOpen() { return isOpen; } public bool IsConnected() { return hasClient; } public void Send(byte[] data) { if (hasClient) { m_client.Send(data);
} } }}

2021-7-6 new tcpip的更多相关文章

图解TCP-IP协议
本文通过图来梳理TCP-IP协议相关知识.TCP通信过程包括三个步骤:建立TCP连接通道,传输数据,断开TCP连接通道.如图1所示,给出了TCP通信过程的示意图. 图1 TCP 三次握手四次挥手图1 ...
TCPIP、Http、Socket的协议~ 写得挺形象，赞
这篇文章写得挺形象,对TCPIP.HTTP.Socket的作用有一个整体层次的理解. 转载文章内容如下: 网络由下往上分为物理层.数据链路层.网络层.传输层.会话层.表示层和应用层. 通过初步的了 ...
codevs 2021 中庸之道
2021 中庸之道时间限制: 1 s 空间限制: 128000 KB 题目等级 : 钻石 Diamond 题目描述 Description 给定一个长度为N的序列,有Q次询问,每次 ...
[TCPIP] 传输控制协议 Note
TCPIP TCP 传输控制协议 TCP提供一种面向连接的,可靠的字节流服务. 面向连接意味着两个使用TCP的应用在传输数据之前先建立一个TCP连接,这个过程跟打电话相似.在一个TCP连接中仅有两方 ...
[TCPIP] DNS Note
TCPIP DNS 域名系统 DNS 是一个应用于TCP/IP应用程序的分布式数据库,它提供主机名字和IP地址之间的转换及有关电子邮件的选路信息. 对DNS的访问是通过一个地址解析器来完成的,在Un ...
拿搬东西来解释udp tcpip bio nio aio aio异步
[群主]雷欧纳德简单理解 tcpip是有通信确认的面对面通信有打招呼的过程有建立通道的过程有保持通道的确认有具体传输udp是看到对面的人好像在对面等你就往对面扔东西[群主]雷欧 ...
Bzoj 1982: [Spoj 2021]Moving Pebbles 博弈论
1982: [Spoj 2021]Moving Pebbles Time Limit: 10 Sec Memory Limit: 64 MBSubmit: 130 Solved: 88[Submi ...
TCPIP通信
最近在开发TCPIP通信,封装了3个类,望各位大神指点指点. using System; using System.Collections.Generic; using System.Text; us ...
Linux之TCPIP内核参数优化
/proc/sys/net目录所有的TCP/IP参数都位于/proc/sys/net目录下(请注意,对/proc/sys/net目录下内容的修改都是临时的,任何修改在系统重启后都会丢失),例如下面这 ...
配置HP LaserJet M1536dnf MFP打印机通过TCPIP共享多台计算机
HP LaserJet M1536dnf MFP打印机通过TCPIP共享多台计算机配置配置过程:1.确保网线插入到打印机后,点设置按钮,到网络配置中查看IP地址,确保与主机或者路由器的IP地址一致,设 ...

随机推荐

Python tkinter的简单使用，在绘布上播放GIF和图片
Python tkinter的简单使用,在绘布上播放GIF和图片文章目录 Python tkinter的简单使用,在绘布上播放GIF和图片前言一.tkinter 的简单组件以及pack(),gr ...
List 集合手动分页的方法总结
前言在工作中难免会遇到,将组装的集合数据进行分页处理,现在我将自己手动分页的三种方法进行总结,有不对的地方敬请大家批评指正! 一.数据准备 // 当前页 int pageIndex = 1; // ...
音视频八股文（12）-- ffmpeg 音频重采样
1重采样 1.1 什么是重采样所谓的重采样,就是改变⾳频的采样率.sample format.声道数等参数,使之按照我们期望的参数输出. 1.2 为什么要重采样为什么要重采样?当然是原有的⾳频参数 ...
2022-02-04：组合总和 Ⅳ。给你一个由不同整数组成的数组 nums ，和一个目标整数 target 。请你从 nums 中找出并返回总和为 target 的元素组合的个数。题目数据保证
2022-02-04:组合总和 Ⅳ. 给你一个由不同整数组成的数组 nums ,和一个目标整数 target .请你从 nums 中找出并返回总和为 target 的元素组合的个数. 题目数据保证 ...
vue全家桶进阶之路11：计算属性
Vue2 中的计算属性是指在组件中声明的计算属性,它们的值是根据其他数据计算得出的,并且会根据依赖数据的变化而自动更新.计算属性可以在模板中使用,与普通属性一样使用,但是它们具有以下优点: 缓存:计算 ...
2023-05-20：go语言的slice和rust语言的Vec的扩容流程是什么？
2023-05-20:go语言的slice和rust语言的Vec的扩容流程是什么? 答案2023-05-20: go语言的slice扩容流程 go版本是1.20.4. 扩容流程见源码见runtime/ ...
vue项目连接socket.io跨域及400异常处理
最近看人家用socket.io聊天,于是自己也想打个服务试试,不试不知道,一试吓一跳,原来这里吗还有这么多坑,下面就是所遇的坑,记录一哈,但愿可以帮助到遇到同样的坑的小伙伴文章目录一.服务端配置 ...
Golang 协程/线程/进程区别以及 GMP 详解
Golang 协程/线程/进程区别详解转载请注明来源:https://janrs.com/mffp 概念进程每个进程都有自己的独立内存空间,拥有自己独立的地址空间.独立的堆和栈,既不共享堆,亦 ...
WPF中关于转换器
实例:关于播放器按钮状态的改变说明:对Kind(种类)的绑定首先在viewmodel中声明一个属性IsPlay,然后在转换器中实现按钮的状态转换器在解决方案中的项目里新建一个Converters ...
Jenkins部署前后端不分离springboot项目
背景写这篇博客的时候我还是大学生,学校期末课程设计时要求使用Jenkins部署项目,所以使用windows,但是企业中都是使用linux,往往还会搭建一个gitlab.下面我介绍的是在window环 ...

2021-7-6 new tcpip

2021-7-6 new tcpip的更多相关文章

随机推荐

热门专题