Wie kann Unity Dependency Injection die bedingte Auflösung für mehrere Authentifizierungsanbieter verarbeiten?

Bedingte Auflösung in Dependency Injection Unity

Dependency Injection (DI) ermöglicht die automatische Injektion von Abhängigkeiten in Objekte, wodurch der manuelle Bedarf reduziert wird Instanziierung und Konfiguration. Bedingte Auflösung bezieht sich auf die Fähigkeit, verschiedene Implementierungen einer Schnittstelle basierend auf bestimmten Bedingungen dynamisch aufzulösen.

Problem:

Stellen Sie sich das folgende Szenario mit zwei Authentifizierungsanbietern vor, TwitterAuth und FacebookAuth, Implementierung der IAuthenticate-Schnittstelle:

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 einem Controller möchten Sie eine IAuthenticate-Implementierung basierend injizieren auf dem Authentifizierungsanbieter, der in diesem Fall durch die Aktionsmethode (z. B. Twitter oder Facebook) bestimmt wird.

Factory Pattern als Lösung:

Ein Ansatz ist Verwenden Sie das Fabrikmuster, wie von Ihrem Freund vorgeschlagen. Dies erfordert jedoch die Erstellung einer Factory-Klasse für jeden Authentifizierungsanbieter, was zu potenziellen Codeduplizierungen und Wartungsproblemen führt.

Strategiemuster mit bedingter Auflösung:

Eine flexiblere Lösung besteht darin, das Strategiemuster in Verbindung mit der Bedingung zu verwenden Auflösen:

Schnittstellen:

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

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

Authentifizierungsanbieter:

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

Jeder Anbieter implementiert IAuthenticate und stellt eine bereit Methode, um festzustellen, ob sie für einen bestimmten Anbieter gilt Name.

Strategie:

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

Die Strategie verwendet eine Reihe von IAuthenticate-Anbietern und übernimmt die bedingte Auflösung. Es durchläuft die Anbieter, um denjenigen zu finden, der dem Anbieternamen entspricht, und delegiert den Anmeldevorgang an ihn.

Unity-Registrierung:

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>

Diese Registrierung konfiguriert Unity um IAuthenticate-Implementierungen nach Anbieternamen aufzulösen und die AuthenticateStrategy mithilfe dieser aufgelösten Elemente einzufügen Instanzen.

Verwendung:

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

Die AuthenticateStrategy wird in den Controller injiziert, der dann die Anmeldevorgänge basierend auf dem Anbieternamen delegiert.

Vorteile:

• Flexibel Design: Das Hinzufügen oder Entfernen von Anmeldeanbietern ist unkompliziert und erfordert lediglich Änderungen an der Unity-Registrierung.
• Wartbar: Reduziert Duplikate und verbessert die Lesbarkeit des Codes, da der anbieterspezifische Code darin enthalten ist separate Klassen.
• Testbar: Das Strategiemuster ermöglicht einfachere Unit-Tests der individuellen Authentifizierung Anbieter.

Das obige ist der detaillierte Inhalt vonWie kann Unity Dependency Injection die bedingte Auflösung für mehrere Authentifizierungsanbieter verarbeiten?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!