C# on Sutra Library

避免Newtonsoft.Json反序列化出现重复列表项

Mon, 01 Dec 2025 00:00:00 +0000

问题描述

我们公司的项目是一个基于.NET的Web应用，它需要和一些第三方的API交互数据。为了方便地处理JSON格式的数据，我们使用了Newtonsoft.Json这个框架，它可以让我们轻松地将.NET对象序列化为JSON字符串，或者将JSON字符串反序列化为.NET对象。
在项目中，我们定义了一些实体类来表示我们需要处理的数据。其中有一个类叫做Product，它有三个属性：Property，MemberVariable和Array。Property是一个列表类型的属性，它有一个get和set方法。MemberVariable是一个列表类型的成员变量，它没有get和set方法。Array是一个数组类型的成员变量，它也没有get和set方法。在Product的构造函数中，这三个属性都被初始化为一些整数值。代码如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


public class Product
{
public List<int> Property { get; set; }
public List<int> MemberVariable;
public int[] Array;
public Product()
{
Property = new List<int>() { 1, 2, 3 };
MemberVariable = new List<int>() { 4, 5, 6 };
Array = new int[] { 7, 8, 9 };
}
}

在项目中，我们需要将Product对象序列化为JSON字符串，并发送给第三方的API。然后，我们需要从第三方的API接收JSON字符串，并反序列化为Product对象。我们使用了Newtonsoft.Json的SerializeObject和DeserializeObject方法来实现这个功能。代码如下：

1
2
3
4
5


Product product = new Product();
string json = JsonConvert.SerializeObject(product);
// 发送json给第三方API
// 接收json从第三方API
Product deserializedProduct = JsonConvert.DeserializeObject<Product>(json);

按照我们的预期，当我们序列化Product对象时，应该得到如下的JSON字符串：

1

{"Property":[1,2,3],"MemberVariable":[4,5,6],"Array":[7,8,9]}

当我们反序列化JSON字符串时，应该得到一个和原来相同的Product对象。
然而，在测试过程中，我们发现了一个奇怪的现象。当我们反序列化JSON字符串时，得到的Product对象并不是和原来相同的。它的Property和MemberVariable属性的值都被重复了，而Array属性的值没有变化。例如：

1

{"Property":[1,2,3,1,2,3],"MemberVariable":[4,5,6,4,5,6],"Array":[7,8,9]}

这就是我们遇到的问题：为什么使用Newtonsoft.Json反序列化时，列表项会被重复呢？

问题分析

为了找出问题的原因，我们首先查看了Newtonsoft.Json的文档，并搜索了一些相关的资料。我们发现了以下几点：

Newtonsoft.Json在反序列化时，会先调用对象的构造函数，然后再根据JSON字符串中的键值对来设置对象的属性或字段。
如果对象的属性或字段已经在构造函数中被初始化了，那么反序列化时就会把JSON字符串中的值追加到原来的值上，而不是替换掉它们。
这种行为只会发生在列表类型的属性或字段上，因为列表类型有一个Add方法，可以把新的值添加到列表中。而数组类型没有这个方法，所以反序列化时会直接替换掉原来的值。
根据这些信息，我们就可以理解为什么我们的问题会发生了。当我们反序列化JSON字符串时，Newtonsoft.Json会先调用Product的构造函数，这时Property和MemberVariable属性就被初始化为一些整数值。然后，Newtonsoft.Json会根据JSON字符串中的键值对来设置Property和MemberVariable属性，这时它会把JSON字符串中的值添加到原来的值上，导致列表项重复。而Array属性没有这个问题，因为它是一个数组类型，反序列化时会直接替换掉原来的值。

问题解决

既然我们知道了问题的原因，那么我们就可以想办法解决它了。在网上搜索后，我们发现了几种可能的方法：

一种方法是在对象的构造函数中不要初始化属性或字段，而是在属性的get方法中检查是否为空，并在需要时进行初始化。这样就可以避免在反序列化时调用构造函数导致的重复。例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


public class Product
{
private List<int> _property;
public List<int> Property
{
get
{
if (_property == null)
{
_property = new List<int>() { 1, 2, 3 };
}
return _property;
}
set
{
_property = value;
}
}
// 省略其他属性和构造函数
}

另一种方法是使用[JsonIgnore]特性来忽略不需要序列化或反序列化的属性或字段。这样就可以避免在反序列化时设置对象的属性或字段导致的重复。例如：

1
2
3
4
5
6


public class Product
{
[JsonIgnore]
public List<int> Property { get; set; }
// 省略其他属性和构造函数
}

还有一种方法是使用[ObjectCreationHandling]设置来控制反序列化时对象的创建方式。这个设置有三个选项：Auto，Reuse和Replace。Auto是默认的选项，它会根据对象的类型来决定是重用还是替换。Reuse表示会重用已经存在的对象，并把JSON字符串中的值追加到对象上。Replace表示会创建一个新的对象，并把JSON字符串中的值赋给对象。这样就可以避免在反序列化时追加列表项导致的重复。例如：

1
2
3
4


Product deserializedProduct = JsonConvert.DeserializeObject<Product>(json, new JsonSerializerSettings
{
ObjectCreationHandling = ObjectCreationHandling.Replace
});

我们根据项目的实际需求，选择了第三种方法，并修改了代码。经过测试，完美解决问题，反序列化后得到的Product对象和原来相同了。

Wpf生成操作：内容和资源

Wed, 05 Nov 2025 00:00:00 +0000

🧱 一、生成操作（Build Action）的基本概念

在 Visual Studio 中，文件属性里的 “生成操作（Build Action）” 决定了这个文件在编译时如何被处理、是否会被打包进最终的程序集（.exe 或 .dll）中，或者是否会被复制到输出目录。

常见的选项包括：

None（不参与编译）
Content（内容文件）
Resource（WPF 资源）
Embedded Resource（嵌入资源）
Page（用于 XAML）
Compile（用于代码文件）

我们重点看你提到的这三个：

🎨 二、“内容（Content）”、“资源（Resource）”、“嵌入的资源（Embedded Resource）”的区别

生成操作	编译后是否打包进 EXE	访问方式	典型用途	特点
Content（内容）	❌ 否（但会复制到输出目录）	文件路径（URI 或磁盘路径）	图片、配置文件、外部可替换资源	文件存在于磁盘上，可以替换或修改
Resource（资源）	✅ 是（打包进程序集）	`pack://application:,,,/路径`	WPF UI 图片、图标等	推荐用于 UI 图片，编译时自动压缩打包
Embedded Resource（嵌入的资源）	✅ 是（打包进程序集）	程序代码通过 `Assembly.GetManifestResourceStream()`	非 WPF 特有，一般用于代码访问的二进制数据	不会被 WPF 资源系统识别

🧩 三、具体区别举例

假设项目中有一个文件结构如下：

1
2
3
4


MyApp/
 ├── Images/
 │ └── logo.png
 └── MainWindow.xaml

1️⃣ Content（内容）

属性设置：

1
2


生成操作: Content
复制到输出目录: 始终复制

编译后：

logo.png 会出现在输出目录（如 bin/Debug/net8.0-windows/Images/logo.png）。
不会打包进 .exe。

访问方式（XAML）：

1

<Image Source="Images/logo.png"/>

访问方式（代码）：

1

var image = new BitmapImage(new Uri("Images/logo.png", UriKind.Relative));

✅ 优点：可以替换图片，不用重新编译 ❌ 缺点：发布时需要确保图片随程序一起拷贝

2️⃣ Resource（资源）

属性设置：

1

生成操作: Resource

编译后：

logo.png 会被压缩并打包进 MyApp.exe 程序集中。

访问方式（XAML）：

1

<Image Source="pack://application:,,,/Images/logo.png"/>

或更简单写法（推荐）：

1

<Image Source="/MyApp;component/Images/logo.png"/>

访问方式（代码）：

1
2


var uri = new Uri("pack://application:,,,/Images/logo.png");
var image = new BitmapImage(uri);

✅ 优点：

不需要单独拷贝文件。
不怕丢失，发布简单。
是 WPF 的默认推荐方式。

❌ 缺点：

修改图片需要重新编译程序。

3️⃣ Embedded Resource（嵌入的资源）

属性设置：

1

生成操作: Embedded Resource

编译后：

文件会以二进制流形式嵌入到程序集，但不属于 WPF 的资源系统。

访问方式（仅代码）：

1
2
3
4
5
6


var assembly = Assembly.GetExecutingAssembly();
using var stream = assembly.GetManifestResourceStream("MyApp.Images.logo.png");
var image = new BitmapImage();
image.BeginInit();
image.StreamSource = stream;
image.EndInit();

✅ 优点：

对于非 WPF 程序（如控制台、WinForms）很方便。 ❌ 缺点：
WPF 的 XAML 无法直接识别这种资源。
不推荐在纯 WPF 界面中使用。

💡 四、总结与推荐使用

使用场景	推荐生成操作	理由
UI 图片（按钮图标、背景）	Resource	打包在程序集内，URI 可直接访问
可替换图片（用户可更改）	Content	放在输出目录中，可替换
嵌入配置/模板文件（仅代码访问）	Embedded Resource	用流访问，灵活
大图标（AppIcon.ico）	Resource	被打包并自动识别

🧠 小技巧

项目打包路径推荐：
1 2

/Assets/Icons/ /Assets/Images/
并将这些文件设置为 Resource。
快速判断是否打包： 在输出目录看不到图片 → 多半是 Resource。能看到图片 → 多半是 Content。

C#高频面试题

Thu, 30 Oct 2025 00:00:00 +0000

C#值类型和引用类型的区别是什么 (30)
C#字典的底层实现是什么 (26)
请解释什么是垃圾回收（GC）及其工作原理？ (25)
C#中什么是装箱和拆箱？ (18)
请详述在C#中类(class)与结构(struct)的异同？ (9)
怎么防止过度的GC产生？ (8)
C#中的反射（Reflection）是什么？它有哪些应用场景？ (8)
请说明c#委托和事件的区别 (7)
C#中什么是值类型与引用类型？ (7)
请解释什么是泛型，如何在C#中使用泛型？ (6)
C#中abstract class和interface有什么区别? (5)
C#中的委托是什么？事件是不是一种委托？ (5)
请说明C#协程和线程的概念 (5)
ArrayList和List的区别是什么 (4)
请说明垃圾回收机制何时自动释放，何时需要手动释放 (4)
C#中如何实现异步编程？ (4)
请介绍C#中的数据结构，如列表（List）和字典（Dictionary）等 (3)
简述dictionary发生哈希冲突时的解决方法 (3)
C#中List的底层是什么 (2)
C#中的事件是什么？ (2)
c#当中int和long分别占用多少字节 (2)
说明C#如何把一个值类型转换为引用类型 (2)
请说明 private、protected、public、internal 的访问权限 (2)
C#中值传递与引用传递的区别是什么？ (2)
C#中堆和栈的区别？ (2)
C#反射怎么获取一个类然后调用里面的方法 (2)
如何在C#中实现依赖注入？ (2)
如果有数以百万计的数据要插入哈希表，应该如何尽量减少哈希冲突 (2)
请解释异步编程的概念、工作原理以及实现方式 (2)
请阐述ASP.NET和ASP.NET Core的区别。 (2)
怎么去设计一个对象池？（用具体的程序逻辑、数据结构、对外提供哪些接口） (2)
C# List是什么类型的容器
C# yield的作用是什么
C# 成员变量和成员函数前加static的作用？
C#中IEnumerator的概念和作用是什么
C#中out关键字如何实现将参数传到方法外？
C#中实现多线程的方式有哪些？
C#中引用类型加ref和不加ref有什么差别？
C#中用static定义构造函数会怎么样
C#中的List和数组的区别是什么
C#所有类的基类是什么
C#添加事件和删除事件一般通过+=或-=，如果添加两次+=同一个事件，调用会执行一次还是两次
C#的协程是什么
HashSet和Dictionary的区别是什么
int?和int有什么区别
int32的最大值2147483647加1之后等于多少
List中如果中间删除了某些元素，List会做什么操作，原数组会有什么问题
sealed关键字的作用是什么
什么时候使用class，什么时候使用struct
列举哪些情况会发生装箱
前台线程和后台线程有什么差别？
当字符串操作非常频繁时，如何进行优化
简述 readonly 关键字的作用
简述C# dictionary查询的复杂度是多少，为什么
简述C#装箱拆箱时，在内存上发生了什么变化
请列举Using关键字的用法
请列举引用类型和值类型，说明它们的数据存储结构，以及拆装箱时底层发生了什么
请简述装箱的危害
请说明C#中拆装箱操作的运行机制
请说明StringBuilder和String的区别，拼接字符串时的区别，以及StringBuild
AOT打包项目后，是否还能使用反射
C#中两个线程之间如何实现通信机制？
C#中参数传递 ref 与 out 的区别？
C#中的partial类是什么？它有什么用途？
C#中的互斥量和锁分别是什么？
C#中的扩展方法是什么，如何使用？
C#中的管道如何实现？
c#可否对内存直接操作？
C#实现多态的过程中 overload 重载与override 重写的区别？
C#闭包和匿名表达式在什么情况下会产生GC
Lock锁的是一个对象，对这个对象有什么要求？
Parallel的应用场景有哪些
不使用反射，有什么办法可以实现类似的效果
为什么数组查找比List快？
分析C# Lambda表达式及其性能
协程是否算是异步
在C#中如何让GC延迟调用
在C#中如何进行深拷贝？
多个线程之间访问同一个数据时如何保证数据的线程安全，如何处理多线程并发安全问题？
如何解决装箱拆箱带来的性能消耗
如果用字符串作为dictionary的键，会有什么问题和性能损耗
当await异步等待加载网络AB包出错时，应如何处理
接口传递结构体时，是进行装箱还是拆箱操作？
是否了解 unity 的垃圾回收机制
有一个积分变量，在操作过程中存在频繁拆装箱的情况，如何进行优化；若积分最多只有1000，又该如何优化
简述C# GC区域划分
简述C#中的泛型（Generic）及其优势。
线程池相对于基础的线程有什么优缺点？
设置线程池的最大进程数的目的是什么？
说一下C#的编译流程
请介绍各种锁的概念和应用
请解释为什么GC会产生卡顿
请详细说明C#内存分配情况，包括string对象、StringBuilder对象和const修饰的变
请说明Using里面用到哪些固定类型，工作原理和机制，在内存中发生了什么，是否可以在里面使用多线程
请说明对 DI 和 IOC 的了解，以及.NET 内置容器的三种生命周期
请说明对异步多线程的看法以及异步多线程可能导致的问题
请阐述对IOC与AOP的理解
请阐述对ORM框架的理解，列举认识的ORM框架并说明常用的有哪些
请阐述数据库连接池释放的原理，是否使用到了垃圾回收机制以及原因
C#中的多线程如何实现？
请阐述异步、多线程的底层原理，以及在项目中的应用和遇到的问题
ADO.NET常用对象有哪些？
byte a = 255; a += 5; a的值是多少？
C#中的LINQ是什么？它有哪些主要组件？
new关键字的作用
Strings = new String(“xyz”); 创建了几个String Object?
什么是LINQ？请给出一个简单示例。
什么是NuGet？如何在C#项目中使用。
在ASP.NET中所有的自定义用户控件都必须继承自？
字符串中string str=null和string str=““和string str=strin
请描述C#中的字符串格式化方法。
请解释C#中的foreach循环的工作原理。
请解释C#中的命名空间（Namespace）及其作用。
C#中如何实现单例模式？
C#中用sealed修饰的类有什么特点？
C#中的Attributes是什么？它们的用途是什么？
C#中的Serialization和Deserialization是什么？
C#中的Task和Thread的区别是什么？
C#中的动态类型（dynamic）和var关键字有什么区别？
C#中的多线程编程是怎样的？简述Thread、ThreadPool和Task的区别。
C#中的属性和字段有什么区别？
C#中的异常处理机制是怎样的？try-catch-finally块的作用是什么？
C#中的构造函数和析构函数有什么区别？
C#中的版本控制（Versioning）如何管理？
C#中的索引器是什么？如何创建自定义索引器？
C#中的集合（Collection）有哪些主要类型？它们各自的特点是什么？
C#静态构造函数特点是什么？
const和readonly有什么区别？
CTS、CLS、CLR分别作何解释
ORM中的延迟加载与直接加载有什么异同？
什么叫应用程序域(AppDomain)
什么是ASP.NET中的Web API？
什么是MVC架构，它是如何在C#中实现的？
什么是MVC模式
什么是多态？如何在C#中实现多态？
什么是强类型，什么是弱类型？哪种更好些？为什么?
什么是数据绑定？如何在C#中实现？
什么是数据访问层（DAL）？如何实现它？
什么是线性链表和双向链表的区别？
什么是虚函数？什么是抽象函数？
在.NET托管代码总我们不必担心内存泄漏，这是因为？
如何在C#中实现接口的多重继承？
描述C#中的垃圾回收机制（Garbage Collection）。
描述C#中的构造函数和析构函数的作用及用法。
简述C#中的委托（Delegate）和匿名方法（Anonymous Method）。
简述Func与Action的区别？
请描述ASP.NET中的路由机制。
请描述C#中的可空类型（Nullable Types）。
请描述如何在C#中处理异常。
请解释C#中字符串的不变性。
请解释C#中的lambda表达式及其语法。
请解释C#中的属性（Property）及其访问器（Accessor）。
请解释C#中的特性（Attribute）及其作用。
请解释C#中的锁（lock）语句及其使用场景。
请解释什么是async和await，以及它们的使用场景。
请解释如何处理JSON数据。
请阐述MVC与MVVM模式的区别。
C#中如何实现命令模式？
什么是反序列化攻击？如何防范？
请解释C#中的锁自由（Lock-free）编程模型。
请解释如何处理并发问题。

