Einheit und Abhängigkeit mit Konstruktorparametern

Question

Ich habe ein Problem mit Unity, wenn ich versuche, eine Klasse mit Schnittstelle zu verwenden, die eine Implementierung mit 4 Parametern haben.

Hier ist der Fehler-Stack-Trace:

Resolution of the dependency failed, type = "Keolis.ODM.Controllers.TypeTacheApiController", name = "(none)". 
↵Exception occurred while: while resolving. 
↵Exception is: InvalidOperationException - The type String cannot be constructed. You must configure the container to supply this value. 
↵----------------------------------------------- 
↵At the time of the exception, the container was: 
↵ 
↵ Resolving Keolis.ODM.Controllers.TypeTacheApiController,(none) 
↵ Resolving parameter "typeTacheService" of constructor Keolis.ODM.Controllers.TypeTacheApiController(Keolis.ODM.Business.ITypeTacheService typeTacheService) 
↵ Resolving Keolis.ODM.Business.TypeTacheService,(none) (mapped from Keolis.ODM.Business.ITypeTacheService, (none)) 
↵ Resolving parameter "mediation" of constructor Keolis.ODM.Business.TypeTacheService(Keolis.Mediation.IMediation mediation, Keolis.ODM.Models.Repositories.ITypeTacheRepository typeTacheRepository, Keolis.Okapi.Models.Repositories.ITypeTacheRepository typeTacheOkapiRepository) 
↵  Resolving Keolis.Mediation.WebService.Mediation,(none) (mapped from Keolis.Mediation.IMediation, (none)) 
↵  Resolving parameter "profilOkapiRepository" of constructor Keolis.Mediation.WebService.Mediation(Keolis.Okapi.Models.Repositories.IProfilOkapiRepository profilOkapiRepository, Keolis.Okapi.Models.Repositories.ISocieteOkapiRepository societeOkapiRepository, Keolis.Okapi.Models.Repositories.ICentreOkapiRepository centreOkapiRepository, Keolis.Okapi.Models.Repositories.IUtilisateurOkapiRepository utilisateurOkapiRepository) 
↵  Resolving Keolis.Okapi.Models.Repositories.ProfilOkapiRepository,(none) (mapped from Keolis.Okapi.Models.Repositories.IProfilOkapiRepository, (none)) 
↵  Resolving parameter "serveur" of constructor Keolis.Okapi.Models.Repositories.ProfilOkapiRepository(System.String serveur, System.String catalog, System.String user, System.String pass) 
↵   Resolving System.String,(none) 
↵" 

Und die UnityConfig

