Question

Consider this example

The Interface

interface IBusinessRules
{
    string Perform();
}

The Inheritors

class Client1BusinessRules: IBusinessRules
{
    public string Perform()
    {
        return "Business rule for Client 1 Performed";
    }
}

class Client2BusinessRules: IBusinessRules
{
    public string Perform()
    {
        return "Business rule for Client 2 Performed";
    }
}

class Client3BusinessRules: IBusinessRules
{
    public string Perform()
    {
        return "Business rule for Client 3 Performed";
    }
}

The factory class

class BusinessRulesFactory
{
    public IBusinessRules GetObject(int clientIdentityCode)
    {
        IBusinessRules objbase = null;
        switch (clientIdentityCode)
        {
            case 1:
                objbase = new Client1BusinessRules();
                break;
            case 2:
                objbase = new Client2BusinessRules();
                break;
            case 3:
                objbase = new Client3BusinessRules();
                break;
            default:
                throw new Exception("Unknown Object");
        }
        return objbase;
    }
}

sample usage:

class Program
{
    static void Main(string[] args)
    {
        BusinessRulesFactory objfactory = new BusinessRulesFactory ();
        IBusinessRulesFactory objBase = objfactory.GetObject(2);
        Console.WriteLine(objBase.Perform());

        objBase = objfactory.GetObject(3);
        Console.WriteLine(objBase.Perform());
        Console.Read();
    }
}

My question is, how about I add another method on the ALgorithm1 Class
but not in the interface because im going to just use it on special scenario?

class Client1BusinessRules: IBusinessRules
{
    public string Perform()
    {
        return "Client1 Business rules is Performed";
    }


    public string Calculate()
    {
        return "Additional functionality for CLient1";
    }
}

how Am I suppose to call that on the UI something like this

 objBase = objfactory.GetObject(1);
 Console.WriteLine(objBase.Calculate());

Is there any other solution? thanks in advance

EDIT: I rewrite it to resemble my current project design

Answer 1

I presume you are using the factory class in order to:

• have a standard facade accepting parameters that lead to business rule selection and provisioning
• encapsulate business rule provisioning
• decouple the users from actual implementations of IBusinessRules

Hence I would solve your problem by introducing new interface

interface IComputableRules : IBusinessRules
{
    string Calculate();
}

As long as you follow the interface-based design, there’s nothing wrong about casting the actual instance to an interface different from IBusinessRules.

IBusinessRules businessRule = objFactory.GetObject(...some input...)
...
// check if the computable service is supported and print the result
IComputableRules computable = businessRule as IComputableRules;
if (computable)
{
     Console.WriteLine(computable.Calculate());
}

Here you can think of you business rule classes as service providers, that guarantee some basic service, plus optional additional services depending on the nature of the business rule.

Note: By turning the BusinessRulesFactory into a generic class you might make the indication of a specific service a part of the factory contract, and make sure the returned business rule implementation will support a particular (otherwise optional) service.

class BusinessRulesFactory<TService> where TService : IBusinessRules
{
     public TService GetObject(int clientIdentityCode)
     {
         // ... choose business rule in respect to both clientIdentityCode and TService
     }
}

In case where you wouldn’t require a specific additional service to be available, you’d just use IBusinessRules as the actual type parameter.