Python 的 self 和 C# 的 this

Tue, 28 Oct 2025 00:00:00 +0000

🧩 一、基本作用对比

对比点	Python 中的 `self`	C# 中的 `this`
含义	当前对象的引用（实例本身）	当前对象的引用（实例本身）
显式性	必须显式写出在方法参数中（通常命名为 `self`）	编译器隐式提供，在实例方法中自动可用
是否关键字	不是关键字，只是约定俗成的名字（可改成别的）	是语言关键字
使用场景	类的实例方法第一个参数必须传入 `self`	类的实例方法可直接使用 `this`
静态方法是否可用	不可用，除非手动传实例	不可用，只能用于实例方法

🧠 二、示例对比

🐍 Python

1
2
3
4
5
6


class Person:
 def __init__(self, name):
 self.name = name # self 指当前实例

 def greet(self):
 print(f"Hello, I'm {self.name}")

使用：

1
2


p = Person("Alice")
p.greet() # 等价于 Person.greet(p)

✅ 注意：调用 p.greet() 时，Python 自动传入 self=p。

💻 C#

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


class Person
{
 private string name;

 public Person(string name)
 {
 this.name = name; // this 指当前实例
 }

 public void Greet()
 {
 Console.WriteLine($"Hello, I'm {this.name}");
 }
}

使用：

1
2


var p = new Person("Alice");
p.Greet(); // 编译器自动绑定 this = p

✅ 在 C# 中不需要显式传参，this 是隐式存在的。

⚙️ 三、调用机制差异

对比点	Python	C#
方法本质	实例方法其实是普通函数，通过绑定对象成为“方法”	实例方法是类成员，编译器自动关联实例
调用本质	`p.greet()` → `Person.greet(p)`	`p.Greet()` → 编译器自动传递 `this`
函数与方法界限	较模糊（函数本身独立于类存在）	明确区分（方法绑定在类型上）

🧩 四、可用场景差异

场景	Python (self)	C# (this)
引用实例成员	`self.name`	`this.name`（也可省略）
区分同名变量	`self.name = name`（手动）	`this.name = name`（常用）
链式调用	`return self` 可实现	`return this` 可实现
静态方法	`@staticmethod` 不带 `self`	`static` 方法不能用 `this`
类方法	`@classmethod` 用 `cls`（类本身）	没有类似的机制（但可用泛型或反射实现）

💡 五、总结一句话

self 是 Python 显式传递的实例引用； this 是 C# 编译器隐式提供的实例引用。

C#.NET 中间件详解

Mon, 27 Oct 2025 00:00:00 +0000

简介

中间件（Middleware）是 ASP.NET Core 的核心组件，用于处理 HTTP 请求和响应的管道机制。它是基于管道模型的轻量级、模块化设计，允许开发者在请求处理过程中插入自定义逻辑。中间件广泛应用于日志记录、认证授权、异常处理、路由等场景。

定义：中间件是处理 HTTP 请求和响应的组件，位于服务器接收到请求到最终返回响应之间的“管道”中。
作用：可用于身份认证、授权、日志、静态文件、异常处理、CORS、压缩、路由等横切关注点。
职责链：请求依次经过每个中间件，执行“前置逻辑”→调用下一个中间件→执行“后置逻辑”，最终形成责任链。

请求管道（Request Pipeline）

构建：在 Startup.Configure(IApplicationBuilder app) 中，通过 app.UseXXX()、app.Run() 等方法，按注册顺序构建一条 RequestDelegate 链。
执行：框架在收到 HTTP 请求时，从管道头部（第一个中间件）开始执行，直到找到终结点（UseEndpoints/Run）或管道结束。
短路：中间件可以选择不调用 next()，直接生成响应，阻断后续中间件。
请求流程：Client → Middleware1 → Middleware2 → … → Endpoint
响应流程：Endpoint → … → Middleware2 → Middleware1 → Client

1
2
3


HTTP → [Middleware A] → [Middleware B] → [Middleware C] → Response
 ↑ ↓
 前置逻辑 A 后置逻辑 B

请求委托（RequestDelegate）

每个中间件通过 RequestDelegate 封装处理逻辑，接收 HttpContext 并异步执行操作

1
2
3
4
5
6


public async Task InvokeAsync(HttpContext context, RequestDelegate next)
{
 // 预处理请求
 await next(context); // 调用下一个中间件
 // 后处理响应
}

短路（Short-Circuiting）

中间件可通过不调用 next() 终止管道，直接返回响应（如静态文件中间件找到文件时）

中间件的注册与类型

注册方式

通过 IApplicationBuilder 在 Program.cs 或 Startup.Configure 中注册，顺序决定执行优先级

方法	方法	示例
`Use`	添加可调用下一个中间件的组件	`app.Use(async (ctx, next) => { ... await next(); ... })`
`Run`	添加终端中间件（强制短路）	`app.Run(ctx => ctx.Response.WriteAsync("End"))`
`Map`	根据路径分支管道	`app.Map("/admin", branch => { ... })`
`MapWhen`	按条件分支管道	`app.MapWhen(ctx => ctx.Request.Query.ContainsKey("log"), branch => ...)`

生命周期管理

单例构造：中间件类在应用启动时实例化（构造函数仅执行一次）
按请求执行：Invoke 或 InvokeAsync 方法对每个请求调用一次

自定义中间件实现

基本模板

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


public class MyMiddleware
{
 private readonly RequestDelegate _next;

 public MyMiddleware(RequestDelegate next)
 {
 _next = next;
 }

 public async Task InvokeAsync(HttpContext context)
 {
 // 前置逻辑
 // e.g. 日志：Console.WriteLine("Request start: " + context.Request.Path);

 await _next(context); // 调用下一个中间件

 // 后置逻辑
 // e.g. 日志：Console.WriteLine("Request end: " + context.Response.StatusCode);
 }
}

扩展方法

1
2
3
4
5
6
7


public static class MyMiddlewareExtensions
{
 public static IApplicationBuilder UseMyMiddleware(this IApplicationBuilder app)
 {
 return app.UseMiddleware<MyMiddleware>();
 }
}

在 Startup.Configure 或 Program 中调用：

1

app.UseMyMiddleware();

内置中间件概览

中间件	功能
`UseRouting` / `UseEndpoints`	路由匹配与终结点执行
`UseStaticFiles`	提供静态文件服务
`UseAuthentication`	验证用户身份
`UseAuthorization`	授权策略检查
`UseCors`	跨域请求支持
`UseResponseCompression`	响应内容压缩
`UseSession`	会话状态管理
`UseExceptionHandler` / `UseDeveloperExceptionPage`	全局异常捕获与开发环境错误页
`UseHttpsRedirection`	HTTP 自动重定向到 HTTPS
`UseForwardedHeaders`	X-Forwarded-For / X-Forwarded-Proto 处理

典型的注册顺序：

1
2
3
4
5
6
7
8
9


app.UseExceptionHandler("/Error"); // 异常处理（最先）
app.UseHttpsRedirection(); // HTTPS 重定向
app.UseStaticFiles(); // 静态文件
app.UseRouting(); // 路由
app.UseAuthentication(); // 认证
app.UseAuthorization(); // 授权
app.UseEndpoints(endpoints => { // 端点处理（最后）
 endpoints.MapControllers();
});

注册顺序与注意事项

异常处理：
- UseDeveloperExceptionPage（开发环境）或 UseExceptionHandler 应放在最前面，捕获后续所有异常。
HTTPS 重定向：
- UseHttpsRedirection 需在路由、静态文件之前。
静态文件：
- 若站点静态资源较多，应尽早调用 UseStaticFiles，避免无谓路由匹配。
路由与终结点：
- 必须在 UseRouting 后调用 UseAuthentication/UseAuthorization，再调用 UseEndpoints。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
 if (env.IsDevelopment())
 app.UseDeveloperExceptionPage();
 else
 app.UseExceptionHandler("/Home/Error");

 app.UseHttpsRedirection();
 app.UseStaticFiles();

 app.UseRouting();

 app.UseAuthentication();
 app.UseAuthorization();

 app.UseEndpoints(endpoints =>
 {
 endpoints.MapControllers();
 endpoints.MapRazorPages();
 });
}

终结点与分支

终结点（Endpoint）：UseEndpoints 中注册具体的请求处理，如 MVC 控制器、Razor 页面、SignalR、gRPC。
分支管道：app.Map("/path", branch => { /* branch.UseXXX() */ });
- 根据路径或条件，将请求“分流”到不同的子管道。

1
2
3
4
5
6


app.Map("/api", apiApp =>
{
 apiApp.UseRouting();
 apiApp.UseAuthorization();
 apiApp.UseEndpoints(endpoints => endpoints.MapControllers());
});

进阶用法

条件执行

1
2
3
4


app.UseWhen(ctx => ctx.Request.Path.StartsWithSegments("/mobile"), mobileApp =>
{
 mobileApp.UseMiddleware<MobileSpecificMiddleware>();
});

中间件短路

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


app.Use(async (ctx, next) =>
{
 if (ctx.Request.Path == "/health")
 {
 ctx.Response.StatusCode = 200;
 await ctx.Response.WriteAsync("OK");
 return; // 不调用 next，直接返回
 }

 await next();
});

捕获并处理异常

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


public class ErrorHandlingMiddleware
{
 private readonly RequestDelegate _next;
 public ErrorHandlingMiddleware(RequestDelegate next) => _next = next;

 public async Task InvokeAsync(HttpContext ctx)
 {
 try
 {
 await _next(ctx);
 }
 catch (Exception ex)
 {
 ctx.Response.StatusCode = 500;
 await ctx.Response.WriteAsync("Internal Server Error");
 // TODO: 日志记录 ex
 }
 }
}

分支中间件（Map/MapWhen）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


// 基于路径分支
app.Map("/api", apiApp => {
 apiApp.UseAuthentication();
 apiApp.UseEndpoints(endpoints => {
 endpoints.MapControllers();
 });
});

// 基于条件分支
app.MapWhen(context => context.Request.Query.ContainsKey("debug"), debugApp => {
 debugApp.UseMiddleware<DebugLoggingMiddleware>();
});

终结点中间件（Run）

1
2
3
4


// 直接终止请求管道，不调用后续中间件
app.Run(async context => {
 await context.Response.WriteAsync("Hello from terminal middleware!");
});

中间件与依赖注入一

在中间件中使用服务

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


public class AuthenticationMiddleware {
 private readonly RequestDelegate _next;
 private readonly IAuthService _authService;

 public AuthenticationMiddleware(RequestDelegate next, IAuthService authService) {
 _next = next;
 _authService = authService;
 }

 public async Task InvokeAsync(HttpContext context) {
 var token = context.Request.Headers["Authorization"];
 var user = await _authService.ValidateToken(token);
 context.User = user;
 await _next(context);
 }
}

作用域服务注入

1
2
3
4
5
6
7
8
9


public async Task InvokeAsync(HttpContext context) {
 // 手动解析作用域服务
 using (var scope = context.RequestServices.CreateScope()) {
 var scopedService = scope.ServiceProvider.GetRequiredService<IScopedService>();
 await scopedService.ProcessRequest(context);
 }

 await _next(context);
}

带配置的中间件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


public class CustomHeaderMiddleware
{
 private readonly RequestDelegate _next;
 private readonly string _headerValue;

 public CustomHeaderMiddleware(
 RequestDelegate next,
 string headerValue) // 配置参数
 {
 _next = next;
 _headerValue = headerValue;
 }

 public async Task Invoke(HttpContext context)
 {
 context.Response.Headers["X-Custom"] = _headerValue;
 await _next(context);
 }
}

// 注册时传递配置
app.UseMiddleware<CustomHeaderMiddleware>("MyValue");

中间件工厂 (IMiddlewareFactory)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


public class CustomMiddlewareFactory : IMiddlewareFactory
{
 public IMiddleware Create(Type middlewareType)
 {
 return ActivatorUtilities.CreateInstance(_serviceProvider, middlewareType) as IMiddleware;
 }

 public void Release(IMiddleware middleware) => (middleware as IDisposable)?.Dispose();
}

// 注册工厂
builder.Services.AddSingleton<IMiddlewareFactory, CustomMiddlewareFactory>();

中间件依赖注入二

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


public class MyMiddleware
{
 private readonly RequestDelegate _next;
 private readonly IUserService _userService;

 public MyMiddleware(RequestDelegate next, IUserService userService)
 {
 _next = next;
 _userService = userService;
 }

 public async Task InvokeAsync(HttpContext context)
 {
 var userName = _userService.GetUserName(1);
 await context.Response.WriteAsync($"User: {userName}");
 await _next(context);
 }
}

public static class MyMiddlewareExtensions
{
 public static IApplicationBuilder UseMyMiddleware(this IApplicationBuilder builder)
 {
 return builder.UseMiddleware<MyMiddleware>();
 }
}

// 注册服务
builder.Services.AddScoped<IUserService, UserService>();
app.UseMyMiddleware();

内置中间件

1
2
3
4
5
6
7
8


app.UseRouting(); // 路由匹配

app.UseEndpoints(endpoints =>
{
 endpoints.MapControllers(); // API控制器
 endpoints.MapRazorPages(); // Razor页面
 endpoints.MapHub<ChatHub>("/chat"); // SignalR
});

异常处理中间件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


app.UseExceptionHandler(errorApp =>
{
 errorApp.Run(async context =>
 {
 var exceptionHandler = context.Features.Get<IExceptionHandlerFeature>();
 // 记录异常
 await context.Response.WriteAsJsonAsync(new
 {
 Error = exceptionHandler.Error.Message
 });
 });
});

静态文件中间件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


app.UseStaticFiles(new StaticFileOptions
{
 FileProvider = new PhysicalFileProvider(
 Path.Combine(builder.Environment.ContentRootPath, "Assets")),
 RequestPath = "/static",
 OnPrepareResponse = ctx =>
 {
 ctx.Context.Response.Headers.Append("Cache-Control", "public,max-age=3600");
 }
});

System.Text.Json 和 Newtonsoft.Json 默认序列化时的大小写行为差异

Sat, 11 Oct 2025 00:00:00 +0000

在使用 RestSharp 时，很多人会遇到一个常见问题：序列化成 JSON 时字段的大小写被改变（比如属性名变成小写或 camelCase）。这通常与 RestSharp 默认使用的 JSON 序列化器（System.Text.Json 或 Newtonsoft.Json） 有关。

序列化器	默认属性命名策略	结果示例	说明	关闭大小写变化的方法
System.Text.Json (.NET Core 3+ 默认)	✅ camelCase（首字母小写）	`UserName` → `userName`	更符合前端 JavaScript 习惯	`options.PropertyNamingPolicy = null`
Newtonsoft.Json (Json.NET)	❌ 保留原有大小写	`UserName` → `UserName`	更传统，更适合后端系统间通信	`ContractResolver = new DefaultContractResolver()`

最容易踩坑的6个async/await 使用错误

