🚀 go-pugleaf

OD wrote:

> public class A
>  {
>    public A()
>    {
>    }
> 
>    public A(int param):this()
>    {
>    }
>  }
> 

> public class B : A
>  {
>   public class B():base() // Problem 1
>   {
>   }
> 
>   public class B(int param):this() // Problem 2
>   {
>   }
>  }
> 
> Problem 1 : is using ":base()" correct ?

Yes, although it's redundant: "public class B() {}" is exactly
equivalent to "public class B(): base() {}" (down to the "no
parameter-less constructor" msg, if A has no public/protected
parameter-less constructor.)
 
> Problem 2, the worst : this constructor can call either ":this()" or
> ":base(param)".
> In the first case I lose the init of the parameter (done in A class),
> in the second case I lose local init of class B done in the first
> constructor...
> 
> What is the best construction ? Is there some "best practices" or
> coding patterns for such a situation ?

I don't think case 1 or case 2 is always right: I'd always go with the
version that reads the most clearly and/or takes the least custom
code.

In many cases, of course, the "local init" can get pushed to an
ordinary, private method that simply gets called in two different
constructors. (Though you can't set readonly fields from a normal
instance method.)

-- 

www.midnightbeach.com