流量地球
流量地球

C#异步并发网络编程 ping、追踪路由、tcp等

MainForm.cs

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Diagnostics;

using System.Drawing;

using System.Linq;

using System.Net;

using System.Net.NetworkInformation;

using System.Net.Sockets;

using System.Text;

using System.Text.RegularExpressions;

using System.Threading;

using System.Windows.Forms;

namespace webSniff

{

    public partial class MainForm : Form

    {

        public MainForm()

        {

            InitializeComponent();

            this.Load += MainForm_Load;

        }

        //public Close()

        //{

        //    InitializeComponent();

        //    this.Load += MainForm_Load;

        //}

        private void MainForm_Load(object sender, EventArgs e)

        {

            Console.WriteLine("MainForm_Load");

          // MessageBox.Show("MainForm_Load a");

        }

        //private new void FormClosing(object sender, EventArgs e)

        //{

        //    Console.WriteLine("FormClosing");

        //    MessageBox.Show("FormClosing a");

        //}

        private void MainForm_FormClosed(object sender, FormClosedEventArgs e)

        {

            Console.WriteLine("MainForm_FormClosed");

          // MessageBox.Show("MainForm_FormClosed a");

        }

        private void tryIP_Click(object sender, EventArgs e)

        {

          // Console.WriteLine("tryIP_Click");

            if (pingIP(textBox4IP.Text))

            {

                richTextBox4return.Text += "\n" + textBox4IP.Text + "网络可达";

            }

            else {

                richTextBox4return.Text += "\n" + textBox4IP.Text + "网络不可达";

            }

        }

        List pingContIPList = new List();

        //DateTime sniffIP_Click_Time_B4 = DateTime.Now.AddSeconds(-60);

        //DateTime Async_SniffIP_Time = DateTime.Now;

        int sniffIP_Click_times = 0;

        Thread asynPingJobTh = null;

        private void sniffIP_Click(object sender, EventArgs e)

        {

            try

            {

                DateTime sniffIP_Click_Time = DateTime.Now;

                //if(sniffIP_Click_Time_B4.AddSeconds(5)>sniffIP_Click_Time){

                //    richTextBox4return.Text += "\n" +"检测同网段IP时间间隔不得小于5秒钟！！！";

                //    return;

                //}else

                //{

                //    sniffIP_Click_Time_B4 = sniffIP_Click_Time;

                //}

                if (connectIPMap.Count == 0)

                {

                    richTextBox4return.Text += "\n" + "已经预热完毕，请再次点击！多次点击更加精确！但点击不要过于频繁！";

                }

                else

                {

                    richTextBox4return.Text = "第" + sniffIP_Click_times + "次搜索";

                    richTextBox4return.Text += "\n" + "共有" + connectIPMap.Count + "个可达的IP";

                }

                int k = 0;

                foreach (var item in connectIPMap.ToList())

                {

                    richTextBox4return.Text += "\n" + ++k + "：" + item.Key + "  平均耗时：" + connectIPMap[item.Key][1] / connectIPMap[item.Key][0] + " ms" + " 连接次数：" + connectIPMap[item.Key][0];

                    //Debug.Log(item.Key + "," + item.Value);

                    //pings[item.Key].SendAsyncCancel();

                    //pings[item.Key].Dispose();

                    //pings.Remove(item.Key);

                }

                //if (sniffIP_Click_Time_B4.AddSeconds(3) > sniffIP_Click_Time)

                //{

                //    richTextBox4return.Text = "检测同网段IP时间间隔不得小于3秒钟！！！" + "\n" + richTextBox4return.Text;

                //    return;

                //}

                //else

                //{

                //}

                if (asynPingJobTh != null)

                {

                    if (!asynPingJobTh.IsAlive)

                    {

                        Thread.Sleep(200);

                        foreach (var item in asynPings.ToList())

                        {

                            //Debug.Log(item.Key + "," + item.Value);

                            asynPings[item.Key].SendAsyncCancel();

                            asynPings[item.Key].Dispose();

                            asynPings.Remove(item.Key);

                        }

                        asynPingJobTh = null;

                    }

                    else if (asynPingJobTh == null) { }

                    else { return; }

                }

                //foreach (KeyValuePair> kvp in connectIPMap)

                //{

                //    richTextBox4return.Text += "\n" + ++k +"：" + kvp.Key + "  平均耗时：" + kvp.Value[1] / kvp.Value[0]+" ms" + " 连接次数：" + kvp.Value[0];

                //}

                // richTextBox4return.Text += "\n" + enableIPList[0].Substring(0,enableIPList[0].LastIndexOf(".")+1);

                //异步

                string func = "异步";

                if (func == "异步")

                {

                    //richTextBox4return.Text += "\n" + "8秒内给出结果，请稍等待";

                    if (asynPings.Count == 0)

                    {

                        //sniffIP_Click_Time_B4 = sniffIP_Click_Time;

                        //if (asynPingJobTh != null && asynPingJobTh.IsAlive) return;

                        sniffIP_Click_times++;

                        asynPingJobTh = new Thread(asynPingJob);

                        asynPingJobTh.IsBackground = true;

                        asynPingJobTh.Start(getAllEnableIP());

                        //asynPingAllJob(getAllEnableIP());

                    }

                    // asynPingJob(getAllEnableIP());

                    //运行时间小于是秒或者检查还未开始,且运行时间小于15秒

                    //while (!(Async_SniffIP_Time.AddSeconds(2) > DateTime.Now && sniffIP_Click_Time.AddSeconds(10) >DateTime.Now))

                    //{

                    //    //首次运行或者超过4秒没运行到检查

                    //    if (Async_SniffIP_Time < sniffIP_Click_Time)

                    //    {

                    //        asynPingJob(getAllEnableIP());

                    //        Thread.Sleep(4000);

                    //    }

                    //    else if (Async_SniffIP_Time.AddMilliseconds(100) < DateTime.Now)

                    //    {

                    //        if (sniffIP_Click_Time.AddSeconds(5) < Async_SniffIP_Time)

                    //        {

                    //            break;

                    //        }

                    //        else

                    //        {

                    //            asynPingJob(getAllEnableIP());

                    //            Thread.Sleep(2000);

                    //        }

                    //    }

                    //    else

                    //    {

                    //        Thread.Sleep(500);

                    //    }

                    //}

                }

                else

                {

                    //同步

                    synPingJob(getAllEnableIP());

                }

                //while (connectIPMap.Count == 0 || Async_SniffIP_Time.AddMilliseconds(100) < DateTime.Now)

                //{

                //    Thread.Sleep(450);

                //}

            }

            catch

            {

            }

        }


        //DateTime sniffAllIP_Click_Time_B4 = DateTime.Now.AddSeconds(-180);

        Object sniffAllIP_Clicklock = new object();

        Thread asynPingAllJobTh = null;

        private void sniffAllIP_Click(object sender, EventArgs e)

