Comment l'injection de dépendances Unity peut-elle gérer la résolution conditionnelle pour plusieurs fournisseurs d'authentification ?

Résolution conditionnelle dans l'injection de dépendances Unity

L'injection de dépendances (DI) permet l'injection automatique de dépendances dans des objets, réduisant ainsi le besoin de manipulation manuelle instanciation et configuration. La résolution conditionnelle fait référence à la capacité de résoudre dynamiquement différentes implémentations d'une interface en fonction de conditions spécifiques.

Problème :

Considérez le scénario suivant avec deux fournisseurs d'authentification, TwitterAuth et FacebookAuth, implémentant l'interface IAuthenticate :

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 */ }
}

Dans un contrôleur, vous souhaitez injecter un IAuthenticate implémentation basée sur le fournisseur d'authentification, qui dans ce cas est déterminé par la méthode d'action (par exemple, Twitter ou Facebook).

Modèle d'usine comme solution :

Un L'approche consiste à utiliser le modèle d'usine, comme suggéré par votre ami. Cependant, cela implique la création d'une classe d'usine pour chaque fournisseur d'authentification, ce qui entraîne des problèmes potentiels de duplication de code et de maintenance.

Modèle de stratégie avec résolution conditionnelle :

Une solution plus flexible consiste à utiliser le modèle de stratégie en conjonction avec le conditionnel résolution :

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);
}

Authentifier les fournisseurs :

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);
    }
}

Chaque fournisseur implémente IAuthenticate et fournit un méthode pour déterminer si elle s’applique à un fournisseur donné nom.

Stratégie :

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);
    }
}

La stratégie prend un éventail de fournisseurs IAuthenticate et gère la résolution conditionnelle. Il parcourt les fournisseurs pour trouver celui qui correspond au nom du fournisseur et lui délègue l'opération de connexion.

Inscription Unity :

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")
        )
    ));</iauthenticate></iauthenticate></iauthenticate></iauthenticatestrategy></iauthenticate></iauthenticate>

Cette inscription configure Unity pour résoudre les implémentations d'IAuthenticate par nom de fournisseur et injecter AuthenticateStrategy en utilisant ces résolutions instances.

Utilisation :

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);
}

L'AuthenticateStrategy est injectée dans le contrôleur, qui délègue ensuite les opérations de connexion en fonction du nom du fournisseur.

Avantages :

• Flexible Conception : L'ajout ou la suppression de fournisseurs de connexion est simple, il suffit de modifier l'enregistrement Unity.
• Maintenable : Réduit la duplication et améliore la lisibilité du code, car le code spécifique au fournisseur est contenu dans classes séparées.
• Testable : Le modèle de stratégie permet de tester plus facilement l'unité d'authentification individuelle fournisseurs.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!