效率提升利器，一个全龄段友好的DotNET万能工具库

1
float load = SystemInfo.CpuLoad;// 获取CPU占用率
2
long physicalMemory = SystemInfo.PhysicalMemory;// 获取物理内存总数
3
long memoryAvailable = SystemInfo.MemoryAvailable;// 获取物理内存可用率
4
double freePhysicalMemory = SystemInfo.GetFreePhysicalMemory();// 获取可用物理内存
5
double temperature = SystemInfo.GetCPUTemperature();// 获取CPU温度
6
int cpuCount = SystemInfo.GetCpuCount();// 获取CPU核心数
7
var ipAddress = SystemInfo.GetLocalIPs();// 获取本机所有IP地址
8
string localUsedIp = SystemInfo.GetLocalUsedIP();// 获取本机当前正在使用的IP地址
9
IList<string> macAddress = SystemInfo.GetMacAddress();// 获取本机所有网卡mac地址
10
string osVersion = Windows.GetOsVersion();// 获取操作系统版本
11
RamInfo ramInfo = SystemInfo.GetRamInfo();// 获取内存信息
12
var cpuSN=SystemInfo.GetCpuInfo()[0].SerialNumber; // CPU序列号
13
var driveSN=SystemInfo.GetDiskInfo()[0].SerialNumber; // 硬盘序列号
14

15
// 快速方法
16
var cpuInfos = CpuInfo.Locals; // 快速获取CPU的信息
17
var ramInfo = RamInfo.Local; // 快速获取内存的信息
18
var diskInfos = DiskInfo.Locals; // 快速获取硬盘的信息
19
var biosInfo = BiosInfo.Local; // 快速获取主板的信息

1
using System;
2
using System.Collections.Generic;
3
using System.Linq.Expressions;
4

5
namespace Masuit.Tools.Linq;
6

7
/// <summary>
8
/// LINQ扩展方法
9
/// </summary>
10
public static class LinqExtension
11
{
12
    /// <summary>
13
    /// 与连接
14
    /// </summary>
15
    /// <typeparam name="T">类型</typeparam>
16
    /// <param name="left">左条件</param>
17
    /// <param name="right">右条件</param>
18
    /// <returns>新表达式</returns>
19
    public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> left, Expression<Func<T, bool>> right)
20
    {
21
        return CombineLambdas(left, right, ExpressionType.AndAlso);
22
    }
23

24
    /// <summary>
25
    /// 与连接
26
    /// </summary>
27
    /// <typeparam name="T">类型</typeparam>
28
    /// <param name="left">左条件</param>
29
    /// <param name="condition">符合什么条件</param>
30
    /// <param name="right">右条件</param>
31
    /// <returns>新表达式</returns>
32
    public static Expression<Func<T, bool>> AndIf<T>(this Expression<Func<T, bool>> left, bool condition, Expression<Func<T, bool>> right)
33
    {
34
        return condition ? CombineLambdas(left, right, ExpressionType.AndAlso) : left;
35
    }
36

37
    /// <summary>
38
    /// 与连接
39
    /// </summary>
40
    /// <typeparam name="T">类型</typeparam>
41
    /// <param name="left">左条件</param>
42
    /// <param name="condition">符合什么条件</param>
43
    /// <param name="right">右条件</param>
44
    /// <returns>新表达式</returns>
45
    public static Expression<Func<T, bool>> AndIf<T>(this Expression<Func<T, bool>> left, Func<bool> condition, Expression<Func<T, bool>> right)
46
    {
47
        return condition() ? CombineLambdas(left, right, ExpressionType.AndAlso) : left;
48
    }
49

50
    /// <summary>
51
    /// 或连接
52
    /// </summary>
53
    /// <typeparam name="T">类型</typeparam>
54
    /// <param name="left">左条件</param>
55
    /// <param name="right">右条件</param>
56
    /// <returns>新表达式</returns>
57
    public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> left, Expression<Func<T, bool>> right)
58
    {
59
        return CombineLambdas(left, right, ExpressionType.OrElse);
60
    }
61

62
    /// <summary>
63
    /// 或连接
64
    /// </summary>
65
    /// <typeparam name="T">类型</typeparam>
66
    /// <param name="left">左条件</param>
67
    /// <param name="condition">符合什么条件</param>
68
    /// <param name="right">右条件</param>
69
    /// <returns>新表达式</returns>
70
    public static Expression<Func<T, bool>> OrIf<T>(this Expression<Func<T, bool>> left, bool condition, Expression<Func<T, bool>> right)
71
    {
72
        return condition ? CombineLambdas(left, right, ExpressionType.OrElse) : left;
73
    }
74

75
    /// <summary>
76
    /// 或连接
77
    /// </summary>
78
    /// <typeparam name="T">类型</typeparam>
79
    /// <param name="left">左条件</param>
80
    /// <param name="condition">符合什么条件</param>
81
    /// <param name="right">右条件</param>
82
    /// <returns>新表达式</returns>
83
    public static Expression<Func<T, bool>> OrIf<T>(this Expression<Func<T, bool>> left, Func<bool> condition, Expression<Func<T, bool>> right)
84
    {
85
        return condition() ? CombineLambdas(left, right, ExpressionType.OrElse) : left;
86
    }
87

88
    private static Expression<Func<T, bool>> CombineLambdas<T>(this Expression<Func<T, bool>> left, Expression<Func<T, bool>> right, ExpressionType expressionType)
89
    {
90
        var visitor = new SubstituteParameterVisitor
91
        {
92
            Sub =
93
            {
94
                [right.Parameters[0]] = left.Parameters[0]
95
            }
96
        };
97

98
        Expression body = Expression.MakeBinary(expressionType, left.Body, visitor.Visit(right.Body));
99
        return Expression.Lambda<Func<T, bool>>(body, left.Parameters[0]);
100
    }
101
}
102

103
internal class SubstituteParameterVisitor : ExpressionVisitor
104
{
105
    public Dictionary<Expression, Expression> Sub = new();
106

107
    protected override Expression VisitParameter(ParameterExpression node)
108
    {
109
        return Sub.TryGetValue(node, out var newValue) ? newValue : node;
110
    }
111
}