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地址一致,设 ...
随机推荐
- 快速上手Linux核心命令（五）：文本处理三剑客
@ 目录 前言 正则表达式 第一剑客 grep 第二剑客 sed 第三 剑客 awk 小结 剑仙镇楼~ O(∩_∩)O 前言 上一篇中已经预告,我们这篇主要说Linux文本处理三剑客.他们分别是gre ...
- 「学习笔记」2-SAT问题
SAT 是适定性 (Satisfiability) 问题的简称.一般形式为 k - 适定性问题,简称 k-SAT.而当 \(k>2\) 时该问题为 NP 完全的.所以我们只研究 \(k=2\) ...
- 数据剖析更灵活、更快捷，火山引擎 DataLeap 动态探查全面升级
更多技术交流.求职机会,欢迎关注字节跳动数据平台微信公众号,回复[1]进入官方交流群 近期,火山引擎 DataLeap 上线"动态探查"能力,为用户提供全局数据视角.完善的抽样策略 ...
- 2022-09-01：字符串的 波动 定义为子字符串中出现次数 最多 的字符次数与出现次数 最少 的字符次数之差。 给你一个字符串 s ，它只包含小写英文字母。请你返回 s 里所有 子字符串的 最大波
2022-09-01:字符串的 波动 定义为子字符串中出现次数 最多 的字符次数与出现次数 最少 的字符次数之差. 给你一个字符串 s ,它只包含小写英文字母.请你返回 s 里所有 子字符串的 最大波 ...
- 2021-03-24：给定一个整数组成的无序数组arr，值可能正、可能负、可能0。给定一个整数值K，找到arr的所有子数组里，哪个子数组的累加和等于K，并且是长度最大的。返回其长度。
2021-03-24:给定一个整数组成的无序数组arr,值可能正.可能负.可能0.给定一个整数值K,找到arr的所有子数组里,哪个子数组的累加和等于K,并且是长度最大的.返回其长度. 福大大 答案20 ...
- promise及异步编程async await
前置说明 ECMAScript 6 新增了正式的 Promise(期约)引用类型,支持优雅地定义和组织异步逻辑.接下来几个版本增加了使用 async 和 await 关键字定义异步函数的机制 Java ...
- Jenkins - 构建时运行Selenium打不开浏览器解决方法
Jenkins-构建时运行Selenium打不开浏览器解决方法 前言 为了让Jenkins执行的Web自动化测试任务,能顺利调出浏览器页面,我们需要以命令行的方式启动Jenkins并执行脚本. 注:通 ...
- MyBatis 在大数据量下使用流式查询进行数据同步
通常的数据同步中,如果数据量比较少的话可以直接全量同步,默认情况下,完整的检索结果集会将其存储在内存中.在大多数情况下,这是最有效的操作方式,并且由于 MySQL 网络协议的设计,因此更易于实现.但是 ...
- django 如何提升性能（高并发）
django 如何提升性能(高并发) 对一个后端开发程序员来说,提升性能指标主要有两个一个是并发数,另一个是响应时间网站性能的优化一般包括 web 前端性能优化,应用服务器性能优化,存储服务器优化. ...
- 【一步步开发AI运动小程序】十、姿态动作相似度比较
随着人工智能技术的不断发展,阿里体育等IT大厂,推出的"乐动力"."天天跳绳"AI运动APP,让云上运动会.线上运动会.健身打卡.AI体育指导等概念空前火热.那 ...