编写干净的代码对于可维护性、可读性和可扩展性至关重要。
这里有 12 个简单的技巧可以帮助您在 .Net 中编写更干净的代码，每个技巧都附有好的和坏的代码片段。
1. 使用有意义的名字
糟糕的代码
public class C
{
public void M()
{
var a = 10;
var b = 20;
var c = a + b;
}
}
好代码
public class Calculator
{
public void AddNumbers()
{
var firstNumber = 10;
var secondNumber = 20;
var sum = firstNumber + secondNumber;
}
}
**说明：**使用有意义的名称来解释变量、类或方法的用途。
2. 避免使用神奇数字
糟糕的代码
public double CalculateCircumference(double radius)
{
return radius * 3.14 * 2;
}
好代码
public double CalculateCircumference(double radius)
{
const double Pi = 3.14159;
return radius * Pi * 2;
}
**说明：**使用常量作为魔法数字可以使代码更具可读性和可维护性。
3. 使用字符串插值
糟糕的代码
string name = "John";
int age = 30;
string message = "Name: " + name + ", Age: " + age;
好代码
string name = "John";
int age = 30;
string message = $"Name: {name}, Age: {age}";
**说明：**字符串插值比连接更具可读性且更易于管理。
4.避免深度嵌套
糟糕的代码
糟糕的代码
if (user != null)
{
if (user.IsActive)
{
if (user.HasPermission)
{
// Do something
}
}
}
好代码
if (user == null || !user.IsActive || !user.HasPermission)
{
return;
}
// Do something
**说明：**通过首先处理异常情况并尽早返回来扁平化您的代码。
5. 使用保护子句
糟糕的代码
public void ProcessOrder(Order order)
{
if (order != null)
{
if (order.IsValid)
{
// Process order
}
}
}
好代码
public void ProcessOrder(Order order)
{
if (order == null || !order.IsValid)
{
return;
}
// Process order
}
**说明：**解释：保护子句有助于减少嵌套并使代码更具可读性。
6.使用依赖注入
糟糕的代码
public class UserService
{
private readonly UserRepository _userRepository = new UserRepository();
public void CreateUser(User user)
{
_userRepository.Add(user);
}
}
好代码
public class UserService
{
private readonly IUserRepository _userRepository;
public UserService(IUserRepository userRepository)
{
_userRepository = userRepository;
}
public void CreateUser(User user)
{
_userRepository.Add(user);
}
}
**说明：**依赖注入通过分离依赖关系来提高可测试性和可维护性。
7.单一职责原则
糟糕的代码
public class User
{
public void AddUserToDatabase(User user)
{
// Add user to database
}
public void SendWelcomeEmail(User user)
{
// Send email
}
}
好代码
public class User
{
public void AddToDatabase(UserRepository userRepository)
{
userRepository.Add(this);
}
}
public class EmailService
{
public void SendWelcomeEmail(User user)
{
// Send email
}
}
**说明：**一个类应该有一个改变的原因。将关注点分成不同的类。
8. 使用 Async 和 Await 编写异步代码
糟糕的代码
public Task<string> GetData()
{
return Task.Run(() =>
{
// Simulate long-running task
Thread.Sleep(2000);
return "Data";
});
}
好代码
public async Task<string> GetData()
{
await Task.Delay(2000); // Simulate long-running task
return "Data";
}
**说明：**使用 async 和 await 可以获得更好的异步代码的可读性和性能。
9. 对简单条件使用三元运算符
糟糕的代码
string status;
if (isActive)
{
status = "Active";
}
else
{
status = "Inactive";
}
好代码
string status = isActive ? "Active" : "Inactive";
**说明：**三元运算符可以简化简单的条件赋值。
10. 封装条件
糟糕的代码
if (age > 18 && !isMember)
{
// Do something
}
好代码
if (IsEligibleForOffer(age, isMember))
{
// Do something
}
private bool IsEligibleForOffer(int age, bool isMember)
{
return age > 18 && !isMember;
}
**说明：**将复杂的条件封装到方法中以提高可读性。
11. 避免对所有事物都使用静态类
糟糕的代码
public static class Utility
{
public static int Add(int a, int b)
{
return a + b;
}
}
好代码
public class Calculator
{
public int Add(int a, int b)
{
return a + b;
}
}
**说明：**仅当类无状态且仅用于实用功能时才使用静态类。
12. 优先使用组合而不是继承
糟糕的代码
public class Animal
{
public void Eat() { }
public void Sleep() { }
}
public class Dog : Animal
{
public void Bark() { }
}
好代码
public class Animal
{
public void Eat() { }
public void Sleep() { }
}
public class Dog
{
private readonly Animal _animal = new Animal();
public void Bark() { }
public void Eat() { _animal.Eat(); }
public void Sleep() { _animal.Sleep(); }
}
**说明：**组合通常比继承更灵活且更易于管理。
结论
应用这些整洁代码原则可以显著提高代码质量，使其更易于阅读、维护和扩展。请记住，编写整洁代码是一项持续的实践，这些技巧是帮助您踏上这一旅程的良好起点。
标签：12,return,技巧,代码,public,class,user,NET,void From： https://blog.csdn.net/xiefeng240601/article/details/140225179