2021-6-16 TcpIp

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Net.Sockets;

using System.Net;

using System.Threading;

namespace BatteryDetectWorkA

{

    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

                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(socket);

            }

            catch (Exception ex)

            {

                //SetMessage("连接服务器异常:" + ex.Message);

                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 ex)

                {

                    //SetMessage("服务器异常:" + ex.Message);

                }

            }

        }

        /// <summary>

        /// 关闭连接

        /// </summary>

        /// <param name="sender"></param>

        /// <param name="e"></param>

        public bool close()

        {

            bool result = true;

            try

            {

                socket.Shutdown(SocketShutdown.Both);

                socket.Close();

                socket.Dispose();

                thread.Abort();

                socket = null;

                thread = null;

                GC.Collect();

            }

            catch (Exception ex)

            {

                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 ex)

                    {

                        return false;

                    }

                }

                byte[] tmp = new byte[1];

                socket.Blocking = false;

                socket.Send(tmp, 0, 0);

                socket.Blocking = blockingState;    // 恢复状态

                return true;

            }

            catch (SocketException e)

            {

                //try

                //{

                //   // socket.Close();

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

                //}

                //catch(Exception ex) { }

                // 产生 10035 == WSAEWOULDBLOCK 错误，说明被阻止了，但是还是连接的

                //if (e.NativeErrorCode.Equals(10035))

                return false;

                //else

                //    return true;

            }

            //finally

            //{

            //    socket.Blocking = blockingState;    // 恢复状态

            //}

        }

    }

    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));

                //绑定ip和端口

                socket.Bind(IEP);

                //开启监听

                socket.Listen(20);

                //Logger.WriteLog(ip + ':' + port + "开始监听");

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

                thread.IsBackground = true;

                thread.Start(socket);

            }

            catch (Exception ex)

            {

                // Logger.WriteLog(ex.Message.ToString(), ex);

            }

        }

        public void StartServer(object obj)

        {

            string str;

            while (true)

            {

                //等待接收客户端连接 Accept方法返回一个用于和该客户端通信的Socket

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

                //获取客户端ip和端口号

                str = recviceSocket.RemoteEndPoint.ToString();

                socketList.Add(str, recviceSocket);

                //Logger.LogOperate.Info(str + "已连接");

                //Accept()执行过后 当前线程会阻塞 只有在有客户端连接时才会继续执行

                //创建新线程,监控接收新客户端的请求数据

                Thread thread = new Thread(startRecive);

                thread.IsBackground = true;

                thread.Start(recviceSocket);

            }

        }

        public void startRecive(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 ex)

                {

                    // Logger.WriteLog(ex.Message.ToString(), ex);

                }

            }

        }

        private void send2Client(string ip, string str)

        {

            byte[] bytes = new byte[2048];

            bytes = Encoding.Default.GetBytes(str);

            if (socketList.ContainsKey(ip))

            {

                Logger.QuiesceThread(new Action(() => {

                    try

                    {

                        socketList[ip].Send(bytes);

                    }

                    catch (Exception ex)

                    { }

                }));

            }

        }

    }

    public 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

            {

                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;

                    Logger.LogApp.Info("监听到Socket断线");

                }

                if (isOpen)

                    Open();

            }

            catch

            {

            }

        }

        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 ex) { }

        }

        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));

                Logger.LogApp.Info("A工位通过Socket发送" + str.ToString());

            }

            else

            {

                Logger.LogApp.Info("Socket断线，数据未发送，数据为" + str.ToString());

            }

        }

    }

    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

            {

                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 { }

        }

        void ReceiveCallBack(IAsyncResult ar)

        {

            try

            {

                var client = ar.AsyncState as Socket;

                int length = client.EndReceive(ar);

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

                //接收一下个信息

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

            }

            catch { }

        }

        public event Action<byte[]> OnDataRecive;

        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.Text;using System.Threading.Tasks;using System.Net.Sockets;using System.Net;using System.Threading;
