C#基础与进阶扩展合集-进阶篇（持续更新）
目录
本文分两篇，基础篇点击：C#基础与进阶扩展合集-基础篇
一、进阶
1、Predicate
2、设置C#语言版本
3、ListCollectionView过滤集合
4、值类型与引用类型
5、程序设置当前项目工作目录
6、获取App.config配置文件中的值
7、Linq常用语句
8、并行LINQ
9、强引用与弱引用
10、using处理非托管资源
11、模块初始化器
二、进阶扩展
1、Adapt适配器
2、Mutex互斥及防止App多开
3、Monitor设置等待资源时间
4、扩展方法实现解构
5、Span实现切片
6、数组池减少GC工作
7、深度解析await关键字
8、Task常用方法
9、ValueTask
10、异步方法的异常处理
三、版本新增
1、范围运算符
2、字符串格式控制
3、数字分隔符
4、小数点前后保留格式
本文分两篇，基础篇点击：C#基础与进阶扩展合集-基础篇
一、进阶
1、Predicate
拥有一个或多个泛型参数并返回一个 bool 值，常用于对 collection 进行一组条件检索，类似于Func。
举例：Predicate pre=m=>m.Id==2;
2、设置C#语言版本
工程文件 x.csproj中修改
PropertyGroup节点内添加子节点:
latest
3、ListCollectionView过滤集合
使用ListCollectionView类构造函数注入列表
通过该类的 Filter属性过滤集合
List animals = new List() { new Animal(1,"ani1"),new Animal(2,"动物2") };
List bears = new List();
var tmp = animals.Adapt>();
tmp.ForEach(m => m.Description = "Animal adapt bear...");
ListCollectionView view=new ListCollectionView(tmp);
view.Filter = i => ((Bear)i).ID == 2;
foreach (var animal in view)
MessageBox.Show(((Bear)animal).Name); 4、值类型与引用类型
值类型：变量直接保存其数据，作为类的字段（成员变量）时，跟随其所属的实例存储，也就是存储在堆中；作为方法中的局部变量时，存储在栈上；
引用类型：变量保存其数据的引用（地址）分配在栈中，具体数据(实例)部署在托管堆中；
值类型：结构体（数值类型，bool型，用户定义的结构体），枚举，可空类型
引用类型：数组，用户定义的类、接口、委托，object，字符串
引用类型string：
string a = "A";
string b = a;
Console.WriteLine($"a:{a}\tb:{b}");
a= "B";
Console.WriteLine($"a:{a}\tb:{b}");
string为引用类型，上面示例看出string像值类型：
实际上，是由于运算符的重构所导致的结果。当a被重新赋值时，.NET为a在托管堆上重新分配了一块内存。这样做的目的是，使字符串类型与通俗意义上讲的字符串更接地气。
引用类型数组：
数组元素为值类型时，在托管堆中一次性分配全部值类型空间（堆中栈），并自动初始化；
元素为 引用类型时，先在托管堆分配一次空间，此时不会自动初始化任何元素（均为null）。等到有代码初始化某个元素的时，这个引用类型元素的存储空间才会被分配在托管堆上；
5、程序设置当前项目工作目录
Directory.SetCurrentDirectory(Path.GetDirectoryName(typeof(Test).Assembly.Location));
6、获取App.config配置文件中的值
1、获取appSettings节点值：
ConfigurationManager.AppSettings[key];
2、获取connectionStrings节点值:
var list= ConfigurationManager.ConnectionStrings;
string str="";
foreach (ConnectionStringSettings item in list)
{
if(item.Name=="ConTest")
str = item.ConnectionString;
}
7、Linq常用语句
定义LINQ扩展方法的一个类是System.Linq名称空间中的Enumerable；
Linq常用语句，详细讲解点击：C#-关于LINQ
select：以指定形式返回
Where查询特点条件（方式1：from in；方式2：Lambda表达式）
Order排序：1、descending 降序；2、ascending 升序
OfType查询特定类型
Join合并两集合通过指定键，返回指定结构类型集合
GroupJoin:俩集合通过指定键分组
Reverse反转集合元素顺序
GroupBy按指定键对自身分组
Any / All 判断是否（任意一个/全部）满足条件
Skip跳过指定数量元素
Take拿取指定数量元素
Count获取元素个数
Sum、Average、Max、Min获取集合总值、平均值、最大值、最小值
Concat连接集合
Distinct去重（去重类中某个字段需实现IEqualityComparer接口）
ElementAt获取指定索引元素（与[ ]类似）
First/Single、Last：获取集合中第一个、最后一个元素(如果集合中包含多个元素，使用Single会报错)；
ToDictionary：将集合转换为字典；
ToList： 将集合转换为List；
SequenceEqual：判断两个集合是否相等；
8、并行LINQ
System.Linq名称空间中包含的类ParallelEnumerable可将查询的工作拆分到多个处理器上同时运行的多个线程中；
通常可使用AsParallel（）方法让集合类以并行方式查询，该方法扩展了IEnumerable
接口，返回ParallelQuery 类； 示例如下，示例中并行LINQ所用时间约90ms，普通LINQ所用时间约为420ms，可以看出并行LINQ加快了代码运行速度
var list=Enumerable.Range(0, 5000_0000).Select(x => Random.Shared.Next(100)).ToList();
Stopwatch sw = Stopwatch.StartNew();
var avera= list.AsParallel().Where(m=>m<50).Select(m=>m).Average();
sw.Stop();
Stopwatch sw2 = Stopwatch.StartNew();
var avera2= list.Where(m => m < 50).Select(m => m).Average();
sw2.Stop();
Console.WriteLine(sw.Elapsed.TotalMilliseconds);//约90ms
Console.WriteLine(sw2.Elapsed.TotalMilliseconds);//约420ms9、强引用与弱引用
1、在应用程序中实例化一个类或结构时，只要有代码引用它，就会形成强引用；
2、GC不能收集仍在引用的对象的内存，也就是强引用的内存，但它可以收集不在根表中直接或间接引用的托管内存；
3、弱引用允许创建和使用对象，但如果垃圾收集器碰巧运行，就会收集对象并释放内存，弱引用开销比小对象大，用于小对象没有意义；
4、弱引用使用WeakReference类创建的，使用构造函数传递强引用，其Target属性的值若不为null，则该对象仍可使用，若赋值给传递类型对象，则会再次创建该对象的强引用，不能被GC收集（注意：在访问Target时可能被GC收集，所以通常赋值后需对其进行null判断）；
WeakReference weakReference = new WeakReference(new Pig());
Pig pig = weakReference.Target as Pig;
if (pig != null)
{
//use pig
}
else
{
//reference not available
}10、using处理非托管资源
方式一：声明一个析构函数（或终结器finalizer）作为类的成员；
C#中，析构函数在底层.NET体系结构中为终结器，编译器会隐式的把析构函数编译成等价于重写Finalize（）方法的代码，如下：
protected override void Finalize()
{
try
{
//Finalizer implementation
}
finally
{
base.Finalize();
}
}方式二：实现IDisposable或IAsyncDisposable接口；
C#中，推荐使用该方式替代析构函数，这些接口定义了一种模具（具有语言级的支持），该模式为释放非托管的资源提供了确定的机制，并避免产生析构函数固有的与GC相关的问题；
注意：若处理过程中出现异常则不会释放，通常在finally块中释放，如下：
People people = null;
try
{
people = new();
//other process
}
finally
{
people.Dispose();
}
class People : IDisposable
{
public void Dispose()
{
//implementation
}
}方式三：using语句和using声明（推荐），实现了对方式二的封装；
用于实现IDisposable接口的对象，当对象的引用超出作用域时，自动调用该对象的Dispose（）或DisposeAsync（）方法，如下示例，会生成与上面try块等价的IL代码；
using (People people = new())
{
//other process
}11、模块初始化器
若需要在使用一个库的任何类型之前调用该库的初始化代码，可使用C#的一个新特性，模块初始化器[ModuleInitializer]；
在使用该类的任何类型之前，会自动调用该特性标记的初始化方法，该方法必须是静态、无参，返回void，使用public或internal访问修饰符；
[ModuleInitializer]
public static void Initializer()
{
Console.WriteLine("*******Module Initializer********");
}二、进阶扩展
1、Adapt适配器
安装NutGet包：Mapster
可理解成转换器，适配器适配的是不同类间相同的名称，不论字段或属性（必须为值类型或字符串类型），只要名字相同，都适配给目的对象；
注意：即使名称相同，属性或字段也不能适配成方法
Animal animal = new Animal(18);
Bear bear = animal.Adapt();
Console.WriteLine(bear.Age.ToString());
Console.WriteLine(bear.Description.ToString());
Console.WriteLine("************************");
Bear bear1=new Bear();
Console.WriteLine(bear1.Age.ToString());
Console.WriteLine(bear1.Description.ToString());
Console.WriteLine("*************************");
Banana banana = animal.Adapt(new Banana());
Console.WriteLine(banana.Description); 
2、Mutex互斥及防止App多开
1、继承自WaitHandle类：抽象基类，用于等待一个信号的设置（有静态方法WaitOne（）、WaitAll（）、WaitAny（））；
2、Mutex互斥锁可定义互斥名称，所以可用于跨进程的同步操作（因为操作系统可识别有名称的互斥，在不同进程间共享）；
3、Mutex构造函数中，可指定互斥是否最初应由主调线程拥有、定义互斥名称、获取互斥是否已存在的信息；
用法1：跨进程互斥实现进程间同步（未命名互斥只能用于跨线程）
Mutex mutext = new Mutex(false,"MyConsole");
mutext.WaitOne();
Console.WriteLine($"{Process.GetCurrentProcess().ProcessName}:\tStart......");
Console.ReadLine();
mutext.ReleaseMutex();
Console.WriteLine($"{Process.GetCurrentProcess().ProcessName}:\tEnd.......");用法2：防止App重复开启
Mutex mutext = new Mutex(false,"MyConsole",out bool createNew);
if (!createNew)
return;3、Monitor设置等待资源时间
lock关键字是由Monitor类实现（抛出异常也会解锁）如下：
Monitor.Enter(_obj);
try{Count--;}
finally { Monitor.Exit(_obj); }Monitor相对于lock的优点在于，使用Monitor的TryEnter（）方法，其中可传递一个超时值，用于指定等待被锁定的最长时间，若_obj被锁定，TryEnter（）方法将布尔型的引用参数设置为true，并同步的访问_obj锁定状态，若另一个线程锁定_obj时间超过指定时间，TryEnter（）将bool引用参数置为false，线程将不再等待，而是去执行其它操作，如下：
Monitor.TryEnter(_obj, 2000, ref _lockTaken);
if (_lockTaken)
{
try
{
Console.WriteLine(Thread.CurrentThread.Name + ":\t obj lock.....");
Thread.Sleep(5000);
Console.WriteLine(Thread.CurrentThread.Name + ":\t obj release.....");
}
finally
{
Monitor.Exit(_obj);
}
}
else
Console.WriteLine("Timeout,Run other.....");4、扩展方法实现解构
了解扩展方法点击：扩展方法定义与使用
创建Deconstruct（）方法（也称解构器），将分离部分放入out参数中，这里使用扩展方法实现解构，示例如下：
Stu stu = new Stu(98, "Auston");
stu.Deconstruct(out int score, out string name);
Console.WriteLine($"{name}:{score}");
static class StuExtension
{
public static void Deconstruct(this Stu stu, out int score, out string name)
{
score = stu.Score;
name = stu.Name;
}
}
5、Span实现切片
1、Span
，可快速访问托管与非托管的连续内存，如数组、长字符串； 2、可实现对数组部分进行访问或切片，不会复制数组元素，是从span中直接访问的，切片的两种方式①构造函数传递数组的开头与结尾；②Slice方法传递开头索引，提取到数组末尾；
3、可使用Span改变值，除了索引访问更改，还提供方法有:Clear()、填充Fill（）、复制CopyTo()（不推荐，目标span不够大会抛异常）、复制推荐TryCopyTo（）（span不够大不抛异常，而是返回false）;
4、若只需对数组片段进行读访问，可使用ReadOnlySpan
;
int[] c = { 1, 3, 5, 8 };
Span span = new Span(c);
Span span1= new Span();
span[1] = 11;
span.Clear();
span.Fill(11);
Span span2 = new Span(c,0,3);
Span span3 = span.Slice(0,3); //切片
ReadOnlySpan span4 = new(c); //只读变量
if (!span.TryCopyTo(span3))
Console.WriteLine("Argument"); 6、数组池减少GC工作
通过ArrayPool类（名称空间System.Buffers）使用数组池，可减少垃圾收集器的工作，ArrayPool管理一个数组池，数组可以从这租借，并返回池中，内存在ArrayPool中管理。
创建ArrayPool
，调用静态Create（）方法； 使用预定义共享池，通过访问Shared属性；
从池中租用内存，可调用Rent（）方法，(池中数组元素数量最低16，且都是成倍增加)；
内存（数组）返回到池中，调用Return（）方法，可指定返回池之前是否清除该数组（false，下次租用数组的人可读取数据）；
ArrayPool arrayPool = ArrayPool.Create(maxArrayLength: 100, maxArraysPerBucket: 10);
int[] arr = ArrayPool.Shared.Rent(10);
arr[15] = 15;
Console.WriteLine($"Len={arr.Length}\tarr[15]={arr[15]}");//输出Len=16 arr[15]=15
ArrayPool.Shared.Return(arr,true);
Console.WriteLine(arr[15]);//输出0 7、深度解析await关键字
await通常与async一同使用来实现异步编程，async没有await搭配使用将毫无意义；
使用Task任务的GetAwaiter（）方法，返回一个TaskAwaiter
类型对象，该对象的OnCompleted（）方法实现了INotifyCompletion接口，在任务完成时调用； await实际就是编译器把await关键字后的所有代码放进了OnCompleted（）方法的代码块中。
public static void Main(string[] args)
{
TestAsync();
Console.ReadLine();
}
public static async void TestAsync()
{
var awaiter = MyAsync().GetAwaiter();
awaiter.OnCompleted(() =>
{
Console.WriteLine($"MyAsync ended....");
});
//await MyAsync();
//Console.WriteLine("MyAsync ended.....");
}
public static async Task MyAsync()
{
Thread.Sleep(100);
Console.WriteLine(nameof(MyAsync));
return nameof(MyAsync);
} 8、Task常用方法
GetAwaiter（）方法，用于await关键字的实现，详细如上；
ContinueWith（）方法，用于延续任务；
WhenAll（）静态方法，用于等待所有任务结束；
WhenAny（）静态方法，用于等待任意一个任务结束；
9、ValueTask
C#7新增可用作await的新类型，ValueTask是一个结构，相对于Task具有性能上的优势，因为其在堆上没有对象；
10、异步方法的异常处理
若调用异步方法没有等待，try/catch不会捕获异常，因为在抛出异常前，就已经执行完毕了，若要捕获异常，需await等待异步方法。
static void PutError()
{
try
{
await ThrowExcp();
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
static async Task ThrowExcp()
{
await Task.Delay(1000);
throw new Exception("Exception.....");
}19、
三、版本新增
C#9新增顶级语句;
字符串的范围除SubString方法，C#8新增hat(^)、范围运算符（[..]）;
1、范围运算符
string rangstr ="hello,auston!" ;
Console.WriteLine(rangstr[..5]);//范围运算符
Console.WriteLine(rangstr[7^2]);//hat^运算符，从索引7往前数第2个字符
2、字符串格式控制
DateTime t = DateTime.Now;
Console.WriteLine($"{t:D}");//字符串格式控制
3、数字分隔符
int a = 2_2_2;//使用数字分隔符，提高代码可读性（编译器会忽略下划线）
Console.WriteLine($"{a:c}");
4、小数点前后保留格式
double d = 22.336_6;
Console.WriteLine($"{d:###.##}");//小数点后四舍五入保留2位
Console.WriteLine($"{d:000.00}");//小数点前保留3位，后保留2位