        {

            try

            {

                DateTime sniffIP_Click_Time = DateTime.Now;

                GC.Collect();

                if (connectAllIPMap.Count == 0)

                {

                    richTextBox4return.Text += "\n" + "已经预热完毕，请再次点击！";

                }

                else

                {

                    richTextBox4return.Text = "还有" + pings.Count + "个未完成ping的连接";

                    richTextBox4return.Text += "\n" + "共有" + connectAllIPMap.Count + "个可达的IP";

                }

                int k = 0;

                foreach (var item in connectAllIPMap.ToList())

                {

                    richTextBox4return.Text += "\n" + ++k + "：" + item.Key + "  平均耗时：" + connectAllIPMap[item.Key][1] / connectAllIPMap[item.Key][0] + " ms" + " 连接次数：" + connectAllIPMap[item.Key][0];

                    //Debug.Log(item.Key + "," + item.Value);

                    //pings[item.Key].SendAsyncCancel();

                    //pings[item.Key].Dispose();

                    //pings.Remove(item.Key);

                }

                //foreach (KeyValuePair> kvp in connectIPMap)

                //{

                //    richTextBox4return.Text += "\n" + ++k + "：" + kvp.Key + "  平均耗时：" + kvp.Value[1] / kvp.Value[0] + " ms" + " 连接次数：" + kvp.Value[0];

                //}

                // richTextBox4return.Text += "\n" + enableIPList[0].Substring(0,enableIPList[0].LastIndexOf(".")+1);

                //异步

                if (asynPingAllJobTh != null)

                {

                    if (!asynPingAllJobTh.IsAlive)

                    {

                        Thread.Sleep(300);

                        foreach (var item in pings.ToList())

                        {

                            //Debug.Log(item.Key + "," + item.Value);

                            pings[item.Key].SendAsyncCancel();

                            pings[item.Key].Dispose();

                            pings.Remove(item.Key);

                        }

                        asynPingAllJobTh = null;

                        richTextBox4return.Text = "请先清理内存（例如点击深度加速的小火箭）！！" + richTextBox4return.Text;

                    }

                    else if (asynPingAllJobTh == null) { }

                    else { return; }

                }

                //if (sniffAllIP_Click_Time_B4.AddSeconds(180) > sniffIP_Click_Time)

                //{

                //    richTextBox4return.Text = "检测私网IP时间间隔不得小于3分钟！请清理计算机内存！" + "\n" + richTextBox4return.Text;

                //    GC.Collect();

                //    return;

                //}

                //else

                //{

                //}

                //foreach (KeyValuePair kvp in pings)

                //{

                //    kvp.Value.SendAsyncCancel();

                //    //pings[254].Dispose();

                //}

                //pings.Clear();

                string func = "异步";

                if (func == "异步")

                {

                    //richTextBox4return.Text += "\n" + "8秒内给出结果，请稍等待";

                    lock (sniffAllIP_Clicklock)

                    {

                        if (pings.Count == 0)

                        {

                            Dictionary ipType = new Dictionary();

                            ipType.Add("A类地址", "10.");

                            ipType.Add("B类地址", "172.");

                            ipType.Add("C类地址", "192.");

                            List enableIPList = getAllEnableIP();

                            //string backHostIP = "";

                            List used = new List();

                            for (int i = 0; i < enableIPList.Count; i++)

                            {

                                string iIP = (enableIPList[i].Substring(0, enableIPList[i].LastIndexOf(".")));//.Substring(0, enableIPList[i].LastIndexOf(".") + 1);

                                iIP = iIP.Substring(0, iIP.LastIndexOf("."));

                                if (((iIP.Substring(0, iIP.LastIndexOf(".") + 1)).Equals(ipType[comboBox4ip.Text])))

                                {

                                    //sniffAllIP_Click_Time_B4 = sniffIP_Click_Time;

                                    asynPingAllJobTh = new Thread(asynPingAllJob);

                                    asynPingAllJobTh.IsBackground = true;

                                    asynPingAllJobTh.Start(iIP);

                                    break;

                                }//

                                if (enableIPList.Count == i + 1)

                                {

                                    richTextBox4return.Text = "不存在" + comboBox4ip.Text + "的网卡\n";

                                }

                            }

                            //asynPingAllJob(getAllEnableIP());

                        }

                    }

                    //运行时间小于是秒或者检查还未开始,且运行时间小于15秒

                    //while (!(Async_SniffIP_Time.AddSeconds(2) > DateTime.Now && sniffIP_Click_Time.AddSeconds(10) >DateTime.Now))

                    //{

                    //    //首次运行或者超过4秒没运行到检查

                    //    if (Async_SniffIP_Time < sniffIP_Click_Time)

                    //    {

                    //        asynPingJob(getAllEnableIP());

                    //        Thread.Sleep(4000);

                    //    }

                    //    else if (Async_SniffIP_Time.AddMilliseconds(100) < DateTime.Now)

                    //    {

                    //        if (sniffIP_Click_Time.AddSeconds(5) < Async_SniffIP_Time)

                    //        {

                    //            break;

                    //        }

                    //        else

                    //        {

                    //            asynPingJob(getAllEnableIP());

                    //            Thread.Sleep(2000);

                    //        }

                    //    }

                    //    else

                    //    {

                    //        Thread.Sleep(500);

                    //    }

                    //}

                    //while(asynPingAllJobTh.IsAlive)

                    //{

                    //    Application.DoEvents();

                    //    Thread.Sleep(100);

                    //}

                }

                else

                {

                    //同步

                    synPingJob(getAllEnableIP());

                }

                //while (connectIPMap.Count == 0 || Async_SniffIP_Time.AddMilliseconds(100) < DateTime.Now)

                //{

                //    Thread.Sleep(450);

                //}

            }

            catch

            {


            }

        }


        private void tryTelnet_Click(object sender, EventArgs e)

        {

            if (testIPPortConnect(textBox4IP.Text, cvt_int(textBox4Port.Text))) {

                richTextBox4return.Text += "\n" + textBox4IP.Text + ":" + textBox4Port.Text + "端口畅通";

            }

            else

            {

                richTextBox4return.Text += "\n" + textBox4IP.Text + ":" + textBox4Port.Text + "端口不畅通";

            }

        }

        private void tryTracert_Click(object sender, EventArgs e)

        {

            doTryTracert(textBox4IP.Text);

        }

        private void getLocIP_Click(object sender, EventArgs e)

        {

            richTextBox4return.Text += "\n第一个网卡IPv4为" + GetLocalIP() + "\n" + GetLocalAllIP();

        }

        private void getNetCard_Click(object sender, EventArgs e)

        {

            richTextBox4return.Text += getNetworkCard();

        }

        public static int cvt_int(object num)

        {

            try { return (int)Convert.ToDouble(num); }

            catch { return 0; }

        }

        public  bool pingIP(string address)

        {

            int sleepTime = 0;

            pingOK = false;

            Thread th = new Thread(PingJob);

            th.IsBackground = true;

            th.Start(address);


            while (!pingOK && sleepTime < 500)//最多等待 n s，如果还没结果，判断本次连接失败

            {

                sleepTime += 10;

                Thread.Sleep(10);

                Application.DoEvents();

            }

            return pingOK;

        }

        static bool pingOK = false;

        void PingJob(object pingIP)

        {

            Ping ping = null;

            try

            {

                ping = new Ping();

              // ping.PingCompleted += new PingCompletedEventHandler(OnPingCompleted);

                PingReply pingReply = ping.Send(pingIP.ToString(), 500);

                pingOK = pingReply.Status == IPStatus.Success;

            }

            catch

            {

                pingOK = false;

            }

            finally

            {

                if (ping != null) // 2.0 下ping 的一个bug，需要显示转型后释放

                {

                    IDisposable disposable = ping;

                    disposable.Dispose();

                    ping.Dispose();

                }

            }

        }

        bool synPingJob(List  enableIPList)

        {

            Ping ping = null;

            pingOK = false;

            try

            {

                ping = new Ping();

                //PingReply pingReply = null;//ping.Send(pingIP, 100);

              // pingOK = pingReply.Status == IPStatus.Success;


                for (int i = 0; i < enableIPList.Count; i++)

                {

                    richTextBox4return.Text += "\n" + "开始搜索：" + enableIPList[i];

                    Thread.Sleep(100);

                    for (int j = 1; j < 254; j++)

                    {


                        PingReply pingReply=ping.Send(enableIPList[i].Substring(0, enableIPList[i].LastIndexOf(".") + 1) + j, 100);

                        if (pingReply.Status == IPStatus.Success)

                        {


                            pingContIPList.Add(enableIPList[i].Substring(0, enableIPList[i].LastIndexOf(".") + 1) + j);

                            richTextBox4return.Text += "\n" + "可连接的IP:" + enableIPList[i].Substring(0, enableIPList[i].LastIndexOf(".") + 1) + j;

                        }

                    }

                    richTextBox4return.Text += "\n" + "第" + (i+1) + "次搜索结束";

                }

                // ping.PingCompleted += new PingCompletedEventHandler(OnPingCompleted);


                return pingOK;

            }

            catch

            {

                return pingOK;

            }

            finally

            {

                if (ping != null) // 2.0 下ping 的一个bug，需要显示转型后释放

                {


                    IDisposable disposable = ping;

                    disposable.Dispose();

                    ping.Dispose();

                }

            }

        }


        Dictionary asynPings = new Dictionary();

        void asynPingJob(Object o)

        {

            List enableIPList = (List)o;

            //Ping ping = null;

            pingOK = false;

            try

            {


                for (int i = 0; i < enableIPList.Count; i++)

                {

                    //richTextBox4return.Text += "\n" + "开始搜索：" + enableIPList[i];

                    //Thread.Sleep(100);

                    for (int j = 1; j < 254; j++)

                    {

                        string IPKey= enableIPList[i].Substring(0, enableIPList[i].LastIndexOf(".") + 1) + j;

                        asynPings.Add( IPKey,new Ping());

                        asynPings[IPKey].PingCompleted += PingSuccess;

                        asynPings[IPKey].SendAsync(IPKey, 500, IPKey);


                    }


                }


            }

            catch

            {


            }

            finally

            {


            }

        }


