Einheit mit ASP.NET Core und MVC6 (Core)

Nach einigen Recherchen habe ich folgende Lösungen für meine Probleme gefunden:

Verwenden Sie Unity mit ASP
Um Unity mit ASP) verwenden zu können, benötigte ich einen benutzerdefinierten IServiceProvider ( ASP Documentation ), also schrieb ich einen Wrapper für den IUnityContainer, der so aussieht

public class UnityServiceProvider : IServiceProvider
{
    private IUnityContainer _container;

    public IUnityContainer UnityContainer => _container;

    public UnityServiceProvider()
    {
        _container = new UnityContainer();
    }

    #region Implementation of IServiceProvider

    /// <summary>Gets the service object of the specified type.</summary>
    /// <returns>A service object of type <paramref name="serviceType" />.-or- null if there is no service object of type <paramref name="serviceType" />.</returns>
    /// <param name="serviceType">An object that specifies the type of service object to get. </param>
    public object GetService(Type serviceType)
    {
        //Delegates the GetService to the Containers Resolve method
        return _container.Resolve(serviceType);
    }

    #endregion
}

Außerdem musste ich die Signatur der ConfigureServices-Methode in meiner Startup-Klasse folgendermaßen ändern:

public void ConfigureServices(IServiceCollection services)

dazu:

public IServiceProvider ConfigureServices(IServiceCollection services)

Jetzt kann ich meinen benutzerdefinierten IServiceProvider zurückgeben und er wird anstelle des Standard-IServiceProviders verwendet.
Die vollständige ConfigureServices-Methode wird im Abschnitt "Verdrahten" unten angezeigt.

Auflösen von Controllern
Ich fand diesen Blogeintrag . Daraus habe ich erfahren, dass MVC eine IControllerActivator-Schnittstelle verwendet, um die Controller-Instanziierung zu handhaben. Also habe ich meine eigene geschrieben, die so aussieht:

public class UnityControllerActivator : IControllerActivator
{
    private IUnityContainer _unityContainer;

    public UnityControllerActivator(IUnityContainer container)
    {
        _unityContainer = container;
    }

    #region Implementation of IControllerActivator

    public object Create(ControllerContext context)
    {
        return _unityContainer.Resolve(context.ActionDescriptor.ControllerTypeInfo.AsType());
    }


    public void Release(ControllerContext context, object controller)
    {
        //ignored
    }

    #endregion
}

Wenn jetzt eine Controller-Klasse aktiviert ist, wird sie mit meinem UnityContainer installiert. Deshalb muss mein UnityContainer wissen, wie man einen Controller auflöst!

Nächstes Problem: Verwenden Sie den Standard-IServiceProvider
Wenn ich jetzt Dienste wie Mvc in ASP.NET registriere, würde ich das normalerweise so machen:

services.AddMvc();

Wenn ich jetzt einen UnityContainer verwende, können alle MVC-Abhängigkeiten nicht aufgelöst werden, da sie nicht registriert sind. So kann ich sie entweder registrieren (wie AutoFac) oder eine UnityContainerExtension erstellen. Ich habe mich für die Erweiterung entschieden und mir folgende zwei Klassen ausgedacht:
UnityFallbackProviderExtension

public class UnityFallbackProviderExtension : UnityContainerExtension
{
    #region Const

    ///Used for Resolving the Default Container inside the UnityFallbackProviderStrategy class
    public const string FALLBACK_PROVIDER_NAME = "UnityFallbackProvider";

    #endregion

    #region Vars

    // The default Service Provider so I can Register it to the IUnityContainer
    private IServiceProvider _defaultServiceProvider;

    #endregion

    #region Constructors

    /// <summary>
    /// Creates a new instance of the UnityFallbackProviderExtension class
    /// </summary>
    /// <param name="defaultServiceProvider">The default Provider used to fall back to</param>
    public UnityFallbackProviderExtension(IServiceProvider defaultServiceProvider)
    {
        _defaultServiceProvider = defaultServiceProvider;
    }

    #endregion

    #region Overrides of UnityContainerExtension

