Appel surchargée Constructor et Constructor Base en C#

Question

J'ai deux classes, Foo et Bar, qui ont des constructeurs comme celui-ci:

class Foo 
{ 
    Foo() 
    { 
     // do some stuff 
    } 

    Foo(int arg) 
    { 
     // do some other stuff 
    } 
} 

class Bar : Foo 
{ 
    Bar() : base() 
    { 
     // some third thing 
    } 
} 

Maintenant, je veux présenter un constructeur Bar qui prend un int, mais je veux ce qui se passe dans Bar() pour exécuter ainsi que comme le truc de Foo (int). Quelque chose comme ceci:

Bar(int arg) : Bar(), base(arg) 
{ 
    // some fourth thing 
} 

Y at-il un moyen de le faire en C#? Le meilleur que j'ai jusqu'ici est de mettre le travail fait par Bar() dans une fonction, qui est également appelée par Bar (int), mais c'est assez inélégant.

Answer 1

Non, ce n'est pas possible. Si vous utilisez Reflector pour examiner l'IL générée pour chaque constructeur, vous verrez pourquoi: vous finirez par appeler les deux constructeurs de la classe de base. En théorie, le compilateur pourrait construire des méthodes cachées pour accomplir ce que vous voulez, mais il n'y a vraiment aucun avantage sur vous à faire la même chose explicitement.

Answer 2

Vous ne pouvez pas avoir le constructeur de barre qui prend un int invoquer le constructeur sans paramètre?

Answer 3

Pouvez-vous mettre les choses de Bar() dans Bar (int) et appelez Bar (int) avec Bar() avec une valeur par défaut? Alors Bar (int) peut appeler le constructeur de base.

class Bar : Foo 
{ 
    Bar() : this(0) 
    { 
    } 

    Bar(int arg) : base(arg) 
    { 
    } 
} 

qui ne répond pas exactement à votre question, mais en fonction de votre scénario pourrait être une solution viable.

Answer 4

Je constructeurs re-chaîne, de sorte qu'ils sont appelés comme

Bar() : this(0) 
Bar(int) : Foo(int) initializes Bar 
Foo(int) initializes Foo 
Foo() : this(0) 

Ceci est approprié, si les constructeurs assument sans paramètre une sorte de valeur par défaut pour le paramètre int d'autres constructeur. Si les constructeurs ne sont pas liés, vous faites probablement quelque chose de mal avec votre type, ou peut-être que nous avons besoin de plus d'informations sur ce que vous essayez d'atteindre.

Answer 5

C'est ce que je peux penser ...

public class Foo 
{ 
    public Foo() 
    { 
    } 
    public Foo(int? arg): this() 
    { 
    } 

} 
public class Bar : Foo 
{ 
    private int x; 
    public Bar(): this(new int?()) // edited to fix type ambiguity 
    { 
     // stuff that only runs for paramerless ctor 
    } 
    public Bar(int? arg) 
     : base(arg) 
    { 
     if (arg.HasValue) 
     { 
      // Do stuff for both parameterless and parameterized ctor 
     } 
     // Do other stuff for only parameterized ctor 
    } 
} 

Answer 6

Je recommanderais de changer votre chaîne de constructeur pour passer du moins spécifique à la plus spécifique. Toute création de l'objet Bar appelle maintenant les 4 constructeurs. Le chaînage de constructeur devrait fournir des valeurs par défaut à des constructeurs plus spécifiques, et non l'inverse. Vous devriez vraiment regarder ce que vous essayez d'accomplir et vous assurer que ce que vous faites est logique. Curt a raison de dire qu'il y a des raisons techniques que vous ne pouvez pas faire, mais il y a aussi des raisons logiques pour lesquelles vous ne devriez pas.

Answer 7

pouvez-vous prendre le code d'initialisation pour Bar() et en faire une méthode et l'appeler des deux constructeurs, et le nouveau constructeur appelez simplement base (arg)?

Answer 8

Vous pouvez utiliser ce code:

public Foo 
{ 
    public Foo() 
    { 
     this.InitializeObject(); 
    } 

    public Foo(int arg) : this() 
    { 
     // do something with Foo's arg 
    } 

    protected virtual void InitializeObject() 
    { 
     // initialize object Foo 
    } 
} 

public Bar : Foo 
{ 
    public Bar : base() { } 

    public Bar(int arg) : base(arg) 
    { 
     // do something with Bar's arg 
    } 

    protected override void InitializeObject() 
    { 
     // initialize object Bar 

     base.InitializeObject(); 
    } 
} 

Juste remplacer la méthode InitializeObject() comme dans le code ci-dessus, et mettre tout votre code que vous voulez mettre en paramètre moins il constructeur. Et enfin appeler base.InitializeObject() à la fin du code.

Espérons que cela soit utile.