        Dictionary pings = new Dictionary();


        void asynPingAllJob(Object o)

        {

            string iIP = (string)o;


                for (int k = 0; k < 255; k++)// for (int k = 254; k >0; k--)//

                {

                    string kIP = iIP + "." + k;

                    //string kBackHostIP = backHostIP + "." + k;

                    for (int j = 1; j < 255; j++)// for (int j = 254; j > 0; j--)//

                    {



                        string jIP = kIP + "." + j;

                        //ping = new Ping();

                        if (!pings.ContainsKey(jIP))

                        {

                            pings.Add(jIP, new Ping());

                            pings[jIP].PingCompleted += PingAllIn1Success;

                            pings[jIP].SendAsync(jIP, 600, jIP);



                        }


                    }

                }


        }

        static Object _lock = new object();

        void PingSuccess(object sender, PingCompletedEventArgs e)

        {


            BackgroundWorker worker = sender as BackgroundWorker;


            lock (_lock)

            {

                try

                {


                    if (e.Reply.Status == IPStatus.Success)

                    {

                        //string temp = e.UserState + "请求结果:" + e.Reply.Status + "(编号" + i + "),耗时：" + e.Reply.RoundtripTime + "ms";

                        //richTextBox4return.Text += "\n"+"IP地址:" + e.UserState + "->请求结果:" + e.Reply.Status + "耗时：" + e.Reply.RoundtripTime + "ms";

                        if (connectIPMap.ContainsKey((e.UserState).ToString()))

                        {

                            connectIPMap[e.UserState.ToString()][0]++;

                            connectIPMap[e.UserState.ToString()][1] += (int)e.Reply.RoundtripTime;

                        }

                        else

                        {

                            List v = new List() { 1, (int)e.Reply.RoundtripTime };

                            connectIPMap.Add(e.UserState.ToString(), v);

                        }

                    }

                }

                catch (Exception ex)

                {

                    Console.WriteLine(ex.ToString());

                }

            }


        }

        void PingAllIn1Success(object sender, PingCompletedEventArgs e)

        {

            BackgroundWorker worker = sender as BackgroundWorker;

            lock (_lock)

            {

                try

                {


                    if (e.Reply.Status == IPStatus.Success)

                    {


                        if (connectAllIPMap.ContainsKey((e.UserState).ToString()))

                        {

                            connectAllIPMap[e.UserState.ToString()][0]++;

                            connectAllIPMap[e.UserState.ToString()][1] += (int)e.Reply.RoundtripTime;

                        }

                        else

                        {

                            List v = new List() { 1, (int)e.Reply.RoundtripTime };

                            connectAllIPMap.Add(e.UserState.ToString(), v);

                        }

                        pings[e.UserState.ToString()].SendAsyncCancel();

                        //pings[254].Dispose();

                        pings.Remove(e.UserState.ToString());

                    }

                }

                catch (Exception ex) { Console.WriteLine(ex.ToString()); }

            }

        }

        Dictionary> connectIPMap = new Dictionary>();

        Dictionary> connectAllIPMap = new Dictionary>();

        List getAllEnableIP()

        {

            List netInfo =new List();

            IPAddress[] dnsIps = Dns.GetHostAddresses(Dns.GetHostName());

            for (int i = 0; i < dnsIps.Length; i++)

            {

                if (dnsIps[i].AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)

                {

                    netInfo .Add( dnsIps[i].ToString());

                }

            }

            return netInfo;

        }

        public static bool testIPPortConnect(string ipAddress, int portNum)

        { //将IP和端口替换成为你要检测的

            //string ipAddress = "192.168.1.1";

            //int portNum = 22;

            try

            {

                IPAddress ip = IPAddress.Parse(ipAddress);

                IPEndPoint point = new IPEndPoint(ip, portNum);

                using (System.Net.Sockets.Socket sock = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))

                {

                    sock.Connect(point);

                    sock.Close();

                    return true;

                }

            }

            catch (SocketException e)

            {

                Console.WriteLine(e.ToString());

                return false;

            }

            catch (Exception e) {

                Console.WriteLine(e.ToString());

                return false;

            }

        }

        static byte[] PING_BUFFER = new byte[] { 0 };

        static int g_nHops = 30;

        static int g_nTimeout = 3000;

        static bool g_bCanceled = false;

        public struct ICMP_PARAM

        {

            internal long m_nSendTicks;

            internal IPAddress m_IPAddress;

            internal PingOptions m_PingOptions;

        }


        void icmp_PingCompleted(object sender, PingCompletedEventArgs e)

        {

            ICMP_PARAM param = (ICMP_PARAM)e.UserState;

            long nDeltaMS = (DateTime.Now.Ticks - param.m_nSendTicks) / TimeSpan.TicksPerMillisecond;

          richTextBox4return.Text += "\n" +param.m_PingOptions.Ttl+":\t"+((e.Reply.Status == IPStatus.TimedOut) ? "*" : nDeltaMS.ToString())+" ms\t" +e.Reply.Address.ToString();

            if (param.m_IPAddress.Equals(e.Reply.Address))

            {

              richTextBox4return.Text += "\n" + "已到达目标地址！";

                g_bCanceled = true;

                return;

            }

            if (param.m_PingOptions.Ttl >= g_nHops)

            {

                richTextBox4return.Text += "\n" + "已达到最大跃点计数！";

                g_bCanceled = true;

                return;

            }

            Ping icmp = (Ping)sender;

            param.m_PingOptions.Ttl++;

            param.m_nSendTicks = DateTime.Now.Ticks;

            icmp.SendAsync(param.m_IPAddress, g_nTimeout, PING_BUFFER, param.m_PingOptions, param);

        }

        void Usage()

        {

            richTextBox4return.Text += "\n" +"Usage: "+Process.GetCurrentProcess().ProcessName+" [-h max_hops] [-w timeout] ip/domain";

        }

        void doTryTracert(string szDomain)

        {


            Console.CancelKeyPress += new ConsoleCancelEventHandler(Console_CancelKeyPress);

            ICMP_PARAM param = new ICMP_PARAM();

            param.m_PingOptions = new PingOptions(1, false);

            if (!IPAddress.TryParse(szDomain, out param.m_IPAddress))

            {

                // 解析域名

                try

                {

                    Regex regEx = new Regex("\\d+\\.\\d+\\.\\d+\\.\\d+");

                    IPHostEntry hostEntry = Dns.GetHostEntry(szDomain);

                    foreach (IPAddress ipAddr in hostEntry.AddressList)

                    {

                        if (regEx.IsMatch(ipAddr.ToString()))

                        {

                            param.m_IPAddress = ipAddr;

                            break;

                        }

                    }

                    if (param.m_IPAddress == null)

                    {

                        Usage();

                        return;

                    }

                    richTextBox4return.Text += "\n" + "正在跟踪到 "+szDomain+"["+ param.m_IPAddress.ToString()+"] 间的路由：";

                }

                catch (Exception ex)

                {

                    Console.WriteLine(ex.ToString());

                    return;

                }

            }

            else

            {

              richTextBox4return.Text += "\n" + "正在跟踪到" + param.m_IPAddress.ToString()+" 间的路由：";

            }

            Ping icmp = new Ping();

            icmp.PingCompleted += new PingCompletedEventHandler(icmp_PingCompleted);

            param.m_nSendTicks = DateTime.Now.Ticks;

            icmp.SendAsync(param.m_IPAddress, g_nTimeout, PING_BUFFER, param.m_PingOptions, param);

            while (!g_bCanceled)

            {

                Application.DoEvents();

                Thread.Sleep(10);

            }

        }

        void Console_CancelKeyPress(object sender, ConsoleCancelEventArgs e)

        {

          richTextBox4return.Text += "\n" + "程序被终止！";

        }


        public string GetLocalIP()

        {

            IPAddress localIp = null;

            try

            {

                IPAddress[] ipArray;

                ipArray = Dns.GetHostAddresses(Dns.GetHostName());

                localIp = ipArray.First(ip => ip.AddressFamily == AddressFamily.InterNetwork);

            }

            catch (Exception ex)

            {

                MessageBox.Show(ex.StackTrace + "\r\n" + ex.Message, "错误", MessageBoxButtons.OKCancel, MessageBoxIcon.Error);

                //Log.WriteLog(ex);

            }

            if (localIp == null)

            {

                localIp = IPAddress.Parse("127.0.0.1");

            }

            return localIp.ToString();

        }

