使用稍微不同的方法签名标准化子类

Question

Iam refactoring a project but finding difficulties.

The goal is to remove some switch cases from the code that are based on the ServiceType (see in code).

Some context

ServiceA , ServiceB , etc. are all classes pretty similar that describe different services. I would like to:

• let them implement an interface (let's say IService )
• make a Factory that returns the right concrete ( ServiceXX : IService )

so that in the end I will be able to reduce the amount of switch cases.

Here a switch that I would like to remove:

foreach (Service s in PartnerServices)
{
    int min = 0;
    int max = 0;
                
    switch (s.Type)
    {
        case "ServiceA":
            min = ServiceA.GetMinPrice();
            max = ServiceA.GetMaxPrice();
            break;
    
        case "ServiceB":
            min = ServiceB.GetMinPrice();
            max = ServiceB.GetMaxPrice();
            break;
                    
        case "ServiceC":
            min = ServiceC.GetMinPrice();
            max = ServiceC.GetMaxPrice();
            break;

        case "ServiceD":
            min = ServiceD.GetMinPrice(StateID);
            max = ServiceD.GetMaxPrice(StateID);
            break;  
                    
        case "ServiceE":
            min = ServiceE.GetMinPrice(StateID, CustomerID);
            max = ServiceE.GetMaxPrice(StateID, CustomerID);
            break;                       
    }
    ...
}

The problem Iam facing is that the majority of GetMinPrice and GetMaxPrice implementations need 0 parameters, while a few needs parameters.

This is due to the fact that some services need external info to calculate the price (for example ServiceE , needs to know the StateID and the CustomerID cause the price can be customized for that two keys).

So while the classes belong to the same "root" the method signature is different.

How is this usually managed? Do you have any suggestion?

Please consider that I cannot insert these parameters as properties of the relevant Service class because these are external infos and do not belong there.

Thank you very much in advance.

Answer 1

I might have had an idea that got me closer to the solution... What if i create a new class that will contain all the potential options needed to calculate the price and then pass it to the methods?

Here a sample of the final code that explain what i mean:

public class PriceCalculationOptions
{
     public int StateID { get; set; }
     public int CustomerID { get; set; }
}

public interface IService
{
     int GetMinPrice(PriceCalculationOptions options);
     int GetMaxPrice(PriceCalculationOptions options);
}

public class ServiceA/B/C/D/E : IService 
{
     public int GetMinPrice(PriceCalculationOptions options)
     {
        //custom implementation using options
     }
     
     public int GetMaxPrice(PriceCalculationOptions options)
     {
        //custom implementation using options
     }

}

public class ServiceFactory
{
    public static IService CreateService(string ServiceType)
    {
        switch (ServiceType)
        {
            case "ServiceA":
                return new ServiceA();
                break;
        
            case "ServiceB":
                return new ServiceB();
                break;
                        
            ...                      
        }
    }
}

And so the initial foreach which contained the switch case becomes:

foreach (Service s in PartnerServices)
{
    int min = 0;
    int max = 0;
                
    IService service = ServiceFactory.CreateService(s.Type);
    PriceCalculationOptions priceCalculationOptions = new PriceCalculationOptions()
    {
        StateID=1,
        CustomerID = 20
    };
    
    min = service.GetMinPrice(priceCalculationOptions);
    max = service.GetMaxPrice(priceCalculationOptions);
                
    ...
}

What do you guys think? Do you see any downside? To me it seems that it might work!