public static void RegisterTypes(IUnityContainer container) 
    { 
     // NOTE: To load from web.config uncomment the line below. Make sure to add a Microsoft.Practices.Unity.Configuration to the using statements. 
     container.LoadConfiguration(); 

     var repository = container.Resolve<ILocalDatabaseService>(); 
     var referentielLocalDatabase = repository.GetRsh(); 

     container.RegisterType<Okapi.Models.Repositories.ITypeHeureRepository, Okapi.Models.Repositories.TypeHeureRepository>(); 
     container.Resolve<Okapi.Models.Repositories.ITypeHeureRepository>(new ResolverOverride[] { 
      new ParameterOverride("serveur", referentielLocalDatabase.Serveur), 
      new ParameterOverride("catalog", referentielLocalDatabase.Base), 
      new ParameterOverride("user", referentielLocalDatabase.User), 
      new ParameterOverride("pass", referentielLocalDatabase.Password) 
      }); 

     container.RegisterType<Okapi.Models.Repositories.ITypeTacheRepository, Okapi.Models.Repositories.TypeTacheRepository>(); 
     container.Resolve<Okapi.Models.Repositories.ITypeTacheRepository>(new ResolverOverride[] { 
      new ParameterOverride("serveur", referentielLocalDatabase.Serveur), 
      new ParameterOverride("catalog", referentielLocalDatabase.Base), 
      new ParameterOverride("user", referentielLocalDatabase.User), 
      new ParameterOverride("pass", referentielLocalDatabase.Password) 
      }); 

     container.RegisterType<Okapi.Models.Repositories.IUtilisateurOkapiRepository, Okapi.Models.Repositories.UtilisateurOkapiRepository>(); 
     var utilisateur = container.Resolve<Okapi.Models.Repositories.IUtilisateurOkapiRepository>(new ResolverOverride[] { 
      new ParameterOverride("serveur", referentielLocalDatabase.Serveur), 
      new ParameterOverride("catalog", referentielLocalDatabase.Base), 
      new ParameterOverride("user", referentielLocalDatabase.User), 
      new ParameterOverride("pass", referentielLocalDatabase.Password) 
      }); 

     container.RegisterType<Okapi.Models.Repositories.ISocieteOkapiRepository, Okapi.Models.Repositories.SocieteOkapiRepository>(); 
     var societe = container.Resolve<Okapi.Models.Repositories.ISocieteOkapiRepository>(new ResolverOverride[] { 
      new ParameterOverride("serveur", referentielLocalDatabase.Serveur), 
      new ParameterOverride("catalog", referentielLocalDatabase.Base), 
      new ParameterOverride("user", referentielLocalDatabase.User), 
      new ParameterOverride("pass", referentielLocalDatabase.Password) 
      }); 

     container.RegisterType<Okapi.Models.Repositories.IProfilOkapiRepository, Okapi.Models.Repositories.ProfilOkapiRepository>(); 
     var profil = container.Resolve<Okapi.Models.Repositories.IProfilOkapiRepository>(new ResolverOverride[] { 
      new ParameterOverride("serveur", referentielLocalDatabase.Serveur), 
      new ParameterOverride("catalog", referentielLocalDatabase.Base), 
      new ParameterOverride("user", referentielLocalDatabase.User), 
      new ParameterOverride("pass", referentielLocalDatabase.Password) 
      }); 

     container.RegisterType<Okapi.Models.Repositories.ICentreOkapiRepository, Okapi.Models.Repositories.CentreOkapiRepository>(); 
     var centre = container.Resolve<Okapi.Models.Repositories.ICentreOkapiRepository>(new ResolverOverride[] { 
      new ParameterOverride("serveur", referentielLocalDatabase.Serveur), 
      new ParameterOverride("catalog", referentielLocalDatabase.Base), 
      new ParameterOverride("user", referentielLocalDatabase.User), 
      new ParameterOverride("pass", referentielLocalDatabase.Password) 
      }); 

     container.RegisterType<Okapi.Models.Repositories.IBuildVersionOkapiRepository, Okapi.Models.Repositories.BuildVersionOkapiRepository>(); 
     container.Resolve<Okapi.Models.Repositories.IBuildVersionOkapiRepository>(new ResolverOverride[] { 
      new ParameterOverride("serveur", referentielLocalDatabase.Serveur), 
      new ParameterOverride("catalog", referentielLocalDatabase.Base), 
      new ParameterOverride("user", referentielLocalDatabase.User), 
      new ParameterOverride("pass", referentielLocalDatabase.Password) 
      }); 

     container.RegisterType<Keolis.Mediation.IMediation, Keolis.Mediation.WebService.Mediation>(new InjectionConstructor(
      new Okapi.Models.Repositories.ProfilOkapiRepository(referentielLocalDatabase.Serveur, referentielLocalDatabase.Base, referentielLocalDatabase.User, referentielLocalDatabase.Password), 
      new Okapi.Models.Repositories.SocieteOkapiRepository(referentielLocalDatabase.Serveur, referentielLocalDatabase.Base, referentielLocalDatabase.User, referentielLocalDatabase.Password), 
      new Okapi.Models.Repositories.CentreOkapiRepository(referentielLocalDatabase.Serveur, referentielLocalDatabase.Base, referentielLocalDatabase.User, referentielLocalDatabase.Password), 
      new Okapi.Models.Repositories.UtilisateurOkapiRepository(referentielLocalDatabase.Serveur, referentielLocalDatabase.Base, referentielLocalDatabase.User, referentielLocalDatabase.Password) 
      )); 

     //container.RegisterType<Keolis.Mediation.IMediation, Keolis.Mediation.WebService.Mediation>(new InjectionConstructor(
     // profil, societe, centre, utilisateur)); 

     //container.Resolve<Keolis.Mediation.IMediation>(new ResolverOverride[] { 
     // new ParameterOverride("profilOkapiRepository", profil), 
     // new ParameterOverride("societeOkapiRepository", societe), 
     // new ParameterOverride("centreOkapiRepository", centre), 
     // new ParameterOverride("utilisateurOkapiRepository", utilisateur) 
     //}); 
    } 

Und die Umsetzung von iMediation

