Creazione di un'interfaccia solo per disaccoppiare da librerie di terze parti

Attualmente sto sviluppando il modulo Autorizzazione su un mio framework.

Ho finora la seguente classe:

public interface IAuthorizationManager<C>
       where C : AuthorizationConfiguration
{
    void Configure(C configuration);
}

Una delle mie implementazioni sarà l'autenticazione OAuth.

Per questo ho creato il seguente gestore:

public class OAuthAuthorizationManager : IAuthorizationManager<OAuthConfiguration>
{
    private IOAuthAuthorizationServerProvider _authorizationProvider;
    private IAuthenticationTokenProvider _refreshTokenProvider;

    public AuthorizationManager(IOAuthAuthorizationServerProvider authorizationProvider,
                                IAuthenticationTokenProvider refreshTokenProvider)
    {
        this._authorizationProvider = authorizationProvider;
        this._refreshTokenProvider = refreshTokenProvider;
    }

    public void Configure(OAuthConfiguration configuration)
    {
       configuration.Application.UseOAuthAuthorizationServer(new OAuthAuthorizationServerOptions() {
             AllowInsecureHttp = !configuration.IsSecure,
             TokenEndpointPath = new PathString(configuration.TokenEndpoint),
             AccessTokenExpireTimeSpan = configuration.TokenExpiration,
             Provider = _authorizationProvider,
             RefreshTokenProvider = _refreshTokenProvider
       });
       configuration.Application.UseOAuthBearerAuthentication(new OAuthBearerAuthenticationOptions());
    }
}

Ora, ecco la cosa, le implementazioni di IOAuthAuthorizationServerProvider e IAuthenticationTokenProvider verranno iniettate tramite il costruttore.

Sto usando Ninject per l'iniezione delle dipendenze.

Nel progetto di avvio della mia applicazione ho il seguente modulo:

public class AuthorizationModule : ApplicationModule
{
      public override void Load()
      {
          Kernel.Bind<IOAuthAuthorizationServerProvider>().To<AuthorizationProvider<User, Client>>();
          Kernel.Bind<IAuthenticationTokenProvider>().To<RefreshTokenProvider<RefreshToken>();

          Kernel.Bind<IAuthorizationManager<OAuthConfiguration>>().To<OAuthAuthorizationManager>();
      }
}

Il problema è che le interfacce IOAuthAuthorizationServerProvider e IAuthenticationTokenProvider fanno parte della libreria Owin.Security.OAuth , quindi quando sto configurando l'iniezione, il progetto di avvio dell'applicazione deve fare direttamente riferimento a questa libreria e alle sue dipendenze. Questo inquina il mio packages.config . Non mi piace l'idea di avere la stessa libreria referenziata due volte nella mia soluzione, quando solo un progetto effettivamente la usa.

AuthorizationProvider<User, Client> e RefreshTokenProvider<RefreshToken> sono le mie, quindi non c'è problema con quelle.

Stavo pensando di creare un'interfaccia come questa (ovviamente avrei scelto un altro nome):

public class IMyOAuthAuthorizationServerProvider : IOAuthAuthorizationServerProvider { }

public class IMyAuthenticationTokenProvider : IAuthenticationTokenProvider { }

Insieme alle modifiche associate:

public AuthorizationManager(IMyOAuthAuthorizationServerProvider authorizationProvider, IMyAuthenticationTokenProvider refreshTokenProvider)
{
    this._authorizationProvider = authorizationProvider;
    this._refreshTokenProvider = refreshTokenProvider;
}

E

Kernel.Bind<IMyOAuthAuthorizationServerProvider>().To<AuthorizationProvider<User, Client>>();
Kernel.Bind<IMyAuthenticationTokenProvider>().To<RefreshTokenProvider<RefreshToken>>();

Ovviamente Owin.Security.OAuth continuerà a essere referenziato, ma questa volta indirettamente, quindi non ho bisogno di installarli (tramite NuGet) sul mio progetto principale.

Volevo sapere se questa è una pratica comune, quali sono gli svantaggi di questo approccio e qualsiasi suggerimento o soluzione alternativa sarebbe altamente (e volentieri) accettato.