using System;

using System.Collections.Generic;

using System.Linq;

​

public class FeeCalculator

{

    public string Name;

    // Function Delegates are arguably less readabile, but this could be subbed with a small interface and concrete classes instead or even 

    // Concrete functions

    public Func<int, /* in type */ int /* return type */>  Calculation;

    // leaving these public allows for them to be inspected and even modified.  There are side effects to that

    public static FeeCalculator FeeA = new FeeCalculator() { Name="FeeA", Calculation = (x) =>  x+2}; //lambdas aren't for everyone

    public static FeeCalculator FeeB = new FeeCalculator() { Name="FeeB", Calculation = (x) =>  x+5};

    public static FeeCalculator FeeX = new FeeCalculator() { Name="FeeX", Calculation = CalculateFeeX}; // thats why you could use concrete functions

    private static int CalculateFeeX(int x) 

    {

        return x - 2;

    }

    // Structure to accumulate all of the options

    private  List<FeeCalculator> FeeCalculations = new List<FeeCalculator>() { FeeA, FeeB};

    // For planned runtime additions to the options

    public void AddCalculation(string aName, Func<int, int> aCalculation) 

    {

        FeeCalculations.Add(new FeeCalculator() { Name = aName, Calculation = aCalculation });

    }

    // Main calculation function 

    // The method variable could be omitted in cases where the caller doesn't need to know. -- This service could be

    // injected with runtime configuration instead

    public int Calculate(string Method, int input) 

    {

        return FeeCalculations.Where(w => w.Name == Method).Single().Calculation.Invoke(input);

    }

}

​

​

public class Program

{

    public static void Main()

    {

        FeeCalculator calc = new FeeCalculator();

        Console.WriteLine("Hello World");

        // If the callers are aware of the runtime variable to branch on.

        // No icky if/then branching structures in the caller.  Complexity can be squirrelled away in a service class

        // If we preferred, the service could be made aware of the flag instead and the caller doesn't need to know it -- all depends on the use case

        Console.WriteLine(calc.Calculate("FeeA", 5));

        Console.WriteLine(calc.Calculate("FeeB", 5));

        // The service could be altered at runtime with additional branches, perhaps being seeded by a number

        // of methods.  Reflection, some other form of discovery and enumeration

        calc.AddCalculation("FeeC", (x) => x * x);

        // New branch is callable

        Console.WriteLine(calc.Calculate("FeeC", 5));

        // Existing (defualt) items can even be altered 

        FeeCalculator.FeeA = new FeeCalculator() { Name="FeeA", Calculation = (x) => x*x*x};

        // but, perhaps with side effects

        Console.WriteLine(calc.Calculate("FeeA", 5));

        // They don't take effect until it's reinstaciated

        calc = new FeeCalculator();

        Console.WriteLine(calc.Calculate("FeeA", 5));

    }

}