1. 入门
在面向对象编程的世界里，我们经常会遇到想给现有类加点新功能的需求。有时候你根本拿不到这些类的源码（比如标准的.NET类型、第三方库的类，或者自动生成的代码）。
这种时候，Extension Methods就派上用场了——这是C#里一个又强大又优雅的功能，让你“假装”给现有类型加新方法，而不用直接改它们。
Extension methods其实就是C#里的语法糖，让你能像调用实例方法一样去用静态方法。它们看起来、用起来就像本来就是那个类型自带的方法，实际上并不是。
比如你想要个方法，把字符串的第一个字母变成大写：
public static class StringUtil
{
public static string CapitalizeFirstLetter(string str)
{
if (string.IsNullOrEmpty(str)) return str;
return char.ToUpper(str[0]) + str.Substring(1);
}
}
// 用法
string hello = StringUtil.CapitalizeFirstLetter("hello"); // "Hello"
Console.WriteLine(hello);
这代码没啥特别的，但C#其实能让你写得更简洁。
这一行
string hello = StringUtil.CapitalizeFirstLetter("hello"); // "Hello"
可以这样写：
string hello = "hello".CapitalizeFirstLetter(); // "Hello"
现在我来解释下为啥能这样。
2. Extension Methods的原理
虽然Extension Methods看起来像魔法，其实底层很简单。Extension method其实就是普通的静态方法，写在静态类里，但有个关键区别：第一个参数前面要加this关键字。这个参数就表示你要“扩展”的类型。
来看个给string类型加扩展的例子：
namespace MyProject.Extensions
{
// 1. Extension Methods必须写在静态类里。
public static class StringExtensions
{
// 2. 方法必须是静态的。
// 3. 第一个参数前要加 'this'。
public static string CapitalizeFirstLetter(this string str)
{
if (string.IsNullOrEmpty(str))
return str;
// 用String.ToUpper和String.Substring拼新字符串
return char.ToUpper(str[0]) + str.Substring(1);
}
// 再加一个例子：
public static int WordCount(this string text)
{
if (string.IsNullOrEmpty(text))
return 0;
// 最简单的词数统计，按空格分
return text.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).Length;
}
}
}
现在你只要在文件里引入命名空间MyProject.Extensions就能用这些方法了：
using MyProject.Extensions; // 注意：要引入有Extension Methods的命名空间
string hello = "hello, world!";
Console.WriteLine(hello.CapitalizeFirstLetter()); // 输出: "Hello, world!"
string sentence = "This is a test string for counting words.";
Console.WriteLine($"Count words: {sentence.WordCount()}"); // 输出: "Count words: 6"
string emptyString = "";
Console.WriteLine(emptyString.CapitalizeFirstLetter()); // 输出: ""
注意：如果this没写在第一个参数string str前面，CapitalizeFirstLetter就只是StringExtensions类的普通静态方法，你只能像StringExtensions.CapitalizeFirstLetter("hello")这样用。正是this让它变成Extension Method，可以用面向对象的风格来调用。
3. Extension Methods语法
要写和用Extension Methods，按这几个步骤来：
- 写静态类：所有Extension Methods都得写在静态类里。类名随便，但一般习惯叫[TypeName]Extensions（比如StringExtensions、ListExtensions、DateTimeExtensions）。
- 写静态方法：在你的静态类里写普通静态方法。
- 第一个参数加this：最关键的就是第一个参数要加this，后面跟你想扩展的类型。这个参数就是你调用Extension Method时的对象实例。
- 引入命名空间：在你想用Extension Method的文件里，记得using一下有你静态类的命名空间。不然编译器找不到你的扩展。
- 像普通方法一样用：现在你就能像用实例方法一样用你的Extension Method了。
4. “魔法”到底怎么实现的
Extension Methods的“魔法”其实是C#编译器搞的。运行时这些方法并不是类自带的方法。实际上，C#编译器会把你写的Extension Method调用转成普通的静态方法调用。
当你写obj.Method(args)，而Method是Extension Method时，编译器会把它变成ContainingClass.Method(obj, args)。这都是自动完成的，所以你才觉得这个方法像是类自带的。
冲突怎么解决：Extension Methods vs 普通方法
如果类本身已经有个和你的Extension Method同名同参数的方法，会发生什么？
public class MyClass
{
public void DoSomething(int value)
{
Console.WriteLine($"原生方法 MyClass.DoSomething: {value}");
}
}
public static class MyClassExtensions
{
public static void DoSomething(this MyClass instance, int value)
{
Console.WriteLine($"扩展方法 MyClassExtensions.DoSomething: {value}");
}
}
// 用法:
MyClass obj = new MyClass();
obj.DoSomething(10); // 会调用原生方法 MyClass.DoSomething: 10
优先级规则：如果类本身有同名同参数的实例方法，一定会调用原生实例方法，不会用Extension Method。Extension Methods在名字冲突时优先级更低。
Extension Methods的限制
- 不能override已有方法：Extension Methods不参与多态。
- 不能加新字段、属性或事件：只能加方法，不能给类型加新状态。
- 不能扩展静态类：第一个this参数必须是实例（对象）。
- 不能扩展字段或属性：只能扩展类型。
- 不能访问私有或保护成员：Extension Methods只能用public成员。
不过，你可以给这些加Extension Methods：
- 接口：这个超强！你可以给实现某接口的所有类加方法，不用改接口或每个类。比如所有实现IEnumerable<T>的类都能用LINQ的Extension Methods。
- object类型：这样你能给C#里任何对象加Extension Methods。但要小心用，别把全局命名空间搞乱，也别引发名字冲突。
5. 真实例子和Best Practices
Extension Methods不是纸上谈兵，而是日常开发的利器。来看几个实用场景：
1. 扩展DateTime：
加点常用的日期操作方法，业务逻辑里经常用到。
using System;
namespace MyProject.TimeHelpers
{
public static class DateTimeExtensions
{
public static bool IsWeekend(this DateTime date)
{
return date.DayOfWeek == DayOfWeek.Saturday || date.DayOfWeek == DayOfWeek.Sunday;
}
public static bool IsWeekday(this DateTime date)
{
return !date.IsWeekend(); // 复用已有的Extension Method!
}
public static DateTime NextDay(this DateTime date)
{
return date.AddDays(1);
}
public static DateTime AddBusinessDays(this DateTime date, int days)
{
DateTime newDate = date;
while (days > 0)
{
newDate = newDate.NextDay();
if (newDate.IsWeekday())
{
days--;
}
}
return newDate;
}
}
}
用法：
using MyProject.TimeHelpers;
DateTime today = DateTime.Now;
if (today.IsWeekend())
{
Console.WriteLine("今天是周末！");
}
else
{
Console.WriteLine("今天是工作日。");
}
DateTime tomorrow = today.NextDay();
Console.WriteLine($"明天: {tomorrow.ToShortDateString()}");
DateTime futureDate = today.AddBusinessDays(5);
Console.WriteLine($"5个工作日后是: {futureDate.ToShortDateString()}");
2. 扩展你自己的类型（比如Dog）：
就算你能改类源码，Extension Methods也很适合把辅助逻辑分离出来，或者遵循单一职责原则（Single Responsibility Principle）。
namespace MyProject.Animals
{
public class Dog
{
public string Name { get; set; }
public int Age { get; set; }
public string Breed { get; set; }
}
public static class DogExtensions
{
public static bool IsPuppy(this Dog dog)
{
// 判断是不是小狗
return dog.Age < 2;
}
public static string GetAgeCategory(this Dog dog)
{
if (dog.Age < 1) return "小狗";
if (dog.Age < 7) return "成年狗";
return "老年狗";
}
public static void Bark(this Dog dog)
{
Console.WriteLine($"{dog.Name} 说: 汪！汪！");
}
}
}
用法：
using MyProject.Animals;
var sharik = new Dog { Name = "Snoopy", Age = 1, Breed = "Mongrel" };
if (sharik.IsPuppy())
{
Console.WriteLine($"{sharik.Name} — 还是小狗！"); // Snoopy — 还是小狗！
}
Console.WriteLine($"{sharik.Name} 属于: {sharik.GetAgeCategory()}"); // Snoopy 属于: 小狗
sharik.Bark(); // Snoopy 说: 汪！汪！
var rex = new Dog { Name = "Rex", Age = 5, Breed = "Shepherd" };
Console.WriteLine($"{rex.Name} 属于: {rex.GetAgeCategory()}"); // Rex 属于: 成年狗
Best Practices:
起有意义的名字：扩展类名（StringExtensions、ListExtensions）和方法名要清晰，能看出干啥的。
放在合适的命名空间：把Extension Methods分组放在有意义的命名空间里，别把全局命名空间搞乱。
别滥用：能直接改类源码就直接加，别啥都用Extension Methods。它们最适合加非侵入式功能。
避免名字冲突：记住原生方法优先。如果你的Extension Method和已有方法同名同参数，是不会被调用的。
方法要专一：Extension Methods要做一件事，别写得太复杂。
易于测试：Extension Methods就是普通静态方法，测试起来很方便。
GO TO FULL VERSION