该项目的上篇文章是：关于SI9000计算阻抗接口的研究；
上篇讲解了Si9000的接口调用，可以被任何高级编程语言使用，如上篇文章中的Python；
本篇发布前，本人也使用Python写了6个常见的模型，包括正算、反算，但由于Python的UI方面没有过多的知识储备，
导致Python始终是使用命令行终端来呈现的... 总之难用就对了，而且终端的话无法做到批量的数据正算、反算；
这里也放出Python的GitHub项目地址：Auto_Si9000_Py，仅供学习参考；
以上这就是我转换到.NET C# WPF编写的原因；

Auto_Si9000 功能

1、支持常见的8个阻抗模型：
外层单线不对地,外层单线对地,
内层单线不对地,内层单线对地,
外层双线不对地,外层双线对地,
内层双线不对地,内层双线对地；

2、支持批量阻抗的正算、反算；

3、支持生成原生的Si9000软件界面的预览图，并支持复制到剪贴板；
预览图中还圈出了重要的数据，如线宽、线距、对地数据，用于EQ的建议；

软件截图

程序主界面：

预览界面：

支持复制到剪贴板：

项目地址

https://github.com/XiaM-Admin/Auto_Si9000_WPF
如果帮助到你，可以点一个小小的Star哦~

1. 开发过程是在Debug模式下写的，需要与服务器对接一个指定的调试指令，才能正常调试。
2. 但是在发布时，需要手动将指令接口换成用户使用环境,切换至Release环境编译生产软件才可。
3. 这就导致，如果说，忘记了自己切换，这就影响了用户体验。

那么怎么改成自动？
我需要使用编译预处理指令#if等操作，
如下：

#if DEBUG
    Console.WriteLine("Debug模式");//调试环境
#else
    Console.WriteLine("Release模式");//生产发布环境
#endif

这就能做到在切换发布环境时，编译器自动编译相应的代码了。

本篇文章采用第三方开源库openhardwaremonitor来辅助编写查询信息，并且网上大多都是采用这种方式监控硬件信息。
常用的硬件信息有：温度、时钟频率、电压、内存占用、存储空间占用、网络传输状态···
这里仅获取到CPU温度以及GPU温度，其他查询方式类似，自己琢磨...

一.下载第三方库

下载方式：

1. 项目开源地址：https://github.com/hexagon-oss/openhardwaremonitor，自己去releases中下载最新版本
   并且自己编译好后，找到生成文件夹中的OpenHardwareMonitorLib.dll，我们就使用它！
2. 这里提供文章的第三方dll文件OpenHardwareMonitorLib.rar，解压打开即可(Ver：0.9.7.11)

二.引用dll文件

1. 如图打开项目 - 右键引用 - 添加引用
   
2. 点击"浏览" - 选中下载解压好的dll文件即可。

三.使用

1. 这里首先引用命名空间

   using OpenHardwareMonitor.Hardware;
   using System;

2. 然后复制粘贴下面的类

    public class UpdateVisitor : IVisitor
    {
        public void VisitComputer(IComputer computer)
        {
            computer.Traverse(this);
        }
   
        public void VisitHardware(IHardware hardware)
        {
            hardware.Update();
            foreach (IHardware subHardware in hardware.SubHardware)
                subHardware.Accept(this);
        }
   
        public void VisitSensor(ISensor sensor) { }
   
        public void VisitParameter(IParameter parameter) { }
    }
   
    public class ComputerCore
    {
        private UpdateVisitor updateVisitor = new UpdateVisitor();
        private Computer computer = new Computer();
   
        public ComputerCore()
        {
            computer.Open();
            computer.CPUEnabled = true;//开启CPU信息监控
            computer.GPUEnabled = true;//开启GPU信息监控
            computer.Accept(updateVisitor);
        }
   
        /// <summary>
        /// 获取CPU温度
        /// </summary>
        /// <returns></returns>
        public float GetCpuTemp()
        {
            computer.Accept(updateVisitor);
            float num = 0;
            float cc = 0;
            float avg = 0;
            for (int i = 0; i < computer.Hardware.Length; i++)
            {
                //查找硬件类型为CPU
                if (computer.Hardware[i].HardwareType == HardwareType.CPU)
                {
                    for (int j = 0; j < computer.Hardware[i].Sensors.Length; j++)
                    {
                        //找到温度传感器
                        if (computer.Hardware[i].Sensors[j].SensorType == SensorType.Temperature)
                        {
                            if (computer.Hardware[i].Sensors[j].Value is null)
                                continue;
   
                            num += (float)computer.Hardware[i].Sensors[j].Value;
                            if((float)computer.Hardware[i].Sensors[j].Value!=0)
                                cc++;
                            avg = num / cc;
                        }
                    }
                }
            }
            return avg;
        }
   
        /// <summary>
        /// 获取GPU温度
        /// </summary>
        /// <param name="isNva">是不是英伟达GPU</param>
        /// <returns></returns>
        public float GetGpuTemp(bool isNva = true)
        {
            computer.Accept(updateVisitor);
            HardwareType type = isNva ? HardwareType.GpuNvidia : HardwareType.GpuAti;
   
            for (int i = 0; i < computer.Hardware.Length; i++)
            {
                //查找硬件类型为CPU
                if (computer.Hardware[i].HardwareType == type)
                {
                    for (int j = 0; j < computer.Hardware[i].Sensors.Length; j++)
                    {
                        //找到温度传感器
                        if (computer.Hardware[i].Sensors[j].SensorType == SensorType.Temperature)
                        {
                            if (computer.Hardware[i].Sensors[j].Value is null)
                                continue;
   
                            return (float)computer.Hardware[i].Sensors[j].Value;
                        }
                    }
                }
            }
            return 0;
        }
   
    }
   

