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地址一致,设 ...
随机推荐
- class(类)和构造函数(原型对象)
构造函数和class的关系,还有面向对象和原型对象,其实很多人都会很困惑这些概念,这是第二次总结这些概念了,之前一次,没有class类,其实了解了构造函数,class也就很容易理解了 一. 构造函数和 ...
- [人脸活体检测] 论文：Searching Central Difference Convolutional Networks for Face Anti-Spoofing
文章目录 Searching Central Difference Convolutional Networks for Face Anti-Spoofing 1 导读 2 简介 3 方法 中心差分卷 ...
- 从源码深入理解读写锁(golang-RWMutex)
环境:go 1.19.8 在读多写少的情况下,即使一段时间内没有写操作,大量并发的读访问也不得不在Mutex的保护下变成串行访问,这种情况下,使用Mutex,对性能影响比较大. 所以就要区分读写操作. ...
- 聊一聊redis十种数据类型及底层原理
概述 Redis 是一个开源的高性能键值数据库,它支持多种数据类型,可以满足不同的业务需求.本文将介绍 Redis 的10种数据类型,分别是 string(字符串) hash(哈希) list(列表) ...
- Yolov5 根据自己的需要更改 预测框box和蒙版mask的颜色
1.首先找到项目中 utils/plots.py 文件,打开该代码 将原来的 Colors类注释掉(或删掉),改成如下Colors类 class Colors: def __init__(self): ...
- 2022-07-20：以下go语言代码是关于json 和 context的，输出什么？A：{}；B：{“a“:“b“}；C：{“Context“:0}；D：不确定。 package main imp
2022-07-20:以下go语言代码是关于json 和 context的,输出什么?A:{}:B:{"a":"b"}:C:{"Context&quo ...
- 2021-02-13：字符串str最少添加多少个字符变成回文串？
福哥答案2020-02-13: 假设字符串str是"abcde12344321",在str后添加"edcba"即可变成回文串.需要添加5个字符. 解法:包含最后 ...
- 2021-04-03：给定两个字符串str1和str2，想把str2整体插入到str1中的某个位置，形成最大的字典序，返回字典序最大的结果。
2021-04-03:给定两个字符串str1和str2,想把str2整体插入到str1中的某个位置,形成最大的字典序,返回字典序最大的结果. 福大大 答案2021-04-03: 1.暴力法. 2.DC ...
- 防抖节流utils
/** * 防抖原理:一定时间内,只有最后一次操作,再过wait毫秒后才执行函数 * * @param {Function} func 要执行的回调函数 * @param {Number} wait ...
- ent M2M模型在pxc集群中的一个大坑
ent M2M模型在pxc集群中的一个大坑 事故简要分析 PXC集群3个节点,在插入数据时,如果使用数据库自己生成的主键,一般顺序为1,4,7,10- 这里就是坑的源头,在ent底层代码中,在做M2M ...