C#工具类重复代码重构咨询：内部函数差异型代码优化

这种重复代码的痛点我太懂了！结合C#的特性，有几个非常适合你的重构方案，而且完全不会把内部的funcA和funcB暴露给外部调用者，完美保持封装性：

1. 提取公共内部方法 + 内置委托（最简洁首选方案） #

核心思路是把Func1和Func2中重复的逻辑抽成一个私有公共方法，然后把差异点（调用funcA还是funcB）通过委托传递进去。整个过程都是类内部操作，完全不会暴露内部方法给外部。

重构前的重复代码示例 #

public class U
{
    // 内部方法，外部不可见
    private void funcA(int param1, string param2)
    {
        // 你的业务逻辑
    }

    private void funcB(int param1, string param2)
    {
        // 你的业务逻辑
    }

    // 对外暴露的方法1
    public void Func1(int param1, string param2)
    {
        // 大量重复的前置/后置逻辑
        Console.WriteLine("执行参数校验");
        Console.WriteLine("初始化资源");
        // 唯一差异点
        funcA(param1, param2);
        Console.WriteLine("释放资源");
    }

    // 对外暴露的方法2
    public void Func2(int param1, string param2)
    {
        // 和Func1完全一致的重复逻辑
        Console.WriteLine("执行参数校验");
        Console.WriteLine("初始化资源");
        // 唯一差异点
        funcB(param1, param2);
        Console.WriteLine("释放资源");
    }
}

重构后的代码（消除重复） #

public class U
{
    private void funcA(int param1, string param2)
    {
        // 你的业务逻辑
    }

    private void funcB(int param1, string param2)
    {
        // 你的业务逻辑
    }

    // 提取的私有公共方法，用委托接收差异逻辑
    private void ExecuteCommonLogic(int param1, string param2, Action<int, string> action)
    {
        // 重复逻辑只写一次，后续维护更省心
        Console.WriteLine("执行参数校验");
        Console.WriteLine("初始化资源");
        action(param1, param2); // 执行传入的内部方法（funcA/funcB）
        Console.WriteLine("释放资源");
    }

    // 对外方法1：仅传入funcA委托
    public void Func1(int param1, string param2)
    {
        ExecuteCommonLogic(param1, param2, funcA);
    }

    // 对外方法2：仅传入funcB委托
    public void Func2(int param1, string param2)
    {
        ExecuteCommonLogic(param1, param2, funcB);
    }
}

这个方案的优势：

• 彻底消除重复代码，核心逻辑只维护一次
• 外部调用者完全感知不到funcA/funcB的存在，原有对外接口100%兼容
• 代码简洁，利用C#内置的Action<>委托，无需额外定义类型

2. 内部策略模式（适合未来需扩展更多方法的场景） #

如果以后可能新增Func3、Func4这类对应更多内部方法的接口，策略模式会是更具扩展性的选择。我们可以把不同的内部操作封装成内部策略类，公共方法根据传入的策略执行逻辑，同样不会暴露内部实现。

代码示例 #

public class U
{
    // 内部策略接口，仅类内部可见
    private interface IOperationStrategy
    {
        void Execute(int param1, string param2);
    }

    // 对应funcA的策略实现
    private class StrategyA : IOperationStrategy
    {
        public void Execute(int param1, string param2)
        {
            // 原funcA的业务逻辑
        }
    }

    // 对应funcB的策略实现
    private class StrategyB : IOperationStrategy
    {
        public void Execute(int param1, string param2)
        {
            // 原funcB的业务逻辑
        }
    }

    private void ExecuteCommonLogic(int param1, string param2, IOperationStrategy strategy)
    {
        Console.WriteLine("执行参数校验");
        Console.WriteLine("初始化资源");
        strategy.Execute(param1, param2);
        Console.WriteLine("释放资源");
    }

    public void Func1(int param1, string param2)
    {
        ExecuteCommonLogic(param1, param2, new StrategyA());
    }

    public void Func2(int param1, string param2)
    {
        ExecuteCommonLogic(param1, param2, new StrategyB());
    }
}

这个方案的优势：

• 扩展性极强，新增对外方法仅需添加新的策略类和一行调用代码
• 内部逻辑隔离更清晰，适合复杂业务场景
• 同样严格保持封装性，外部无感知内部实现

3. 局部函数（仅适合逻辑极简单的场景） #

如果Func1和Func2中的重复逻辑非常短，也可以用局部函数临时复用，但本质上还是有代码重复，只推荐在小范围场景下使用：

public class U
{
    private void funcA(int param1, string param2) { /*...*/ }
    private void funcB(int param1, string param2) { /*...*/ }

    public void Func1(int param1, string param2)
    {
        void CommonSetup() => Console.WriteLine("执行前置逻辑");
        
        CommonSetup();
        funcA(param1, param2);
        Console.WriteLine("执行后置逻辑");
    }

    public void Func2(int param1, string param2)
    {
        void CommonSetup() => Console.WriteLine("执行前置逻辑");
        
        CommonSetup();
        funcB(param1, param2);
        Console.WriteLine("执行后置逻辑");
    }
}

总结 #

最推荐第一个方案（提取公共方法+委托），它兼顾了简洁性、封装性和低改动成本，完全匹配你的需求：既消除了重复代码，又严格隐藏了内部的funcA/funcB，对外接口也不需要做任何调整。

内容的提问来源于stack exchange，提问作者Nika