3. 调用即可
   实例化：public ComputerCore CCore= new ComputerCore();
   CPU温度：CCore.GetCpuTemp()
   GPU温度：CCore.GetGpuTemp()(英伟达显卡) - CCore.GetGpuTemp(false)(非英伟达显卡)

注意

• 项目框架的Framework 版本要求 4.8
• 引用后直接使用会出错，这里需要下载一个NuGet包
  
  作者使用的就是5.0.0版本，我也就没找事，用最新版。可自行测试。
• CPU温度因为有很多内核 每个内核温度不一样，所以我取了平均值。

热键即快捷键，就是键盘上某几个特殊键组合起来完成一项特定任务。笔记本电脑上最常见的热键组合即Fn键加其他键(能够与Fn进行组合使用的键多被用特殊颜色标记，并以图示或文字显示其功能在键帽上)的组合，可被用来设定系统参数，如扬声器音量。

现在很多程序都离不开快捷键，只需要按下某组合键，就能触发一些事件，如window中的复制粘贴键，只用Ctrl+C、V就可以快捷操作，不需要右键再复制粘贴。
快捷键会让程序使用更‘快捷’、‘方便’

C# HotKey类

public class Hotkey
{
    #region 系统api
    [DllImport("user32.dll")]
    [return: MarshalAs(UnmanagedType.Bool)]
    static extern bool RegisterHotKey(IntPtr hWnd, int id, HotkeyModifiers fsModifiers, Keys vk);

    [DllImport("user32.dll")]
    static extern bool UnregisterHotKey(IntPtr hWnd, int id);
    #endregion

    /// <summary> 
    /// 注册快捷键 
    /// </summary> 
    /// <param name="hWnd">持有快捷键窗口的句柄</param> 
    /// <param name="fsModifiers">组合键</param> 
    /// <param name="vk">快捷键的虚拟键码</param> 
    /// <param name="callBack">回调函数</param> 
    public static void Regist(IntPtr hWnd, HotkeyModifiers fsModifiers, Keys vk, HotKeyCallBackHanlder callBack)
    {
        int id = keyid++;
        if (!RegisterHotKey(hWnd, id, fsModifiers, vk))
            throw new Exception("regist hotkey fail.");
        keymap[id] = callBack;
    }

    /// <summary> 
    /// 注销快捷键 
    /// </summary> 
    /// <param name="hWnd">持有快捷键窗口的句柄</param> 
    /// <param name="callBack">回调函数</param> 
    public static void UnRegist(IntPtr hWnd, HotKeyCallBackHanlder callBack)
    {
        foreach (KeyValuePair<int, HotKeyCallBackHanlder> var in keymap)
        {
            if (var.Value == callBack)
                UnregisterHotKey(hWnd, var.Key);
        }
    }

    /// <summary> 
    /// 快捷键消息处理 
    /// </summary> 
    public static void ProcessHotKey(Message m)
    {
        if (m.Msg == WM_HOTKEY)
        {
            int id = m.WParam.ToInt32();
            HotKeyCallBackHanlder callback;
            if (keymap.TryGetValue(id, out callback))
            {
                callback();
            }
        }
    }

    const int WM_HOTKEY = 0x312;
    static int keyid = 10;
    static Dictionary<int, HotKeyCallBackHanlder> keymap = new Dictionary<int, HotKeyCallBackHanlder>();

    public delegate void HotKeyCallBackHanlder();
}
public enum HotkeyModifiers
{
    MOD_ALT = 0x1,
    MOD_CONTROL = 0x2,
    MOD_SHIFT = 0x4,
    MOD_WIN = 0x8
}

百度一搜就有...

如何使用

因为CSharp没有直接的提供热键绑定等操作，所以上面类简单封装了一下Windows系统中user32库的热键api。

