C#中的
default关键字主要用于获取一个类型在内存中的默认值。无论是值类型（如
int、
bool、结构体）还是引用类型（如
string、自定义类），它都能提供一个统一且类型安全的初始状态。这在编写泛型代码时尤其有用，因为它能确保无论泛型参数
T最终是什么类型，我们都能为其提供一个合法的“空”或“零”状态。
解决方案
要指定默认值，最直接的方式就是使用
default关键字。
对于值类型（
int,
double,
bool,
struct等），
default会返回该类型的零值。比如，
default(int)是
0，
default(bool)是
false，而对于结构体，它的所有字段都会被初始化为各自的默认值。
对于引用类型（
string,
object, 自定义类等），
default则返回
null。这意味着该类型变量不引用任何对象实例。
在C# 7.1及更高版本中，你还可以使用更简洁的
default字面量（
default literal），当编译器能够从上下文推断出类型时，就不需要显式指定类型了。
示例：
int myInt = default(int); // myInt 会是 0 string myString = default(string); // myString 会是 null bool myBool = default(bool); // myBool 会是 false // C# 7.1+ 的简化写法： int anotherInt = default; // 同样是 0 MyClass myObject = default; // 同样是 null (假设 MyClass 是一个类)
这种方式特别强调了类型安全和代码的普适性，尤其是在你无法预知具体类型，或者想表达“给我这个类型最原始、最未经初始化的状态”时。
在泛型编程中，default
关键字如何避免类型困扰？
泛型编程，说白了就是写一套代码能适配多种数据类型，但这里面有个让人头疼的问题：你不知道
T到底是个
int还是个
string，或者是你自定义的某个类。当你需要给一个
T类型的变量赋一个初始值时，传统的
0或
null就不够用了。
想象一下，如果你要创建一个泛型列表，需要在内部初始化数组元素。如果
T是
int，你肯定想赋值
0；如果
T是
string，你大概率想赋值
null。你不可能写
if (T is int) ... else if (T is string) ...这样的代码，那太笨重了，而且不具备通用性。
default(T)就是为了解决这个“不知道
T是什么类型”的困境而生的。它提供了一个类型安全的万能初始值。无论
T是值类型还是引用类型，
default(T)总能给出那个类型最自然的“空”状态。
举个例子，我以前写一个泛型缓存类，需要预分配一个
T类型的数组：
public class SimpleCache<T>
{
private T[] _items;
private int _capacity;
public SimpleCache(int capacity)
{
_capacity = capacity;
_items = new T[capacity];
// 关键来了，如何初始化这些槽位？
// 如果没有default(T)，我真的不知道该怎么办
for (int i = 0; i < capacity; i++)
{
_items[i] = default(T); // 这行代码简直是救星
}
}
// ... 其他方法
}这行
_items[i] = default(T);简直是救星。它让代码变得简洁、通用，而且完全符合类型系统。如果
T是
int，
_items[i]就成了
0；如果
T是
MyObject，它就成了
null。这种设计上的优雅，是
default关键字在泛型世界里不可或缺的价值体现。
default
关键字与null
有什么不同，以及它们在不同上下文中的应用？
default和
null，初看有点像，但它们有着本质的区别，尤其是在C#的类型系统里。
null是一个非常具体的概念，它仅适用于引用类型（以及可空值类型，如
int?）。
null表示“没有对象实例”，或者说“这个引用不指向任何内存中的对象”。你不能把
null赋值给一个非可空的值类型，比如
int i = null;这会直接报错。
而
default则是一个更广泛、更抽象的概念。它代表的是任何给定类型在内存中的“零状态”或“空状态”。 当类型是引用类型时，
default(MyClass)的结果就是
null。所以，
string s = default;和
string s = null;是等价的。 当类型是值类型时，
default(int)的结果是
0，
default(bool)的结果是
false。这里，
default就不是
null了，它是一个实际的值。
上下文应用差异：
明确表示“无引用”： 当你明确知道你在处理引用类型，并且想要表达“这个引用目前不指向任何对象”时，直接使用null通常更清晰。
MyObject obj = null; // 明确表示obj当前没有实例泛型或类型不确定： 当你处于泛型上下文中，或者你希望代码能够适用于值类型和引用类型，并且需要一个通用的初始值时，
default是你的首选。
// 在泛型方法中返回一个T的默认值
public T GetDefault<T>()
{
return default; // T可能是int，也可能是MyClass
}
简洁的变量初始化： 在C# 7.1+中，如果你只是想给一个变量赋其类型的默认值，并且编译器能推断出类型，default字面量让代码更简洁。
int count = default; // 等同于 count = 0; List<string> names = default; // 等同于 names = null;
简而言之，
null是引用类型的特定值，而
default是一个通用的机制，能为任何类型提供一个类型安全的默认值，它包含了
null作为引用类型的默认情况。
除了变量初始化，default
关键字在现代C#语言特性中还有哪些进阶用法？
default关键字的用途远不止于简单的变量初始化。随着C#语言的发展，它在一些新的语言特性中也扮演了关键角色，让代码更简洁、更富有表现力。
一个很常见的场景是在可选参数中。从C# 7.1开始，我们可以用
default作为方法的默认参数值：
public void ProcessItem<T>(T item = default)
{
// 如果调用时没有提供item，它就会是T的默认值
if (item is null) // 对于引用类型，可以这样判断
{
Console.WriteLine("Item is null or default for its type.");
}
else if (EqualityComparer<T>.Default.Equals(item, default(T))) // 对于值类型，这样判断
{
Console.WriteLine("Item is default for its type (e.g., 0 for int).");
}
else
{
Console.WriteLine($"Processing item: {item}");
}
}
// 调用示例：
ProcessItem<int>(); // item 是 0
ProcessItem<string>(); // item 是 null
ProcessItem<int>(10); // item 是 10
ProcessItem<string>("hello"); // item 是 "hello"这让泛型方法的默认参数处理变得非常灵活，避免了为值类型和引用类型编写重载。
另一个非常有用的场景是在C# 8.0引入的switch
表达式中。
default可以作为一个模式，匹配所有未被显式处理的情况：
public string GetStatusCodeDescription(int code) => code switch
{
200 => "OK",
404 => "Not Found",
_ => default // 这里的default是string的默认值，也就是null
};
// 调用：
Console.WriteLine(GetStatusCodeDescription(200)); // 输出 "OK"
Console.WriteLine(GetStatusCodeDescription(500)); // 输出 "" (因为string的default是null，Console.WriteLine会打印空字符串)在这个
switch表达式里，
_模式匹配了所有其他情况，然后我们用
default字面量来返回
string类型的默认值，也就是
null。这比写
_ => null更简洁，尤其是在处理可空值类型时，比如
int?：
public int? ParseNullableInt(string s) => s switch
{
"one" => 1,
"two" => 2,
_ => default // 这里的default是int?的默认值，也就是null
};这种用法非常优雅，它让代码更具表达力，并且减少了冗余。
default字面量的引入，可以说是在不牺牲类型安全的前提下，极大地提升了C#代码的简洁性和可读性。它不再仅仅是一个获取默认值的函数，而是一个可以在各种表达式和模式匹配中使用的强大工具。