        public string GetLocalAllIP()

        {

            string netInfo = "";

            try

            {

                IPAddress[] ipArray;

                ipArray = Dns.GetHostAddresses("");

                for (int i = 0; i < ipArray.Length; i++)

                {

                    netInfo += string.Format("{0}) [ip:]{1}，  [ip类型:]{2}\r\n", i.ToString(), ipArray[i].ToString(), ipArray[i].AddressFamily);

                }

                return netInfo;


            }

            catch (Exception ex)

            {

                MessageBox.Show(ex.StackTrace + "\r\n" + ex.Message, "错误", MessageBoxButtons.OKCancel, MessageBoxIcon.Error);

                //Log.WriteLog(ex);

                return "获取所有网卡失败" + ex.ToString();

            }


        }


        string getNetworkCard()

        {

            string netInfo ="";

            //3、获取网卡的名字等信息

            netInfo += "\r\n以下是网卡接口数组中的信息。\r\n通过NetworkInterface.GetAllNetworkInterfaces()获取本机所有网卡接口信息:\r\n";

            int count = 0;

            foreach (NetworkInterface netInt in NetworkInterface.GetAllNetworkInterfaces())

            {


                count++;

                netInfo += string.Format("{0})接口名:{1}\r\n    接口类型:{2}\r\n    接口MAC:{3}\r\n    接口速度:{4}\r\n    接口描述信息:{5}\r\n", count, netInt.Name, netInt.NetworkInterfaceType, netInt.GetPhysicalAddress().ToString(), netInt.Speed / 1000 / 1000, netInt.Description);


                netInfo += "    接口配置的IP地址:\r\n";

                foreach (UnicastIPAddressInformation ipIntProp in netInt.GetIPProperties().UnicastAddresses.ToArray())

                {

                    netInfo += string.Format("    接口名:{0}，  ip:{1}，  ip类型:{2}\r\n",netInt.Name, ipIntProp.Address.ToString(),ipIntProp.Address.AddressFamily);


                }

                //单个网卡的IP对象

                IPInterfaceProperties ip = netInt.GetIPProperties();

                GatewayIPAddressInformationCollection gateways = ip.GatewayAddresses;

                foreach (var gateWay in gateways)

                {

                    //如果能够Ping通网关

                    if (pingIP(gateWay.Address.ToString()))

                    {

                        //得到网关地址

                        netInfo += "畅通的网关：" + gateWay.Address.ToString() + "\r\n";

                        //跳出循环

                        //break;

                    }

                    else

                    {

                        netInfo += "不可达的网关：" + gateWay.Address.ToString() + "\r\n";

                    }

                }

                IPAddressCollection dnsAddresses =ip.DnsAddresses;

                foreach (var DnsAddress in dnsAddresses)

                {

                    netInfo += "DNS地址：" + DnsAddress.ToString() + "\r\n";


                }


            }

            return netInfo;

        }

        private void getPasNetAddr_Click(object sender, EventArgs e)

        {

            richTextBox4return.Text += "\n" + getImportantIP();

        }

        string getImportantIP()


        {

            string netInfo = "";

            foreach (var item in NetworkInterface.GetAllNetworkInterfaces())

            {

                if (item.OperationalStatus == OperationalStatus.Up && item.NetworkInterfaceType == NetworkInterfaceType.Ethernet)

                {//先获取需要的接口。两个条件确定当前正在使用的网口。1、接口状态为up；2、接口类型为Ethernet。


                    foreach (var ipInfo in item.GetIPProperties().UnicastAddresses.ToArray())

                    {

                        if (ipInfo.Address.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)

                        {

                            netInfo += string.Format("本机正在使用接口为:{0}\r\n本机正在使用的IP为：{1}", item.Name, ipInfo.Address.ToString());

                            break;

                        }

                    }

                }               

            }

            //与上面一样，只不过用了Dns.GetHostAddresses()的方法

            IPAddress[] dnsIps = Dns.GetHostAddresses(Dns.GetHostName());

            for (int i = 0; i < dnsIps.Length; i++)

            {

                if (dnsIps[i].AddressFamily==System.Net.Sockets.AddressFamily.InterNetwork)

                {

                    netInfo += "\r\n已启用的IPv4：" + dnsIps[i].ToString();

                }

            }

            return netInfo;

        }

        private void button4RichClear_Click(object sender, EventArgs e)

        {

            richTextBox4return.Text = "";

        }

        Thread urlIsExistTh = null;

        private void button4url_Click(object sender, EventArgs e)

        {

            List urls =new List ();

            urls.Add(richTextBox4url.Text);

            UrlIsExistThStart(urls);

            foreach(string url in urls){

                if (connectURLMap.ContainsKey(url))

                {

                    richTextBox4return.Text += "\r\n"+ richTextBox4url.Text +"--"+ connectURLMap[url];

                }

            }


        }

        private void UrlIsExistThStart(List urls)

        {

            if (urlIsExistTh == null)

            {

                urlIsExistTh = new Thread(UrlIsExist);

                urlIsExistTh.IsBackground = true;

                urlIsExistTh.Start(urls);

            }

            else if (!urlIsExistTh.IsAlive)

            {

                urlIsExistTh = new Thread(UrlIsExist);

                urlIsExistTh.IsBackground = true;

                urlIsExistTh.Start(urls);

            }

            if (connectURLMap.Count > 100) connectURLMap.Clear();

        }

        Dictionary connectURLMap = new Dictionary();

        private void UrlIsExist(Object o)

        {

            List urls = (List)o;

            System.Uri u = null;

            foreach(String url in urls){

                  System.Net.HttpWebRequest r =null;

                try

                {

                    u = new Uri(url);

                    if (u == null) throw new  Exception();

                    r = System.Net.HttpWebRequest.Create(u) as System.Net.HttpWebRequest;

                    r.Method = "HEAD";

                }

                catch

                {

                    if (connectURLMap.ContainsKey(url))

                    {

                        connectURLMap[url] = "url格式不正确";

                    }

                    else

                    {

                        connectURLMap.Add(url, "url格式不正确");

                    }

                    continue;


                }

                bool isExist = false;


                try

                {

                    System.Net.HttpWebResponse s = r.GetResponse() as System.Net.HttpWebResponse;

                    if (s.StatusCode == System.Net.HttpStatusCode.OK)

                    {

                        isExist = true;

                    }

                }

                catch (System.Net.WebException x)

                {

                    try

                    {

                        isExist = ((x.Response as System.Net.HttpWebResponse).StatusCode != System.Net.HttpStatusCode.NotFound);

                    }

                    catch { isExist = (x.Status == System.Net.WebExceptionStatus.Success); }

                }

                if (isExist)

                {

                    if (connectURLMap.ContainsKey(url))

                    {

                        connectURLMap[url] = "目的地址的服务器存活";

                    }

                    else

                    {

                        connectURLMap.Add(url, "目的地址的服务器存活");

                    }

                }

                else

                {

                    if (connectURLMap.ContainsKey(url))

                    {

                        connectURLMap[url] = "无法连接";

                    }

                    else

                    {

                        connectURLMap.Add(url, "无法连接");

                    }

                }

            }

            //return isExist;

        }

        private void banIPButton_Click(object sender, EventArgs e)

        {

            IISTool iisTool = new IISTool();

            IEnumerable  siteNames= iisTool.GetSiteNames();

            if (siteNames == null)

            {

                MessageBox.Show("权限不足");

            }

            else {

                foreach (string s in iisTool.GetSiteNames())

                {


                        richTextBox4return.Text += "\n" + s;


                }

              // siteNames.

            }

            if (pingIP(banIPButtonTextBox.Text))

            {

                if (banIPButton.Text.Equals("禁止访问IP"))

                {

                    try

                    {

                        IISTool.banIP(banIPButtonTextBox.Text);

                        richTextBox4return.Text += "\n" + banIPButtonTextBox.Text + "被禁止";

                    }

                    catch

                    {

                        richTextBox4return.Text += "\n" + banIPButtonTextBox.Text + "禁止时出现异常";

                    }

                    banIPButton.Text = "解除禁制IP";

                    banIPButtonTextBox.Enabled = false;

                }

                else

                {

                    try

                    {

                        IISTool.allowIP(banIPButtonTextBox.Text);

                        richTextBox4return.Text += "\n" + banIPButtonTextBox.Text + "被解除禁止";

                    }

                    catch

                    {

                        richTextBox4return.Text += "\n" + banIPButtonTextBox.Text + "解除禁止时出现异常";

                    }

                    banIPButton.Text = "禁止访问IP";

                    banIPButtonTextBox.Enabled = true;

                }

            }

            else

            {

                richTextBox4return.Text += "\n" + banIPButtonTextBox.Text + "网络不可达";

            }

        }

    }

}