    /// <summary>
    /// Initializes the container with this extension's functionality.
    /// </summary>
    /// <remarks>
    /// When overridden in a derived class, this method will modify the given
    /// <see cref="T:Microsoft.Practices.Unity.ExtensionContext" /> by adding strategies, policies, etc. to
    /// install it's functions into the container.</remarks>
    protected override void Initialize()
    {
        // Register the default IServiceProvider with a name.
        // Now the UnityFallbackProviderStrategy can Resolve the default Provider if needed
        Context.Container.RegisterInstance(FALLBACK_PROVIDER_NAME, _defaultServiceProvider);

        // Create the UnityFallbackProviderStrategy with our UnityContainer
        var strategy = new UnityFallbackProviderStrategy(Context.Container);

        // Adding the UnityFallbackProviderStrategy to be executed with the PreCreation LifeCycleHook
        // PreCreation because if it isnt registerd with the IUnityContainer there will be an Exception
        // Now if the IUnityContainer "magically" gets a Instance of a Type it will accept it and move on
        Context.Strategies.Add(strategy, UnityBuildStage.PreCreation);
    }

    #endregion
}

UnityFallbackProviderStrategy :

public class UnityFallbackProviderStrategy : BuilderStrategy
{
    private IUnityContainer _container;

    public UnityFallbackProviderStrategy(IUnityContainer container)
    {
        _container = container;
    }

    #region Overrides of BuilderStrategy

    /// <summary>
    /// Called during the chain of responsibility for a build operation. The
    /// PreBuildUp method is called when the chain is being executed in the
    /// forward direction.
    /// </summary>
    /// <param name="context">Context of the build operation.</param>
    public override void PreBuildUp(IBuilderContext context)
    {
        NamedTypeBuildKey key = context.OriginalBuildKey;

        // Checking if the Type we are resolving is registered with the Container
        if (!_container.IsRegistered(key.Type))
        {
            // If not we first get our default IServiceProvider and then try to resolve the type with it
            // Then we save the Type in the Existing Property of IBuilderContext to tell Unity
            // that it doesnt need to resolve the Type
            context.Existing = _container.Resolve<IServiceProvider>(UnityFallbackProviderExtension.FALLBACK_PROVIDER_NAME).GetService(key.Type);
        }

        // Otherwise we do the default stuff
        base.PreBuildUp(context);
    }

    #endregion
}

Wenn mein UnityContainer keine Registrierung für etwas hat, frage einfach den Standardanbieter danach.
All das habe ich aus verschiedenen Artikeln gelernt

• MSDN Unity-Artikel
• Auto-Mocking Unity Container Extension
• Erweiterung der Factory-Einheit für benutzerdefinierte Objekte

Das Schöne an diesem Ansatz ist, dass ich jetzt auch Abhängigkeiten "mischen" kann. Wenn ich Dienste und ein IOptions-Interface von ASP) benötige, löst mein UnityContainer alle diese Abhängigkeiten auf und injiziert sie in meinen Controller !!!
Wenn ich eine meiner eigenen Abhängigkeiten verwende, muss ich meine Controller-Klasse bei Unity registrieren, da der Standard-IServiceProvider meine Controller-Abhängigkeiten nicht mehr auflösen kann.

Zum Schluss: Verdrahten
Jetzt verwende ich in meinem Projekt verschiedene Dienste (ASP-Optionen, MVC mit Optionen). Damit alles funktioniert, sieht meine ConfigureServices-Methode jetzt so aus:

public IServiceProvider ConfigureServices(IServiceCollection services)
    {
        // Add all the ASP services here
        // #region ASP
        services.AddOptions();
        services.Configure<WcfOptions>(Configuration.GetSection("wcfOptions"));

        var globalAuthFilter = new AuthorizationPolicyBuilder()
            .RequireAuthenticatedUser()
            .Build();

        services.AddMvc(options => { options.Filters.Add(new AuthorizeFilter(globalAuthFilter)); })
                .AddJsonOptions
            (
                options => options.SerializerSettings.ContractResolver = new DefaultContractResolver()
            );
        // #endregion ASP

        // Creating the UnityServiceProvider
        var unityServiceProvider = new UnityServiceProvider();

        IUnityContainer container = unityServiceProvider.UnityContainer;

        // Adding the Controller Activator
        // Caution!!! Do this before you Build the ServiceProvider !!!
        services.AddSingleton<IControllerActivator>(new UnityControllerActivator(container));

        //Now build the Service Provider
        var defaultProvider = services.BuildServiceProvider();

        // Configure UnityContainer
        // #region Unity

        //Add the Fallback extension with the default provider
        container.AddExtension(new UnityFallbackProviderExtension(defaultProvider));

        // Register custom Types here

        container.RegisterType<ITest, Test>();

        container.RegisterType<HomeController>();
        container.RegisterType<AuthController>();

        // #endregion Unity

        return unityServiceProvider;
    }

Da ich in der letzten Woche das meiste über DI gelernt habe, hoffe ich, dass ich kein großes Pricipal/Pattern gebrochen habe, wenn ja, sag es mir bitte!