<p>default关键字提供类型安全的默认值，对值类型返回零值（如0、false），对引用类型返回null；在泛型中统一处理不同类型初始化，避免使用null带来的类型不安全问题；C# 7.1+支持default字面量实现简洁赋值，C# 8.0+可在switch表达式中作为默认分支返回对应类型的默认状态。</p>

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

关键字在泛型世界里不可或缺的价值体现。

可画AI

Canva可画魔力工作室，一站式ai智能设计工具平台

174

查看详情

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#代码的简洁性和可读性。它不再仅仅是一个获取默认值的函数，而是一个可以在各种表达式和模式匹配中使用的强大工具。