WorkWait.cs //这个类几乎没啥用

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading;

namespace webSniff

{

    public class WorkWait

    {

        Consumer c = new Consumer();

        Producer p = new Producer();

        public void maked()

        {

            p.maked();

        }

        public void used()

        {

            c.used();

        }

        public void wait()

        {

            int i = 0;

            int cSumTemp = c.sum;

            while ((p.sum - c.sum) > 12)

            {

                //让出时间片

                Thread.Sleep(1);

                if (c.sum == cSumTemp & i > 30)

                {

                    GC.Collect();

                    if (c.sum == cSumTemp)

                        p.sum = c.sum = 0;

                }

                else if (c.sum == cSumTemp)

                {

                    i++;

                }

                else

                {

                    i = 0;

                    cSumTemp = c.sum;

                }

            }

        }


    }

    class Producer

    {

        public int sum = 0;

        public void maked()

        {

            sum++;

        }

    }

    class Consumer

    {

        public int sum = 0;

        public void used() {

            sum++;

        }

    }

}

IISTool.cs //禁用IP连接的类，没测试成功

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using Microsoft.Web.Administration;

namespace webSniff

{

    public  class IISTool

    {

        private readonly ServerManager serverManager;

        public IISTool()

        {

            serverManager = new Microsoft.Web.Administration.ServerManager();

        }

        ///

        /// 给IIS添加禁止IP限制

        /// 仅针对iis 7及以上版本

        /// 首先需要引入Microsoft.Web.Administration.dll

        /// 该文件位置在windows2008的\Windows\System32\inetsrv目录下

        /// 注意：生成的EXE文件必须以管理员身份运行

        ///

        ///

        /// 过 http://go.microsoft.com/fwlink/?LinkId=213942

        public static void banIP(string ip)

        {

            using (ServerManager serverManager = new ServerManager())

            {

                Configuration config = serverManager.GetApplicationHostConfiguration();

                ConfigurationSection ipSecuritySection = config.GetSection("system.webServer/security/ipSecurity");

                ConfigurationElementCollection ipSecurityCollection = ipSecuritySection.GetCollection();

                ConfigurationElement addElement = ipSecurityCollection.CreateElement("add");

                addElement["ipAddress"] = ip;

                ipSecurityCollection.Add(addElement);

                serverManager.CommitChanges();

            }

        }

        public static void allowIP(string ip)

        {

            using (ServerManager serverManager = new ServerManager())

            {

                Configuration config = serverManager.GetApplicationHostConfiguration();

                ConfigurationSection ipSecuritySection = config.GetSection("system.webServer/security/ipSecurity");

                ConfigurationElementCollection ipSecurityCollection = ipSecuritySection.GetCollection();

                ConfigurationElement removeElement = ipSecurityCollection.CreateElement("remove");

                removeElement["ipAddress"] = ip;

                //ipSecurityCollection.Add(removeElement);

                ipSecurityCollection.Remove(removeElement);

                serverManager.CommitChanges();

            }

        }

        public  IEnumerable GetSiteNames()

        {

            foreach (var item in GetWorkerProcesses())

            {

                yield return item.AppPoolName;

            }

        }

        public IEnumerable GetWorkerProcesses()

        {

            return serverManager.WorkerProcesses;

        }

    }

}

