流量地球
流量地球

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

  • element实现动态路由+面包屑 软件技术NINI vue案例vue.js前端
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
  • 微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务java架构
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
  • 学点心理知识，呵护孩子健康 静候花开_7090
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
  • 扫地机类清洁产品之直流无刷电机控制 悟空胆好小 清洁服务机器人单片机人工智能
    扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • 向内而求 陈陈_19b4
    10月27日，阴。阅读书目:《次第花开》。作者:希阿荣博堪布，是当今藏传佛家宁玛派最伟大的上师法王，如意宝晋美彭措仁波切颇具影响力的弟子之一。多年以来，赴海内外各地弘扬佛法，以正式授课、现场开示、发表文章等多种方法指导佛学弟子修行佛法。代表作《寂静之道》、《生命这出戏》、《透过佛法看世界》自出版以来一直是佛教类书籍中的畅销书。图片发自App金句:1.佛陀说，一切痛苦的根源在于我们长期以来对自身及外
  • 消息中间件有哪些常见类型 xmh-sxh-1314 java
    消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
  • 高级编程--XML+socket练习题 masa010 java开发语言
    1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
  • 《大清方方案》| 第二话 谁佐清欢
    和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
  • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
  • C#中使用split分割字符串 互联网打工人no1 c#
    1、用字符串分隔：usingSystem.Text.RegularExpressions;stringstr="aaajsbbbjsccc";string[]sArray=Regex.Split(str,"js",RegexOptions.IgnoreCase);foreach(stringiinsArray)Response.Write(i.ToString()+"");输出结果：aaabbbc
  • 怎么起诉借钱不还的人？怎样起诉欠款不还的人？ 影子爱学习
    怎么起诉借钱不还的人？怎样起诉欠款不还的人？如果遇到难以解决的法律问题，我们可以匹配专业律师。例如：婚姻家庭（离婚纠纷）、刑事辩护、合同纠纷、债权债务、房产（继承）纠纷、交通事故、劳动争议、人身损害、公司相关法律事务（法律顾问）等咨询推荐手机/微信:15633770876【全国案件皆可】借钱不还起诉对方需要哪些资料起诉欠钱不还的，一般需要的材料包括以下这些：借据、收据、欠条、付款凭证等证据，以及向
  • 相信相信的力量 孙丽_cdb3
    孙丽中级十期坚持分享第345天有一个特别有哲理的故事：有一只老鹰下了蛋，这个蛋，不知怎的就滚到了鸡窝里去了，鸡也下了一窝蛋，然后鸡妈妈把这些蛋全都浮出来了，孵出来之后等小鸡长大一点了，就觉得鹰蛋孵出来的那只小鹰怪模怪样，这些小鸡都嘲笑它，真难看，真笨，丑死了，那只小鹰觉得自己真是谁也不像，真是不好看，后来鸡妈妈也不喜欢他，我怎么生出你这样的孩子来了？真烦人，后来这群小鸡和小鹰一起生活，有一天，老鹰
  • 将cmd中命令输出保存为txt文本文件 落难Coder Windowscmdwindow
    最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
  • 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器） 编程经验分享 开发工具服务器sshlinux
    目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
  • 春季养肝正当时 dxn悟
    重温快乐2023年2月4日立春。春天来了，春暖花开，小鸟欢唱，那在这样的季节我们如何养肝呢？自然界的春季对应中医五行的木，人体五脏肝属木，“木曰曲直”，是以树干曲曲直直地向上、向外伸长舒展的生发姿态，来形容具有生长、升发、条达、舒畅等特征的食物及现象。根据中医天人相应的理念，肝五行属木，喜条达，主疏泄，与春天相应，所以春天最适合养肝。养肝首先要少生气，因为肝喜条达恶抑郁。人体五志肝为怒，生气发怒最
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业javascripthtmlcss旅游风景
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
  • 人工智能时代，程序员如何保持核心竞争力？ jmoych 人工智能
    随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
  • 每日算法&面试题，大厂特训二十八天——第二十天（树） 肥学 ⚡算法题⚡面试题每日精进java算法数据结构
    目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
  • 2022现在哪个打车软件比较好用又便宜 实惠的打车软件合集 高省APP珊珊
    这是一个信息高速传播的社会。信息可以通过手机，微信，自媒体，抖音等方式进行传播。但同时这也是一个交通四通发达的社会。高省APP，是2022年推出的平台，0投资，0风险、高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，也期待你的加入。珊珊导师，高省邀请码777777，注册送2皇冠会员，送万元推广大礼包，教你如何1年做到百万团队。高
  • webpack图片等资源的处理 dmengmeng
    需要的loaderfile-loader（让我们可以引入这些资源文件）url-loader（其实是file-loader的二次封装）img-loader（处理图片所需要的）在没有使用任何处理图片的loader之前，比如说css中用到了背景图片，那么最后打包会报错的，因为他没办法处理图片。其实你只想能够使用图片的话。只加一个file-loader就可以，打开网页能准确看到图片。{test:/\.(p
  • 走向以教育叙事为载体的教育叙事研究 666小飞鱼
    今天我读了吴松超老师的《给教师的68条建写作建议》中的第23条《如何通过教育叙事走向研究》，吴老师在文中与我们分享了一个德育案例，这是一个反面的案例，意在告知我们在处理问题时，不能就考虑的点太窄，思考要全面。走向教育叙事研究，教师要有敏锐的“感知力”，这个感知力来自于背后专业知识的支撑，思维能力以及广阔的视野和见识等。所以对于同一件事处理方法不同，这个就是教师背后“敏锐力”的不同造成的，也就是说是
  • CX8903：Ebike自行车仪表电源方案开发,Ebike智能仪表电源芯片 诚芯微科技 社交电子
    CX8903：电动Ebike自行车仪表电源方案开发,Ebike智能仪表电源芯片推荐。电动助力自行车EBIKE凭借其环保、健康、低噪、和便捷等特点，成为了越来越受欢迎的骑行便利交通工具。提供电动Ebike自行车仪表电源方案开发、E-BIKE电动助力自行车仪表供电电源解决方案。CX8903采用100V高压制造工艺（芯片最高耐压可到100V以上），SOP-8L贴片封装，CX8903内置100V/90mΩ
  • CX8836：小体积大功率升降压方案推荐（附Demo设计指南） 诚芯微科技 社交电子
    CX8836是一颗同步四开关单向升降压控制器，在4.5V-40V宽输入电压范围内稳定工作，持续负载电流10A，能够在输入高于或低于输出电压时稳定调节输出电压，可适用于USBPD快充、车载充电器、HUB、汽车启停系统、工业PC电源等多种升降压应用场合，为大功率TYPE-CPD车载充电器提供最优解决方案。提供CX8836Demo测试、CX8836样品申请及CX8836方案开发技术支持。CX8836同升
  • 穷人做什么生意最赚钱？10个适合穷人赚钱的路子？ 氧惠爱高省
    不管在什么地方，一般都是穷人占大量数，而富人只有少数，但是它们却掌握着大量的财富。对于穷人来说，想要买车、买房等奢侈品就难如登天，因为他们只能通过打工来赚取几千元的月薪。➤推荐网购返利app“氧惠”，一个领隐藏优惠券+现金返利的平台。氧惠只提供领券返利链接，下单全程都在淘宝、京东、拼多多等原平台，更支持抖音、快手电商、外卖红包返利等。（应用市场搜“氧惠”下载，邀请码:521521，全网优惠上氧惠！
  • 高级 ECharts 技巧：自定义图表主题与样式 SnowMan1993 echarts信息可视化数据分析
    ECharts是一个强大的数据可视化库，提供了多种内置主题和样式，但你也可以根据项目的设计需求，自定义图表的主题与样式。本文将介绍如何使用ECharts自定义图表主题，以提升数据可视化的吸引力和一致性。1.什么是ECharts主题？ECharts的主题是指定义图表样式的配置项，包括颜色、字体、线条样式等。通过预设主题，你可以快速更改图表的整体风格，而自定义主题则允许你在此基础上进行个性化设置。2.
  • Low Power概念介绍-Voltage Area 飞奔的大虎
    随着智能手机，以及物联网的普及，芯片功耗的问题最近几年得到了越来越多的重视。为了实现集成电路的低功耗设计目标，我们需要在系统设计阶段就采用低功耗设计的方案。而且，随着设计流程的逐步推进，到了芯片后端设计阶段，降低芯片功耗的方法已经很少了，节省的功耗百分比也不断下降。芯片的功耗主要由静态功耗（staticleakagepower）和动态功耗(dynamicpower)构成。静态功耗主要是指电路处于等
  • Rust基础知识 GRKF15 rust开发语言后端
    1.Rust语言简介1.1基础语法变量声明：let关键字用于声明变量，可以指定或不指定类型，如leta=10;和letmutc=30i32;。函数定义：使用fn关键字定义函数，并指定参数类型及返回类型，如fnadd(i:i32,j:i32)->i32{i+j}。控制流：包括if、else等，控制语句后需要使用;来结束语句。1.2数据类型整数类型：i8、i16、i32、i64、i128，以及无符号的
  • 直返的东西正品吗?直返APP安全吗?直返是正规平台吗? 氧惠购物达人
    亲们，你们是不是经常在直返APP上买东西呀？但是，你们有没有想过，里面的东西到底是不是正品呢？这个APP安全吗？它是不是一个正规的平台呀？别着急，今天我就来给大家揭秘一下！氧惠APP（带货领导者）——是与以往完全不同的抖客+淘客app！2023全新模式，我的直推也会放到你下面。主打：带货高补贴，深受各位带货团队长喜爱（每天出单带货几十万单）。注册即可享受高补贴+0撸+捡漏等带货新体验。送万元推广大
  • 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其他