MVC Custom Attributes and Binding

I've got a project where we have our own customer registration and account management system, but certain elements of the application link to 3rd party services. These services have common functionality e.g. creating an account in their own DB, but the underlying implementation will be different for how to interactive with the third party services.

What I've done so far is create a CustomerRepository which implements ICustomerRepository. This contains all our own specific requirements. ICustomerRepository also has definitions for the common methods that all third parties will have, but these methods are set to virtual in the CustomerRepository class, which throws exceptions if they're called, requiring you to implement them in the third party classes.

Then from this, I have:

ThirdPartyACustomer : CustomerRepository, IThirdPartyACustomer
ThirdPartyBCustomer : CustomerRepository

As you can probably guess, both of those sub classes inherit and override the virtual methods, with the exception of ThirdPartyACustomer which also implements additional methods that are specific to that particular type of third party user (e.g. there might be a place where the user can edit specific features related to third party A, which third party B doesn't offer.

Now, with that out of the way, the real basis of my question:

Some of the processes (controllers) in my application can use the CustomerRepository without any problems as they only need our core functionality.

Other processes in the app require a particular type of ICustomerRepository to be passed. Anything that calls a method that was defined as virtual in CustomerRepository will need to pass either ThirdPar开发者_如何学PythontyACustomer or ThirdPartyBCustomer so that the correct implementation is called.

Originally in this initialisation of this type of controller I'd do something like:

public RegistrationController()
{
    ICustomerRepository _customerRepository = GetCustomerRepository();
}

where GetCustomerRepository() had some logic that determined which type of ThirdParty to use, based on the subdomain, for example.

Now, what I'm thinking is that I improve this by creating a custom attribute, along the lines of this:

[ThirdPartyDependent]
class RegistrationController
{
    public RegistrationController(ICustomerRepository customerRepository)
    {
        _customerRepository = customerRepository;
    }
}

and move the population of customerRepository parameter into that attribute, e.g. the logic in GetCustomerRepository would happen in there.

I'm fairly sure something like this is doable and seems to make sense for testing purposes, but not quite sure of what I should be googling for, or whether there is a better way to do things, so looking for some guidance from someone more experienced with MVC.

That's the responsibility of your DI framework. For example Ninject provides you access to the HttpContext when configuring the dependencies, so you could pick the proper implementation based on some HttpContext value. For example:

kernel.Bind<ICustomerRepository>().ToMethod(ctx =>
{
    if (HttpContext.Current.... Test something on the request or domain or whatever)
    {
        return new ThirdPartyACustomer();
    }
    return ThirdPartyBCustomer();
});

and then of course your controller will be totally agnostic. All that a controller should care is that it gets injected some repository which obeys a given contract:

public class RegistrationController: Controller
{
    private readonly ICustomerRepository _customerRepository;
    public RegistrationController(ICustomerRepository customerRepository)
    {
        _customerRepository = customerRepository;
    }
}