Implicitement, l'injection de dépendance dans la classe de Base, tandis que la classe dérivée est résolu grâce à l'Unité

J'ai une Classe de base de Base ayant dépendance au Dep et par défaut et l'Injection de Constructeur de

Class Base : IBase
 {

    public IDep Dep { get; set; }

    public Base()
    {
        Console.WriteLine("Default Constructor Base ");
    }

    [InjectionConstructor]
    public Base(IDep dep)
    {
        Console.WriteLine("Injection Constructor Base ");
        Dep = dep;            
    }
}

Je pensais que la Dépendance de la dep doit obtenir injecté automatiquement(par Constructeur Injection) lors de la classe dérivée est résolu.

Mais ca n'a pas l'air de fonctionner quand j'ai dériver une classe à partir d'elle et de Résoudre cette classe, au Lieu d'un Constructeur par défaut de la Base de la demande.

Je ne peux obtenir que cela fonctionne quand je l'ai appeler explicitement le constructeur de la Classe Dérivée.

class Derived : Base
{

    public Derived ()
    {
        Console.WriteLine("Default Constructor Derived ");
    }

    public Derived (IDep dep) : base(dep1)
    {
        Console.WriteLine("Injection Constructor Derived ");            
    }
}

Ne l'unité de fournir une quelconque façon implicitement appel à l'injection Constructeur de la classe de base (ce n'est pas explicite Construtor appel)?
Si non, Est-il une raison pourquoi l'unité de conteneur n'est pas de faire par lui-même??

Vos problèmes sont causés par le fait d'avoir plusieurs constructeurs. Vos services ne devrait avoir qu'un seul constructeur. Avoir plusieurs constructeurs est un anti-pattern et il devrait être évité.
J'ai reçu votre point que plusieurs constructeurs est un anti-pattern. Mais le fait d'enlever le constructeur par Défaut ne résout pas le but ici.
Je pense qu'il fait résout vos problèmes, parce que si les deux Base et Derived contiennent chacun un constructeur qui prend dans les dépendances nécessaires, le problème de l'habitude. Je suis d'accord cependant avec @BatteryBackupUnit que le fait d'avoir une classe de base peut ne pas être la meilleure conception.
faut-il toujours inclure un constructeur par défaut de la classe . Je ne peut pas avoir un Paramétrées Constructeur sans définir un Constructeur par Défaut.
Même si je ne produis pas de Constructeur par Défaut de la classe de base de ma classe dérivée constructeur donnera l'erreur de compilation.

OriginalL'auteur Rajat Srivastava | 2014-09-11

c#constructor-injection dependency-injection unity-container

16

Non, l'unité est incapable de le faire. En fait, il n'y a pas un seul conteneur qui peut le faire.
Un constructeur est là pour instancier une classe. Si vous appelez de deux constructeurs, vous vous retrouverez avec deux instances. Si la classe de base abstraite, on ne pouvait même pas appeler son constructeur (à l'exception provenant des constructeurs comme vous le savez).

Ainsi de par les limitations de la C#.net si vous souhaitez utiliser le constructeur de l'injection, il ne fonctionnera que si vous avez explicitement injecter de la valeur dans le Derived constructeur qui appelle à la non-par défaut Base constructeur.

Cependant, vous pouvez choisir d'utilisation de la Propriété ou de la Méthode d'injection à la place. Avec eux, vous n'avez pas à ajouter de la dépendance à chaque constructeur d'une classe dérivée.

Propriété D'Injection:
```
class Base
{
    [Dependency]
    public IDep Dep { get; set; }
} 
```
Méthode D'Injection:
```
class Base
{
     private IDep dep;

     [InjectionMethod]
     public void Initialize(IDep dep)
     {
         this.dep = dep;
     }
}
```
Veuillez noter:
- L'objet est instancié (ctor injection) avant de méthode /propriété de l'injection est effectuée
- Il pouvait être utile d'adapter le design pour ne pas nécessiter une classe de base, voir La Composition au cours de l'Héritage
OriginalL'auteur BatteryBackupUnit
5

C'est la façon dont vous devriez résoudre le problème:
```
class abstract Base : IBase
{
    private readonly IDep dep;

    protected Base(IDep dep)
    {
        if (dep == null) throw new ArgumentNullException("dep");
        this.dep = dep;
    }
}
```
Maintenant votre classe de base vient d'un constructeur et ce constructeur définit toutes les dépendances de la classe exige. Il y a juste une façon de créer cette classe et la classe de protéger ses invariants. La dépendance est des lieux dans un domaine privé depuis les autres classes n'ont pas d'utilisation en accédant à cette dépendance.

Avec cette classe de base, la classe dérivée doit ressembler à cela:
```
class Derived : Base
{
    private readonly IDep dep;

    public Derived(IDep dep) : base(dep)
    {
        this.dep = dep;
    }
}
```
Ici la dérivée de la classe a un constructeur unique de définir les dépendances de cette classe exige. Il ne peut pas être créé de manière différente. Dans le cas où la classe utilise la dépendance elle-même, il doit stocker la dépendance dans un domaine privé pour les utiliser plus tard. Notez également que, parce que cette classe n'a qu'un seul constructeur, il n'y a aucune ambiguïté dans ce que le constructeur à appeler et il n'y a aucune raison pour marquer le constructeur avec un [InjectionConstructor] attribut.

Ne remarque que je suis d'accord avec BatteryBackupUnit. Depuis j'applique de l'Injection de Dépendances et les principes SOLIDES de mes applications, je vois peu de raisons pour l'utilisation de classes de base. L'utilisation de la Composition à la place de l'héritage permet souvent de réduire la complexité du système.

Ouais je peux faire comme ceci. Mais mon objectif, a été de ne pas utiliser explicitement appel du Constructeur ( : base(dep)).Et oui, pour de multiples Constructeur je suis d'accord avec vous que je devrais éviter de multiples Constructeur. Je suis d'accord avec BatteryBackupUnit que l'unité ne peut pas implicitement appel à l'Injection Constructeur, car il est des limites de C#.net
Je voudrais déclarer dep comme protected readonly dans la classe de base. Le protected modificateur permet de classes dérivées pour l'accès dep, tandis que readonly empêche les modifications. Cela fait un dédoublement de la dep variable et son initialisation dans la classe dérivée superflu.

OriginalL'auteur Steven

Simple et la solution est d'avoir un "InjectionMethod" dans votre classe de Base.

> public abstract class Base : IBase
>     {
> 
>         private IDep dep;
> 
>         [InjectionMethod]
>         public void Initialize(IDep dep)
>         {
>             if (dep == null) throw new ArgumentNullException("dep");
>             this.dep = dep;
> 
>             OnInitialize();
>         }
> 
>         public dep DepProperty
>         {
>             get
>             {
>                 return dep;
>             }
>         }
>         protected abstract void OnInitialize();
>     }

//maintenant, votre Constructeur de classe Dérivée ne seront pas obligés d'avoir l'IDep Paramètre

class Derived : Base
{
    public Derived()
    {

    }

    protected override void OnInitialize()
    {
        //you can access the baseclass dependency Instance in this override
        object depObject = this.DepProperty;
    }
}

OriginalL'auteur Dominic Savio M

Vous devez vous connecter pour publier un commentaire.