public Mediation(IProfilOkapiRepository profilOkapiRepository, 
     ISocieteOkapiRepository societeOkapiRepository, 
     ICentreOkapiRepository centreOkapiRepository, 
     IUtilisateurOkapiRepository utilisateurOkapiRepository) 
    { 
     _profilOkapiRepository = profilOkapiRepository; 
     _societeOkapiRepository = societeOkapiRepository; 
     _centreOkapiRepository = centreOkapiRepository; 
     _utilisateurOkapiRepository = utilisateurOkapiRepository; 
     _deser = new Deserializer(); 
    } 

ich mehrere Config versucht haben, Code hinter und Web. config, aber immer die gleichen Fehler beim letzten Auflösen (Mediation).

Also, wie man eine Klasse registriert, die Schnittstelle mit Parametern haben?

Danke für Ihre Hilfe.

EDIT: Arbeits Code

public static void RegisterTypes(IUnityContainer container) 
{ 
    // NOTE: To load from web.config uncomment the line below. Make sure to add a Microsoft.Practices.Unity.Configuration to the using statements. 
    container.LoadConfiguration(); 

    var repository = container.Resolve<ILocalDatabaseService>(); 
    var referentielLocalDatabase = repository.GetRsh(); 

    // This says "if you ever need need a string called 'xxxx', get that one." 
    container.RegisterInstance<string>("serveur", referentielLocalDatabase.Serveur); 
    container.RegisterInstance<string>("catalog", referentielLocalDatabase.Base); 
    container.RegisterInstance<string>("user", referentielLocalDatabase.User); 
    container.RegisterInstance<string>("pass", referentielLocalDatabase.Password); 

    // Here it says "Find a constructor that needs 4 strings, and use 
    // these registered string. 
    container.RegisterType<Okapi.Models.Repositories.ITypeHeureRepository, Okapi.Models.Repositories.TypeHeureRepository>(
     new InjectionConstructor(
      new ResolvedParameter<string>("serveur"), 
      new ResolvedParameter<string>("catalog"), 
      new ResolvedParameter<string>("user"), 
      new ResolvedParameter<string>("pass")) 
     ); 

    container.RegisterType<Okapi.Models.Repositories.ITypeTacheRepository, Okapi.Models.Repositories.TypeTacheRepository>(
     new InjectionConstructor(
      new ResolvedParameter<string>("serveur"), 
      new ResolvedParameter<string>("catalog"), 
      new ResolvedParameter<string>("user"), 
      new ResolvedParameter<string>("pass")) 
     ); 

    container.RegisterType<Okapi.Models.Repositories.IUtilisateurOkapiRepository, Okapi.Models.Repositories.UtilisateurOkapiRepository>(
     new InjectionConstructor(
      new ResolvedParameter<string>("serveur"), 
      new ResolvedParameter<string>("catalog"), 
      new ResolvedParameter<string>("user"), 
      new ResolvedParameter<string>("pass")) 
     ); 

    container.RegisterType<Okapi.Models.Repositories.ISocieteOkapiRepository, Okapi.Models.Repositories.SocieteOkapiRepository>(
     new InjectionConstructor(
      new ResolvedParameter<string>("serveur"), 
      new ResolvedParameter<string>("catalog"), 
      new ResolvedParameter<string>("user"), 
      new ResolvedParameter<string>("pass")) 
     ); 

    container.RegisterType<Okapi.Models.Repositories.IProfilOkapiRepository, Okapi.Models.Repositories.ProfilOkapiRepository>(
     new InjectionConstructor(
      new ResolvedParameter<string>("serveur"), 
      new ResolvedParameter<string>("catalog"), 
      new ResolvedParameter<string>("user"), 
      new ResolvedParameter<string>("pass")) 
     ); 

    container.RegisterType<Okapi.Models.Repositories.ICentreOkapiRepository, Okapi.Models.Repositories.CentreOkapiRepository>(
     new InjectionConstructor(
      new ResolvedParameter<string>("serveur"), 
      new ResolvedParameter<string>("catalog"), 
      new ResolvedParameter<string>("user"), 
      new ResolvedParameter<string>("pass")) 
     ); 

    container.RegisterType<Okapi.Models.Repositories.IBuildVersionOkapiRepository, Okapi.Models.Repositories.BuildVersionOkapiRepository>(
     new InjectionConstructor(
      new ResolvedParameter<string>("serveur"), 
      new ResolvedParameter<string>("catalog"), 
      new ResolvedParameter<string>("user"), 
      new ResolvedParameter<string>("pass")) 
     ); 

    // Here it says "For IMediation, use the Mediation class". 
    // The constructor you've shown us will required the other interfaces and 
    // the container will be like "I know how to create a class of all of 
    // these interfaces. I'll do that!" 
    container.RegisterType<Mediation.IMediation, Mediation.WebService.Mediation>();    
} 