Tue, 15 Jul 2025 00:00:00 +0000

📌 引言：async/await 很强大，但也很容易用错！

在 .NET 中使用 async 和 await 进行异步编程，确实让代码看起来更简洁、逻辑更清晰。但正因为写起来太“顺手”，很多开发者（包括我自己）都曾不小心掉进过各种“坑”里。

比如程序卡死、性能下降、异常丢失、资源耗尽……这些问题往往不是语法错误造成的，而是对异步机制的理解不到位。

今天我就来总结一下，.NET 开发者最容易犯的 6 个 async/await 使用错误，并告诉你正确的做法是什么。希望你看了之后能少走弯路，写出真正高效又稳定的异步代码。

🔥 常见错误一：用了 `.Result` 或 `.Wait()` 阻塞异步方法

❌ 错误示例：

1

var result = GetDataAsync().Result;

或者：

1

GetDataAsync().Wait();

⚠️ 为什么有问题？

这看似只是等一个结果，但在某些上下文环境中（比如 UI 线程或 ASP.NET 请求线程），这样做会导致死锁！

原因在于：

await 默认会尝试回到原来的上下文线程去继续执行。
如果主线程被 .Result 或 .Wait() 阻塞了，就没人去释放它，导致死循环。

✅ 正确做法：

如果当前方法支持异步，就把它也标记为 async，然后用 await：

1

var result = await GetDataAsync();

💡 小贴士：

★

在 ASP.NET Core、WPF、WinForms、Blazor Server 这类框架中，一定要避免使用 .Result 或 .Wait()，否则很容易引发死锁问题。

🔥 常见错误二：写了 `async` 方法，却没用 `await`

❌ 错误示例：

1
2
3
4


public async Task DoWorkAsync()
{
 Task.Delay(1000); // 啥也没干
}

⚠️ 有什么问题？

这个方法虽然加了 async，但没有用 await，所以它其实是一个同步方法，只不过多了一个状态机包装而已。

更糟的是，编译器并不会报错，你可能还以为自己写了个异步方法。

✅ 正确做法：

要用 await 才能真正进入异步流程：

1
2
3
4


public async Task DoWorkAsync()
{
 await Task.Delay(1000);
}

💡 小贴士：

★

每一个 async 方法都应该至少有一个 await；如果没有，那就不应该加 async。

🔥 常见错误三：使用 `async void`（除了事件处理）

❌ 错误示例：

1
2
3
4


public async void SaveDataAsync()
{
 await Task.Delay(500);
}

⚠️ 为什么危险？

async void 方法就像“幽灵”一样，你无法等待它完成，也无法捕获它的异常。

一旦抛出异常，就会直接崩溃整个应用程序 —— 即使你在外面写了 try-catch 也没用！

✅ 正确做法：

除非是事件处理函数（比如按钮点击），否则一律返回 Task：

1
2
3
4


public async Task SaveDataAsync()
{
 await Task.Delay(500);
}

这样就可以被 await 调用，并且能正确处理异常。

💡 小贴士：

★

除了事件处理器，永远不要写 async void 方法。它就像是“裸奔”的异步方法，非常不安全。

🔥 常见错误四：明明不需要异步，却还加 `async`

❌ 错误示例：

1
2
3
4


public async Task<int> GetNumberAsync()
{
 return 42;
}

⚠️ 有什么问题？

这个方法根本没有做任何异步操作，但却加了 async 关键字，白白引入了状态机，增加了性能开销。

这不是“为了异步而异步”，而是“为了装样子而异步”。

✅ 正确做法：

如果你的方法就是同步返回数据，那就不要用 async，直接返回已完成的 Task：

1
2
3
4


public Task<int> GetNumberAsync()
{
 return Task.FromResult(42);
}

💡 小贴士：

★

只有当你真的在调用 I/O、数据库、网络请求等异步操作时，才需要用 async/await，否则就别滥用。

🔥 常见错误五：每次调用都 new HttpClient

❌ 错误示例：

1
2
3
4
5


public async Task<string> GetData()
{
 using var client = new HttpClient(); // 每次都新建一个
 return await client.GetStringAsync("https://api.example.com/data");
}

⚠️ 有什么风险？

每次创建 HttpClient 实际上都会打开一个新的 TCP 连接，而且关闭后不会立刻释放端口，容易造成端口耗尽（Socket Exhaustion）。

尤其是在高并发场景下，这种写法可能会让你的应用突然“挂掉”。

✅ 正确做法：

把 HttpClient 当作共享资源来使用，推荐通过依赖注入的方式获取：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


private readonly HttpClient _httpClient;

public MyService(HttpClient httpClient)
{
 _httpClient = httpClient;
}

public async Task<string> GetData()
{
 return await _httpClient.GetStringAsync("https://api.example.com/data");
}

这样不仅复用了连接，还能更好地控制生命周期。

💡 小贴士：

★

HttpClient 是设计用来长期使用的，频繁 new 它是一种“反模式”。建议配合 IHttpClientFactory 或服务注入一起使用。

🔥 常见错误六：忽略 ConfigureAwait(false)，导致上下文捕获引发死锁

❌ 错误示例：

1
2
3
4
5


// 默认捕获当前上下文，可能导致线程阻塞
public async Task DoWorkAsync()
{
 await SomeIoOperationAsync(); // 默认会尝试回到原始上下文
}

⚠️ 有什么问题？

在很多异步库或框架中（如 ASP.NET 或 WPF），await 默认会尝试捕获当前的同步上下文（Synchronization Context），并在任务完成后回到这个上下文继续执行后续代码。

这在 UI 应用中是有意义的，但在非 UI 层（如类库、服务层）中，这种行为反而可能带来不必要的性能开销，甚至在某些情况下引发死锁。

✅ 正确做法：

在非 UI 代码中，建议加上 .ConfigureAwait(false) 来避免上下文捕获：

1
2
3
4
5


// 避免上下文捕获，提高性能并防止死锁
public async Task DoWorkAsync()
{
 await SomeIoOperationAsync().ConfigureAwait(false);
}

💡 小贴士：

★

在类库、通用方法、后台服务中，建议始终加上 .ConfigureAwait(false)，除非你确实需要回到原始上下文。

🧾 总结：async/await 的最佳实践清单

问题	推荐做法
❌ 使用 `.Result` 或 `.Wait()`	✅ 改成 `async/await`，保持异步链
❌ 写了 `async` 却不用 `await`	✅ 该删就删，不该加就别加
❌ 乱用 `async void`	✅ 仅限事件处理，其他一律用 `Task`
❌ 不需要异步却加了 `async`	✅ 用 `Task.FromResult()` 替代
❌ 每次都 new HttpClient	✅ 全局复用或通过 DI 获取
❌ 忽略 `ConfigureAwait(false)`	✅ 非 UI 代码中加上 `.ConfigureAwait(false)`

🎯 写在最后

async/await 是 .NET 中非常强大的工具，但也是一把双刃剑。用得好，能让你的应用响应更快、吞吐更高；用不好，轻则性能下降，重则系统崩溃。

这篇文章列出的六个常见错误，都是我们在实际项目中最容易踩到的“地雷”。希望你能从中吸取经验教训，写出更稳定、更高效的异步代码。

基本数据类型

Wed, 25 Jun 2025 00:00:00 +0000

当谈及计算机中的数据时，我们会想到文本、图片、视频、语音、3D 模型等各种形式。尽管这些数据的组织形式各异，但它们都由各种基本数据类型构成。

基本数据类型是 CPU 可以直接进行运算的类型，在算法中直接被使用，主要包括以下几种。

整数类型 byte、short、int、long 。
浮点数类型 float、double ，用于表示小数。
字符类型 char ，用于表示各种语言的字母、标点符号甚至表情符号等。
布尔类型 bool ，用于表示“是”与“否”判断。

基本数据类型以二进制的形式存储在计算机中。一个二进制位即为1 比特。在绝大多数现代操作系统中，1 字节（byte）由8 比特（bit）组成。

基本数据类型的取值范围取决于其占用的空间大小。下面以 Java 为例。

整数类型 byte 占用1 字节 =8 比特，可以表示28 个数字。
整数类型 int 占用4 字节 =32 比特，可以表示232 个数字。

表 3-1 列举了 Java 中各种基本数据类型的占用空间、取值范围和默认值。此表格无须死记硬背，大致理解即可，需要时可以通过查表来回忆。

表 3-1 基本数据类型的占用空间和取值范围

类型	符号	占用空间	最小值	最大值	默认值
整数	`byte`	1 字节	$-2^7$ ($-128$)	$2^7 - 1$ ($127$)	$0$
	`short`	2 字节	$-2^{15}$	$2^{15} - 1$	$0$
	`int`	4 字节	$-2^{31}$	$2^{31} - 1$	$0$
	`long`	8 字节	$-2^{63}$	$2^{63} - 1$	$0$
浮点数	`float`	4 字节	$1.175 \times 10^{-38}$	$3.403 \times 10^{38}$	$0.0\text{f}$
	`double`	8 字节	$2.225 \times 10^{-308}$	$1.798 \times 10^{308}$	$0.0$
字符	`char`	2 字节	$0$	$2^{16} - 1$	$0$
布尔	`bool`	1 字节	$\text{false}$	$\text{true}$	$\text{false}$

请注意，表 3-1 针对的是 Java 的基本数据类型的情况。每种编程语言都有各自的数据类型定义，它们的占用空间、取值范围和默认值可能会有所不同。

在 Python 中，整数类型 int 可以是任意大小，只受限于可用内存；浮点数 float 是双精度 64 位；没有 char 类型，单个字符实际上是长度为 1 的字符串 str 。
C 和 C++ 未明确规定基本数据类型的大小，而因实现和平台各异。表 3-1 遵循 LP64 数据模型，其用于包括 Linux 和 macOS 在内的 Unix 64 位操作系统。
字符 char 的大小在 C 和 C++ 中为 1 字节，在大多数编程语言中取决于特定的字符编码方法，详见“字符编码”章节。
即使表示布尔量仅需 1 位（

0 或

1），它在内存中通常也存储为 1 字节。这是因为现代计算机 CPU 通常将 1 字节作为最小寻址内存单元。

那么，基本数据类型与数据结构之间有什么联系呢？我们知道，数据结构是在计算机中组织与存储数据的方式。这句话的主语是“结构”而非“数据”。

如果想表示“一排数字”，我们自然会想到使用数组。这是因为数组的线性结构可以表示数字的相邻关系和顺序关系，但至于存储的内容是整数 int、小数 float 还是字符 char ，则与“数据结构”无关。

换句话说，基本数据类型提供了数据的“内容类型”，而数据结构提供了数据的“组织方式”。例如以下代码，我们用相同的数据结构（数组）来存储与表示不同的基本数据类型，包括 int、float、char、bool 等。

Windows桌面程序单例

Thu, 19 Jun 2025 00:00:00 +0000

使用 `EventWaitHandle`

原理：通过命名的事件对象（EventWaitHandle）检测是否已有实例运行。

特点：

适合跨进程通信（IPC）。
可以通过 Set() 和 WaitOne() 唤醒其他实例（如你的代码中唤醒主窗口）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84


 public bool EnsureAppSingletion()
 {
 EventWaitHandle singletonEvent = new EventWaitHandle(false, EventResetMode.AutoReset, "SlimeNull/OpenGptChat", out bool createdNew);

 if (createdNew)
 {
 Task.Run(() =>
 {
 while (true)
 {
 // wait for the second instance of OpenGptChat
 singletonEvent.WaitOne();

 Dispatcher.Invoke(() =>
 {
 ShowApp();
 });
 }
 });

 return true;
 }
 else
 {
 singletonEvent.Set();
 return false;
 }
 }
 public static void ShowApp()
{
 Window mainWindow = Application.Current.MainWindow;
 if (mainWindow == null)
 return;

 mainWindow.Show();

 if (mainWindow.WindowState == WindowState.Minimized)
 mainWindow.WindowState = WindowState.Normal;

 if (!mainWindow.IsActive)
 mainWindow.Activate();
}
 public bool EnsureAppSingletion()
 {
 EventWaitHandle singletonEvent = new EventWaitHandle(false, EventResetMode.AutoReset, "SlimeNull/OpenGptChat", out bool createdNew);

 if (createdNew)
 {
 Task.Run(() =>
 {
 while (true)
 {
 // wait for the second instance of OpenGptChat
 singletonEvent.WaitOne();

 Dispatcher.Invoke(() =>
 {
 ShowApp();
 });
 }
 });

 return true;
 }
 else
 {
 singletonEvent.Set();
 return false;
 }
 }
 public static void ShowApp()
{
 Window mainWindow = Application.Current.MainWindow;
 if (mainWindow == null)
 return;

 mainWindow.Show();

 if (mainWindow.WindowState == WindowState.Minimized)
 mainWindow.WindowState = WindowState.Normal;

 if (!mainWindow.IsActive)
 mainWindow.Activate();
}

使用 `Mutex`（互斥锁）

原理：通过命名的互斥锁检测是否已有实例运行。
特点：
- 更轻量级，适合单纯判断单例（不涉及复杂通信）。
- 系统会自动释放资源（Mutex 继承自 WaitHandle，有 Dispose() 机制）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


public bool EnsureAppSingleton()
{
 bool isFirstInstance;
 Mutex mutex = new Mutex(true, "SlimeNull/OpenGptChat", out isFirstInstance);

 if (isFirstInstance)
 {
 // 首次运行，保持 Mutex 不释放（通过不调用 ReleaseMutex）
 return true;
 }
 else
 {
 mutex.Dispose(); // 立即释放资源
 return false;
 }
}
public bool EnsureAppSingleton()
{
 bool isFirstInstance;
 Mutex mutex = new Mutex(true, "SlimeNull/OpenGptChat", out isFirstInstance);

 if (isFirstInstance)
 {
 // 首次运行，保持 Mutex 不释放（通过不调用 ReleaseMutex）
 return true;
 }
 else
 {
 mutex.Dispose(); // 立即释放资源
 return false;
 }
}

两种方式的对比

特性	`EventWaitHandle`	`Mutex`
主要用途	跨进程通信 + 单例判断	单例判断（轻量级）
资源释放	需手动 `Dispose()` 或 `Close()`	自动释放（`using` 语句）
唤醒其他实例	支持（通过 `Set()`）	不支持
性能	稍重（适合复杂场景）	更轻量

如何选择？

如果只需要判断单例（不涉及唤醒其他实例），优先用 Mutex（代码更简洁）。
如果需要唤醒已有实例（如你的代码中唤醒主窗口），用 EventWaitHandle。

时间复杂度与空间复杂度

Thu, 06 Mar 2025 00:00:00 +0000

常数时间复杂度 O(1)

示例：访问数组元素

1
2


int[] arr = { 1, 2, 3, 4, 5 };
int firstElement = arr[0]; // 直接访问第一个元素

• 时间复杂度：O(1)
直接通过索引访问数组元素，操作次数与输入规模无关。 • 空间复杂度：O(1)
仅使用固定内存存储变量 firstElement，无额外空间占用。

对比：时间和空间均为常数级别，效率极高。

线性时间复杂度 O(n)

示例1：遍历数组求和

1
2
3
4
5
6
7


int SumArray(int[] arr) {
 int sum = 0;
 foreach (int num in arr) { // 遍历每个元素
 sum += num;
 }
 return sum;
}

• 时间复杂度：O(n)
需要遍历数组的每个元素，操作次数与输入规模 n 成线性关系。 • 空间复杂度：O(1)
仅使用固定变量 sum，不随输入规模增加。

示例2：复制数组

1
2
3
4
5
6
7


int[] CopyArray(int[] arr) {
 int[] newArr = new int[arr.Length];
 for (int i = 0; i < arr.Length; i++) {
 newArr[i] = arr[i];
 }
 return newArr;
}

• 时间复杂度：O(n)
遍历数组复制每个元素。 • 空间复杂度：O(n)
需要额外创建一个长度为 n 的新数组。

对比：
• 同样是 O(n) 时间，SumArray 的空间复杂度更优（O(1) vs O(n)）。
• 空间与时间的权衡：复制数组牺牲空间来保留原始数据。

平方时间复杂度 O(n²)

示例：冒泡排序

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


void BubbleSort(int[] arr) {
 for (int i = 0; i < arr.Length; i++) {
 for (int j = 0; j < arr.Length - 1; j++) {
 if (arr[j] > arr[j + 1]) {
 int temp = arr[j];
 arr[j] = arr[j + 1];
 arr[j + 1] = temp;
 }
 }
 }
}