namespace BatteryDetectWorkA{ 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 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(socket); } catch (Exception ex) { //SetMessage("连接服务器异常:" + ex.Message); 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 ex) { //SetMessage("服务器异常:" + ex.Message);
} }
}
/// <summary> /// 关闭连接 /// </summary> /// <param name="sender"></param> /// <param name="e"></param> public bool close() { bool result = true; try { socket.Shutdown(SocketShutdown.Both); socket.Close(); socket.Dispose(); thread.Abort(); socket = null; thread = null; GC.Collect(); } catch (Exception ex) { 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 ex) { return false; } } byte[] tmp = new byte[1]; socket.Blocking = false; socket.Send(tmp, 0, 0); socket.Blocking = blockingState; // 恢复状态 return true; } catch (SocketException e) { //try //{ // // socket.Close(); // socket.Connect(new IPEndPoint(IPAddress.Parse(this.ip), int.Parse(this.port))); //} //catch(Exception ex) { } // 产生 10035 == WSAEWOULDBLOCK 错误，说明被阻止了，但是还是连接的 //if (e.NativeErrorCode.Equals(10035)) return false; //else // return true; } //finally //{ // socket.Blocking = blockingState; // 恢复状态 //}
}
}
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)); //绑定ip和端口 socket.Bind(IEP); //开启监听 socket.Listen(20); //Logger.WriteLog(ip + ':' + port + "开始监听");
Thread thread = new Thread(new ParameterizedThreadStart(StartServer)); thread.IsBackground = true; thread.Start(socket);
} catch (Exception ex) { // Logger.WriteLog(ex.Message.ToString(), ex);
} }
public void StartServer(object obj) { string str; while (true) { //等待接收客户端连接 Accept方法返回一个用于和该客户端通信的Socket Socket recviceSocket = ((Socket)obj).Accept(); //获取客户端ip和端口号 str = recviceSocket.RemoteEndPoint.ToString(); socketList.Add(str, recviceSocket); //Logger.LogOperate.Info(str + "已连接");
//Accept()执行过后当前线程会阻塞只有在有客户端连接时才会继续执行 //创建新线程,监控接收新客户端的请求数据 Thread thread = new Thread(startRecive); thread.IsBackground = true; thread.Start(recviceSocket); } }

public void startRecive(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 ex) { // Logger.WriteLog(ex.Message.ToString(), ex);
} } } private void send2Client(string ip, string str) { byte[] bytes = new byte[2048]; bytes = Encoding.Default.GetBytes(str); if (socketList.ContainsKey(ip)) { Logger.QuiesceThread(new Action(() => { try { socketList[ip].Send(bytes); } catch (Exception ex) { } })); }
}

}
public 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 { 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; Logger.LogApp.Info("监听到Socket断线"); } if (isOpen) Open(); } catch { } } 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 ex) { } }
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)); Logger.LogApp.Info("A工位通过Socket发送" + str.ToString()); } else { Logger.LogApp.Info("Socket断线，数据未发送，数据为" + str.ToString()); } }
}

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 { 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 { } } void ReceiveCallBack(IAsyncResult ar) { try { var client = ar.AsyncState as Socket; int length = client.EndReceive(ar); OnDataRecive?.Invoke(buffer.Take(length).ToArray());
//接收一下个信息 client.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallBack), client); } catch { } }
public event Action<byte[]> OnDataRecive;
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-6-16 TcpIp的更多相关文章

2021.12.16 eleveni的刷题记录
2021.12.16 eleveni的刷题记录 1. 数论 https://www.luogu.com.cn/problem/P2532 1.1卡特兰数 https://www.luogu.com.c ...
2021.11.16 P2375 [NOI2014] 动物园（EXKMP+差分）
2021.11.16 P2375 [NOI2014] 动物园(EXKMP+差分) https://www.luogu.com.cn/problem/P2375 题意: PS:这道神题的背景让人疑惑,重 ...
2021.08.16 P1260 工程规划（差分约束）
2021.08.16 P1260 工程规划(差分约束) 重点: 1.跑最短路是为了满足更多约束条件. P1260 工程规划 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn) 题意: 造 ...
2021.08.16 P1078 文化之旅（最短路）
2021.08.16 P1078 文化之旅(最短路) 题意: n个地,k个信仰,每个地都有自己的信仰,信仰之间会相互排斥,同信仰之间也会相互排斥,有m条路,问从s到t的最短距离是多少? 有一位使者要游 ...
2021.08.16 P1300 城市街道交通费系统（dfs）
2021.08.16 P1300 城市街道交通费系统(dfs) P1300 城市街道交通费系统 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn) 题意: 城市街道交费系统最近创立了.一 ...
2021.08.16 P1363 幻象迷宫（dfs，我感受到了出题人浓浓的恶意）
2021.08.16 P1363 幻象迷宫(dfs,我感受到了出题人浓浓的恶意) P1363 幻象迷宫 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn) 题意: 幻象迷宫可以认为是无限 ...
Noip模拟78 2021.10.16
这次时间分配还是非常合理的,但可惜的是$T4$没开$\textit{long long}$挂了$20$ 但是$Arbiter$上赏了蒟蒻$20$分,就非常不错~~~ T1 F 直接拿暴力水就可以过,数 ...
Noip模拟54 2021.9.16
T1 选择现在发现好多题目都是隐含的状压,不明面给到数据范围里,之凭借一句话比如这道题就是按照题目里边给的儿子数量不超过$10$做状压,非常邪门由于数据范围比较小,怎么暴力就怎么来从叶子节点向 ...
Noip模拟41 2021.8.16
T1 你相信引力吗对于区间的大小关系问题,往往使用单调栈来解决这道题的优弧和劣弧很烦,考虑将其等价的转化由于所有的合法情况绕过的弧都不会经过最高的冰锥, 又因为环可以任意亲定起点,这样可以直接把 ...
Noip模拟17 2021.7.16
我愿称这场考试为STL专练 T1 世界线巧妙使用$bitset$当作vis数组使用,内存不会炸,操作还方便,的确是极好的. 但是这个题如果不开一半的$bitset$是会炸内存的,因为他能开得很大,但 ...

