可维护性反模式

识别和避免影响代码可维护性的问题。

---

📋 文档信息

属性	值
难度	中级
阅读时间	20 分钟
前置知识	代码质量基础
相关文档	反模式索引、最佳实践

---

反模式 1: 硬编码字符串

❌ 错误做法

public void GenerateCode()
{
    var code = @"
namespace MyNamespace
{
    public class MyClass
    {
        public void MyMethod()
        {
            // 硬编码的命名空间和类名
        }
    }
}";
}

✅ 正确做法

private const string DefaultNamespace = "MyNamespace";
private const string DefaultClassName = "MyClass";

public void GenerateCode(string namespaceName = null, string className = null)
{
    namespaceName ??= DefaultNamespace;
    className ??= DefaultClassName;
    
    var code = $@"
namespace {namespaceName}
{
    public class {className}
    {
        // 使用参数化的名称
    }
}";
}

---

反模式 2: 缺少文档

❌ 错误做法

public void Process(ISymbol s)
{
    var t = s as ITypeSymbol;
    if (t != null)
    {
        var n = t.Name;
        // 做一些事情...
    }
}

✅ 正确做法

/// <summary>
/// 处理符号并提取类型信息
/// </summary>
/// <param name="symbol">要处理的符号</param>
public void ProcessSymbol(ISymbol symbol)
{
    // 尝试将符号转换为类型符号
    if (symbol is ITypeSymbol typeSymbol)
    {
        var typeName = typeSymbol.Name;
        // 处理类型名称...
    }
}

---

反模式 3: 复杂的嵌套逻辑

❌ 错误做法

public void ProcessNode(SyntaxNode node)
{
    if (node != null)
    {
        if (node is ClassDeclarationSyntax cls)
        {
            if (cls.Members.Count > 0)
            {
                foreach (var member in cls.Members)
                {
                    if (member is MethodDeclarationSyntax method)
                    {
                        if (method.Modifiers.Any(m => m.IsKind(SyntaxKind.PublicKeyword)))
                        {
                            // 深度嵌套...
                        }
                    }
                }
            }
        }
    }
}

✅ 正确做法

public void ProcessNode(SyntaxNode node)
{
    // 早期返回减少嵌套
    if (node == null) return;
    if (node is not ClassDeclarationSyntax cls) return;
    if (cls.Members.Count == 0) return;
    
    foreach (var member in cls.Members)
    {
        ProcessMember(member);
    }
}

private void ProcessMember(MemberDeclarationSyntax member)
{
    if (member is not MethodDeclarationSyntax method) return;
    if (!IsPublicMethod(method)) return;
    
    // 处理公共方法...
}

private bool IsPublicMethod(MethodDeclarationSyntax method)
{
    return method.Modifiers.Any(m => m.IsKind(SyntaxKind.PublicKeyword));
}

---

反模式 4: 代码重复

❌ 错误做法

public void ProcessClass(ClassDeclarationSyntax cls)
{
    var name = cls.Identifier.Text;
    var namespaceName = GetNamespace(cls);
    var fullName = $"{namespaceName}.{name}";
    // 使用 fullName...
}

public void ProcessStruct(StructDeclarationSyntax str)
{
    var name = str.Identifier.Text;
    var namespaceName = GetNamespace(str);
    var fullName = $"{namespaceName}.{name}";
    // 使用 fullName...
}

✅ 正确做法

public void ProcessClass(ClassDeclarationSyntax cls)
{
    var fullName = GetFullTypeName(cls);
    // 使用 fullName...
}

public void ProcessStruct(StructDeclarationSyntax str)
{
    var fullName = GetFullTypeName(str);
    // 使用 fullName...
}

private string GetFullTypeName(BaseTypeDeclarationSyntax typeDecl)
{
    var name = typeDecl.Identifier.Text;
    var namespaceName = GetNamespace(typeDecl);
    return $"{namespaceName}.{name}";
}

---

关键要点

• ✅ 避免硬编码字符串，使用常量或配置
• ✅ 添加清晰的文档和注释
• ✅ 减少嵌套深度，使用早期返回
• ✅ 提取重复代码到共享方法

---

相关文档

• 性能反模式
• 正确性反模式
• 反模式索引

---

最后更新: 2026-02-06