[DllImport("user32.dll")]
[return: MarshalAs(UnmanagedType.Bool)]
static extern bool RegisterHotKey(IntPtr hWnd, int id, HotkeyModifiers fsModifiers, Keys vk);

[DllImport("user32.dll")]
static extern bool UnregisterHotKey(IntPtr hWnd, int id);

所以，注册完之后，只要保证程序正常运行，就可以全局触发热键绑定的回调函数。

使用步骤：

1. 重构消息处理函数

   /// <summary>
   /// 重构消息处理
   /// </summary>
   /// <param name="m"></param>
   protected override void WndProc(ref Message m)
   {
    base.WndProc(ref m);
    Hotkey.ProcessHotKey(m);
   }

2. 写一个测试回调函数

   void test(){
    MessageBox.Show("Test");
   }

3. 调用注册热键方法

   Hotkey.Regist(this.Handle, HotkeyModifiers.MOD_ALT, Keys.X, Test);

   这里注册的热键为"Alt + X"键

4. 注销热键方法

   Hotkey.UnRegist(this.Handle, Test);

• 需要注意的是：此回调函数的内存地址不能改变，不能使用lamda表达式，否则不能注销热键！

• 命名空间：using System.Diagnostics;
• 类名：Stopwatch stopwatch = new Stopwatch();

代码：

Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();                            //开始计时
//
// 放入耗时操作 
//
stopwatch.Stop();                             //结束计时
Console.WriteLine(stopwatch.Elapsed);

使用场景

1. 程序初始化用时统计优化
2. 算法用时统计优化
3. 网络请求用时统计 api优化

利用进程监听事件值守进程😘

记录自UP：B站知识就是暴力

步骤

1. 首先获取进程的信息
2. 开启进程的事件接受
3. 绑定进程退出后执行的事件
4. 完成

事件说明

• 如果检测到程序退出了，那么新建一个相同进程
• 并且开启事件接受，绑定当前事件
• 就做到了一个进程守护的功能

WMI 监视进程😘

是用于管理基于Windows操作系统的数据和操作的基础结构。

想法来自：知识就是暴力i

微软介绍文档

使用步骤

1. 引用包 using System.Management;
2. 创建查询对象，wql的事件查询，参1：事件名 参2：查询间隔 参3：条件语句

3. new 事件监听对象

4. 注册事件

5. 开始异步侦听

描述

简单描述一下问题：
使用C#发送POST请求给宝塔邮局发邮件的api时，出现错误代码500,
在ApiPost6、Python官方示例中，请求可以正确发送，返回200。

正常的POST代码

public static string ApiPost(string url, Dictionary<string, string> parameters)
{
    try
    {
        Encoding charset = Encoding.UTF8;
    
        HttpWebRequest request = null;
        //HTTPSQ请求
        ServicePointManager.ServerCertificateValidationCallback = CheckValidationResult;
        request = (HttpWebRequest)WebRequest.Create(url.Trim());
        request.Method = "POST";
        request.ContentType = "application/x-www-form-urlencoded";

        //如果需要POST数据
        if (!(parameters == null || parameters.Count == 0))
        {
            var buffer = new StringBuilder();
            foreach (var key in parameters.Keys)
            {
                string str = System.Web.HttpUtility.UrlEncode(parameters[key]);
                buffer.AppendFormat(buffer.Length > 0 ? "&{0}={1}" : "{0}={1}", key, str);
            }
        
            byte[] data = charset.GetBytes(buffer.ToString());
            request.ContentLength = data.Length;
            request.GetRequestStream().Write(data, 0, data.Length);
        }
        HttpWebResponse response;
        try
        {
            response = (HttpWebResponse)request.GetResponse();
        }
        catch (WebException ex)
        {
            response = (HttpWebResponse)ex.Response;
        }
        Stream htmlStream = response.GetResponseStream();
        StreamReader sr = new StreamReader(htmlStream, Encoding.UTF8);
        var html = sr.ReadToEnd();
        return html;
    }
    catch (Exception e)
    {
        Console.WriteLine($"api:{url} 异常：{e.Message}");
        return null;
    }
}

分析

使用Fiddler抓包工具，抓取正常200和错误500的，进行比较，发现
C#在POST请求是自动加上了request.Expect这个表头的属性，我们只需要把它去掉就行，
去掉后有几率会发送请求失败，需要加入一个错误重试，就能增大请求成功几率。

修改过后的代码

此代码即可正常请求宝塔邮局发邮件的api