随机推荐

聊一聊redis十种数据类型及底层原理
概述 Redis 是一个开源的高性能键值数据库,它支持多种数据类型,可以满足不同的业务需求.本文将介绍 Redis 的10种数据类型,分别是 string(字符串) hash(哈希) list(列表) ...
#Powerquery 数据结构基础一维数据与二维数据
本文参考了采悟老师的文章,推荐大家看原文,本文为笔记随笔 https://mp.weixin.qq.com/s?__biz=MzA4MzQwMjY4MA==&mid=2484068871&am ...
Finalshell
使用VMware可以得到Linux虚拟机,但是在VMware中操作Linux的命令行页面不太方便 1.内容的复制.粘贴跨越VMware不方便 2.文件的上传.下载跨越VMware不方便 3.也就是和L ...
mysql 结合python一些日常写法
python sql语句in写法 sql = "SELECT * FROM user WHERE name in ({})".format(','.join(["'%s' ...
2021-05-28：跳跃游戏 II。给定一个非负整数数组，你最初位于数组的第一个位置。数组中的每个元素代表你在该位置可
2021-05-28:跳跃游戏 II.给定一个非负整数数组,你最初位于数组的第一个位置.数组中的每个元素代表你在该位置可以跳跃的最大长度.你的目标是使用最少的跳跃次数到达数组的最后一个位置.假设你总是 ...
Django4全栈进阶之路14 项目实战（用户管理）：base.html基础模板设计
在 Django 中,我们可以使用模板继承来避免代码的重复.模板继承是指我们可以在一个模板中定义一些公共的 HTML 代码,然后在其他模板中继承这个基础模板,并根据需要添加或覆盖一些内容. 通常情况下 ...
django时区问题的解决
django时区问题的解决更新时间:2021年05月18日 09:37:58 作者:Silent丿丶黑羽我们都知道时区,标准时区是UTC时区,django默认使用的就是UTC时区,我 ...
Python对两个Excel操作
简介现在有个需求,我们根据需要 data.xlsx 中某些单元格的内容来查找 find.xlsx 中的某些內容. 数据内容(为了数据安全,所有数据均已模糊处理) data.xlsx内容: find. ...
20个Golang片段让我不再健忘
前言本文使用代码片段的形式来解释在 go 语言开发中经常遇到的小功能点,由于本人主要使用 java 开发,因此会与其作比较,希望对大家有所帮助. 1. hello world 新手村的第一课,毋庸置 ...
cmd+ssh配置远程服务器Anaconda3_2023+pytorch
一.上传Anaconda3到远程服务器注意:如果要将这个东西安装在anaconda3文件夹里的话,当前这个目录里不能有这个文件夹.(安的时候会自动创建) 二.安装Anaconda3 1. win+r ...

2021-6-16 TcpIp

2021-6-16 TcpIp的更多相关文章

随机推荐

热门专题