Conditional Resolving in Dependency Injection Unity

Dependency injection (DI) allows for the automatic injection of dependencies into objects, reducing the need for manual instantiation and configuration. Conditional resolving refers to the ability to dynamically resolve different implementations of an interface based on specific conditions.

Problem:

Consider the following scenario with two authentication providers, TwitterAuth and FacebookAuth, implementing the IAuthenticate interface:

public interface IAuthenticate
{
    bool Login(string user, string pass);
}

public class TwitterAuth : IAuthenticate
{
    bool Login(string user, string pass) { /* connect to twitter api */ }
}

public class FacebookAuth : IAuthenticate
{
    bool Login(string user, string pass) { /* connect to fb api */ }
}

In a controller, you want to inject an IAuthenticate implementation based on the authentication provider, which in this case is determined by the action method (e.g., Twitter or Facebook).

Factory Pattern as a Solution:

One approach is to use the factory pattern, as suggested by your friend. However, this involves creating a factory class for each authentication provider, leading to potential code duplication and maintenance issues.

Strategy Pattern with Conditional Resolving:

A more flexible solution is to use the strategy pattern in conjunction with conditional resolving:

Interfaces:

public interface IAuthenticate
{
    bool Login(string user, string pass);
    bool AppliesTo(string providerName);
}

public interface IAuthenticateStrategy
{
    bool Login(string providerName, string user, string pass);
}

Authenticate Providers:

public class TwitterAuth : IAuthenticate
{
    bool Login(string user, string pass) { /* connect to twitter api */ }

    bool AppliesTo(string providerName)
    {
        return this.GetType().Name.Equals(providerName);
    }
}

public class FacebookAuth : IAuthenticate
{
    bool Login(string user, string pass) { /* connect to fb api */ }

    bool AppliesTo(string providerName)
    {
        return this.GetType().Name.Equals(providerName);
    }
}

Each provider implements IAuthenticate and provides a method to determine if it applies to a given provider name.

Strategy:

public class AuthenticateStrategy : IAuthenticateStrategy
{
    private readonly IAuthenticate[] authenticateProviders;

    public AuthenticateStrategy(IAuthenticate[] authenticateProviders)
    {
        this.authenticateProviders = authenticateProviders;
    }

    public bool Login(string providerName, string user, string pass)
    {
        var provider = authenticateProviders.FirstOrDefault(x => x.AppliesTo(providerName));
        if (provider == null) throw new Exception("Login provider not registered");
        return provider.Login(user, pass);
    }
}

The strategy takes an array of IAuthenticate providers and handles the conditional resolving. It iterates through the providers to find the one that matches the provider name and delegates the login operation to it.

Unity Registration:

unityContainer.RegisterType<IAuthenticate, TwitterAuth>("twitterAuth");
unityContainer.RegisterType<IAuthenticate, FacebookAuth>("facebookAuth");
unityContainer.RegisterType<IAuthenticateStrategy, AuthenticateStrategy>(
    new InjectionConstructor(
        new ResolvedArrayParameter<IAuthenticate>(
            new ResolvedParameter<IAuthenticate>("twitterAuth"),
            new ResolvedParameter<IAuthenticate>("facebookAuth")
        )
    ));

This registration configures Unity to resolve IAuthenticate implementations by provider name and to inject the AuthenticateStrategy using these resolved instances.

Usage:

private readonly IAuthenticateStrategy _authenticateStrategy;

public AuthenticateController(IAuthenticateStrategy authenticateStrategy)
{
    _authenticateStrategy = authenticateStrategy;
}

// login with twitter
public virtual ActionResult Twitter(string user, string pass)
{
    bool success = _authenticateStrategy.Login("TwitterAuth", user, pass);
}

// login with fb
public virtual ActionResult Facebook(string user, string pass)
{
    bool success = _authenticateStrategy.Login("FacebookAuth", user, pass);
}

The AuthenticateStrategy is injected into the controller, which then delegates the login operations based on the provider name.

Advantages:

• Flexible Design: Adding or removing login providers is straightforward with just changes to the Unity registration.
• Maintainable: Reduces duplication and improves code readability, as the provider-specific code is contained in separate classes.
• Testable: The Strategy pattern enables easier unit testing of individual authentication providers.

The above is the detailed content of How Can Unity Dependency Injection Handle Conditional Resolution for Multiple Authentication Providers?. For more information, please follow other related articles on the PHP Chinese website!