public static string ApiPost(string url, Dictionary<string, string> parameters)
{
    //重试3次
    int recount = 0;
    while(recount < 3)
        try
        {
            Encoding charset = Encoding.UTF8;
        
            HttpWebRequest request = null;
            //HTTPSQ请求
            ServicePointManager.ServerCertificateValidationCallback = CheckValidationResult;
            request = (HttpWebRequest)WebRequest.Create(url.Trim());
            request.Method = "POST";
            request.ContentType = "application/x-www-form-urlencoded";
            request.UserAgent = DefaultUserAgent;
            request.Accept = "*/*";
            request.Expect = null;
            //如果需要POST数据
            if (!(parameters == null || parameters.Count == 0))
            {
                var buffer = new StringBuilder();
                foreach (var key in parameters.Keys)
                {
                    string str = System.Web.HttpUtility.UrlEncode(parameters[key]);
                    buffer.AppendFormat(buffer.Length > 0 ? "&{0}={1}" : "{0}={1}", key, str);
                }
            
                byte[] data = charset.GetBytes(buffer.ToString());
                request.ContentLength = data.Length;
                request.GetRequestStream().Write(data, 0, data.Length);
            }
            HttpWebResponse response;
            try
            {
                response = (HttpWebResponse)request.GetResponse();
            }
            catch (WebException ex)
            {
                response = (HttpWebResponse)ex.Response;
                recount++;
                continue;
            }
            Stream htmlStream = response.GetResponseStream();
            StreamReader sr = new StreamReader(htmlStream, Encoding.UTF8);
            var html = sr.ReadToEnd();
            return html;
        }
        catch (Exception e)
        {
            Console.WriteLine($"api:{url} 异常：{e.Message}");
            recount++;
            continue;
        }
    return null;
}

委托（Delegate）

委托（Delegate）就是一个引用变量，

委托（Delegate）特别用于实现事件和回调方法。

声明委托

// 一个参数一个返回值的委托声明
public delegate int MyDelegate (string s);
//无返回值 一个object参数的委托声明
public delegate void MyDelegate (object s);

上例子声明了一个，一个参数一个返回值的委托函数。

声明形式：

delegate <return type> <delegate-name> <parameter list>

实例化委托

委托必须使用 new 关键字来创建，并且new 的构造函数中，必须有一个特定的方法，其方法的形参返回值与委托声明相同，如：

public delegate void printString(string s);
...
printString ps1 = new printString(WriteToScreen);
printString ps2 = new printString(WriteToFile);

上面的实例化的ps1 和 ps2 ，可以当做函数来调用。

委托的多播

一个委托对象，可以使用 + 来绑定多个委托实例，所有委托实例参数必须相同，同样，也可以使用-来解除绑定。

绑定过后，使用委托对象使用，函数方法调用队列，是和绑定顺序相同的执行方式，通过+来绑定的实例委托是一个调用列表。这被称为委托的 多播（multicasting），也叫组播。

using System;

delegate int NumberChanger(int n);
namespace DelegateAppl
{
   class TestDelegate
   {
      static int num = 10;
      public static int AddNum(int p)
      {
         num += p;
         return num;
      }

      public static int MultNum(int q)
      {
         num *= q;
         return num;
      }
      public static int getNum()
      {
         return num;
      }

      static void Main(string[] args)
      {
         // 创建委托实例
         NumberChanger nc;
         NumberChanger nc1 = new NumberChanger(AddNum);
         NumberChanger nc2 = new NumberChanger(MultNum);
         nc = nc1;
         nc += nc2;
         // 调用多播
         nc(5);
         Console.WriteLine("Value of Num: {0}", getNum());
         Console.ReadKey();
      }
   }
}

委托用途

using System;
using System.IO;

namespace DelegateAppl
{
   class PrintString
   {
      static FileStream fs;
      static StreamWriter sw;
      // 委托声明
      public delegate void printString(string s);

      // 该方法打印到控制台
      public static void WriteToScreen(string str)
      {
         Console.WriteLine("The String is: {0}", str);
      }
      // 该方法打印到文件
      public static void WriteToFile(string s)
      {
         fs = new FileStream("c:\\message.txt", FileMode.Append, FileAccess.Write);
         sw = new StreamWriter(fs);
         sw.WriteLine(s);
         sw.Flush();
         sw.Close();
         fs.Close();
      }
      // 该方法把委托作为参数，并使用它调用方法
      public static void sendString(printString ps)
      {
         ps("Hello World");
      }
      static void Main(string[] args)
      {
         printString ps1 = new printString(WriteToScreen);
         printString ps2 = new printString(WriteToFile);
         sendString(ps1);
         sendString(ps2);
         Console.ReadKey();
      }
   }
}

下面的实例演示了委托的用法。委托 printString 可用于引用带有一个字符串作为输入的方法，并不返回任何东西。

我们使用这个委托来调用两个方法，第一个把字符串打印到控制台，第二个把字符串打印到文件。