Explicit constructor call in C#

Question

So, today I reflected an arbitary .NET assembly using ILSpy + dotPeek to gain deeper insight about how IL code works when I stumbled upon this weird part (dummy example):

public class SomeBaseClass {
    public SomeBaseClass(SomeType[] iExpectACollection) {
        ...
    }
}

public class SomeDerivedClass {
    public SomeDerivedClass(SomeType onlyOneInstance) {
        SomeType[] collection;
        if(onlyOneInstance != null)
            collection = new SomeType[] { onlyOneInstance };
        base.\u002Ector(collection);
    }
}

As far as I can see, the derived class doesn't call the base constructor in the first place, but instead does something with onlyOneInstance and then calls be base constructor.

My question is: Is it possible to call the base constructor explicitly in C# after some work has been done? Or is this only possible in IL? I know it's being easily done in e.g. Java using super(), however I've never seen it in .NET.

EDIT

I just had a talk with my boss and he's okay with posting some real world code of the library (it's one of our companys internal):

**IL PART**
.method public hidebysig specialname rtspecialname 
instance void .ctor (
    string contextId,
    class MyComp.NetStack.BufferManager bufferManager,
    class MyComp.NetStack.TcpChannelQuotas quotas,
    class [System]System.Security.Cryptography.X509Certificates.X509Certificate2 clientCertificate,
    class [System]System.Security.Cryptography.X509Certificates.X509Certificate2[] clientCertificateChain,
    class [System]System.Security.Cryptography.X509Certificates.X509Certificate2 serverCertificate,
    class MyComp.NetStack.EndpointDescription endpoint,
    class MyComp.NetStack.ApplicationThreadPool threadPool
) cil managed 
{
// Method begins at RVA 0x648e0
// Code size 263 (0x107)
.maxstack 10
.locals init (
    [0] class MyComp.NetStack.EndpointDescription[]
)

IL_0000: ldarg.0
IL_0001: ldarg.1
IL_0002: ldarg.2
IL_0003: ldarg.3
IL_0004: ldarg.s serverCertificate
IL_0006: ldarg.s clientCertificateChain
IL_0008: ldarg.s endpoint
IL_000a: brtrue.s IL_000f

IL_000c: ldnull
IL_000d: br.s IL_0021

IL_000f: ldc.i4.1
IL_0010: newarr MyComp.NetStack.EndpointDescription
IL_0015: stloc.0
IL_0016: ldloc.0
IL_0017: ldc.i4.0
IL_0018: ldarg.s endpoint
IL_001a: stelem.ref
IL_001b: ldloc.0
IL_001c: newobj instance void MyComp.NetStack.EndpointDescriptionCollection::.ctor(class [mscorlib]System.Collections.Generic.IEnumerable`1<class MyComp.NetStack.EndpointDescription>)

Yes, it is possible with code contracts. In this case a special library rearranges compiled code so that validation runs before calling base constructor. — GSerg, Feb 12 '15 at 22:04
possible duplicate of [Are code contracts guaranteed to be evaluated before chained constructors are called?](http://stackoverflow.com/questions/17067484/are-code-contracts-guaranteed-to-be-evaluated-before-chained-constructors-are-ca) — GSerg, Feb 12 '15 at 22:21
Actually there is no mention of code contracts in the IL, so they might be just using the `this(convertArg(s))` method from the linked question. — GSerg, Feb 12 '15 at 22:27

Dan Bryant · Accepted Answer · 2015-02-12T22:21:47.813

4

You can do this:

public class SomeDerivedClass : SomeBaseClass {
    public SomeDerivedClass(SomeType onlyOneInstance)
        : base(new[] { onlyOneInstance})

    {
    }
}

In other words, you definitely can run code prior to the base constructor as part of constructing the parameters passed to it. In this case, we're constructing an array to pass to the base class. You can also call static methods, as recursive mentions.

I missed the null check. Apparently they want to preserve the null passing case rather than an array containing null. That would be the equivalent of :

public class SomeDerivedClass : SomeBaseClass {
    public SomeDerivedClass(SomeType onlyOneInstance)
        : base(onlyOneInstance != null ? new [] { onlyOneInstance} : null)

    {
    }
}

edited Feb 12 '15 at 22:21

answered Feb 12 '15 at 22:03

Dan Bryant

27,329
4
56
102

This was my thought as well but after trying it out and looking at the decompiled code in DotPeek I didn't notice any difference. I don't see why there would be an `if` check inserted if this was the case. – Jeroen Vannevel Feb 12 '15 at 22:18
@JeroenVannevel, Ah, I missed that part; you can still do it with the base call, though. – Dan Bryant Feb 12 '15 at 22:22
Ah the fun of looking at the wrong output folder and not seeing anything change.. coupled with your suggestion I also believe that this might be the correct solution. For example, this is the output DotPeek gives me: http://i.imgur.com/3ZJ1MgI.png – Jeroen Vannevel Feb 12 '15 at 22:33

recursive · Answer 2 · 2015-02-12T22:21:41.760

2

One way something like this might happen is field initializer logic.

Another way you can kind of achieve it is calling static methods for base constructor argument values.

class Base {
    public Base(object value) { 
        Console.WriteLine ("Base constructor");
    }
}

class Child : Base {
    public Child() : base(DoWorkBeforeBaseConstructor()) { }

    private static object DoWorkBeforeBaseConstructor() {
        Console.WriteLine ("doing work");
        return null;
    }
}

edited Feb 12 '15 at 22:21

answered Feb 12 '15 at 22:02

recursive

83,943
34
151
241

I don't think it's a field initializer in this case, as it's a parameter being passed to the base constructor. – Dan Bryant Feb 12 '15 at 22:14
@DanBryant: You're right. I changed my answer to reflect your comment. – recursive Feb 12 '15 at 22:22

score 2 · Answer 3 · answered Feb 12 '15 at 22:52

Complementing the other answers:

The CLR allows you to run arbitrary stuff before calling the base class ctor. The CLR enforces that you do call the base class ctor in all possible paths through the method exactly once. I recently experimented with that using peverify.

C# enforces other restrictions as you have noticed. If a different language was used to compile this assembly then only the CLR rules apply. And even those do not apply for SkipVerification code which, I believe, is almost all code that runs nowadays.

Explicit constructor call in C#

3 Answers3