• 时间复杂度：O(n²)
双重循环导致操作次数与 n² 成正比。 • 空间复杂度：O(1)
原地排序，仅用临时变量 temp，无额外空间占用。

对比：时间效率低但空间效率高，适合内存受限的场景。

递归算法的复杂度分析

示例1：斐波那契数列（递归实现）

1
2
3
4


int Fibonacci(int n) {
 if (n <= 1) return n;
 return Fibonacci(n - 1) + Fibonacci(n - 2);
}

• 时间复杂度：O(2ⁿ)
递归调用指数级增长（每次调用产生两个子问题）。 • 空间复杂度：O(n)
递归调用栈深度为 n，占用线性空间。

示例2：斐波那契数列（迭代实现）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


int FibonacciIterative(int n) {
 if (n <= 1) return n;
 int a = 0, b = 1, sum;
 for (int i = 2; i <= n; i++) {
 sum = a + b;
 a = b;
 b = sum;
 }
 return b;
}

• 时间复杂度：O(n)
单层循环遍历 n 次。 • 空间复杂度：O(1)
仅使用固定变量 a, b, sum。

对比：
• 递归实现牺牲时间（O(2ⁿ)）和空间（O(n)）换取代码简洁性。
• 迭代实现通过优化，时间降至 O(n)，空间降至 O(1)，但代码稍复杂。

时间与空间的权衡

哈希表：以空间换时间

1
2
3
4
5
6
7
8


bool HasDuplicate(int[] arr) {
 HashSet<int> seen = new HashSet<int>();
 foreach (int num in arr) {
 if (seen.Contains(num)) return true;
 seen.Add(num);
 }
 return false;
}

• 时间复杂度：O(n)
HashSet 的插入和查询操作平均为 O(1)。 • 空间复杂度：O(n)
需要额外存储所有元素的哈希表。

对比：
通过牺牲 O(n) 的空间，将时间从暴力法的 O(n²) 优化到 O(n)。

总结对比

场景	时间复杂度	空间复杂度	核心权衡
直接访问数组元素	O(1)	O(1)	无
遍历数组求和	O(n)	O(1)	时间线性增长，空间高效
复制数组	O(n)	O(n)	空间换数据完整性
冒泡排序	O(n²)	O(1)	时间低效，空间高效
斐波那契递归	O(2ⁿ)	O(n)	时间和空间均低效，代码简洁
斐波那契迭代	O(n)	O(1)	时间高效，空间高效
哈希表查重	O(n)	O(n)	空间换时间

核心思想：
• 时间复杂度关注操作次数的增长率，空间复杂度关注内存占用的增长率。
• 实际开发中需根据场景选择：
• 内存敏感（如嵌入式系统）优先优化空间复杂度。
• 时间敏感（如实时计算）优先优化时间复杂度。
• 递归需警惕栈溢出风险，迭代更可控。

C#泛型底层

Fri, 21 Feb 2025 00:00:00 +0000

C# 泛型的底层实现是 CLR（公共语言运行时）和 JIT（即时编译器）协作的结果，其核心目标是实现 类型安全、性能优化 和 代码复用。以下是其底层实现的关键细节：

泛型的运行时支持

C# 泛型是 “真泛型”（与 Java 的类型擦除不同），泛型类型参数在运行时完全保留。这意味着：

类型信息保留
泛型类型参数（如 T）会被编译到 IL（中间语言）和元数据中，CLR 在运行时可以感知具体类型。

动态实例化
泛型类型（如 List<int>）在首次使用时由 JIT 动态生成具体实现，而非编译时展开。

值类型 vs 引用类型的实现差异

值类型（如 `int`, `struct`）

独立代码生成
CLR 会为每个值类型参数生成 完全独立的机器代码。例如：
List<int> 和 List<double> 在运行时是不同的类型，拥有独立的方法表和内存布局。
优势：避免装箱拆箱，直接操作原生数据类型。
内存布局优化
值类型泛型的实例在内存中连续存储，无需指针间接访问。

引用类型（如 `string`, `class`）

代码共享
所有引用类型参数共享 同一份 JIT 编译后的代码。例如：
List<string> 和 List<object> 共享大部分实现，因为它们的内存布局（指针大小）一致。
优势：减少代码膨胀，节省内存。
类型擦除的假象
虽然代码共享，但运行时类型信息（如 typeof(List<>).GetGenericArguments()）仍然完整保留。

泛型类型的实例化过程

JIT 编译时的动态生成

当首次使用某个泛型类型（如 List<int>）时，JIT 编译器会根据类型参数生成对应的 本地机器代码。
值类型：生成专用代码（如直接操作 int 的指令）。
引用类型：生成通用代码（通过指针操作，适配所有引用类型）。

代码共享机制

引用类型共享条件
若两个引用类型参数的 内存布局相同（如 string 和 object），则共享同一份代码。
值类型不共享
每个值类型（如 int、long）生成独立代码，因其内存大小不同。

泛型方法的内联优化

JIT 编译器可能对泛型方法进行 内联展开（尤其是值类型参数），例如：

1
2
3
4
5


public static T Add<T>(T a, T b) where T : struct => a + b;

// 调用 Add<int>(1, 2) 时，JIT 可能直接生成类似以下机器码：
// mov eax, 1
// add eax, 2

优势：消除方法调用开销，进一步提升性能。

静态字段的隔离

每个封闭泛型类型（如 MyClass<int> 和 MyClass<string>）拥有 独立的静态字段：

1
2
3
4
5
6
7


public class MyClass<T>
{
 public static int Count;
}

MyClass<int>.Count = 10;
MyClass<string>.Count = 20; // 与 MyClass<int>.Count 完全独立

底层原因：不同泛型类型在运行时被视为完全不同的类型。

类型约束的底层实现

类型约束（如 where T : IComparable）通过以下方式实现：

编译时验证
编译器确保所有对 T 的操作符合约束（如调用 T.CompareTo 方法）。
运行时验证
当通过反射动态创建泛型实例时，CLR 会检查类型参数是否满足约束。

协变（Covariance）与逆变（Contravariance）

协变（`out T`）

允许将 IEnumerable<Cat> 赋值给 IEnumerable<Animal>。
实现方式：CLR 通过虚方法表和类型转换表动态处理类型兼容性。

逆变（`in T`）

允许将 Action<Animal> 赋值给 Action<Cat>。
实现方式：JIT 生成通用代码，确保输入参数类型安全。

泛型与性能优化

避免装箱拆箱
值类型泛型（如 List<int>）直接操作栈内存，无需将 int 装箱为 object。

缓存机制
CLR 会缓存已生成的泛型类型代码，避免重复编译。

内存效率
值类型泛型集合（如 List<int>）在内存中连续存储，比 ArrayList（存储 object）更紧凑。

对比 C++ 模板

特性	C# 泛型	C++ 模板
实例化时机	运行时由 JIT 动态生成	编译时展开为具体代码
类型安全	编译时 + 运行时双重检查	编译时模板展开后检查
代码生成	值类型独立生成，引用类型共享代码	所有类型独立生成代码
跨程序集支持	是（元数据保留泛型信息）	否（模板定义需在头文件中）

反射与泛型

通过反射可以动态操作泛型类型：

1
2
3
4
5
6
7
8
9


// 动态创建 List<int>
Type openType = typeof(List<>);
Type closedType = openType.MakeGenericType(typeof(int));
object list = Activator.CreateInstance(closedType);

// 调用泛型方法
MethodInfo method = typeof(MyClass).GetMethod("MyMethod");
MethodInfo closedMethod = method.MakeGenericMethod(typeof(string));
closedMethod.Invoke(null, new object[] { "test" });

底层 IL 表示

泛型在 IL（中间语言）中使用 类型参数占位符（如 !!0）表示：

1
2
3
4
5
6
7


// 泛型方法的 IL 代码示例
.method public static void Swap<T>(!!T& a, !!T& b)
{
 ldarg.0
 ldarg.1
 // 交换操作的 IL 指令
}

总结

C# 泛型的底层实现通过 CLR 和 JIT 的深度协作，实现了：

真泛型：运行时保留类型信息，支持反射和动态类型操作。
高性能：值类型专用代码、引用类型共享代码、内联优化。
类型安全：编译时和运行时双重验证。
灵活性：协变/逆变、泛型约束、跨程序集支持。

这种设计使 C# 泛型在效率、安全性和灵活性上达到了平衡，成为现代 C# 开发的核心工具。

C#泛型基础

Fri, 21 Feb 2025 00:00:00 +0000

C# 泛型是一种强大的编程特性，允许开发者编写可重用、类型安全且高效的代码。通过泛型，可以在定义类、接口、方法或委托时使用类型参数，实际使用时再指定具体类型。以下是关于 C# 泛型的详细介绍：

泛型的核心优势

类型安全

泛型在编译时检查类型，避免运行时类型转换错误（如 object 的装箱拆箱操作）。

代码复用

同一套逻辑可适用于多种数据类型，无需为不同类型重复编写代码。

性能优化

避免值类型的装箱拆箱操作，提升性能（例如使用 List<int> 而非 ArrayList）。

泛型的基本用法

泛型类（Generic Class）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


public class GenericRepository<T>
{
 private List<T> _items = new List<T>();

 public void Add(T item) => _items.Add(item);
 public T Get(int index) => _items[index];
}

// 使用示例
var intRepo = new GenericRepository<int>();
intRepo.Add(42);

var stringRepo = new GenericRepository<string>();
stringRepo.Add("Hello");

泛型接口（Generic Interface）

1
2
3
4
5
6
7
8
9


public interface IComparer<T>
{
 int Compare(T x, T y);
}

public class IntComparer : IComparer<int>
{
 public int Compare(int x, int y) => x.CompareTo(y);
}

泛型方法（Generic Method）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


public static void Swap<T>(ref T a, ref T b)
{
 T temp = a;
 a = b;
 b = temp;
}

// 使用示例
int x = 1, y = 2;
Swap(ref x, ref y); // 编译器自动推断类型为 int

泛型委托（Generic Delegate）

1
2
3
4
5


public delegate T Processor<T>(T input);

// 使用示例
Processor<int> square = n => n * n;
int result = square(5); // 25

类型约束（Type Constraints）

通过 where 关键字限制泛型参数的类型范围，增强类型安全性。

约束类型	示例	说明
值类型	`where T : struct`	T 必须是值类型（如 `int`）
引用类型	`where T : class`	T 必须是引用类型（如 `string`）
无参构造函数	`where T : new()`	T 必须有默认构造函数
基类约束	`where T : SomeBaseClass`	T 必须继承自指定基类
接口约束	`where T : ISomeInterface`	T 必须实现指定接口
组合约束	`where T : class, new()`	多条件约束

示例：

1
2
3
4


public class Factory<T> where T : IAnimal, new()
{
 public T Create() => new T();
}

协变与逆变（Covariance & Contravariance）

允许在泛型类型中更灵活地处理继承关系，通过 out（协变）和 in（逆变）关键字实现。

协变（Covariance）

用于返回值类型（out T）。
允许将派生类型作为泛型参数传递给接受基类型的接口。

1
2


IEnumerable<Cat> cats = new List<Cat>();
IEnumerable<Animal> animals = cats; // 合法，因为 IEnumerable<out T>

逆变（Contravariance）

用于参数类型（in T）。
允许将基类型作为泛型参数传递给接受派生类型的接口。

1
2
3


Action<Animal> animalAction = a => a.Eat();
Action<Cat> catAction = animalAction; // 合法，因为 Action<in T>
catAction(new Cat()); // 执行 animalAction

泛型中的默认值

使用 default(T) 获取类型的默认值：

引用类型：null
值类型：0、false 等。

1

public T GetDefault<T>() => default(T);

泛型与集合

.NET 提供了丰富的泛型集合类，如：

List<T>：动态数组
Dictionary<TKey, TValue>：键值对
Queue<T>：先进先出队列
Stack<T>：后进先出栈

对比非泛型集合（如 `ArrayList`）：

泛型集合无需类型转换，直接操作具体类型。
避免因错误类型导致的运行时异常。

高级主题

反射与泛型

通过反射动态创建泛型类型或方法：

1
2
3


Type openType = typeof(List<>);
Type closedType = openType.MakeGenericType(typeof(int));
List<int> intList = (List<int>)Activator.CreateInstance(closedType);

泛型类型推断

编译器根据参数自动推断类型：

1
2


var list = new List<int> { 1, 2, 3 };
var first = list.First(); // 推断返回类型为 int

静态成员行为

每个封闭泛型类型（如 MyClass<int> 和 MyClass<string>）拥有独立的静态成员。

使用场景

需要处理多种数据类型的通用算法（如排序、搜索）。
构建可复用的库或框架（如 ORM 中的泛型 Repository）。
实现设计模式（工厂模式、策略模式等）。

总结

C# 泛型通过类型参数化显著提升了代码的灵活性和安全性，是编写高效、可维护代码的重要工具。合理使用泛型约束、协变/逆变等特性，可以进一步优化设计，减少重复代码。

IIS中.net core和.net framework托管和非托管的对比

Thu, 16 Jan 2025 00:00:00 +0000

在对比 .NET Framework 和 .NET Core 在托管和非托管代码上的处理时，需要考虑两者的运行机制以及在 IIS 中的配置差异。以下从运行时管理、托管与非托管代码支持、性能和场景等方面分析两者的区别：

托管与非托管代码概述

托管代码：
- 由 CLR（公共语言运行时） 管理，运行时提供内存管理、垃圾回收、类型安全等功能。
- 适用于使用 C#、VB.NET 等语言开发的代码。
- 运行时环境：
  - .NET Framework 使用其自身的运行时 (.NET CLR)。
  - .NET Core 使用跨平台的 CoreCLR 或 .NET Runtime。
非托管代码：
- 不由 CLR 管理，直接与操作系统交互（例如原生 C/C++ 代码）。
- 不享受 CLR 提供的功能，开发者需要自己处理内存分配、资源释放等。
- 在 .NET Framework 和 .NET Core 中，可以通过 P/Invoke（平台调用）等方式调用非托管代码。

IIS 托管的差异

.NET Framework

运行机制：
- 在 IIS 中，.NET Framework 应用程序完全依赖 IIS 的托管功能。
- IIS 加载指定版本的 .NET CLR（例如 v4.0），托管代码在 .NET CLR 中执行。
配置选项：
- 托管代码：需要在应用程序池中选择对应的 “.NET CLR 版本”（如 v2.0 或 v4.0）。
- 非托管代码：设置为“无托管代码”，表示不加载 .NET CLR，IIS 仅用作运行非托管应用（如经典 ASP 或纯原生代码）。
特点：
- IIS 负责托管应用的生命周期和运行环境。
- 强依赖于 Windows 和 .NET Framework，无法跨平台。

.NET Core

运行机制：
- .NET Core 应用程序通过 Kestrel Web Server 运行。
- IIS 仅作为反向代理，转发 HTTP 请求到 Kestrel，不直接托管代码。
- .NET Core 的运行时独立于 IIS，可以跨平台运行。
配置选项：
- 托管代码：无需选择 .NET CLR，推荐将“.NET CLR 版本”设置为“无托管代码”。
- 非托管代码：同样选择“无托管代码”，因为 .NET Core 自带运行时，IIS 只负责请求转发。
特点：
- 独立运行时（Self-contained Deployment）使其不依赖服务器上的 .NET 运行时。
- 轻量级设计，更高性能，跨平台能力强。

性能对比

特性	.NET Framework	.NET Core
托管代码性能	较高，但受限于 IIS 和 Windows 平台。	更高性能，Kestrel 比 IIS 更轻量，独立于平台运行。
非托管代码性能	支持 P/Invoke，但调用非托管代码时需要更高的资源管理成本。	同样支持 P/Invoke，性能优化更好，跨平台能力更强。
资源开销	IIS 加载 .NET CLR 时有一定的内存和启动开销。	不依赖 IIS 托管，运行时更轻量，仅用 IIS 作为反向代理时开销低。
启动速度	较慢，依赖 IIS 初始化和加载 .NET CLR。	较快，独立运行时不依赖 IIS 的初始化。

适用场景对比