Answer 1

Du bist irgendwie (Euphemismus) mit Unity falsch. Wenn Sie die Registrierung vornehmen, sollten Sie fast immer nur Registrierungen durchführen, nicht registrieren/auflösen/"das Produkt zur Registrierung verwenden" usw. Sie möchten die Auflösung und die Klasseninstanziierung auf den letzten verantwortlichen Moment verschieben.

Außerdem sollte ParameterOverride verwendet werden, um Parameter zu überschreiben, die Sie für einen bestimmten Fall festgelegt haben, wenn die von Ihnen registrierten nicht funktionieren. In Ihrem Fall könnten Sie sie registrieren. Hier ist, wie ich es tun würde: ("Keolis.Mediation" Ich "Okapi.Models" entfernt und überall zur besseren Lesbarkeit.)

public static void RegisterTypes(IUnityContainer container) 
{ 
    var repository = container.Resolve<ILocalDatabaseService>(); 
    var referentielLocalDatabase = repository.GetRsh(); 

    // This says "if you ever need need a string called 'xxxx', get that one." 
    container.RegisterInstance<string>("serveur", referentielLocalDatabase.Serveur); 
    container.RegisterInstance<string>("catalog", referentielLocalDatabase.Base); 
    container.RegisterInstance<string>("user", referentielLocalDatabase.User); 
    container.RegisterInstance<string>("pass", referentielLocalDatabase.Password); 

    // Here it says "Find a constructor that needs 4 strings, and use 
    // these registered string. 
    container.RegisterType<Repositories.ITypeHeureRepository, Repositories.TypeHeureRepository>(
     new ParameterResolve<string>("serveur"), 
     new ParameterResolve<string>("catalog"), 
     new ParameterResolve<string>("user"), 
     new ParameterResolve<string>("pass")); 

    container.RegisterType<Repositories.ITypeTacheRepository, Repositories.TypeTacheRepository>(
     new ParameterResolve<string>("serveur"), 
     new ParameterResolve<string>("catalog"), 
     new ParameterResolve<string>("user"), 
     new ParameterResolve<string>("pass")); 

    container.RegisterType<Repositories.IUtilisateurOkapiRepository, Repositories.UtilisateurOkapiRepository>(
     new ParameterResolve<string>("serveur"), 
     new ParameterResolve<string>("catalog"), 
     new ParameterResolve<string>("user"), 
     new ParameterResolve<string>("pass")); 

    container.RegisterType<Repositories.ISocieteOkapiRepository, Repositories.SocieteOkapiRepository>(
     new ParameterResolve<string>("serveur"), 
     new ParameterResolve<string>("catalog"), 
     new ParameterResolve<string>("user"), 
     new ParameterResolve<string>("pass")); 

    container.RegisterType<Repositories.IProfilOkapiRepository, Repositories.ProfilOkapiRepository>(
     new ParameterResolve<string>("serveur"), 
     new ParameterResolve<string>("catalog"), 
     new ParameterResolve<string>("user"), 
     new ParameterResolve<string>("pass")); 

    container.RegisterType<Repositories.ICentreOkapiRepository, Repositories.CentreOkapiRepository>(
     new ParameterResolve<string>("serveur"), 
     new ParameterResolve<string>("catalog"), 
     new ParameterResolve<string>("user"), 
     new ParameterResolve<string>("pass")); 

    container.RegisterType<Repositories.IBuildVersionOkapiRepository, Repositories.BuildVersionOkapiRepository>(
     new ParameterResolve<string>("serveur"), 
     new ParameterResolve<string>("catalog"), 
     new ParameterResolve<string>("user"), 
     new ParameterResolve<string>("pass")); 

    // Here it says "For IMediation, use the Mediation class". 
    // The constructor you've shown us will required the other interfaces and 
    // the container will be like "I know how to create a class of all of 
    // these interfaces. I'll do that!" 
    container.RegisterType<IMediation, WebService.Mediation>(); 
} 

Haben Sie nicht den Code, weil es getestet hat zu viele Abhängigkeiten, aber es sollte funktionieren.