Calling code before the base constructor is called

[hamarb123]

When I have some sort of a setup like this:

public abstract class a
{
    public readonly c Field;
    public a(c field) => Field = field;
}
public sealed class b : a
{
    public b() : a(MakeC(dType))
    {
        //rest of ctor here
    }
    private static c MakeC(d dType)
    {
        //<insert many lines of code to convert here>
    }
}

It is annoying to me that I need to have the MakeC method here, and I cannot just do something like:

public sealed class b : a
{
    public b() : a(variable1)
    {
        beforector
        {
            //<insert many lines of code to convert here>
            c variable1 = ...;
        }
        //rest of ctor
    }
}

which in my opinion, is much neater and more logical, or even something better like this (which would allow for calling multiple ctors too, which is permissible in IL code AFAIK, but maybe not particularly useful)

public sealed class b : a
{
    public b()
    {
        //<insert many lines of code to convert here>
        ctor.base(...);
        //rest of ctor
    }
}

I think this should be a feature of C# (I prefer the 2nd version).
Is there any reason that it isn't?

[Joe4evr]

See also #3980. Yes, that solution would still leave you with a separate method, but at least it'll be scoped to the constructor and won't be visible in the rest of your class.

[hamarb123]

That's an interesting solution that would be alright for most use cases.

[rootflood]

this is good but have few problem
for example if i have two inputs then the code block will be confusing
example:
how this code will translate?

public abstract class a
{
    public a(int a, int b){...}
}
public sealed class b : a
{
    public b() : a(Make_A(), Make_B())
    {
        //rest of ctor here
    }
    private static int Make_A()
    {
        //<insert many lines of code to convert here>
    }
    private static int Make_B()
    {
        //<insert many lines of code to convert here>
    }
}

[rootflood]

i have idea for fix

public abstract class a
{
    public a(int a, int b){...}
}
public sealed class b : a
{
    public b() : this(Make_A_B())
    { }

    private b((int a, int b) inputs) : base(inputs.a , inputs.b)
    {
        //rest of ctor here
    }

    private static (int a, int b) Make_A_B()
    {
        //<insert many lines of code to convert here>
    }
}

[rootflood]

    public class A
    {
        public A(int x, int y) { }
    }

    public class B : A
    {

        public B() : base(Helper(out var y), y) { }

        private static int Helper(out int y)
        {
            y = 2;
            return 1;
        }
    }

[hamarb123]

Using my solution, it would translate like this

public abstract class a
{
    public a(int a, int b){...}
}
public sealed class b : a
{
    public b()
    {
        //wow some code to calculate a and b
        ctor.base(a, b);  //obviously this line has to be included
        //the rest of the ctor if applicable
    }
}

[Clockwork-Muse]

private static c MakeC(d dType)
{
   //<insert many lines of code to convert here>
}

Uhm, is there a reason this isn't a constructor for C? Or if it's really long, an independent factory method?

This is potentially somewhat breaking some best practices (because now you're constructing two things). Which is when you normally inject a resource you constructed externally.

[hamarb123]

I agree that my solution is something that shouldn't be used whenever it possibly could be, but if it's the only time you need to convert an object in that kind of way, then any form of additional method shouldn't be necessary as it would have some kind of (likely small) overhead that is completely avoidable in IL code, and I think it looks a bit neater than an extra method somewhere (eg. local static method). I think my solution is useful, but only for a small percent of constructors.

[Clockwork-Muse]

... I'm not going to comment on what variations might be able to inline the method, or otherwise elide stack frames.

Normally you'd want the external constructor/method for testing purposes, especially as it becomes longer.

[HaloFour]

I think this should be a feature of C# (I prefer the 2nd version).
Is there any reason that it isn't?

Only that C# wasn't designed for to allow for this. It inherited the syntax from C++ which forces that the chained constructor call be the first statement. The runtime has a bit of flexibility here and does allow for code before base constructor calls, which is why you can use expressions as the arguments.

From a language perspective the challenge is that this would require some kind of new syntax to express the chained constructor call. I like the suggestion of using base(...) or this(...) within the constructor body, but there would be concerns that it wouldn't be obvious that the constructor has a chained constructor call or calls the default base constructor without reading the constructor body. The other concern is that before the chained constructor call there are some limitations as to what you can do. You're generally limited from accessing this except for the case of initializing fields. The specification and the compiler would have to enforce that limitation.

[rootflood]

this is my often problem in my projects which "this" keyword inaccessible in delegates:

    public abstract class a
    {
        public a(int a, int b) { }
    }
    public sealed class b : a
    {
        string str;

        public b() : this(((Func<(int a, int b)>)(()=>
        {
            this.str = "the string";// CS0027 Keyword 'this' is not available in the current context
            return (1, 2);
        })).Invoke())
        { }

        private b((int a, int b) inputs) : base(inputs.a, inputs.b)
        {
            //rest of ctor here
        }
    }

always i use a block for making new data and the ctor block is for using that data in my codes and don't use "this" keyword on the delegate
so translated code can be something like:

    public sealed class b : a
    {
        string str;
        public b()
        {
            {
                this.str = "the string";// CS0027 Keyword 'this' is not available in the current context
                //<insert many lines of code to convert here>
                base(1, 2); // base ctor must always use in last line
            }
            //rest of ctor
        }
    }

or something like #4140

        public DirInfoByAddress(string Address)  // use a expression for short
            :base
            {
                Info: new DirectoryInfo(Address)  // <<< data block , just declare variables
            }
                (Info.Name,
                 Info.GetFiles().Length,
                 Info.FullName)
                {
                      // code block , rest of ctor
                }

or #3980
but even in #3980 its impassible to use "this" keyword in the "local" method

class A
 {
     public A(int x)
    {
    }
}
class B:A {
   public B(int z):base(Local(z))
   {
            static int Local(int h)
            {
                 this.str = "the string";// CS0027 Keyword 'this' is not available in the current context
                //<insert many lines of code to convert here>
            }
            //rest of ctor
   }
}

[Clockwork-Muse]

but even in #3980 its impassible to use "this" keyword in the "local" method

Well yeah. And you want to avoid it if you can (outside of the fact that a static one probably shouldn't be allowed to access it anyways): it forces a capturing context into the lambda.

For your first example, you could make it return an extra value, or take another lambda taking a ref parameter for the update. However, the way you've written the constructor there seems rather unusual to me; is there a particular reason you're doing it that way? What problem are you attempting to use it to solve?