如何通过字符串结合接口调用函数？附C#代码示例

首先，咱们先梳理下现有代码的核心差异：原Calculator类用float类型做计算，而ICalculate接口定义的是int类型的计算逻辑。为了更好地整合，我会提供两种方案——修改ICalculate适配float（更贴合原框架）和保留原ICalculate做类型适配（不改动原有接口），你可以根据需求选择。

方案一：修改ICalculate接口适配float类型 #

这种方案最直接，让接口和原框架的类型统一，减少额外的转换逻辑。

步骤1：更新ICalculate接口及实现类 #

把接口的参数和返回值改成float，同时补充乘除的实现类（原接口只有加减）：

public interface ICalculate
{
    float Calculate(float x, float y); // 改为float类型，适配原计算器的数值类型
}

public class Add : ICalculate
{
    public float Calculate(float x, float y)
    {
        return x + y;
    }
}

public class Subtract : ICalculate
{
    public float Calculate(float x, float y)
    {
        return x - y;
    }
}

// 补充乘除实现，完善计算器功能
public class Multiply : ICalculate
{
    public float Calculate(float x, float y)
    {
        return x * y;
    }
}

public class Divide : ICalculate
{
    public float Calculate(float x, float y)
    {
        if (y == 0) throw new ArgumentException("除数不能为0");
        return x / y;
    }
}

步骤2：重构Calculator类 #

把原来的Func委托字典替换成ICalculate实例字典，让字符串指令直接关联对应的接口实现类：

public class Calculator
{
    // 现在映射字符串指令到ICalculate实现实例
    private Dictionary<string, ICalculate> _operationMap = new Dictionary<string, ICalculate>
    {
        { "add", new Add() },
        { "subtract", new Subtract() },
        { "multiply", new Multiply() },
        { "divide", new Divide() }
    };

    public float Compute(float[] numbers, string opCode)
    {
        // 先校验指令是否存在，避免KeyNotFoundException
        if (!_operationMap.TryGetValue(opCode, out var operation))
        {
            throw new ArgumentException($"不支持的计算指令：{opCode}");
        }

        float accumulator = numbers[0];
        foreach (var n in numbers.Skip(1))
        {
            // 调用ICalculate接口的Calculate方法完成计算
            accumulator = operation.Calculate(accumulator, n);
        }
        return accumulator;
    }
}

步骤3：测试调用（和原逻辑一致） #

public class Program
{
    public static void Main()
    {
        var c = new Calculator();
        Console.WriteLine(c.Compute(new float[] { 2,2 }, "add")); // 输出4
        Console.WriteLine(c.Compute(new float[] { 3,3 }, "multiply")); // 输出9
        Console.WriteLine(c.Compute(new float[] {-2,2 }, "subtract")); // 输出-4
        Console.WriteLine(c.Compute(new float[] { 9,3 }, "divide")); // 输出3
    }
}

方案二：保留原ICalculate（int类型），添加类型适配 #

如果不想改动原有的ICalculate接口和实现类，咱们可以通过类型转换来兼容float和int的差异：

步骤1：保留原ICalculate及实现类 #

直接使用你提供的原代码，无需修改：

public interface ICalculate
{
    int Calculate(int x, int y);
}

public class Add : ICalculate
{
    public int Calculate(int x, int y)
    {
        return x + y;
    }
}

public class Subtract : ICalculate
{
    public int Calculate(int x, int y)
    {
        return x - y;
    }
}

// 补充乘除实现
public class Multiply : ICalculate
{
    public int Calculate(int x, int y)
    {
        return x * y;
    }
}

public class Divide : ICalculate
{
    public int Calculate(int x, int y)
    {
        if (y == 0) throw new ArgumentException("除数不能为0");
        return x / y;
    }
}

步骤2：修改Calculator类做类型适配 #

在计算过程中把float转成int，调用完ICalculate方法后再转回float：

public class Calculator
{
    private Dictionary<string, ICalculate> _operationMap = new Dictionary<string, ICalculate>
    {
        { "add", new Add() },
        { "subtract", new Subtract() },
        { "multiply", new Multiply() },
        { "divide", new Divide() }
    };

    public float Compute(float[] numbers, string opCode)
    {
        if (!_operationMap.TryGetValue(opCode, out var operation))
        {
            throw new ArgumentException($"不支持的计算指令：{opCode}");
        }

        // 注意：float转int会截断小数部分，存在精度丢失风险
        int accumulator = (int)numbers[0];
        foreach (var n in numbers.Skip(1))
        {
            accumulator = operation.Calculate(accumulator, (int)n);
        }
        return (float)accumulator;
    }
}

关键说明 #

• 方案一优先推荐，因为它完全适配原计算器的float类型，没有精度丢失问题，同时遵循依赖倒置原则，后续新增计算类型（比如取模、幂运算）只需要实现ICalculate接口，再添加字典映射即可，扩展性极强。
• 方案二适合必须保留原ICalculate接口的场景，但要注意float转int的精度丢失问题，仅适用于整数计算场景。

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