场景	.NET Framework	.NET Core
传统 Windows 应用	适用于需要紧密集成 Windows 平台的应用（如企业内部系统）。	不适合传统依赖 Windows 的应用。
跨平台 Web 应用	不支持跨平台，运行时只能在 Windows 上。	完美支持跨平台（Windows、Linux、macOS）。
高性能 Web 应用	性能较低（受限于 IIS 的开销和托管模型）。	性能更高，Kestrel 和反向代理的组合效率更优。
混合托管与非托管	支持，但托管代码和非托管代码的交互需要注意性能损耗。	更高效，特别是在调用本机库时，P/Invoke 更加优化。

总结对比

特性	.NET Framework	.NET Core
托管模型	强依赖 IIS 提供的托管环境	独立托管，通过 Kestrel 与 IIS 集成
运行时环境	依赖 .NET CLR	使用独立的 .NET Core 运行时
IIS 配置推荐	设置为对应 .NET CLR 版本	设置为“无托管代码”
跨平台支持	不支持	完全支持跨平台
性能	较低（受限于 IIS 和 .NET Framework）	更高（轻量级 Kestrel 和独立运行时）

如果你的应用需要高性能、跨平台支持或轻量级架构，选择 .NET Core 是更优的方案。而如果你的应用是针对 Windows 平台的传统应用，且需要使用 .NET Framework 的完整功能，.NET Framework 会是合适的选择。

C# 12 中的新增功能

Thu, 28 Nov 2024 00:00:00 +0000

C# 12 中的新增功能

主构造函数

现在可以在任何 class 和 struct 中创建主构造函数。主构造函数不再局限于 record 类型。主构造函数参数都在类的整个主体的范围内。为了确保显式分配所有主构造函数参数，所有显式声明的构造函数都必须使用 this() 语法调用主构造函数。将主构造函数添加到 class 可防止编译器声明隐式无参数构造函数。在 struct 中，隐式无参数构造函数初始化所有字段，包括 0 位模式的主构造函数参数。

编译器仅在 record 类型（record class 或 record struct 类型）中为主构造函数参数生成公共属性。对于主构造函数参数，非记录类和结构可能并不总是需要此行为。

有关主构造函数的详细信息，请参阅探索主构造函数的教程和实例构造函数的相关文章。

集合表达式

集合表达式引入了新的语法来创建常见的集合值。可以使用展开运算符 .. 将其他集合内联到这些值中。

可以创建多个类似集合的类型，而无需使用外部 BCL(Base Class Library) 支持。这些类型包括：

数组类型，例如 int[]。
System.Span<T> 和 System.ReadOnlySpan<T>。
支持集合初始值设定项的类型，例如 System.Collections.Generic.List<T>。

以下示例演示了集合表达式的使用：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


// Create an array:
int[] a = [1, 2, 3, 4, 5, 6, 7, 8];

// Create a list:
List<string> b = ["one", "two", "three"];

// Create a span
Span<char> c = ['a', 'b', 'c', 'd', 'e', 'f', 'h', 'i'];

// Create a jagged 2D array:
int[][] twoD = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];

// Create a jagged 2D array from variables:
int[] row0 = [1, 2, 3];
int[] row1 = [4, 5, 6];
int[] row2 = [7, 8, 9];
int[][] twoDFromVariables = [row0, row1, row2];

展开运算符（集合表达式中的 ..）可将其参数替换为该集合中的元素。参数必须是集合类型。以下示例演示了展开运算符的工作原理：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


int[] row0 = [1, 2, 3];
int[] row1 = [4, 5, 6];
int[] row2 = [7, 8, 9];
int[] single = [.. row0, .. row1, .. row2];
foreach (var element in single)
{
 Console.Write($"{element}, ");
}
// output:
// 1, 2, 3, 4, 5, 6, 7, 8, 9,

展开运算符的操作数是可以枚举的表达式。展开运算符可计算枚举表达式的每个元素。

可以在需要元素集合的任何位置使用集合表达式。它们可以指定集合的初始值，也可以作为参数传递给采用集合类型的方法。可以在有关集合表达式的语言参考文章或功能规范中详细了解集合表达式。

`ref readonly` 参数

C# 添加了 in 参数作为传递只读引用的方法。 in 参数既允许变量和值，并且无需对参数进行任何注释即可使用。

添加 ref readonly 参数可以更清楚地了解可能使用 ref 参数或 in 参数的 API：

即使参数未修改，在 in 引入之前创建的 API 也可能会使用 ref。可以使用 ref readonly 更新这些 API。对于调用方来说，这不会是一项中断性变更，就像参数 ref 更改为 in 那样。示例为 System.Runtime.InteropServices.Marshal.QueryInterface。
采用 in 参数但逻辑上需要变量的 API。值表达式不起作用。示例为 System.ReadOnlySpan<T>.ReadOnlySpan<T>(T)。
使用 ref 的 API，因为它们需要变量，但不改变该变量。示例为 System.Runtime.CompilerServices.Unsafe.IsNullRef。

若要了解有关 ref readonly 参数的详细信息，请参阅有关语言参考中的参数修饰符的文章，或参考只读参数功能规范。

默认 Lambda 参数

现在可以为 Lambda 表达式的参数定义默认值。语法和规则与将参数的默认值添加到任何方法或本地函数相同。

可以在有关 Lambda 表达式的文章中详细了解 Lambda 表达式上的默认参数。

任何类型的别名

可以使用 using 别名指令创建任何类型的别名，而不仅仅是命名类型。这意味着可以为元组类型、数组类型、指针类型或其他不安全类型创建语义别名。有关详细信息，请参阅功能规范。

内联数组

运行时团队和其他库作者使用内联数组来提高应用的性能。内联数组使开发人员能够创建固定大小的 struct 类型数组。具有内联缓冲区的结构应提供类似于不安全的固定大小缓冲区的性能特征。你可能不会声明自己的内联数组，但当它们从运行时 API 作为 System.Span<T> 或 System.ReadOnlySpan<T> 对象公开时，你将透明地使用这些数组。

内联数组的声明类似于以下 struct：

1
2
3
4
5


[System.Runtime.CompilerServices.InlineArray(10)]
public struct Buffer
{
 private int _element0;
}

它们的用法与任何其他数组类似：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


var buffer = new Buffer();
for (int i = 0; i < 10; i++)
{
 buffer[i] = i;
}

foreach (var i in buffer)
{
 Console.WriteLine(i);
}

区别在于编译器可以利用有关内联数组的已知信息。你可能会像使用任何其他数组一样使用内联数组。有关如何声明内联数组的详细信息，请参阅有关 struct 类型的语言参考。

Experimental 属性

可以使用 System.Diagnostics.CodeAnalysis.ExperimentalAttribute 来标记类型、方法或程序集，以指示实验性特征。如果访问使用 ExperimentalAttribute 注释的方法或类型，编译器将发出警告。用 Experimental 特性标记的程序集中包含的所有类型都是实验性的。可以在有关编译器读取的常规属性的文章或功能规范中阅读详细信息。

拦截器

警告

拦截器是一项试验性功能，在 C# 12 的预览模式下提供。在将来的版本中，该功能可能会发生中断性变更或被删除。因此，不建议将其用于生产或已发布的应用程序。

若要使用拦截器，用户项目必须指定属性 <InterceptorsPreviewNamespaces>。这是允许包含拦截器的命名空间的列表。

例如：<InterceptorsPreviewNamespaces>$(InterceptorsPreviewNamespaces);Microsoft.AspNetCore.Http.Generated;MyLibrary.Generated</InterceptorsPreviewNamespaces>

拦截器是一种方法，该方法可以在编译时以声明方式将对可拦截方法的调用替换为对其自身的调用。通过让拦截器声明所拦截调用的源位置，可以进行这种替换。拦截器可以向编译中（例如在源生成器中）添加新代码，从而提供更改现有代码语义的有限能力。

在源生成器中使用拦截器修改现有编译的代码，而非向其中添加代码。源生成器将对可拦截方法的调用替换为对拦截器方法的调用

。

如果你有兴趣尝试拦截器，可以阅读功能规范来了解详细信息。如果使用该功能，请确保随时了解此实验功能的功能规范中的任何更改。最终确定功能后，我们将在本站点上添加更多指导。

.Net9新特性

Mon, 25 Nov 2024 00:00:00 +0000

隐式索引访问

现在对象初始值设定项表达式中允许隐式“从末尾开始”索引运算符[^]。

我们来看一个例子，首先创建了一个ImplicitIndex类并且包含一个Numbers属性，该属性是一个长度为 5 的整数数组。

现在我们可以在初始化类ImplicitIndex时初始化属性Numbers，并使用“从末尾开始”索引运算符来填充数组值。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


/// <summary>
/// 隐式索引访问
/// </summary>
private static void TestImplicitIndex()
{
 var implicitIndex = new ImplicitIndex()
 {
 Numbers = { [^1] = 5, [^2] = 4, [^3] = 3, [^4] = 2, [^5] = 1 }
 };
 foreach (var item in implicitIndex.Numbers)
 {
 Console.WriteLine(item);
 }
}
public class ImplicitIndex
{
 public int[] Numbers { get; set; } = new int[5];
}

锁对象

本次更新引入新的锁类型System.Threading.Lock，用于实现互斥。在之前的版本中通常通过object类型进行加锁，而现在有了专门的Lock类型用来加锁。

新的Lock类型会使得代码更干净、更安全、更高效。

在新的锁定机制中EnterScope替换了Monitor底层实现。同时它遵循Dispose模式返回ref struct，因此可以与using语句结合使用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


/// <summary>
/// 锁对象
/// </summary>
public class LockExample()
{
 private readonly Lock _lock = new Lock();

 public void Print()
 {
 lock (_lock)
 {
 Console.WriteLine("Lock");
 }
 }
}

生成UUID v7

我们经常在实体中使用Guid作为主键，并且通过Guid.NewGuid()可以很方便的生成一个新的Guid，而此方法生成的Guid是依据UUID第四个版本规范生成的。

当前已经可以通过Guid.CreateVersion7()方法创建UUID第七个版本，这个版本UUID主要功能就是包含了时间戳，数据结构如下：

| 48位时间戳 | 12位随机 | 62位随机 |

这也意味着v7版本的UUID可以按时间排序了，在数据库中使用起来更方便，同时Guid.CreateVersion7()方法还有一个重载方法接收DateTimeOffset类型时间戳，用来通过指定时间创建UUID。

1
2
3


var guid_v4 = Guid.NewGuid();
var guid_v7 = Guid.CreateVersion7();
var guid_v7_time = Guid.CreateVersion7(TimeProvider.System.GetLocalNow());

Linq新方法 CountBy 和 AggregateBy

引入了新的方法 CountBy 和 AggregateBy后，可以在不经过GroupBy 分配中间分组的情况下快速完成复杂的聚合操作，同时方法命名也非常直观，可以大大提升工作效率。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


