L'unité Injecter des classes différentes pour la même interface

J'ai une interface: IFoo

Deux classes implémentant cette interface: FooOne et FooTwo

Et deux classes ClassOne et ClassTwo de la réception d'un IFoo paramètre dans le constructeur.

Comment j'ai configurer l'unité afin ClassOne reçoit un FooOne instance et ClassTwo reçoit un FooTwo l'aide d'un seul conteneur?

Je ne peux pas le faire au moment de l'exécution de sorte qu'il doit être dans le fichier de configuration.

OriginalL'auteur pomber | 2012-10-29

  1. 18

    Ont un look à la L'unité de documentation.

    Pour un plus lisible fichier de configuration, vous devez définir le type d'alias pour IFoo, FooOne, FooTwo, ClassOne et ClassTwo. Ensuite, vous devez enregistrer les mappages de IFoo à vos implémentations. Vous devez définir un name pour les mappages.
    Pour les consommateurs de IFoo vous devez vous inscrire à un InjectionConstructor.

    Votre config va ressembler à quelque chose comme ceci:

    <?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <configSections>
    <section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection,
      Microsoft.Practices.Unity.Configuration"/>
  </configSections>
  <unity xmlns="http://schemas.microsoft.com/practices/2010/unity">
    <alias alias="IFoo" type="UnityConfigFile.IFoo, UnityConfigFile" />
    <alias alias="FooOne" type="UnityConfigFile.FooOne, UnityConfigFile" />
    <alias alias="FooTwo" type="UnityConfigFile.FooTwo, UnityConfigFile" />
    <alias alias="ClassOne" type="UnityConfigFile.ClassOne, UnityConfigFile" />
    <alias alias="ClassTwo" type="UnityConfigFile.ClassTwo, UnityConfigFile" />
    <container>
      <register type="IFoo" name="1" mapTo="FooOne" />
      <register type="IFoo" name="2" mapTo="FooTwo" />
      <register type="ClassOne" mapTo="ClassOne">
        <constructor>
          <param name="foo">
            <dependency type="IFoo" name="1" />
          </param>
        </constructor>
      </register>
      <register type="ClassTwo" mapTo="ClassTwo">
        <constructor>
          <param name="foo">
            <dependency type="IFoo" name="2" />
          </param>
        </constructor>
      </register>
    </container>
  </unity>
</configuration>

    C'est le test correspondant qui montre comment cela fonctionne.

    UnityConfigurationSection config =
  (UnityConfigurationSection) ConfigurationManager.GetSection("unity");
IUnityContainer container = new UnityContainer();
container.LoadConfiguration(config);
ClassTwo two = container.Resolve<ClassTwo>();
Assert.IsInstanceOfType(two.Foo, typeof(FooTwo));

    Mise à jour

    Au moment de l'exécution, vous pouvez le faire comme ceci

    IUnityContainer container = new UnityContainer();
container.RegisterType<IFoo, FooOne>("One");
container.RegisterType<IFoo, FooTwo>("Two");
container.RegisterType<ClassOne>(new InjectionConstructor(
  new ResolvedParameter<IFoo>("One")));
container.RegisterType<ClassTwo>(new InjectionConstructor(
  new ResolvedParameter<IFoo>("Two")));
    Comment voulez-vous faire au moment de l'exécution?
    voir ma mise à jour

    OriginalL'auteur Sebastian Weber

  2. 3

    Vous avez besoin de leur donner de l'enregistrement des noms pour ce faire:

    //Create an instance of a service you want to use. Alternatively, this
//may have been created by another process and passed to your application
LoggingService myLoggingService = new LoggingService();

//Register the existing object instance with the container
container.RegisterInstance<IMyService>("Logging", myLoggingService);

//Register a mapping for another service your application will use
container.RegisterType<IMyService, myDataService>("DataService");

//When required, retrieve an instance of these services
IMyService theDataService = container.Resolve<IMyService>("DataService");
IMyService theLoggingService = container.Resolve<IMyService>("Logging");

    Prises de Résoudre Des Instances De Types À L'Aide De L'Unité

    Dans mon application, nous avons implémentation par défaut de l'interface et qui est enregistré à l'aide de l'Unité. Mais les consommateurs sont libres de disposer de leur propre mise en œuvre, et de l'inscrire à l'aide de app.config. Pouvez-vous dire comment faire pour gérer ce cas? Comment s'assurer que les non-valeur par défaut est utilisé si un tel type est trouvé inscrit ?
    Découvrez la réponse de @SebastianWeber pour plus de détails sur l'utilisation de fichiers de configuration pour enregistrer vos services.
    Merci pour votre réponse. Mais cette réponse n'est pas utile pour moi. Parce que je veux m'assurer que l'instance par défaut enregistré auprès de l'Unité est "non" et celui configuré par l'utilisateur est toujours fournie.
    Je mettrais à votre inscription dans le fichier de configuration - puis si ils veulent changer, ils vont le modifier pour modifier le vôtre à la leur. Cela permettrait de faire ce que vous voulez.

    OriginalL'auteur Fenton

  3. 0

    J'ai installé dans mon application comme cela

    Installé le Package Nuget l'Unité de la version 4.0.1

    <package id="Unity" version="4.0.1" targetFramework="net452" />

    Dans mon Application.config

    <configSections>
     <section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection, Microsoft.Practices.Unity.Configuration" />
</configSections>

<unity>
    <container>
        <register type="MyApp.MainWindow, MyApp">
            <lifetime type="singleton" />
        </register>
        <register name="UnityResolver" type="MyApp.Core.Interface.IResolver, MyApp.Core.Interface" mapTo="Avelyn.Core.Container.UnityResolver, Avelyn.Core" />
        <register name="NinjectResolver" type="MyApp.Core.Interface.IResolver, MyApp.Core.Interface" mapTo="Avelyn.Core.Container.NinjectResolver, Avelyn.Core" />
    </container>
</unity>

    Dans Mon Application.xaml.cs

    var _container = new UnityContainer();
_container.LoadConfiguration();

IResolver _unityResolver = _container.Resolve<IResolver>("UnityResolver");
IResolver _ninject  = _container.Resolve<IResolver>("NinjectResolver");
MainWindow _win = _container.Resolve<MainWindow>();

    OriginalL'auteur dnxit