Hériter d'une classe de base

Question

Disons que je cette classe:

class foo 
{ 
    public foo(Guid guid) 
    { 
     //some code here 
    } 

    public foo(Guid guid, bool myBool) 
    { 
     //some other code here 
    } 

    //Here I have a bunch of method/properties 

    public void GenX(bool french, int width) 
    { 
     //my method implementation 
    } 
} 

et j'ai une autre classe qui fait pratiquement tout le même que foo sauf la mise en œuvre de cette méthode public GenX(bool french, int width) et construtor doit être différent de foo mise en œuvre.

Si je mets en œuvre bar ainsi que le compilateur se plaindre: 'foo' does not contain a constructor that takes '0' arguments

class bar : foo 
{ 
    public bar(Guid guid, bool myBool) 
    { 
     //some code here 
    } 

    new public void GenX(bool french, int width) 
    { 
     //my new method implementation 
    } 

    //I will be using the implementation of `foo` for the rest of the methods/properties 
} 

Qu'est-ce que je fais mal? Est-ce la bonne façon de faire ce genre de chose?

Si ce n'est pas clair enought I excuses et je vais essayer de le rendre plus clair

Answer 1

Vous devrez vous assurer que le constructeur de base est appelée.

Vous pouvez le faire comme ceci:

class bar : foo 
{ 
    public bar(Guid g, bool b) : base (g) 
    { 
     // code here 
    } 
} 

Puisque vous n'avez pas spécifié dans votre code, le compilateur va essayer d'appeler le constructeur par défaut par défaut/implicitement. Cependant, puisque votre classe de base n'a pas de constructeur par défaut (parce que vous avez spécifié un autre constructeur, sans spécifier le constructeur par défaut), il ne peut pas l'appeler. Par conséquent, vous devrez indiquer au compilateur quel constructeur de la classe de base il devrait utiliser.

Dans le cas où le constructeur de votre classe héritée fait quelque chose de complètement différent alors le constructeur dans votre classe de base, et vous ne Whish pas réutiliser le constructeur de votre classe de base, vous pouvez le faire:

class foo 
{ 
    protected foo() 
    { 
     // default constructor which is protected, so not useable from the 'outside' 
    } 

    public foo(Guid g) 
    {} 

    public foo(Guid g, bool b) : this(g) 
    {} 

    public virtual void GenX() {} 
} 

class bar : foo 
{ 
    public bar(Guid g, bool b) : base() 
    {} 

    public override void GenX() {} 
} 

Answer 2

essayez ceci:

class foo 
{ 
    public foo(Guid guid) 
    { 
     //some code here 
    } 

    public foo(Guid guid, bool myBool,bool fooclass = true) 
    { 

     if (fooclass) 
     { 
      //some other code here 
     } 

    } 

    //Here I have a bunch of method/properties 

    public void GenX(bool french, int width) 
    { 
     //my method implementation 
    } 
} 

class bar : foo 
{ 
    public bar(Guid guid, bool myBool,bool barclass = true) : base(guid,myBool,false) 
    { 
     //some code here 
    } 

    new public void GenX(bool french, int width) 
    { 
     //my new method implementation 
    } 
}