public class Student
{
 public string Name { get; set; }
 public int Age { get; set; }
}
public void CountByExample()
{
 var students = new List<Student>
 {
 new Student { Name = "小明", Age = 10 },
 new Student { Name = "小红", Age = 12 },
 new Student { Name = "小华", Age = 10 },
 new Student { Name = "小亮", Age = 11 }
 };
 //统计不同年龄有多少人，两个版本实现
 //.NET 9 之前
 var group = students.GroupBy(x => x.Age);
 foreach (var item in group)
 {
 Console.WriteLine($"年龄为：{item.Key}，有：{item.Count()} 人。");
 }
 //.NET 9
 foreach (var student in students.CountBy(c => c.Age))
 {
 Console.WriteLine($"年龄为：{student.Key}，有：{student.Value} 人。");
 }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


public class Student
{
 public string Name { get; set; }
 public string Grade { get; set; }
 public int Age { get; set; }
}
public void AggregateByExample()
{
 var students = new List<Student>
 {
 new Student { Name = "小明", Grade = "一班", Age = 10 },
 new Student { Name = "小红", Grade = "二班", Age = 12 },
 new Student { Name = "小华", Grade = "一班", Age = 10 },
 new Student { Name = "小亮", Grade = "二班", Age = 11 }
 };
 //统计每个班级各自学生总年龄，两个版本实现
 //.NET 9 之前
 var old = students
 .GroupBy(stu => stu.Grade)
 .ToDictionary(group => group.Key, group => group.Sum(stu => stu.Age))
 .AsEnumerable();
 foreach (var item in old)
 {
 Console.WriteLine($"班级：{item.Key}，总年龄：{item.Value} 。");
 }
 //.NET 9
 foreach (var group in students.AggregateBy(c => c.Grade, 0, (acc, stu) => acc + stu.Age))
 {
 Console.WriteLine($"班级：{group.Key}，总年龄：{group.Value} 。");
 }
}

C#12 中的集合表达式

Thu, 14 Nov 2024 00:00:00 +0000

C#12 中的集合表达式

经典集合初始化器

自 C# 3.0 起，我们就有了 “集合初始化器” 。它们采用 {} 模式来初始化任何实现了 Add() 方法的 IEnumerable 实现。例如，这会创建一个新的 List<string> 并用 5 个值初始化它：

1

var values = new List<string> { "1", "2", "3", "4", "5" };

幕后，编译器生成的代码看起来像这样：

1
2
3
4
5
6


List<string> values = new List<string>();
values.Add("1");
values.Add("2");
values.Add("3");
values.Add("4");
values.Add("5");

C# 中的数组初始化有其特别之处，你可以用比其他集合更多的方法来初始化它们，尽管看起来与标准集合初始化器相似：

1
2
3


var values1 = new[] { "1", "2", "3", "4" };
var values2 = new string[4] { "1", "2", "3", "4" };
string[] values3 = { "1", "2", "3", "4" };

这些工作方式与集合初始化器不同；这里没有调用 Add() 方法。相反，编译器生成的是如果你手动做这一切时同样的初始化代码：

1
2
3
4
5


string[] array = new string[4];
array[0] = "1";
array[1] = "2";
array[2] = "3";
array[3] = "4";

我们已经讨论了通用集合（如 List ）和数组的集合初始化器，还有在 Span 世界中变得更为有用的 stackalloc 表达式，因为不需要使用 unsafe 代码：

1

Span<int> array = stackalloc []{ 1, 2, 3, 4 };

幕后，编译器将这个 stackalloc 初始化器转化为一些类似这样的 unsafe 代码：

1
2
3
4
5
6
7
8


unsafe {
 byte* num = stackalloc byte[16];
 *(int*)num = 1;
 *(int*)(num + 4) = 2;
 *(int*)(num + (nint)2 * (nint)4) = 3;
 *(int*)(num + (nint)3 * (nint)4) = 4;
 Span<int> array = new Span<int>(num, 4);
}

这段代码在栈上创建了一个数组，然后通过指针运算遍历每个元素，设置每个值。

使用集合表达式统一语法

我们已经看到至少有三种不同的场景下我们在初始化集合：

数组
类似 List 的集合
使用 stackalloc 的 ReadOnlySpan

每种情况都需要稍微不同的语法，例如：

1
2
3
4


int[] array = new[] { 1, 2, 3, 4 };
List<int> list = new() { 1, 2, 3, 4 };
HashSet<int> hashset = new() { 1, 2, 3, 4 };
ReadOnlySpan<int> span = stackalloc [] { 1, 2, 3, 4 };

这有点混乱和烦人。C#12 中引入的集合表达式提供了一种简化、统一的语法，适用于所有这些不同的集合类型。例如：

1
2
3
4


int[] array = [1, 2, 3, 4]
List<int> list = [1, 2, 3, 4];
HashSet<int> hashset = [1, 2, 3, 4];
ReadOnlySpan<int> span = [1, 2, 3, 4];

集合表达式在所有集合类型上的一致性是一个真正的优势，但这并不是唯一的优点。集合表达式相比集合初始化器可以提供性能优势（我们将在后续文章中探讨），以及额外的功能。

推断接口类型

想象一下，你想要创建一个集合，但你只关心它实现了 IEnumerable 。你需要自己决定使用哪个后端类型：

1
2
3


IEnumerable<int> list1 = new List<int> { 1, 2, 3, 4 };
IEnumerable<int> list2 = new HashSet<int> { 1, 2, 3, 4 };
IEnumerable<int> list3 = new int[] { 1, 2, 3, 4 };

那么应该选择哪一个呢？如果所有你需要做的就是枚举列表，那理论上选择哪种类型都不应该重要，对吧？那么正确的选项是什么？

使用集合表达式，你可以将此决策委托给编译器。你可以不指定后端类型，而由编译器来决定。而且，集合表达式的额外优点是更加简洁：

1
2
3


IEnumerable<int> ienumerable = [1, 2, 3, 4];
IList<int> ilist = [1, 2, 3, 4];
IReadOnlyCollection<int> icollection = [1, 2, 3, 4];

幕后，编译器完全透明地创建了一个实现所需接口的集合，所以你无需考虑这一点。

值得注意的是，虽然编译器会自动为接口集合选择一个具体的类型，但你需要指定某种类型。例如，你不能使用 var ：

1
2
3
4


var values = [1, 2, 3, 4]; // ❌ 编译错误，CS9176：集合表达式没有目标类型
Sum(values);
Sum([1, 2, 3, 4]); // ✅ 这是可行的
int Sum(IEnumerable<int> v) => v.Sum();

问题在于，根据 C#编译器的工作方式，它无法推断 values 的类型应为 IEnumerable<int> ，因此抛出了错误。未来版本的 C#可能会改变这种情况，但可能的解决方案是始终选择 int[] ，这并不一定是最优的，所以不要抱太大希望。

针对 `ReadOnlySpan` 的高效自动 `stackalloc`

对于 ReadOnlySpan 和 Span 实例来说，如果你只使用集合初始化器，情况也类似。如果你只需要在 Span 或 ReadOnlySpan 中存储一些数据，那么使用集合初始化器就需要决定将数据放在哪里，然后再从中获取 Span：

1
2
3


Span<int> spans2 = stackalloc[] { 1, 2, 3, 4 }; // 栈上分配数组
Span<int> spans3 = new[] { 1, 2, 3, 4 }; // 在堆上分配
Span<string> spans4 = new[] { "1", "2", "3", "4" }; // 不能直接使用 stackalloc 分配字符串数组

虽然这不是一个很大的决策，通常只有两个合理的选择，但还是需要额外考虑的事情。此外，你不能直接使用 stackalloc 为 string[] 分配内存，除非通过一些 InlineArray 的技巧。

使用集合表达式，你可以再次将此决策委托给编译器，它会做出正确的处理。

1
2


ReadOnlySpan<int> readonlyspans = [1, 2, 3, 4];
Span<string> spans = ["1", "2", "3", "4"];

在系列的后续部分，你会发现这些特定的集合表达式案例被高度优化！

集合表达式使重构更简单

到目前为止，我展示的所有例子都是将集合表达式赋值给变量，但实际上你也可以直接将集合表达式作为方法参数使用，比如：

1
2
3
4
5
6
7
8


using System.Linq;
using System.Collections.Generic;

// 创建一个接受IEnumerable<int>的方法
int Sum(IEnumerable<int> values) => values.Sum();

// 使用集合表达式调用方法
Sum([1, 2, 3, 4]);

这种模式的一个好处是，如果我改变了 Sum() 的签名，我不需要改变调用站点。相比之下，如果你使用集合初始化器：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


// 如果方法接受数组...
int Sum1(int[] values) => values.Sum();
Sum1(new [] { 1, 2, 3, 4 }); // 必须使用数组语法

// 如果方法接受IEnumerable...
int Sum2(IEnumerable<int> values) => values.Sum();
Sum2(new List<int> { 1, 2, 3, 4 }); // 必须使用显式类型，如List或类似

// 如果方法接受ReadOnlySpan...
int Sum3(ReadOnlySpan<int> values) {
 var total = 0;
 foreach (var value in values) {
 total += value;
 }
 return total;
}
Sum3(new []{ 1, 2, 3, 4 }); // 必须选择标准数组或者使用stackalloc分配的数组

如果使用集合表达式，那么我们可以使用完全相同的语法来调用所有三个 Sum() 实现：

Sum1([ 1, 2, 3, 4 ]); Sum2([ 1, 2, 3, 4 ]); Sum3([ 1, 2, 3, 4 ]);

并且，编译器会使用最有效的实现方式来创建所需类型的集合。

这看起来可能是一件小事，而且在某种程度上确实是这样，但正是所有这些小小的便利特性使得集合表达式成为一个非常整洁的功能！整体而言，正是这些微小的方便性让集合表达式的使用变得极为顺手和高效。

空集合

在 C# 中，集合表达式的一个特性是编译器明确识别空集合的语法。这意味着你不再需要写像下面这样的代码：

1
2


var empty = new int[]{}; // 通常你不应该这样做...
var empty = Array.Empty<int>(); // ...相反，更倾向于使用这行代码!

现在，你可以使用 [] 来生成一个适当的空集合版本，例如：

1

int[] empty = [];

集合表达式相比于显式初始化有两大主要优势：

编译器可以选择创建空集合的最有效方式，比如选择 Array.Empty()（或其等价方法）。
对于所有集合类型，你可以使用一致的语法。

以下示例展示了多种集合类型，以及如何使用 [] 来创建它们的空版本。每行代码后的注释显示了编译器为特定类型生成的代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


int[] array = []; // Array.Empty()
HashSet<int> hashset = []; // new HashSet<int>()
List<int> list = []; // new List<int>()
IEnumerable<int> ienumerable = []; // Array.Empty()
ICollection<int> icollection = []; // new List<int>()
IList<int> ilist = []; // new List<int>()
IReadOnlyCollection<int> readonlycollection = []; // Array.Empty()
IReadOnlyList<int> readonlyList = []; // Array.Empty()
Span<int> span = []; // default(Span<int>)
ReadOnlySpan<int> readonlyspan = []; // default(ReadOnlySpan<int>)
ImmutableArray<int> immutablearray = []; // ImmutableArray.CreateRange(Array.Empty())
ImmutableList<int> immutablelist = []; // ImmutableList.Create(default(ReadOnlySpan<int>));

如你所见，编译器尽可能地高效；如果类型是可变的，如 HashSet 或 List，那么它只能创建一个新的实例；但如果可以使用不分配内存的版本，如 Array.Empty()，那么它就会采用这种方式！请注意，在最后一个示例中，ImmutableArray 和 ImmutableList 使用了不同的构造函数来创建空集合，因为它们是不可变集合。

使用展开运算符（spread element）从其他集合构建集合

我们已经了解了集合表达式的两个好处：

一致的语法
高效的编译器生成实现

集合表达式的另一个重要特性是 展开运算符 (..)。这使你能够更容易地从其他集合实例构建新的集合。

举个具体的例子，假设你有两个 IEnumerable 集合，并且你想将它们作为数组连接起来。使用 LINQ，这是相当容易做到的，因为它提供了专门用于此类操作的扩展方法：

1
2
3
4


int[] ConcatAsArray(IEnumerable<int> first, IEnumerable<int> second)
{
 return first.Concat(second).ToArray();
}

很好，但是如果现在你需要处理的是 ReadOnlySpan 而不是 IEnumerable 呢？不幸的是，正如我们之前讨论的那样，ReadOnlySpan 不实现 IEnumerable 接口，所以我们可能需要这样做：

1
2
3
4
5
6
7


int[] ConcatAsArray(ReadOnlySpan<int> first, ReadOnlySpan<int> second)
{
 var list = new List<int>(first.Length + second.Length);
 list.AddRange(first);
 list.AddRange(second);
 return list.ToArray();
}

这虽然不是糟糕，但仍然让人感到恼火，因为对于每种不同的集合类型都得考虑这些细节。而使用集合表达式和展开运算符，我们得到了一个简洁的快捷方式，它可以用于所有受支持的集合类型。上述两种重载都可以用同样的方式实现：

1
2


int[] ConcatAsArray(IEnumerable<int> first, IEnumerable<int> second) => [..first, ..second];
int[] ConcatAsArray(ReadOnlySpan<int> first, ReadOnlySpan<int> second) => [..first, ..second];

而且，由于集合表达式的一致性，如果你更改 ConcatAsArray() 方法的参数或者返回类型，你完全不需要修改集合表达式本身，它依旧可以正常工作！

.. 运算符意味着 “写出集合中的所有值” ，因此再举一个例子：

1
2
3
4


int[] array = [1, 2, 3, 4];
IEnumerable<int> oddValues = array.Where(int.IsOddInteger); // 1, 3
int[] evenValues = [..array.Where(int.IsEvenInteger)]; // 2, 4
int[] allValues = [..oddValues, ..evenValues]; // 1, 3, 2, 4

上述代码多次使用了展开运算符，但在每种情况下，它都意味着 “写出集合的所有元素” 。所以在最后一步中，allValues 包含了 oddValues 中的所有元素，后面跟着 evenValues 中的所有值。

你也可以在集合表达式中混合单一值和展开集合，例如：

1
2


int[] arr = [1, 2, 3, 4];
int[] myValues = [0, ..arr, 5, 6]; // 0, 1, 2, 3, 4, 5, 6

最终结果就像是遍历了 arr 并添加了每个值一样。

注意，展开运算符 .. 与 范围运算符（如 1..3 或 2..^ 中的 ..）是不同的，后者用于对数组进行索引。然而，你可以结合使用它们，先用范围来选择元素子集，然后将它们展开到集合表达式中：

1
2


int[] primes = [1, 2, 3, 5, 7, 9, 11];
int[] some = [0, ..primes[1..^1]]; // 0, 2, 3, 5, 7, 9

这段代码使用 1..^1 范围运算符取 primes 数组的第1个至N-1个元素（即 2, 3, 5, 7, 9），然后在集合表达式中使用展开 ..。

集合表达式为创建集合添加了一种很好的对称性（在重构从一种集合类型到另一种时特别有用），并且通过展开运算符使集合的组合变得更加简单。但集合表达式不仅仅是关于语法。重要的是，集合表达式为编译器提供了优化其生成代码的选项。

在下一篇中，我们将探讨更多类型的集合，如 T[] 和 ReadOnlySpan<T>，看看它们在使用集合表达式时是如何被高度优化的。

英文原文

常用数据结构

Thu, 14 Nov 2024 00:00:00 +0000

常见的数据结构包括数组、链表、栈、队列、树和图等。每种数据结构都有其特定的优势和应用场景。例如，数组适用于索引访问和快速查找，链表适用于插入和删除操作频繁的情况，树适用于层次结构数据的表示和搜索，图适用于表示复杂的关系网络等。

1、数组

数组是将具有相同类型的若干变量有序地组织在一起的集合，可以说是最基本的数据结构。

优点：（1）按照索引查询元素的速度很快；

（2）按照索引遍历数组也很方便。

缺点：（1）数组的大小在创建后就确定了，无法扩容：定义（初始化）必须给定数据的大小；

（2）数组只能存储一种类型的数据；

（3）添加、删除元素的操作很耗时间，因为要移动其他元素。

2、栈（电梯）

栈是一种特殊的线性表，它只能在一个表的一个固定端进行数据结点的插入和删除操作。栈按照先进后出或后进先出的原则来存储数据，也就是说，先插入的数据将被压入栈底，最后插入的数据在栈顶，读出数据时，从栈顶开始逐个读出。栈在汇编语言程序中，经常用于重要数据的现场保护。栈中没有数据时，称为空栈。栈的操作规则：后进先出

3、队列（食堂排队）

队列和栈类似，也是一种特殊的线性表。和栈不同的是，队列只允许在表的一端进行插入操作，而在另一端进行删除操作。一般来说，进行插入操作的一端称为队尾，进行删除操作的一端称为队头。队列中没有元素时，称为空队列。

队列的操作规则：先进先出为了提高队列的利用率，采用循环队列来存储数据循环队列: rear 加到顶时回来。

4、链表

链表是一种数据元素按照链式存储结构进行存储的数据结构，这种存储结构具有在物理上存在非连续的特点。链表由一系列数据结点构成，每个数据结点包括数据域和指针域两部分。其中，指针域保存了数据结构中下一个元素存放的地址。链表结构中数据元素的逻辑顺序是通过链表中的指针链接次序来实现的。

链表分为单向链表、双向链表和循环列表。

1）单向链表

前面的黄色方块代表数据域，后面蓝色方块是指针域。

2）双向链表

p代表prev，N代表next。

3）单向循环链表

h是头结点，p是定义的一个指针

单向链表的缺点是只能从头到尾依次遍历，而双向链表可进可退，既能找到下一个，也能找到上一个，每个节点上都需要多分配一个存储空间。

5、树

树是一种数据结构，它是由n（n>=1）个有限节点组成一个具有层次关系的集合。树是典型的非线性结构，在树结构中，有且仅有一个根结点，该结点没有前驱结点。在树结构中的其他结点都有且仅有一个前驱结点，而且可以有两个后继结点。

二叉树二叉树特点:

二叉树第i（i≥1）层上的节点最多为2^i-1个
深度为k（k≥1）的二叉树最多有2^k - 1个节点
在任意一棵二叉树中，树叶的数目比度数为2的节点的数目多1

二叉树遍历二叉树中还包括满二叉树和完全二叉树。

满二叉树：深度为k（k≥1）时有2k－1个节点的二叉树。

完全二叉树：只有最下面两层有度数小于2的节点，且最下面一层的叶节点集中在最左边的若干位置上。

完全二叉树的判断

6、图

图是另一种非线性数据结构。在图结构中，数据结点一般称为顶点，而边是顶点的有序偶对。如果两个顶点之间存在一条边，那么就表示这两个顶点具有相邻关系。

图分为有向图和无向图：

有向图：边不仅连接两个顶点，并且具有方向；无向图：边仅仅连接两个顶点，没有其他含义；

7、堆

堆（heap）是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵树的数组对象。堆总是满足下列性质：

堆中某个结点的值总是不大于或不小于其父结点的值；堆总是一棵完全二叉树。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。

大根堆

小根堆

8、散列表（哈希表）（字典）

散列表就是把Key通过一个固定的算法函数既所谓的哈希函数转换成一个整型数字，然后就将该数字对数组长度进行取余，取余结果就当作数组的下标，将value存储在以该数字为下标的数组空间里，这种存储空间可以充分利用数组的查找优势来查找元素，所以查找的速度很快。

哈希查找有3个概念

1 、关键字 (key)

2 、计算公司(哈希函数又称为散列函数)

3 、存储数据的表 (哈希表又称为散列表)

算法(哈希函数)：

直接寻址法：取关键字或关键字的某个线性函数值为散列地址。数字分析法：通过对数据的分析，发现数据中冲突较少的部分，并构造散列地址。例如同学们的学号，通常同一届学生的学号，其中前面的部分差别不太大，所以用后面的部分来构造散列地址。平方取中法：当无法确定关键字里哪几位的分布相对比较均匀时，可以先求出关键字的平方值，然后按需要取平方值的中间几位作为散列地址。这是因为：计算平方之后的中间几位和关键字中的每一位都相关，所以不同的关键字会以较高的概率产生不同的散列地址。折叠法：将关键字分割成位数相同的几部分，最后一部分位数可以不同，然后取这几部分的叠加和（去除进位）作为散列地址。数位叠加可以有移位叠加和间界叠加两种方法。移位叠加是将分割后的每一部分的最低位对齐，然后相加；间界叠加是从一端向另一端沿分割界来回折叠，然后对齐相加。取随机数法：使用一个随机函数，取关键字的随机值作为散列地址，这种方式通常用于关键字长度不同的场合。除留取余法：取关键字被某个不大于散列表的表长 n 的数 m 除后所得的余数 p 为散列地址。这种方式也可以在用过其他方法后再使用。该函数对 m 的选择很重要，一般取素数或者直接用 n。

C#静态构造函数

Fri, 27 Sep 2024 00:00:00 +0000

在C#中，静态构造函数（也称为类型构造函数）是一种特殊的构造函数，用于初始化静态成员或执行只需要一次的操作。静态构造函数的主要特点包括：

无需显式调用：静态构造函数在第一次访问类型的静态成员或实例成员之前，由运行时自动调用。
不能有访问修饰符：静态构造函数不能有public、private等访问修饰符。它只能由类型定义来确定。
无参数：静态构造函数不能有参数。
每个类型只能有一个静态构造函数。
不能通过对象实例来调用：静态构造函数只能通过类型本身触发，而不能通过类型的实例来触发。

下面是一个简单的示例，展示了如何使用静态构造函数：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


using System;

class MyClass
{
 // 静态字段
 public static int StaticField;

 // 静态构造函数
 static MyClass()
 {
 Console.WriteLine("静态构造函数被调用");
 StaticField = 42;
 }

 // 实例构造函数
 public MyClass()
 {
 Console.WriteLine("实例构造函数被调用");
 }

 // 静态方法
 public static void StaticMethod()
 {
 Console.WriteLine("静态方法被调用");
 }
}

class Program
{
 static void Main()
 {
 // 访问静态字段，触发静态构造函数
 Console.WriteLine(MyClass.StaticField);

 // 创建实例，静态构造函数不会再次被调用
 MyClass myClass = new MyClass();

 // 调用静态方法
 MyClass.StaticMethod();
 }
}

输出：

1
2
3
4


静态构造函数被调用
42
实例构造函数被调用
静态方法被调用

在这个示例中，MyClass类定义了一个静态字段StaticField和一个静态构造函数。在Main方法中，第一次访问StaticField时，静态构造函数被调用并初始化了StaticField。随后的实例创建和静态方法调用不会再次触发静态构造函数。

静态构造函数通常用于执行类型级别的初始化任务，例如设置静态字段的默认值、配置类型级别的资源等。它保证这些初始化逻辑在类型首次使用时恰当地执行。

C#内存泄漏

Fri, 27 Sep 2024 00:00:00 +0000

内存泄漏（Memory Leak）是指程序无法释放已经不再使用的内存，从而导致内存消耗不断增加，最终可能耗尽系统内存资源。尽管C#具有垃圾回收机制（Garbage Collection，简称GC），能够自动管理内存，但某些情况下仍可能出现内存泄漏。内存泄漏在C#中通常不是由于忘记释放内存，而是由于程序中存在对不再需要的对象的引用，导致这些对象无法被GC回收。

常见导致内存泄漏的情况

事件处理器未解除订阅

如果对象A订阅了对象B的事件，但在对象A销毁时未解除订阅，对象B将持有对对象A的引用，导致对象A无法被垃圾回收。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


public class Publisher
{
 public event EventHandler MyEvent;
}

public class Subscriber
{
 public Subscriber(Publisher pub)
 {
 pub.MyEvent += HandleEvent;
 }

 private void HandleEvent(object sender, EventArgs e)
 {
 // Event handler code
 }

 public void Unsubscribe(Publisher pub)
 {
 pub.MyEvent -= HandleEvent;
 }
}

静态变量持有引用

静态变量的生命周期与应用程序相同，如果静态变量持有对象引用，这些对象将无法被垃圾回收。

1
2
3
4
5
6
7
8
9


public class MyClass
{
 private static List<object> staticList = new List<object>();

 public void AddObject(object obj)
 {
 staticList.Add(obj);
 }
}

未能正确处理IDisposable对象

对于实现了IDisposable接口的对象，未能在使用后正确调用Dispose方法会导致资源未释放。

1
2
3
4
5
6


public void ProcessData()
{
 var stream = new FileStream("data.txt", FileMode.Open);
 // Use the stream
 // Forgot to call stream.Dispose()
}

长时间存在的对象引用

长时间存在的集合或缓存未能清理，导致大量对象无法被回收。

1
2
3
4
5
6
7
8
9


public class Cache
{
 private static Dictionary<string, object> cache = new Dictionary<string, object>();

 public static void AddToCache(string key, object value)
 {
 cache[key] = value;
 }
}

避免内存泄漏的方法

及时解除事件订阅

在不再需要事件处理时，及时解除订阅。

1
2
3
4


public void Unsubscribe(Publisher pub)
{
 pub.MyEvent -= HandleEvent;
}

使用弱引用（WeakReference）

对于缓存或长时间存在的引用，使用WeakReference可以允许GC回收不再使用的对象。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


private static Dictionary<string, WeakReference> cache = new Dictionary<string, WeakReference>();

public static void AddToCache(string key, object value)
{
 cache[key] = new WeakReference(value);
}

public static object GetFromCache(string key)
{
 if (cache.TryGetValue(key, out var weakRef) && weakRef.IsAlive)
 {
 return weakRef.Target;
 }
 return null;
}

正确实现IDisposable

对于实现IDisposable接口的对象，使用using语句或手动调用Dispose方法来释放资源。

1
2
3
4
5
6
7
8


public void ProcessData()
{
 using (var stream = new FileStream("data.txt", FileMode.Open))
 {
 // Use the stream
 }
 // stream is automatically disposed here
}

定期清理长时间存在的集合

对于长时间存在的集合或缓存，定期清理不再使用的对象。

1
2
3
4


public static void ClearCache()
{
 cache.Clear();
}

通过以上方法，可以有效减少或避免C#中的内存泄漏问题，从而提升应用程序的性能和稳定性。

C# Invoke

Thu, 26 Sep 2024 00:00:00 +0000

在 C# 中，Invoke() 是一个用于调用方法的方法，它能够在运行时动态地调用一个方法。Invoke方法主要用于以下几种场景：

委托的Invoke

委托是C#中的一种类型，它表示引用方法的对象。你可以通过委托来调用（或“调用”）它所引用的方法。Invoke 方法用于显式地调用委托所引用的方法。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


delegate void MyDelegate(string message);
class Program{
static void Main()
{
MyDelegate myDelegate = new MyDelegate(Hello);
myDelegate.Invoke("Hello, World!"); // 显式调用
myDelegate("Hello, World!"); // 隐式调用，效果与上面的Invoke相同 }
static void Hello(string message)
{
Console.WriteLine(message); }
}

在上面的代码中，myDelegate.Invoke("Hello, World!") 和 myDelegate("Hello, World!") 是等效的。通常，我们更倾向于使用隐式调用（即直接使用委托名和方法参数），因为它更简洁。

反射的Invoke

反射是.NET框架提供的一种功能，它允许程序在运行时检查或修改其类型、成员和属性的行为。使用反射，你可以动态地创建和调用类型、方法、属性等。在这种情况下，Invoke 通常用于调用通过反射获取的方法。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


class Program
{
 static void Main()
 {
 var type = typeof(Program);
 var method = type.GetMethod("Hello");//GetMethod只能获取Public方法
 method.Invoke(null, new object[] { "Hello, Reflection!" });
 }
 public static void Hello(string message)
 {
 Console.WriteLine(message);
 }
}

在上面的代码中，我们使用反射来获取Program类中的Hello方法，并使用Invoke来调用它。注意，当使用反射调用静态方法时，第一个参数（即实例对象）通常为null。对于实例方法，你需要提供一个有效的实例对象作为第一个参数。

跨线程控件Invoke(Windows Forms 和 WPF)

在 Windows Forms 或 WPF 应用程序中，当需要从非 UI 线程更新 UI 控件时，可以使用控件的 Invoke方法。这是因为 UI 控件只能在其所属的 UI 线程上进行操作。如果在其他线程上直接修改控件状态，可能会引发异常或导致不可预测的行为。

Control.Invoke（Windows Forms）
Dispatcher.Invoke（WPF）同步方法，调用后会阻塞调用线程，直到在 UI 线程上执行完指定委托并返回结果。

异步委托调用

BeginInvoke (Windows Forms 和 WPF)
Control.BeginInvoke（Windows Forms）
Dispatcher.BeginInvoke（WPF）异步方法，立即返回，不会阻塞调用线程。指定的委托将在 UI 线程上异步执行。

事件和回调

在某些情况下，Invoke可能被用作事件处理或回调机制的一部分。例如，在异步编程或多线程环境中，当某个事件发生时，可能需要通过Invoke来调用一个事件处理程序或回调函数。

C#中out和ref之间的区别

Thu, 19 Sep 2024 00:00:00 +0000

C#中out和ref之间的区别

首先：两者都是按地址传递的，使用后都将改变原来参数的数值。

其次：ref可以把参数的数值传递进函数，但是out是要把参数清空，就是说你无法把一个数值从out传递进去的，out进去后，参数的数值为空，所以你必须初始化一次。这个就是两个的区别，或者说就像有的网友说的，ref是有进有出，out是只出不进。

ref（C# 参考）

ref 关键字使参数按引用传递。其效果是，当控制权传递回调用方法时，在方法中对参数的任何更改都将反映在该变量中。若要使用 ref 参数，则方法定义和调用方法都必须显式使用 ref 关键字。

例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


class RefExample
{
 static void Method(ref int i)
 {
 i = 44;
 }

 static void Main()
 {
 int val = 0;
 Method(ref val);
 // val is now 44
 }
}

传递到 ref 参数的参数必须最先初始化。这与 out 不同，后者的参数在传递之前不需要显式初始化。

尽管 ref 和 out 在运行时的处理方式不同，但在编译时的处理方式相同。因此，如果一个方法采用 ref 参数，而另一个方法采用 out 参数，则无法重载这两个方法。例如，从编译的角度来看，以下代码中的两个方法是完全相同的，因此将不会编译以下代码：

1
2
3
4
5
6
7


class CS0663_Example
{
 // Compiler error CS0663: "cannot define overloaded
 // methods that differ only on ref and out".
 public void SampleMethod(ref int i) { }
 public void SampleMethod(out int i) { }
}

但是，如果一个方法采用 ref 或 out 参数，而另一个方法不采用这两个参数，则可以进行重载，如下例所示：

1
2
3
4
5


class RefOutOverloadExample
{
 public void SampleMethod(int i) { }
 public void SampleMethod(ref int i) { }
}

out（C# 参考）

out 关键字会导致参数通过引用来传递。这与 ref 关键字类似，不同之处在于 ref 要求变量必须在传递之前进行初始化。若要使用 out 参数，方法定义和调用方法都必须显式使用out 关键字。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


class OutExample
{
 static void Method(out int i)
 {
 i = 44;
 }

 static void Main()
 {
 int value;
 Method(out value);
 // value is now 44
 }
}

尽管作为 out 参数传递的变量不必在传递之前进行初始化，但需要调用方法以便在方法返回之前赋值。

ref 和 out 关键字在运行时的处理方式不同，但在编译时的处理方式相同。因此，如果一个方法采用 ref 参数，而另一个方法采用 out 参数，则无法重载这两个方法。例如，从编译的角度来看，以下代码中的两个方法是完全相同的，因此将不会编译以下代码：

1
2
3
4
5
6
7


class CS0663_Example
{
 // Compiler error CS0663: "Cannot define overloaded
 // methods that differ only on ref and out".
 public void SampleMethod(out int i) { }
 public void SampleMethod(ref int i) { }
}

但是，如果一个方法采用 ref 或 out 参数，而另一个方法不采用这两类参数，则可以进行重载，如下所示：

1
2
3
4
5


class RefOutOverloadExample
{
 public void SampleMethod(int i) { }
 public void SampleMethod(out int i) { }
}

下面是本人的一些心得：

区别：

ref和out的区别在C# 中，既可以通过值也可以通过引用传递参数。通过引用传递参数允许函数成员更改参数的值，并保持该更改。若要通过引用传递参数，可使用ref或out关键字。ref和out这两个关键字都能够提供相似的功效，其作用也很像C中的指针变量。它们的区别是：

1、使用ref型参数时，传入的参数必须先被初始化。对out而言，必须在方法中对其完成初始化。

2、使用ref和out时，在方法的参数和执行方法时，都要加Ref或Out关键字。以满足匹配。

3、out适合用在需要retrun多个返回值的地方，而ref则用在需要被调用的方法修改调用者的引用的时候。

out

方法参数上的 out 方法参数关键字使方法引用传递到方法的同一个变量。当控制传递回调用方法时，在方法中对参数所做的任何更改都将反映在该变量中。

当希望方法返回多个值时，声明 out 方法非常有用。使用 out 参数的方法仍然可以返回一个值。一个方法可以有一个以上的 out 参数。

若要使用 out 参数，必须将参数作为 out 参数显式传递到方法。out 参数的值不会传递到 out 参数。

不必初始化作为 out 参数传递的变量。然而，必须在方法返回之前为 out 参数赋值。

属性不是变量，不能作为 out 参数传递。

ref是有进有出，而out是只出不进。

值传递 vs 引用传递

Thu, 19 Sep 2024 00:00:00 +0000

不知道你在开发过程中有没有遇到过这样的困惑：这个变量怎么值被改？这个值怎么没变？

今天就来和大家分享可能导致这个问题的根本原因值传递 vs 引用传递。

在此之前我们先回顾两组基本概念：

值类型 vs 引用类型

值类型： 直接存储数据，数据存储在栈上；

引用类型： 存储数据对象的引用，数据实际存储在堆上。

形参 vs 实参

形参： 即形式参数，表示调用方法时，方法需要你传递的值。方法声明定义了其形参。也就是说在定义方法时，紧跟在方法名后面括号中的参数列表就是形参。

实参： 即实际参数，表示调用方法时，你传递给方法形参的值。调用代码在调用过程时提供实参。也就是说在调用方法时，紧跟在方法名后面括号中的参数列表就是实参。

再来回顾一下值类型和引用类型在内存中是怎么存储的呢？

对于值类型变量的值直接存储在栈中，如下图的int a=10，10就直接存在栈空间中，而其栈空间对应的内存地址为0x66666668；对于引用类型变量本身存储的是实例对象的引用，即实例对象在堆中的实际内存地址，因此引用类型变量是存储其实例对象的引用于栈上，如下图中变量Test a在栈中实际存储的是实例对象Test a在堆中的内存地址0x88888880，而栈空间对应的内存地址为0x66666668。

栈也是有内存地址的，这一点很重要，无论栈空间上存储的是值还是引用地址，这个栈空间本身也有自己对应的内存地址。

什么是值传递？什么是引用传递？

值传递：如果变量按值传递给方法，则会把变量的副本传递给方法。对于值类型则把变量的副本传递给方法，对于引用类型则把变量的引用的副本传递给方法。因此被调用方法参数会创建一个新的内存地址用于接收存储变量，因此在方法内部对变量修改并不会影响原来的值。

引用传递：如果变量按引用传递给方法，则会把变量的引用传递给方法，对于值类型则把变量的栈空间地址传递给方法，对于引用类型则把变量的引用的栈空间地址传递给方法。因此被调用方法参数不会创建一个新的内存地址用于接收存储变量，意味着形参与实参共同指向相同的内存地址，因此在方法内部修对变量修改会影响原来的值。

上面的描述可能有点拗口，下面我们在基于值类型、引用类型、值传递、引用传递各种组合进行一个详细说明。

01、值类型按值传递

当值类型按值传递时，调用者会把值类型变量的副本传递给方法，因此被调用方法参数会创建一个新的内存地址用于接收存储变量，因此当在方法内部对参数进行修改时并不会影响调用者调用处的值类型变量。

传递值类型变量的副本就是相当于在栈上，又复制了一个同样的值，而且内存地址还不一样，所以互不影响。如下图把a赋值给b，则b直接新开辟了一个栈空间，虽然a和b都是10，但是它们在不同的地址空间中，因此如果他们各自被修改了，也互不影响。

下面我们写个例子演示一下，这个例子就是定义个变量a并赋值，然后调用一个方法此方法内对传进来的参数a进行加1，具体代码如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


public static void ValueByValueRun()
{
 var a = 10;
 Console.WriteLine($"调用者-调用方法前 a 值：{a}");
 ChangeValueByValue(a);
 Console.WriteLine($"调用者-调用方法后 a 值：{a}");
}
public static void ChangeValueByValue(int a)
{
 Console.WriteLine($" 被调用方法-接收到 a 值：{a}");
 a = a + 1;
 Console.WriteLine($" 被调用方法-修改后 a 值：{a}");
}

运行结果如下：

通过代码执行结果可以发现，方法内对变量的修改已经生效，但是不没有影响到调用者调用处的变量值。

02、引用类型按值传递

当引用类型按值传递时，调用者会把引用类型变量的引用副本传递给方法，因此被调用方法参数会创建一个新的内存地址用于接收存储变量，而对于一个引用类型变量来说其本身存储的就是引用类型实例对象的引用副本，而方法接收到的也是此变量引用的副本，所以调用者参数和被调用方法参数是引用了同一个实例对象的两个引用副本。如下图Test a可以理解为调用者传的实参，Test b可以理解为被调用方法定义的形参，这两个参数都只是指向堆中Test a的引用副本。

因此可以得出两个结论：

1、变量a和b都是指向实例对象Test a的引用，所以无论变量a或b，只要有一个更新了实例成员则另一个变量也会同步发生变化。

2、虽然变量a和b都是指向实例对象Test a的引用，但是他们存储在栈上的内存地址却不同，因此如果他们各种重新分配实例也就是new一个新对象，则另一个变量无法感知到还是保持原因状态不变。

我们先用代码说明第一个结论：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


public static void ChangeReferenceByValueRun()
{
 var a = new Test
 {
 Age = 10
 };
 Console.WriteLine($"调用者-调用方法前 a.Age 值：{a.Age}");
 ChangeReferenceByValue(a);
 Console.WriteLine($"调用者-调用方法后 a.Age 值：{a.Age}");
}
public static void ChangeReferenceByValue(Test a)
{
 Console.WriteLine($" 被调用方法-接收到 a.Age 值：{a.Age}");
 a.Age = a.Age + 1;
 Console.WriteLine($" 被调用方法-修改后 a.Age 值：{a.Age}");
}

运行结果如下：

可以看到被调用方法中a实例对象的Age属性发生变化后，调用者中变量也同步发生了变化。

对于第二个结论我们这样论证，在方法中直接对参数new一个新对象，看看原变量是否发生变化，代码如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


public static void NewReferenceByValueRun()
{
 var a = new Test
 {
 Age = 10
 };
 Console.WriteLine($"调用者-调用方法前 a.Age 值：{a.Age}");
 NewReferenceByValue(a);
 Console.WriteLine($"调用者-调用方法后 a.Age 值：{a.Age}");
}
public static void NewReferenceByValue(Test a)
{
 Console.WriteLine($" 被调用方法-接收到 a.Age 值：{a.Age}");
 a = new Test
 {
 Age = 100
 };
 Console.WriteLine($" 被调用方法-new后 a.Age 值：{a.Age}");
}

执行结果如下：

可以发现当在方法中对变量执行new操作后，调用者处的变量并没有发生变化。

为什么会这样呢？因为对于引用类型来说，形参和实参是对引用类型的实例对象引用的两个副本，而这两个副本存储在栈上又分别在不同的内存地址空间上，而new主要就是重新分配内存，这就导致形参变量a=new后，栈上形参变量a指向了Test新的实例对象的引用，而实参变量a还是保持原有实例对象引用不变。

如下图所示。

03、值类型按引用传递

当值类型按引用传递时，调用者会把值类型变量对应的栈空间地址传递给方法，因此被调用方法参数不会创建一个新的内存地址用于接收存储变量，因此当在方法内部对参数进行修改时并同样会影响调用者调用处的值类型变量。

传递值类型变量对应的栈空间地址就意味着形参与实参共同指向相同的内存地址，所以才导致对形参修改时，实参也会同步发生变化。

我们用一个小例子演示一下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


public static void ValueByReferenceRun()
{
 Console.WriteLine($"值类型按引用传递");
 var a = 10;
 Console.WriteLine($"调用者-调用方法前 a 值：{a}");
 ChangeValueByReference(ref a);
 Console.WriteLine($"调用者-调用方法后 a 值：{a}");
}
public static void ChangeValueByReference(ref int a)
{
 Console.WriteLine($" 被调用方法-接收到 a 值：{a}");
 a = a + 1;
 Console.WriteLine($" 被调用方法-修改后 a 值：{a}");
}

执行结果如下：

可以发现调用者处的值类型变量已经发生改变。

04、引用类型按引用传递

当引用类型按引用传递时，调用者会把引用类型变量对应的栈空间地址传递给方法，因此被调用方法参数不会创建一个新的内存地址用于接收存储变量，因此当在方法内部对参数进行修改时并同样会影响调用者调用处的引用类型变量。

传递引用类型变量对应的栈空间地址就意味着形参与实参共同指向相同的内存地址，因此对形参修改时，实参也会同步发生变化，而且这个里的修改不单单指修改实例成员，还包括new一个新实例对象。

下面我们看一个修改实例成员的例子：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


public static void ChangeReferenceByReferenceRun()
{
 Console.WriteLine($"引用类型按引用传递 - 修改实例成员");
 var a = new Test
 {
 Age = 10
 };
 Console.WriteLine($"调用者-调用方法前 a.Age 值：{a.Age}");
 ChangeReferenceByReference(ref a);
 Console.WriteLine($"调用者-调用方法后 a.Age 值：{a.Age}");
}
public static void ChangeReferenceByReference(ref Test a)
{
 Console.WriteLine($" 被调用方法-接收到 a.Age 值：{a.Age}");
 a.Age = a.Age + 1;
 Console.WriteLine($" 被调用方法-修改后 a.Age 值：{a.Age}");
}

执行结果如下：

再看看new一个新对象的例子：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


public static void NewReferenceByReferenceRun()
{
 Console.WriteLine($"引用类型按引用传递 - new 新实例");
 var a = new Test
 {
 Age = 10
 };
 Console.WriteLine($"调用者-调用方法前 a.Age 值：{a.Age}");
 NewReferenceByReference(ref a);
 Console.WriteLine($"调用者-调用方法后 a.Age 值：{a.Age}");
}
public static void NewReferenceByReference(ref Test a)
{
 Console.WriteLine($" 被调用方法-接收到 a.Age 值：{a.Age}");
 a = new Test
 {
 Age = 100
 };
 Console.WriteLine($" 被调用方法-new后 a.Age 值：{a.Age}");
}

执行结果如下：

另外string是一个特殊的引用类型，string类型变量的按值传递和按引用传递和值类型是一致的，也就是要把string类型当值类型一样看待就行。string类型的特殊性我们后面会单独具体介绍。

在C#中以下修饰符可应用与参数声明，并且会使得参数按引用传递：ref、out、readonly ref、in。对于每个修饰符具体怎么使用就不再这里细说了。

静态构造函数

Mon, 12 Aug 2024 00:00:00 +0000

在C#中，静态构造函数（也称为类型构造函数）是一种特殊的构造函数，用于初始化静态成员或执行只需要一次的操作。静态构造函数的主要特点包括：

无需显式调用：静态构造函数在第一次访问类型的静态成员或实例成员之前，由运行时自动调用。
不能有访问修饰符：静态构造函数不能有public、private等访问修饰符。它只能由类型定义来确定。
无参数：静态构造函数不能有参数。
每个类型只能有一个静态构造函数。
不能通过对象实例来调用：静态构造函数只能通过类型本身触发，而不能通过类型的实例来触发。

下面是一个简单的示例，展示了如何使用静态构造函数：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


using System;

class MyClass
{
 // 静态字段
 public static int StaticField;

 // 静态构造函数
 static MyClass()
 {
 Console.WriteLine("静态构造函数被调用");
 StaticField = 42;
 }

 // 实例构造函数
 public MyClass()
 {
 Console.WriteLine("实例构造函数被调用");
 }

 // 静态方法
 public static void StaticMethod()
 {
 Console.WriteLine("静态方法被调用");
 }
}

class Program
{
 static void Main()
 {
 // 访问静态字段，触发静态构造函数
 Console.WriteLine(MyClass.StaticField);

 // 创建实例，静态构造函数不会再次被调用
 MyClass myClass = new MyClass();

 // 调用静态方法
 MyClass.StaticMethod();
 }
}

输出：

1
2
3
4


静态构造函数被调用
42
实例构造函数被调用
静态方法被调用

10 Advanced Techniques

Mon, 05 Aug 2024 00:00:00 +0000

作为 C# 开发人员，学习更高级的技术可以帮助您编写更简洁、更高效和更具创新性的代码。在本文中，我们将探讨一些十个高级 C# 技巧，这些技巧是为想要突破 C# 极限的更有经验的开发人员量身定制的。这些技巧可以提高代码的性能、可读性和可维护性。

利用元组获取多个返回值

传统上，要从方法返回多个值，开发人员必须使用参数并创建自定义类或结构。但是，C# 7 引入了元组，这使得这样做更容易、更易读。

1
2
3
4


public (int sum, int product) Calculate(int a, int b)
{
 return (a + b, a * b);
}

此方法简化了对多个返回值的处理，并提高了代码的清晰度。

模式匹配增强功能

C# 7 及更高版本引入了强大的模式匹配功能，允许更富有表现力和简洁的类型检查和转换。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


public void ProcessShape(object shape)
{
 if (shape is Circle c)
 {
 Console.WriteLine($"Circle with radius: {c.Radius}");
 }
 else if (shape is Square s)
 {
 Console.WriteLine($"Square with side: {s.Side}");
 }
}

此技术减少了样板代码的数量，并使代码更易于阅读。

使用本地函数进行封装

在 C# 7 中，引入了本地函数，这些函数允许您在另一个方法中定义方法。这些函数对于封装仅在特定方法中有意义的帮助程序方法特别有用。

1
2
3
4
5


public IEnumerable<int> Fibonacci(int n)
{
 int Fib(int term) => term <= 2 ? 1 : Fib(term - 1) + Fib(term - 2);
 return Enumerable.Range(1, n).Select(Fib);
}

局部函数可以从封闭方法访问变量，这提供了一种实现复杂逻辑的简洁方法。

简洁代码的表达式成员

表达式成员有助于使代码更简洁，因为它们允许在一行代码上实现方法、属性和其他成员。

1
2
3
4
5


public class Person
{
 public string Name { get; set; }
 public override string ToString() => $"Name: {Name}";
}

此功能在最新版本的 C# 中得到了扩展，使定义轻型类成员变得更加容易。

不可变数据类型的只读结构

只读结构非常适合创建不可变数据类型。这意味着对象一旦创建，就无法更改。

1
2
3
4
5
6
7


public readonly struct Point
{
 public double X { get; }
 public double Y { get; }

 public Point(double x, double y) => (X, Y) = (x, y);
}

此构造可用于表示小型、不可变的数据类型，例如坐标或复数。

用于性能优化的 Ref 返回和局部变量

Ref 返回和局部变量允许方法返回对变量的引用，而不是值本身。这可以显著提高大型对象的性能。

1
2
3
4
5
6
7
8
9


public ref int Find(int[] numbers, int target)
{
 for (int i = 0; i < numbers.Length; i++)
 {
 if (numbers[i] == target)
 return ref numbers[i];
 }
 throw new IndexOutOfRangeException("Not found");
}

此功能在处理大型数据结构的性能敏感代码中特别有用。

使用丢弃来忽略不需要的退货

丢弃是一项高级功能，允许开发人员跳过他们不感兴趣的参数或元组。这使得代码更具可读性且更易于维护。

1

var (_, product) = Calculate(3, 4); // Only interested in the product

这样可以更轻松地处理返回多个值的方法，因为您只需要其中的几个值。

用于简化 Null 检查的 Null 合并赋值

null 合并赋值运算符简化了将值赋值给变量的过程（当变量可能为 null 时）。??=

1
2
3


List<int> numbers = null;
numbers ??= new List<int>();
numbers.Add(1);

此运算符可减少确保在使用对象之前创建对象所需的代码量。

用于轻量级数据结构的 ValueTuple

ValueTuple 是 Tuple 数据结构的轻量级替代方法，它提供了一种更节省内存的方法来管理值集合。

1
2


var person = (Name: "John", Age: 30);
Console.WriteLine($"{person.Name} is {person.Age} years old.");

ValueTuple 对于不需要类开销的临时数据结构特别有用。

具有 IAsyncEnumerable 的异步流

C# 8 中引入的异步流允许对异步加载的集合实现异步迭代。这显著提高了处理流数据或受 I/O 限制的应用程序的性能。

1
2
3
4
5
6
7
8


public async IAsyncEnumerable<int> GetNumbersAsync()
{
 for (int i = 0; i < 10; i++)
 {
 await Task.Delay(100); // Simulate asynchronous work
 yield return i;
 }
}

这允许使用来使用异步流，从而更容易编写高效且可读的异步代码。await foreach

C# 的演变引入了一些功能，可提高其代码的可读性、可维护性和性能。其中包括元组、模式匹配和异步流，这对于在 .NET 生态系统中创建更高效、更现代的 C# 应用程序至关重要。

通过有效利用这些工具，开发人员可以提高应用程序性能、改进其编码风格并提高软件质量。通过掌握这些功能，开发人员可以确保以符合项目需求的方式使用它们，从而释放其成功开发的全部潜力。

委托与事件

Wed, 06 Sep 2023 00:00:00 +0000

委托要解决的问题：
1. 函数传参：回调函数，linq表达式
2. 基于委托声明事件，事件可以注册（按钮点击…）
委托本制是一个引用类型，所以可以实例化
委托是一个函数指针
事件和委托最大的区别是：对于委托来说，任何能得到这个委托引用的代码都可以调用它的Invoke方法来。而事件只能在其被定义的类里才能调用Invoke，这个类的子类都不可以！event其实就是限制委托的invoke不能被乱调用，就是起到安全作用
事件最重要的安全性居然没提到太不应该了。事件和属性是类似的东西。属性是对字段进行封装，而事件是对特殊用途的委托类型的字段进行封装。属性本质是两个方法，也就是两个访问器（get,set），在使用自动属性的时候会自动生成一个私有字段；而事件本质上也是两个方法(add,remove)，声明自动事件的时候也会自动生成一个私有字段，并且和事件完全同名
事件除了保护委托不让外部查看调用列表、移除其他委托、不能赋空、不能调用等保护作用外，没有其他作用
事件是对委托的一种封装
事件说白了是 C# 提供的语法糖，效果是: 1.将委托以私有变量的形式封装在类内，不让外面访问 2.对于委托进行了封装，从而定义add与remove 方法 3.在 add 与 remove 中通过互锁的方式提供了线程安全性

C# on Sutra Library

避免Newtonsoft.Json反序列化出现重复列表项

问题描述

问题分析

问题解决

Wpf生成操作：内容和资源

🧱 一、生成操作（Build Action）的基本概念

🎨 二、“内容（Content）”、“资源（Resource）”、“嵌入的资源（Embedded Resource）”的区别

🧩 三、具体区别举例

1️⃣ Content（内容）

2️⃣ Resource（资源）

3️⃣ Embedded Resource（嵌入的资源）

💡 四、总结与推荐使用

🧠 小技巧

C#高频面试题

Python 的 self 和 C# 的 this

🧩 一、基本作用对比

🧠 二、示例对比

🐍 Python

💻 C#

⚙️ 三、调用机制差异

🧩 四、可用场景差异

💡 五、总结一句话

C#.NET 中间件详解

简介

请求管道（Request Pipeline）

请求委托（RequestDelegate）

短路（Short-Circuiting）

中间件的注册与类型

注册方式

生命周期管理

自定义中间件实现

基本模板

扩展方法

内置中间件概览

注册顺序与注意事项

终结点与分支

进阶用法

条件执行

中间件短路

捕获并处理异常

分支中间件（Map/MapWhen）

终结点中间件（Run）

中间件与依赖注入一

带配置的中间件

中间件工厂 (IMiddlewareFactory)

中间件依赖注入二

内置中间件

内置中间件

异常处理中间件

静态文件中间件

System.Text.Json 和 Newtonsoft.Json 默认序列化时的大小写行为差异

最容易踩坑的6个async/await 使用错误

📌 引言：async/await 很强大，但也很容易用错！

🔥 常见错误一：用了 .Result 或 .Wait() 阻塞异步方法

❌ 错误示例：

⚠️ 为什么有问题？

✅ 正确做法：

💡 小贴士：

🔥 常见错误二：写了 async 方法，却没用 await

❌ 错误示例：

⚠️ 有什么问题？

✅ 正确做法：

💡 小贴士：

🔥 常见错误三：使用 async void（除了事件处理）

❌ 错误示例：

⚠️ 为什么危险？

✅ 正确做法：

💡 小贴士：

🔥 常见错误四：明明不需要异步，却还加 async

❌ 错误示例：

⚠️ 有什么问题？

✅ 正确做法：

💡 小贴士：

🔥 常见错误五：每次调用都 new HttpClient

❌ 错误示例：

⚠️ 有什么风险？

✅ 正确做法：

💡 小贴士：

🔥 常见错误六：忽略 ConfigureAwait(false)，导致上下文捕获引发死锁

🔥 常见错误一：用了 `.Result` 或 `.Wait()` 阻塞异步方法

🔥 常见错误二：写了 `async` 方法，却没用 `await`

🔥 常见错误三：使用 `async void`（除了事件处理）

🔥 常见错误四：明明不需要异步，却还加 `async`

使用 `EventWaitHandle`

使用 `Mutex`（互斥锁）

值类型（如 `int`, `struct`）

引用类型（如 `string`, `class`）

协变（`out T`）

逆变（`in T`）

对比非泛型集合（如 `ArrayList`）：