.NET 代码质量与性能优化的简单最佳实践？-51CTO.COM

今天我们用一些简单易懂的例子，来聊聊如何在 .NET 中编写更好、更快的代码。无论你是新手还是老手，这些基本原则都值得一看。

一、遵循 SOLID 原则

SOLID 是五个面向对象设计的基础原则，理解它们，就像掌握了盖“坚固房子”的五个要点。

单一职责原则（SRP）

每个类应该只负责一件事情，职责越单一，代码越清晰。

// 这个类只处理用户相关的业务
public class UserService
{
    public void AddUser(User user)
    {
        // 添加用户到数据库
    }
}1.
2.
3.
4.
5.
6.
7.
8.

开闭原则（OCP）

对扩展开放，对修改关闭。也就是说新增功能时尽量不去动旧代码。

public interfaceIShape
{
    double Area();
}

publicclassCircle : IShape
{
    publicdouble Radius { get; set; }
    public double Area() => Math.PI * Radius * Radius;
}

publicclassSquare : IShape
{
    publicdouble Side { get; set; }
    public double Area() => Side * Side;
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.

里氏替换原则（LSP）

子类应该可以替换父类并正常工作，不能破坏继承体系。

public class Bird
{
    public virtual void Fly() { }
}

public class Sparrow : Bird
{
    public override void Fly() { }
}1.
2.
3.
4.
5.
6.
7.
8.
9.

接口隔离原则（ISP）

接口要小而精，不要强迫类实现它用不到的方法。

public interfaceIPrinter
{
    void Print();
}

publicinterfaceIScanner
{
    void Scan();
}

publicclassMultiFunctionPrinter : IPrinter, IScanner
{
    public void Print() { }
    public void Scan() { }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.

依赖反转原则（DIP）

依赖抽象，而不是依赖具体实现。这样代码更灵活、更容易测试。

public interfaceIMessageService
{
    void SendMessage(string message);
}

publicclassEmailService : IMessageService
{
    public void SendMessage(string message)
    {
        // 发送邮件
    }
}

publicclassNotification
{
    privatereadonly IMessageService _messageService;

    public Notification(IMessageService messageService)
    {
        _messageService = messageService;
    }

    public void Notify(string message)
    {
        _messageService.SendMessage(message);
    }
}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 async Task<string> GetDataAsync()
{
    HttpClient client = new HttpClient();
    string data = await client.GetStringAsync("https://example.com");
    return data;
}1.
2.
3.
4.
5.
6.

三、优化数据访问

访问数据就像打水，选个近的水井总比跑去远处的河边快。使用合适的工具可以事半功倍。

// 使用 Entity Framework Core 访问数据库
public async Task<List<Product>> GetProductsAsync()
{
    using (var context = new MyDbContext())
    {
        return await context.Products.ToListAsync();
    }
}1.
2.
3.
4.
5.
6.
7.
8.

四、避免不必要的操作

少做无用功，程序自然快。例如，频繁转换类型就会拖慢性能。

// 避免装箱和拆箱操作
List<int> numbers = new List<int> { 1, 2, 3 };1.
2.

五、高效处理字符串

拼接大量字符串时，用 StringBuilder 比用 + 更高效。

StringBuilder sb = new StringBuilder();
sb.Append("Hello");
sb.Append(" ");
sb.Append("World");
string result = sb.ToString();1.
2.
3.
4.
5.

六、优雅地处理错误

错误要“接得住”，不要让程序直接崩掉。

try
{
    int result = 10 / 0;
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("除数不能为零！");
}1.
2.
3.
4.
5.
6.
7.
8.

七、使用依赖注入

依赖注入就像整理好的工具箱，哪种工具放哪里一目了然，管理起来更方便。

public interfaceIMessageService
{
    void SendMessage(string message);
}

publicclassEmailService : IMessageService
{
    public void SendMessage(string message)
    {
        // 发送邮件
    }
}

publicclassMyController
{
    privatereadonly IMessageService _messageService;

    public MyController(IMessageService messageService)
    {
        _messageService = messageService;
    }

    public void NotifyUser()
    {
        _messageService.SendMessage("Hello User!");
    }
}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.

八、性能分析与优化

定期用 Visual Studio 的性能分析工具（Profiler）检查程序性能，找出瓶颈，及时优化。

九、编写单元测试

写测试就像交作业前先自己检查一遍，确保程序按预期运行。

[Fact]
public void AddNumbers_ShouldReturnCorrectSum()
{
    int result = AddNumbers(2, 3);
    Assert.Equal(5, result);
}1.
2.
3.
4.
5.
6.

通过这些简单的技巧和原则，你可以写出既优雅又高效的 .NET 程序！