你可能感兴趣的:(C#异步并发网络编程 ping、追踪路由、tcp等)

  • 大学播音主持都学什么内容？播音主持专业学什么？ 配音新手圈
    有些喜欢播音主持并且犹豫要不要报考这个大学专业的小伙伴们就会想要了解大学播音主持都学什么内容吧，毕竟如果不够了解就直接选择这个专业真的等选择完进去学习以后才知道这个专业并不是自己想要学习的东西那就来不及了。下面是小编为大家整理出来的一些播音主持专业学习的内容，请往下看吧。大学播音主持专业主要学习的课程有：播音发声、播音创作基础、广播播音主持、电视播音主持、文艺作品演播学概论、新闻学概论、新闻采编、
  • 5月8日盘前提示：维持短期可以操作到下周二左右的判断，重个股轻指数 九命_猫妖
    大盘：消息面。取消境外投资者额度限制，这个长线利好股市，短期影响不大，因为3000亿额度只用了1/3。额度本来就够用。走势看，昨天缩量横盘，走的还算中规中矩，近期一直弱势的次新股走势较强，前期强势股京威股份、光大嘉宝等跌停，由此判断市场还是存量博弈的市场，震荡是市场的主基调。维持短期可以操作到下周二左右的判断。下周后半段震荡回调的概率较高。思路：短期重个股轻指数行业和个股：物联网行业有利好，关注下
  • 美团自动配送车2024春季招聘 | 社招专场 美团技术团队
    关于美团自动配送团队美团自动配送以自研L4级自动驾驶软硬件技术为核心，与美团即时零售业务结合，形成满足公开道路、校园、社区、工业园区等室外全场景下的自动配送整体解决方案。美团自动配送团队成立于2016年，团队成员来自于Waymo、Cruise、Pony.ai、泛亚等自动驾驶行业头部公司，自动驾驶技术团队博士占比高达30%，依靠视觉、激光等传感器，实时感知预测周围环境，通过高精地图定位和智能决策规划
  • 天猫超市优惠获取渠道，天猫超市内部优惠劵领取方法使用教程 氧惠全网优惠
    天猫超市是一个不错的购物平台，满足用户所需，基本次日达，很方便的购物平台，那么有人问我，天猫超市优惠获取渠道在哪？怎么能够优惠的购买，今天分享给大家；1、天猫超市优惠券抢好券：天猫超市首页每天可以领取满199减30、满235减35、满299减50、满399减60、满166减30等优惠券，领劵方法复制下条口令打开淘宝进入领劵会场；隐藏神券、实时爆款、天天更新！戳>(CZ9185ZatcdhNADlJ
  • 《对我而言危险的他》：“假千金”归来，携手神秘霸总共破迷局 入骨影评
    由樊治欣李墨之主演的都市悬疑爱情剧《对我而言危险的他》在网上平台一次性播出全集。虽然是个小成本网剧，呈现出来的效果却十分有诚意。剧中从车祸到坠海、再到徒手灭火等惊险场面都是实景拍摄和主演们的无替身上场。说起樊治欣这个名字可能大家都不熟悉，但提起他演过的剧，大家都不陌生。饰演过《暗格里的秘密》中的学长苏柏从的樊治欣在这部剧中饰演霸总严星呈，即便同样戴着眼镜，却给人不一样的观感。该剧主要讲述了女主沈漫
  • 黔东南——苗年（一） 非常道yw
    苗年是雷山县苗族同胞最隆重的民族传统节日，也是苗族人一年中庆祝丰收和最重要的祭祀性的日子，更是雷山苗族一年里劳作的结束和欢乐的开始。如同汉族的春节。节日期间，各村寨都要举行跳芦笙、篮球赛、斗牛、赛马、斗鸟、铜鼓舞、篝火晚会等民间传统娱乐活动。苗年也是最集中地展示苗族服饰、银饰、手工艺美术等有形文化的节日，时间大都在农历十月。苗族认为，一年只有热、冷两个季节，热季和冷季交替的农历十月，既是热季的结束
  • 第一章 山洞传来牛铃声 满眼荷花
    春夏时节，田野一片青碧，山林薄雾蔼蔼，水草萋萋的小河边静静立着一只白鹭，像一位白头钓翁，在耐心地等鱼。王三乐牵着一头老黄牛，正在河边田埂上放牛。看见白鹭，他百无聊赖地捡起一块小石头扔了过去。白鹭动作舒缓、姿势优美地飞起避过，在空中飞行一段后，宛若晴空一片云，翩然而下，又静静立于河边青草间，继续呈现完美的画面。王三乐也觉得自己很无聊，这也难怪，从他记事起就开始放牛，一直到现在都大学毕业了，还没丢下放
  • 社交电商是什么意思通俗的说 氧惠好项目
    社交电商是目前电商发展的一个非常热门的领域，它将传统的电商和社交媒体相结合，让用户可以在社交平台上完成购物、支付等操作。社交电商不同于传统电商，它更加注重用户的社交性和互动性，通过社交媒体的传播，吸引用户关注，让产品能够更加快速地传播。京东密令红包：最爱领红包828红包多多148今天给大家分享我长期在做的副业，也在这里赚到人生第3桶金！氧惠APP佣金高，资质靠谱，各大应用市场均可搜索使用。【氧惠】
  • 数据分析：低代码平台助力大数据时代的飞跃发展 快乐非自愿 数据分析低代码大数据
    随着信息技术的突飞猛进，我们身处于一个数据量空前增长的时代——大数据时代。在这个时代背景下，数据分析已经成为企业决策、政策制定、科学研究等众多领域不可或缺的重要工具。然而，面对海量的数据和日益复杂多变的分析需求，传统的数据分析方法往往捉襟见肘，难以应对。幸运的是，低代码平台的兴起为大数据分析注入了新的活力，成为推动大数据时代发展的重要力量。低代码平台，顾名思义，是一种通过少量甚至无需编写代码，就能
  • 以前开发MFC界面如何快速转成QT界面 广州视觉芯软件有限公司 mfcqtc++
    将MFC界面快速转换为Qt界面可能需要进行一些手动工作，因为MFC和Qt是两个不同的界面框架，它们具有不同的设计和实现原理。但是，以下步骤可以帮助你快速进行转换：创建一个新的Qt项目：使用QtCreator创建一个新的Qt项目。分析MFC界面：仔细分析你的MFC界面，包括窗口、对话框、控件等的布局、样式和行为。重新设计界面：使用Qt的可视化设计器重新设计界面。在QtCreator的设计器中，你可以
  • 购物返利平台是真的吗 返金app平台高佣返利省钱
    购物返利平台是真实存在的，它们提供一种通过购物来获取一定比例返现的服务。这些平台通常与商家合作，通过返利链接或其他追踪方式来追踪用户的购物行为，然后将一部分返现金额返还给用户。然而，需要注意的是，并非所有的购物返利平台都是可信的。在选择使用购物返利平台时，建议您注意以下几个方面：可信度和口碑：查看平台的用户评价和口碑，了解其他用户对该平台的使用体验和返利情况。合作商家：了解平台的合作商家是否可靠，
  • 使用多线程的方式模拟高并发请求接口，用于自测接口的稳定性【项目】 还算善良_ 私有代码库工具类javalist数据结构
    packagecom.gitee.taven.test;importcom.gitee.taven.ApiResult;importcom.gitee.taven.aop.RepeatSubmitAspect;importorg.slf4j.Logger;importorg.slf4j.LoggerFactory;importorg.springframework.beans.factory.an
  • 【嵌入式模块】步进电机使用总结 记录无知岁月 #嵌入式设备嵌入式硬件步进电机
    关于本博客  此前上了一门课《自动控制元件》，但是由于学时有限，讲到步进电机就不讲了，留下了一个小遗憾，导致需要使用步进电机时就有点懵，于是找了一篇博客，链接在这里，推荐具有电机知识（如直流电机，异步电机等）的朋友看，如果完全不懂，建议先啃书。
  • 常用API---初始化，话题和服务对象创建，回旋/头函数，时间（如：获取当前时刻，持续时间执行频率，休眠，定时器等），运行频率，定时器，节点生命周期，日志相关API 李卓璐 机器人人工智能c++
    初始化ROS节点ros::init(argc,argv,“name”,options);作用：ros初始化函数参数： 1.argc—封装实参的个数（n+1个->有一个是自身）； 2.argv—封装参数的数组； 3.name—为节点命名（唯一性）； 4.options—节点启动项，解决节点重名问题。返回值：void使用： 1.argc和argv的使用：  如果按照ROS中的特定格式传入实参，那么RO
  • ChatGPT一路狂飙？ 何鲸洛
    2月2日。根据投行瑞银集团在周三发布的一份研究报告。爆红聊天机器人ChatGPT的月活跃用户在今年1月份预计达到了1亿，这距离它推出只有2个月时间，成为史上增长最快的消费者应用。①ChatGPT一路火花带闪电？▽2014年。OpenAI创始人SamAltman早年曾执掌著名的硅谷孵化器YCombinator。2015年。Altman联合马斯克、彼得·泰尔、AWS、印度Infosys和YC等作为出资
  • 【美丽特色乡村】，景德镇马鞍岭村， 粒子飞翔
    【美丽特色乡村】，景德镇马鞍岭村，就像是陶渊明笔下的山水田园，阡陌交通，精美的白房参差错落，碧绿透亮的河水从不远处的深涧里连绵不绝流入此地，滋养着土里。成群的白鸭悠闲地在河水里戏水，人与环境达成和谐的境界。借助三宝国际瓷谷建设的契机，马鞍岭村迎来了天翻地覆的沧桑巨变,此地以陶瓷文化为特色，融合原来生态资源，修复了水碓遗址、矿坑遗址等历史文化遗产，提升生态环境现状。同时，依托三宝溪围绕整个村落，对河
  • 家长们的福音：教师对书面作业全批全改，学校不得考试选拔学生 丝雨润春风
    年前年后教育部门公布了不少措施，来减轻学生负担，维护学生的身心健康成长，随后各地教育局也陆陆续续颁布了各种新政策，这不最近山东教育厅也起草了《山东普通中小学规范办学十五条规定》。在这15条规定内容之中包括了：教师对书面作业全批全改，不给家长布置作业或要求家长评改作业；义务教育学校不得以考试、面试、评测等名义选拔学生；保障学生每天睡眠时间，高中生不少于8个小时。毋庸置疑这个规定的初衷非常得好，是对学
  • C#中的PLINQ和LINQ的效率对比 搬砖的诗人Z C#c#linq开发语言
    PLINQ（ParallelLINQ）和LINQ（LanguageIntegratedQuery）都是.NET框架中的功能，用于对集合进行查询和操作。它们之间的主要区别在于并行处理能力。LINQ:LINQ是一种用于在.NET应用程序中进行数据查询和操作的语言集成功能。它提供了一种统一的方式来查询各种数据源，如集合、数组、XML、数据库等。LINQ是在单线程环境中执行查询操作的，因此对于大型数据集或
  • npm 搭建 Vite 项目 渺小的虫子 viter前端javascript开发语言
    兼容性注意Vite需要Node.js版本>=12.0.0。1、使用npm安装Viter$npminitvite@latest使用npm初始化项目#npm6.xnpminitvite@latestmy-vue-app--templatevue#npm7+,需要额外的双横线：npminitvite@latestmy-vue-app----templatevue2、配置路由：npminstallvue-
  • 买莆田鞋的app软件，三大app莆田鞋平台推荐给大家 腕表鞋屋
    买莆田鞋的app软件，三大app莆田鞋平台推荐给大家，如毒app、亚马逊、潮鞋之家、鞋子货源app、淘宝等app都非常的好用，还有更多的可以购买莆田鞋子，莆田鞋在哪个app买好用，下面一起看看。微信:pt188x(下单赠送精美礼品)买莆田鞋的三大app软件：一、淘宝app。买莆田鞋当然少不了淘宝，建议大家不要直接去搜索莆田鞋，那样给出的结果是很少的。大家看上哪款鞋子的型号直接去搜索就可以了，然后按
  • 中原焦点团队38期王芳芳坚持分享第236天，20230630总约练134次，来访113次，咨8次，观察员13次 芳芳王
    学习焦点的初心是想拯救孩子，孩子由于沉迷游戏，成绩下滑，在学习的过程中发现是自己的教育方式出了状况。经过半年的学习，一些焦点的基本技巧，如接纳、欣赏、倾听、同理心、尊重等都有了一定的了解。但在实际应用时仍然存在很多问题，感觉自己仍然没有放下对孩子成绩的期望，仍然把握不住对孩子管理的度。我该如何去陪伴好孩子？多用心去听课，并加强反思，多约练。去思考如何让自己快乐起来？
  • 【转载】SSD测试第一神器——FIO running_sheep
    转自：[http://www.ssdfans.com]对于SSD性能测试来说，最好的工具莫过于FIO了。FIO是Jens开发的一个开源测试工具，功能非常强大，本文就只介绍其中一些基本功能。线程，队列深度，Offset，同步异步，DirectIO，BIO使用FIO之前，首先要有一些SSD性能测试的基础知识。线程指的是同时有多少个读或写任务在并行执行，一般来说，CPU里面的一个核心同一时间只能运行一个
  • 大前端-postcss安装使用指南 黑夜照亮前行的路 postcss
    PostCSS是一款强大的CSS处理工具，可以用来自动添加浏览器前缀、代码合并、代码压缩等，提升代码的可读性，并支持使用最新的CSS语法。以下是一份简化的PostCSS安装使用指南：一、安装PostCSS在你的项目目录中，通过npm（NodePackageManager）来安装PostCSS。打开命令行窗口，输入以下命令：bash复制代码npminstallpostcss--save-dev这将把
  • 3、JavaWeb-Ajax/Axios-前端工程化-Element 所谓远行Misnearch #JavaWeb前端ajaxelementuijava前端框架
    P34Ajax介绍Ajax:AsynchroousJavaScriptAndXML，异步的JS和XMLJS网页动作，XML一种标记语言，存储数据，作用：数据交换：通过Ajax给服务器发送请求，并获取服务器响应的数据异步交互：在不重新加载整个页面的情况下，与服务器交换数据并实现更新部分网页的技术，例如：搜索联想、用户名是否可用的校验等等。同步与异步：同步：服务器在处理中客户端要处于等待状态，输入域名
  • 新注册的阿里云账号有哪些优惠？阿里云新用户必看优惠大合集 阿里云最新优惠和活动汇总
    很多用户看到阿里云各种活动中的云服务器、云数据库、企业邮箱等云产品都仅限新用户购买之后，都纷纷直接注册了阿里云新账号之后购买，其实，阿里云新用户不仅可以优惠购买活动中的各种云产品，还有很多优惠，下面是“阿里云最新优惠和活动汇总”整理汇总的阿里云新用户必看优惠大合集。新注册的阿里云账号在购买活动中的云产品之前，还有免费领云产品通用代金券、抽取无门槛代金券、免费试用云服务器和正式购买云服务器等阿里云产
  • 网络安全（黑客）——自学2024 小言同学喜欢挖漏洞 web安全安全网络学习网络安全信息安全渗透测试
    01什么是网络安全网络安全可以基于攻击和防御视角来分类，我们经常听到的“红队”、“渗透测试”等就是研究攻击技术，而“蓝队”、“安全运营”、“安全运维”则研究防御技术。无论网络、Web、移动、桌面、云等哪个领域，都有攻与防两面性，例如Web安全技术，既有Web渗透，也有Web防御技术（WAF）。作为一个合格的网络安全工程师，应该做到攻守兼备，毕竟知己知彼，才能百战百胜。02怎样规划网络安全如果你是一
  • 黑客（网络安全）技术自学30天 一个迷人的黑客 web安全安全网络笔记网络安全信息安全渗透测试
    01什么是网络安全网络安全可以基于攻击和防御视角来分类，我们经常听到的“红队”、“渗透测试”等就是研究攻击技术，而“蓝队”、“安全运营”、“安全运维”则研究防御技术。无论网络、Web、移动、桌面、云等哪个领域，都有攻与防两面性，例如Web安全技术，既有Web渗透，也有Web防御技术（WAF）。作为一个合格的网络安全工程师，应该做到攻守兼备，毕竟知己知彼，才能百战百胜。02怎样规划网络安全如果你是一
  • “播下种子，亲近梦想”北京研学营日记Day2 贝壳Bella
    到目前为止，没有收到同学们想家的反馈，应该没有孩子哭，从门外听到的也是一片安静，估计一个个都进入了梦想。从6:30至9:00回到酒店，的确有些辛苦。有些孩子坚持得很好，有些在下午五点离开科技馆时已经疲惫不堪，嚷嚷着回酒店。于是，餐后在车上立了一个规矩，明天在长城上喊累不能超过三次，因为这也是会传染的。图片发自App从科技馆步行至鸟巢，在等红绿灯时居然就有同学蹲下了。有些孩子一上车睡觉，养好精神，路
  • MyBatis高级面试题-2024 my_styles mybatisjava开发语言面试题
    MyBatis的核心组件有哪些？首先第一个是，SqlSessionFactory，它就像是一个会话工厂。它的任务是创建SqlSession对象，这个对象是我们与数据库交互的主要途径。SqlSessionFactory的作用很重要，因为它可以帮我们配置数据库连接信息和事务管理等。一旦这个工厂被建立起来，它就会加载一些必要的配置和映射文件，为后续的数据库操作提供一个可靠的基础。第二个是SqlSessi
  • 过去一年，这16本好书不容错过 m0_54050778 perl
    编者按：2023年在动荡与希望中收尾，2023年注定会被载入史册。疫情寒冬结束，ChatGPT横空出世，带动了人工智能技术的飞速发展；淄博烧烤、天津大爷、尔滨之旅等充满感动与幸福。但与此同时，2023年又是动荡与不安的一年，俄乌冲突的延宕，新一轮的巴以冲突，极端天气频发。在这个大环境下，有一些经典的书籍著作诞生。本文将分享2023年最值得一读的16本书籍，文章来自翻译，希望对你有所启示。关于202
  • PHP如何实现二维数组排序？ IT独行者 二维数组PHP排序　
    二维数组在PHP开发中经常遇到，但是他的排序就不如一维数组那样用内置函数来的方便了，（一维数组排序可以参考本站另一篇文章【PHP中数组排序函数详解汇总】）。二维数组的排序需要我们自己写函数处理了，这里UncleToo给大家分享一个PHP二维数组排序的函数： 代码： functionarray_sort($arr,$keys,$type='asc'){ $keysvalue= $new_arr
  • 【Hadoop十七】HDFS HA配置 bit1129 hadoop
    基于Zookeeper的HDFS HA配置主要涉及两个文件,core-site和hdfs-site.xml。   测试环境有三台 hadoop.master hadoop.slave1 hadoop.slave2   hadoop.master包含的组件NameNode, JournalNode, Zookeeper，DFSZKFailoverController
  • 由wsdl生成的java vo类不适合做普通java vo darrenzhu VOwsdlwebservicerpc
    开发java webservice项目时，如果我们通过SOAP协议来输入输出，我们会利用工具从wsdl文件生成webservice的client端类，但是这里面生成的java data model类却不适合做为项目中的普通java vo类来使用，当然有一中情况例外，如果这个自动生成的类里面的properties都是基本数据类型，就没问题，但是如果有集合类，就不行。原因如下： 1)使用了集合如Li
  • JAVA海量数据处理之二（BitMap） 周凡杨 java算法bitmapbitset数据
           路漫漫其修远兮，吾将上下而求索。想要更快，就要深入挖掘 JAVA 基础的数据结构，从来分析出所编写的 JAVA 代码为什么把内存耗尽，思考有什么办法可以节省内存呢？ 啊哈！算法。这里采用了 BitMap 思想。   首先来看一个实验： 指定 VM 参数大小： -Xms256m -Xmx540m
  • java类型与数据库类型 g21121 java
    很多时候我们用hibernate的时候往往并不是十分关心数据库类型和java类型的对应关心，因为大多数hbm文件是自动生成的，但有些时候诸如：数据库设计、没有生成工具、使用原始JDBC、使用mybatis(ibatIS)等等情况，就会手动的去对应数据库与java的数据类型关心，当然比较简单的数据类型即使配置错了也会很快发现问题，但有些数据类型却并不是十分常见，这就给程序员带来了很多麻烦。 &nb
  • Linux命令 510888780 linux命令
    系统信息 arch 显示机器的处理器架构(1) uname -m 显示机器的处理器架构(2) uname -r 显示正在使用的内核版本 dmidecode -q 显示硬件系统部件 - (SMBIOS / DMI) hdparm -i /dev/hda 罗列一个磁盘的架构特性 hdparm -tT /dev/sda 在磁盘上执行测试性读取操作 cat /proc/cpuinfo 显示C
  • java常用JVM参数 墙头上一根草 javajvm参数
    -Xms：初始堆大小，默认为物理内存的1/64(<1GB)；默认(MinHeapFreeRatio参数可以调整)空余堆内存小于40%时，JVM就会增大堆直到-Xmx的最大限制 -Xmx：最大堆大小，默认(MaxHeapFreeRatio参数可以调整)空余堆内存大于70%时，JVM会减少堆直到 -Xms的最小限制 -Xmn：新生代的内存空间大小，注意：此处的大小是（eden+ 2
  • 我的spring学习笔记9-Spring使用工厂方法实例化Bean的注意点 aijuans Spring 3
    方法一： <bean id="musicBox" class="onlyfun.caterpillar.factory.MusicBoxFactory" factory-method="createMusicBoxStatic"></bean> 方法二：
  • mysql查询性能优化之二 annan211 UNIONmysql查询优化索引优化
    1 union的限制 有时mysql无法将限制条件从外层下推到内层，这使得原本能够限制部分返回结果的条件无法应用到内层 查询的优化上。 如果希望union的各个子句能够根据limit只取部分结果集，或者希望能够先排好序在 合并结果集的话，就需要在union的各个子句中分别使用这些子句。 例如 想将两个子查询结果联合起来，然后再取前20条记录，那么mys
  • 数据的备份与恢复 百合不是茶 oraclesql数据恢复数据备份
     数据的备份与恢复的方式有: 表,方案 ,数据库;     数据的备份: 导出到的常见命令; 参数 说明 USERID 确定执行导出实用程序的用户名和口令 BUFFER 确定导出数据时所使用的缓冲区大小，其大小用字节表示 FILE 指定导出的二进制文
  • 线程组 bijian1013 java多线程threadjava多线程线程组
    有些程序包含了相当数量的线程。这时，如果按照线程的功能将他们分成不同的类别将很有用。        线程组可以用来同时对一组线程进行操作。        创建线程组：ThreadGroup g = new ThreadGroup(groupName);  &nbs
  • top命令找到占用CPU最高的java线程 bijian1013 javalinuxtop
    上次分析系统中占用CPU高的问题，得到一些使用Java自身调试工具的经验，与大家分享。 (1)使用top命令找出占用cpu最高的JAVA进程PID:28174 (2)如下命令找出占用cpu最高的线程 top -Hp 28174 -d 1 -n 1 32694 root 20 0 3249m 2.0g 11m S 2 6.4 3:31.12 java
  • 【持久化框架MyBatis3四】MyBatis3一对一关联查询 bit1129 Mybatis3
      当两个实体具有1对1的对应关系时，可以使用One-To-One的进行映射关联查询   One-To-One示例数据 以学生表Student和地址信息表为例，每个学生都有都有1个唯一的地址(现实中，这种对应关系是不合适的，因为人和地址是多对一的关系)，这里只是演示目的   学生表   CREATE TABLE STUDENTS (
  • C/C++图片或文件的读写 bitcarter 写图片
    先看代码： /*strTmpResult是文件或图片字符串 * filePath文件需要写入的地址或路径 */ int writeFile(std::string &strTmpResult,std::string &filePath) { int i,len = strTmpResult.length(); unsigned cha
  • nginx自定义指定加载配置 ronin47
    进入 /usr/local/nginx/conf/include 目录，创建 nginx.node.conf 文件，在里面输入如下代码： upstream nodejs { server 127.0.0.1:3000; #server 127.0.0.1:3001; keepalive 64; } server { liste
  • java-71-数值的整数次方.实现函数double Power(double base, int exponent)，求base的exponent次方 bylijinnan double
    public class Power { /** *Q71-数值的整数次方 *实现函数double Power(double base, int exponent)，求base的exponent次方。不需要考虑溢出。 */ private static boolean InvalidInput=false; public static void main(
  • Android四大组件的理解 Cb123456 android四大组件的理解
     分享一下，今天在Android开发文档-开发者指南中看到的:                            App components are the essential building blocks of an Android
  • [宇宙与计算]涡旋场计算与拓扑分析 comsci 计算
         怎么阐述我这个理论呢？ 。。。。。。。。。       首先： 宇宙是一个非线性的拓扑结构与涡旋轨道时空的统一体。。。。       我们要在宇宙中寻找到一个适合人类居住的行星，时间非常重要，早一个刻度和晚一个刻度，这颗行星的
  • 同一个Tomcat不同Web应用之间共享会话Session cwqcwqmax9 session
    实现两个WEB之间通过session 共享数据 查看tomcat 关于 HTTP Connector 中有个emptySessionPath 其解释如下： If set to true, all paths for session cookies will be set to /. This can be useful for portlet specification impleme
  • springmvc Spring3 MVC，ajax，乱码 dashuaifu springjquerymvcAjax
      springmvc Spring3 MVC @ResponseBody返回，jquery ajax调用中文乱码问题解决   Spring3.0 MVC @ResponseBody 的作用是把返回值直接写到HTTP response body里。具体实现AnnotationMethodHandlerAdapter类handleResponseBody方法，具体实
  • 搭建WAMP环境 dcj3sjt126com wamp
    这里先解释一下WAMP是什么意思。W:windows，A：Apache，M：MYSQL，P：PHP。也就是说本文说明的是在windows系统下搭建以apache做服务器、MYSQL为数据库的PHP开发环境。      工欲善其事，必须先利其器。因为笔者的系统是WinXP，所以下文指的系统均为此系统。笔者所使用的Apache版本为apache_2.2.11-
  • yii2 使用raw http request dcj3sjt126com http
    Parses a raw HTTP request using yii\helpers\Json::decode()   To enable parsing for JSON requests you can configure yii\web\Request::$parsers using this class: 'request' =&g
  • Quartz-1.8.6 理论部分 eksliang quartz
    转载请出自出处：http://eksliang.iteye.com/blog/2207691 一.概述 基于Quartz-1.8.6进行学习，因为Quartz2.0以后的API发生的非常大的变化，统一采用了build模式进行构建； 什么是quartz?   答：简单的说他是一个开源的java作业调度框架，为在 Java 应用程序中进行作业调度提供了简单却强大的机制。并且还能和Sp
  • 什么是POJO？ gupeng_ie javaPOJO框架Hibernate
    POJO--Plain Old Java Objects(简单的java对象)   POJO是一个简单的、正规Java对象，它不包含业务逻辑处理或持久化逻辑等，也不是JavaBean、EntityBean等，不具有任何特殊角色和不继承或不实现任何其它Java框架的类或接口。   POJO对象有时也被称为Data对象，大量应用于表现现实中的对象。如果项目中使用了Hiber
  • jQuery网站顶部定时折叠广告 ini JavaScripthtmljqueryWebcss
    效果体验：http://hovertree.com/texiao/jquery/4.htmHTML文件代码： <!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <title>网页顶部定时收起广告jQuery特效 - HoverTree<
  • Spring boot内嵌的tomcat启动失败 kane_xie spring boot
    根据这篇guide创建了一个简单的spring boot应用，能运行且成功的访问。但移植到现有项目（基于hbase）中的时候，却报出以下错误：     SEVERE: A child container failed during start java.util.concurrent.ExecutionException: org.apache.catalina.Lif
  • leetcode: sort list michelle_0916 Algorithmlinked listsort
    Sort a linked list in O(n log n) time using constant space complexity. ====analysis======= mergeSort for singly-linked list  ====code=======   /** * Definition for sin
  • nginx的安装与配置,中途遇到问题的解决 qifeifei nginx
    我使用的是ubuntu13.04系统，在安装nginx的时候遇到如下几个问题，然后找思路解决的，nginx 的下载与安装   wget http://nginx.org/download/nginx-1.0.11.tar.gz tar zxvf nginx-1.0.11.tar.gz ./configure make make install   安装的时候出现
  • 用枚举来处理java自定义异常 tcrct javaenumexception
    在系统开发过程中，总少不免要自己处理一些异常信息，然后将异常信息变成友好的提示返回到客户端的这样一个过程，之前都是new一个自定义的异常，当然这个所谓的自定义异常也是继承RuntimeException的，但这样往往会造成异常信息说明不一致的情况，所以就想到了用枚举来解决的办法。 1，先创建一个接口，里面有两个方法，一个是getCode, 一个是getMessage public
  • erlang supervisor分析 wudixiaotie erlang
    当我们给supervisor指定需要创建的子进程的时候，会指定M,F,A,如果是simple_one_for_one的策略的话，启动子进程的方式是supervisor:start_child(SupName, OtherArgs),这种方式可以根据调用者的需求传不同的参数给需要启动的子进程的方法。和最初的参数合并成一个数组，A ++ OtherArgs。那么这个时候就有个问题了，既然参数不一致，那
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他