• C# 常用功能整合-1

    -目录

    线程

    MD5加密

    计算两个时间间隔

    数组等比例缩放

    时间加减

    字符串转换DateTime类型

    Net5添加管理员权限 以管理员身份运行

    Task执行任务，等待任务完成

    用“\”分割字符

    实现模拟键盘按键

    代码运行耗时

    通过反射获取和设置指定的属性

    特性玩法1

    泛型玩法2

    泛型

    线程

    在运用多线程技术之前，先得理解什么是线程。
    那什么是线程呢？说到线程就不得不先说说进程。通俗的来讲，进程就是个应程序开始运行，那么这个应用程序就会存在一个属于这个应用程序的进程。
    那么线程就是进程中的基本执行单元，每个进程中都至少存在着一个线程，这个线程是根据进程创建而创建的，所以这个线程我们称之为主线程。
    那么多线程就是包含有除了主线程之外的其他线程。
    如果一个线程可以执一个任务，那么多线程就是可以同时执行多个任务。
     

    线程的基本用法：

    1.  
    2. using System;
    3. using System.Collections.Generic;
    4. using System.ComponentModel;
    5. using System.Data;
    6. using System.Drawing;
    7. using System.Linq;
    8. using System.Text;
    9. using System.Threading;
    10. using System.Threading.Tasks;
    11. using System.Windows.Forms;
    12.  
    13. namespace 线程
    14. {
    15.     public partial class Form1 : Form
    16.     {
    17.         private List ThreadPool = new List();
    18.  
    19.         public Form1()
    20.         {
    21.             InitializeComponent();
    22.         }
    23.  
    24.         private void Form1_Load(object sender, EventArgs e)
    25.         {
    26.             Thread thread = new Thread(TestThread);
    27.             ThreadPool.Add(thread);
    28.             thread.Start();
    29.         }
    30.  
    31.         private void Form1_FormClosing(object sender, FormClosingEventArgs e)
    32.         {
    33.             if(ThreadPool.Count > 0)
    34.             {
    35.                 foreach (Thread thread in ThreadPool)
    36.                 {
    37.                     if (thread.IsAlive)//当前线程是否终止
    38.                     {
    39.                         thread.Abort();//终止线程
    40.                     }
    41.                 }
    42.             }
    43.         }
    44.  
    45.         private void TestThread()
    46.         {
    47.             for (int i = 0; i <= 10; i++)
    48.             {
    49.                 Console.WriteLine("输出：" + i);
    50.                 Thread.Sleep(500);
    51.             }
    52.         }
    53.  
    54.         private void Button_Test_Click(object sender, EventArgs e)
    55.         {
    56.             if (ThreadPool.Count > 0)
    57.             {
    58.                 foreach (Thread thread in ThreadPool)
    59.                 {
    60.                     Console.WriteLine("当前线程是否终止：" + thread.IsAlive);
    61.                 }
    62.             }
    63.         }
    64.     }
    65. }

    MD5加密

    1.  
    2.         /// 
    3.         /// 计算md5
    4.         /// 
    5.         /// 
    6.         /// 
    7.         private string CalcMD5(string str)
    8.         {
    9.             byte[] buffer = Encoding.UTF8.GetBytes(str);
    10.             using (MD5 md5 = MD5.Create())
    11.             {
    12.                 byte[] md5Bytes = md5.ComputeHash(buffer);
    13.                 StringBuilder sb = new StringBuilder();
    14.                 for (int i = 0; i < md5Bytes.Length; i++)
    15.                 {
    16.                     sb.Append(md5Bytes[i].ToString("x2"));//X2时，生成字母大写MD5
    17.                 }
    18.                 return sb.ToString();
    19.             }
    20.         }

    计算两个时间间隔

    代码

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Text;
    5. using System.Threading.Tasks;
    6.  
    7. namespace Utils
    8. {
    9.     public class TimeInterval
    10.     {
    11.         /// 
    12.         /// 计算两个时间间隔的时长
    13.         /// 
    14.         /// 返回的时间类型
    15.         /// 开始时间
    16.         /// 结束时间
    17.         /// 返回间隔时间，间隔的时间类型根据参数 TimeType 区分
    18.         public static double GetSpanTime(TimeType TimeType, DateTime StartTime, DateTime EndTime)
    19.         {
    20.             TimeSpan ts1 = new TimeSpan(StartTime.Ticks);
    21.             TimeSpan ts2 = new TimeSpan(EndTime.Ticks);
    22.             TimeSpan ts = ts1.Subtract(ts2).Duration();
    23.             //TimeSpan ts = EndTime - StartTime;
    24.  
    25.             double result = 0f;
    26.             switch (TimeType)
    27.             {
    28.                 case TimeType.MilliSecond:
    29.                     result = ts.TotalMilliseconds;
    30.                     break;
    31.                 case TimeType.Seconds:
    32.                     result = ts.TotalSeconds;
    33.                     break;
    34.                 case TimeType.Minutes:
    35.                     result = ts.TotalMinutes;
    36.                     break;
    37.                 case TimeType.Hours:
    38.                     result = ts.TotalHours;
    39.                     break;
    40.                 case TimeType.Days:
    41.                     result = ts.TotalDays;
    42.                     break;
    43.             }
    44.             return result;
    45.         }
    46.     }
    47.  
    48.     /// 
    49.     /// 时间类型
    50.     /// 
    51.     public enum TimeType
    52.     {
    53.         /// 
    54.         /// 毫秒
    55.         /// 
    56.         MilliSecond,
    57.         /// 
    58.         /// 秒
    59.         /// 
    60.         Seconds,
    61.         /// 
    62.         /// 分钟
    63.         /// 
    64.         Minutes,
    65.         /// 
    66.         /// 小时
    67.         /// 
    68.         Hours,
    69.         /// 
    70.         /// 天
    71.         /// 
    72.         Days,
    73.         /// 
    74.         /// 月
    75.         /// 
    76.         Months
    77.     }
    78. }

    调用：

    1.  
    2.     class Program
    3.     {
    4.         static void Main(string[] args)
    5.         {
    6.             DateTime dateTime1 = DateTime.Now;
    7.             Thread.Sleep(3000);
    8.             DateTime dateTime2 = DateTime.Now;
    9.  
    10.             double timeDifference = TimeInterval.GetSpanTime(timeType, dateTime1, dateTime2);
    11.             Console.WriteLine(string.Format("{0} {1}", timeDifference, timeType.ToString()));
    12.  
    13.             Console.ReadKey();
    14.         }
    15.     }

    输出：

    3 Seconds

    数组等比例缩放

    新建一个C#控制台项目，要新建.NetFramework类型的，不然下面代码中的某些API无法使用。

    代码：

    1.  
    2. using System;
    3. using System.Collections.Generic;
    4. using System.Linq;
    5. using System.Text;
    6. using System.Threading.Tasks;
    7.  
    8. namespace Test1
    9. {
    10.     class Program
    11.     {
    12.         static void Main(string[] args)
    13.         {
    14.             List<double> resultList = ScaleConversion(new List<double>() { 230, 2453, 4353, 65 }, 10);
    15.  
    16.             string value = string.Empty;
    17.             for (int i = 0; i < resultList.Count; i++)
    18.             {
    19.                 value += string.Format("{0}，", resultList[i]);
    20.             }
    21.             Console.WriteLine(value);
    22.  
    23.             Console.ReadKey();
    24.         }
    25.  
    26.         /// 
    27.         /// 将数组等比例缩放
    28.         /// 
    29.         /// 数组
    30.         /// 缩放的最大值，最小值默认为0
    31.         /// 缩放后的数组
    32.         public static List<double> ScaleConversion(List<double> valueList, int maxScale)
    33.         {
    34.             if (valueList == null || valueList.Count == 0)
    35.             {
    36.                 Console.WriteLine("valueList 不能为空");
    37.                 return null;
    38.             }
    39.             if (maxScale < 10)
    40.             {
    41.                 Console.WriteLine("等比例的最大值不能小于10");
    42.                 return null;
    43.             }
    44.  
    45.             double max = valueList.Max();
    46.             double factor = Math.Round(max / maxScale, 2);//系数
    47.             List<double> result = new List<double>();
    48.             for (int i = 0; i < valueList.Count; i++)
    49.             {
    50.                 result.Add(Math.Round(valueList[i] / factor, 2));
    51.             }
    52.  
    53.             if (result.Count > 0)
    54.                 return result;
    55.  
    56.             return null;
    57.         }
    58.     }
    59. }

    运行后，结果是：0.53，5.64，10，0.15，

    这里是将10做为缩放比例中的最大值，有兴趣的读者可以自己算一下是否正确。

    时间加减

    代码：

    1.  
    2. using System;
    3.  
    4. namespace Util
    5. {
    6.     public class TimeCompute
    7.     {
    8.         /// 
    9.         /// 时间间隔 
    10.         /// 
    11.         /// 时间1
    12.         /// 时间2
    13.         /// 同一天的相隔的分钟的整数部分
    14.         public static int DateDiff(DateTime DateTime1, DateTime DateTime2)
    15.         {
    16.             TimeSpan ts1 = new TimeSpan(DateTime1.Ticks);
    17.             TimeSpan ts2 = new TimeSpan(DateTime2.Ticks);
    18.             TimeSpan ts = ts1.Subtract(ts2).Duration();
    19.             return Convert.ToInt32(ts.TotalMinutes);
    20.         }
    21.  
    22.         /// 
    23.         /// 时间相加
    24.         /// 
    25.         /// 时间1
    26.         /// 时间2
    27.         /// 时间和
    28.         public static DateTime DateSum(DateTime DateTime1, DateTime DateTime2)
    29.         {
    30.             DateTime1 = DateTime1.AddHours(DateTime2.Hour);
    31.             DateTime1 = DateTime1.AddMinutes(DateTime2.Minute);
    32.             DateTime1 = DateTime1.AddSeconds(DateTime2.Second);
    33.             return DateTime1;
    34.         }
    35.  
    36.         /// 
    37.         /// 根据秒数得到 DateTime
    38.         /// 
    39.         /// 秒数
    40.         /// 以1970-01-01为日期的时间
    41.         public static DateTime GetDateTimeBySeconds(double seconds)
    42.         {
    43.             return DateTime.Parse(DateTime.Now.ToString("1970-01-01 00:00:00")).AddSeconds(seconds);
    44.         }
    45.  
    46.         /// 
    47.         /// 根据 DateTime 得到秒数
    48.         /// 
    49.         /// 时间
    50.         /// 秒数
    51.         public static double GetDateTimeBySeconds(DateTime dateTime)
    52.         {
    53.             return (Convert.ToInt32(dateTime.Hour) * 3600) + (Convert.ToInt32(dateTime.Minute) * 60) + Convert.ToInt32(dateTime.Second);
    54.         }
    55.     }
    56. }

    将字符串转换为时间

    这里也可以使用 DateTime.Parse 进行转换，如果时间字符串写的不齐，只有时间，没有日期，就会以当前的日期和字符串中的时间进行组合

    DateTime dt = Convert.ToDateTime("1:00:00");

    两个时间相减

    1. DateTime t1 = DateTime.Parse("2007-01-01");
    2. DateTime t2 = DateTime.Parse("2006-01-01");
    3. TimeSpan t3 = t1 - t2;

    字符串转换DateTime类型

    代码

    1.  
    2. //下面这两种字符串写法都可以
    3. string timer = "2022-02-02 18:15:58";
    4. string timer = "2022/2/18 18:18:26";
    5.  
    6. DateTime dateTime = Convert.ToDateTime(timer);
    7. Console.WriteLine(dateTime);

    Net5添加管理员权限 以管理员身份运行

    在 项目 上 添加新项 选择“应用程序清单文件” 然后单击 添加 按钮


    添加后，默认打开app.manifest文件，将： 


     
    修改为：

     重新生成项目，再次打开程序时就会提示 需要以管理员权限运行。
     

    Task执行任务，等待任务完成

    代码：

    1. //任务
    2. Func<int> Funcs = () =>
    3. {
    4.     Console.WriteLine("任务开始");
    5. 	return 1 + 1;
    6. };
    7.  
    8. //执行任务
    9. Task<int> printRes = Task.Run(Funcs);
    10.  
    11. //等待任务完成
    12. printRes.GetAwaiter().OnCompleted(() =>
    13. {
    14.     Console.WriteLine("异步执行结果：" + printRes.Result);        
    15. });

    运行：

    任务开始
    异步执行结果：2

    用“\”分割字符

    1. string Chars = @"\";
    2. string Text = @"ddsdd\dddds";
    3. string[] Arr = Text.Split(new[] { Chars },StringSplitOptions.None);
    4.  
    5. //结果：Arr[0] = "ddsdd， Arr[1] = dddds

    实现模拟键盘按键

    1.发送字符串，这里的字符串可以为任意字符

    1. private void button1_Click(object sender,EventArgs e)
    2. {
    3.     textBox1.Focus();
    4.     SendKeys.Send("{A}");
    5. }

    2.模拟组合键：CTRL + A

    1.  
    2. private void button1_Click(object sender,EventArgs e)
    3. {
    4.     webBrowser1.Focus();
    5.     SendKeys.Send("^{A}");
    6. }

    3.SendKeys.Send  异步模拟按键(不阻塞UI)

    按键参考：虚拟键码 (Winuser.h) - Win32 apps | Microsoft Docs

    1.  
    2. [DllImport("user32.dll", EntryPoint = "keybd_event", SetLastError = true)]
    3. //bvk 按键的虚拟键值，如回车键为 vk_return, tab 键为 vk_tab（其他具体的参见附录）
    4. //bScan 扫描码，一般不用设置，用 0 代替就行；
    5. //dwFlags 选项标志，如果为 keydown 则置 0 即可，如果为 keyup 则设成 "KEYEVENTF_KEYUP"；
    6. //dwExtraInfo 一般也是置 0 即可。
    7. public static extern void keybd_event(Keys bVk, byte bScan, uint dwFlags, uint dwExtraInfo);
    8.  
    9. private void button1_Click(object sender,EventArgs e)
    10. {
    11.     textBox1.Focus();
    12.     keybd_event(Keys.A, 0, 0, 0);
    13. }

    4.模拟组合键：CTRL + A

    1. public const int KEYEVENTF_KEYUP = 2;
    2.  
    3. private void button1_Click(object sender,EventArgs e)
    4. {
    5.     webBrowser1.Focus();
    6.     keybd_event(Keys.ControlKey,0,0,0);
    7.     keybd_event(Keys.A,0,0,0);
    8.     keybd_event(Keys.ControlKey,KEYEVENTF_KEYUP,0,0);
    9. }

    5.上面两种方式都是全局范围呢，现在介绍如何对单个窗口进行模拟按键

    下面代码没测试过，不知道有用没有

    1.  
    2. [DllImport("user32.dll",EntryPoint = "PostMessageA",SetLastError = true)]
    3. public static extern int PostMessage(IntPtr hWnd,int Msg,Keys wParam,int lParam);
    4.  
    5. public const int WM_CHAR = 256;
    6.  
    7. private void button1_Click(object sender,EventArgs e)
    8. {
    9.     textBox1.Focus();
    10.     PostMessage(textBox1.Handle,256,Keys.A,2);
    11. }
    1. public const int WM_KEYDOWN = 256;
    2. public const int WM_KEYUP = 257;
    3.  
    4. private void button1_Click(object sender,0)
    5. {
    6.     PostMessage(webBrowser1.Handle,WM_KEYDOWN,0);
    7. }

    代码运行耗时

    这个功能在代码实现上比较简单，几行代码就可以做到

    声明计时器

    1. System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch();  
    2. stopwatch.Start();

    暂停计时器，输出时间

    1.  
    2. stopwatch.Stop();
    3. Console.WriteLine(stopwatch.Elapsed.Minutes + "分" + stopwatch.Elapsed.Seconds + "秒");

    如果需要分段多次计时，那么就需要将计时器清空

    1.  
    2. stopwatch.Stop();
    3. stopwatch.Reset();
    4. stopwatch.Start();

    通过反射获取和设置指定的属性

    1. public class Program
    2. { 
    3.     //定义类
    4.     public class MyClass
    5.     {
    6.         public int Property1 { get; set; }
    7.     }
    8. 	
    9.     static void Main()
    10.     {
    11.         MyClass tmp_Class = new MyClass();
    12.         tmp_Class.Property1 = 2;
    13. 		//获取类型
    14.         Type type = tmp_Class.GetType(); 
    15. 		//获取指定名称的属性
    16.         System.Reflection.PropertyInfo propertyInfo = type.GetProperty("Property1"); 
    17. 		//获取属性值
    18.         int value_Old = (int)propertyInfo.GetValue(tmp_Class, null); 
    19.         Console.WriteLine(value_Old);
    20. 		
    21. 		//给对应属性赋值
    22.         propertyInfo.SetValue(tmp_Class, 5, null); 
    23.         int value_New = (int)propertyInfo.GetValue(tmp_Class, null);
    24.         Console.WriteLine(value_New);
    25.         Console.ReadLine();
    26.     }
    27. }

    特性玩法1

    1.  
    2. using System;
    3. using System.Collections.Generic;
    4. using System.Linq;
    5. using System.Reflection;
    6. using System.Text;
    7. using System.Threading.Tasks;
    8.  
    9. namespace 特性
    10. {
    11.     public class Program
    12.     {
    13.         static void Main(string[] args)
    14.         {
    15.             //获取程序集所有的类
    16.             Type[] types = typeof(Program).Assembly.GetTypes();
    17.             //遍历所有的类
    18.             foreach (Type t in types)
    19.             {
    20.                 //遍历当前类所有的方法
    21.                 foreach (MethodInfo method in t.GetMethods())
    22.                 {
    23.                     //遍历当前方法的上的所有特性
    24.                     foreach (Attribute attr in method.GetCustomAttributes())
    25.                     {
    26.                         //如果特性是GameSystem
    27.                         if (attr is GameSystem)
    28.                         {
    29.                             //实例化当前类的实例
    30.                             object reflectTest = Activator.CreateInstance(t);
    31.                             //获取当前方法的名字
    32.                             MethodInfo methodInfo = t.GetMethod(method.Name);
    33.                             //执行当前方法
    34.                             methodInfo.Invoke(reflectTest, null);
    35.                         }
    36.                     }
    37.                 }
    38.             }
    39.  
    40.             Console.ReadKey();
    41.         }
    42.     }
    43.  
    44.     //自定义特性类
    45.     [AttributeUsage(AttributeTargets.All)]
    46.     public class GameSystem : Attribute//正常格式是GameSystemAttribute这样的
    47.     {
    48.         public GameSystem() { }
    49.     }
    50.  
    51.     //自定义一个player类
    52.     public class player
    53.     {
    54.         //GameSystem特性类的名字，如果定义的时候特性类的名字是这样GameSystemAttribute打上特性也是一样的
    55.  
    56.         [GameSystem]
    57.         public void Start()
    58.         {
    59.             Console.WriteLine("GameSystem start");
    60.         }
    61.  
    62.  
    63.         [GameSystem]
    64.         public void Updata()
    65.         {
    66.             Console.WriteLine("GameSystem updata");
    67.         }
    68.  
    69.         public void Awaken()
    70.         {
    71.             Console.WriteLine("Awaken~~~~~~");
    72.         }
    73.     }
    74.  
    75. }

    运行：

    泛型玩法2

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Reflection;
    5. using System.Text;
    6. using System.Threading.Tasks;
    7.  
    8. namespace Test_Console
    9. {
    10.     class Program
    11.     {
    12.         static void Main(string[] args)
    13.         {
    14.             Test test = new Test();
    15.             test.Print().Run();
    16.             test.Print().Run();
    17.             //test.Print().ChickenFlew();//报错，因为没实现Movement接口
    18.  
    19.             Console.ReadKey();
    20.         }
    21.     }
    22.  
    23.     public class Test
    24.     {
    25.         private Dictionary<string, object> ObjectDictionary = new Dictionary<string, object>();
    26.  
    27.         public T Print<T>() where T: class, Movement, new()
    28.         {
    29.             Type t = typeof(T);
    30.             string fullName = t.FullName;
    31.             if (ObjectDictionary.ContainsKey(fullName))
    32.             {
    33.                 return (T)ObjectDictionary[fullName];
    34.             }
    35.             else
    36.             {
    37.                 object obj = Activator.CreateInstance(t);
    38.                 ObjectDictionary.Add(fullName, obj);
    39.                 return (T)obj;
    40.             }
    41.         }
    42.     }
    43.  
    44.     public interface Movement
    45.     {
    46.         void Run();
    47.     }
    48.  
    49.     public class Dog : Movement
    50.     {
    51.         public void Run()
    52.         {
    53.             Console.WriteLine("狗跑了");
    54.         }
    55.     }
    56.  
    57.     public class Cat : Movement
    58.     {
    59.         public void Run()
    60.         {
    61.             Console.WriteLine("猫跑了");
    62.         }
    63.     }
    64.  
    65.     public class Chook
    66.     {
    67.         public void ChickenFlew()
    68.         {
    69.             Console.WriteLine("鸡飞了");
    70.         }
    71.     }
    72. }

    运行：

    泛型

    泛型的意义在于免去了类型之间互相转换的系统开销，和同类方法的重载，
    比如，Add方法你要重载两个方法（int和double）或者更多方法，用范型只用写一个Add方法就可以完成int，double，float......等等的相加，
    再如，集合的操作，没有往往是弱类型（object），而用范型可以直接是强类型，无需转换之间的开销，节省了资源，

    代码：
     

    1. using System;  
    2. using System.Collections.Generic;  
    3. using System.Linq;  
    4. using System.Text;  
    5. using System.Threading.Tasks;  
    6.   
    7. namespace _01_自定义泛型  
    8. {  
    9.     class Program  
    10.     {  
    11.         static void Main(string[] args)  
    12.         {  
    13.             // 泛型类  
    14.             MyClass1<string> myClass = new MyClass1<string>();  
    15.             myClass.SayHi("嘻嘻嘻");  
    16.   
    17.             // 泛型委托  
    18.             MyGenericDelegate<string> md = m1;  
    19.             md("泛型委托");  
    20.   
    21.             Console.ReadKey();  
    22.         }  
    23.   
    24.         public static void m1(string msg)  
    25.         {  
    26.             Console.WriteLine(msg);  
    27.         }  
    28.   
    29.         ///   
    30.         /// 泛型类  
    31.         ///   
    32.         ///   
    33.         public class MyClass1<T>  
    34.         {  
    35.             public void SayHi(T arg)  
    36.             {  
    37.                 Console.WriteLine(arg);  
    38.             }  
    39.         }  
    40.   
    41.         public class MyClass2  
    42.         {  
    43.             ///   
    44.             /// 泛型方法  
    45.             ///   
    46.             ///   
    47.             ///   
    48.             public void SayHi<T>(T msg)  
    49.             {  
    50.                 Console.WriteLine(msg);  
    51.             }  
    52.         }  
    53.   
    54.         ///   
    55.         /// 泛型接口  
    56.         ///   
    57.         ///   
    58.         public interface IFace<T>  
    59.         {  
    60.             void SayHi(T msg);  
    61.         }  
    62.   
    63.        //-----实现泛型接口有两种情况-----  
    64.   
    65.         ///   
    66.         /// 1.普通类实现泛型接口  
    67.         ///   
    68.         public class MyClass3 : IFace<string>  
    69.         {  
    70.             public void SayHi(string msg)  
    71.             {  
    72.                 Console.WriteLine(msg);  
    73.             }  
    74.         }  
    75.   
    76.         ///   
    77.         /// 2.泛型类继承泛型接口  
    78.         ///   
    79.         ///   
    80.         public class MyClass4<T> : IFace<T>  
    81.         {  
    82.             public void SayHi(T msg)  
    83.             {  
    84.                 Console.WriteLine(msg);  
    85.             }  
    86.         }  
    87.   
    88.         ///   
    89.         /// 泛型约束  
    90.         ///   
    91.         public class MyClass5<T,K,V,W,X>   
    92.             where T : struct // 约束T必须是值类型  
    93.             where K : class  // 约束K必须是引用类型   
    94.             where V : IFace<T> // 约束V必须实现IFace接口  
    95.             where W: K       // W必须是K类型，或者K类型的子类  
    96.             where X : class,new() // X必须是引用类型，并且有一个无参数的构造函数，当有多个约束时，new()必须写在最后  
    97.         {  
    98.             public void Add(T num)  
    99.             {  
    100.                 Console.WriteLine(num);  
    101.             }  
    102.         }  
    103.   
    104.         ///   
    105.         /// 泛型委托  
    106.         ///   
    107.         ///   
    108.         ///   
    109.         public delegate void MyGenericDelegate<T>(T args);  
    110.     }  
    111. }

    end

  • 相关阅读:
    k8s资源管理操作——陈述式管理方式
    Tensor-LLM简单介绍
    CNN鲜花分类
    Linux 性能优化之使用 Tuned 配置优化方案
    C#使用正则表达式 判断string 字符串是否包含汉字
    OpenCV 05(图像的算术与位运算)
    Flutter高仿微信-第57篇-添加好友
    Spring编程常见错误50例-Spring AOP常见错误（上）
    lc--655:输出二叉树
    【背景渐变】 —— 就算没接触过也能 一遍学会哦
  • 原文地址：https://blog.csdn.net/qq_38693757/article/details/125989568