Cannot call protected constructors in inheriting classes

[Sellorio]

The compiler rejects code that calls a Protected Constructor from an inheriting class.

public class BaseClass
{
    protected BaseClass(int value)
    {
    }
}

public class InheritingClass : BaseClass
{
    public void Method()
    {
        // fails to compile "... inaccessible due to its protection level"
        var instance = new BaseClass(1234);
    }
}

The workaround I need to resort to is creating a protected static method on the base class that calls the constructor.

public class BaseClass
{
    protected BaseClass(int value)
    {
    }

    protected static BaseClass CreateBaseClass(int value) => new BaseClass(value);
}

I would expect the behaviour of calling a constructor to align with the behaviour of calling a method with the same visibility.

[GalaxiaGuy]

I would expect the behaviour of calling a constructor to align with the behaviour of calling a method with the same visibility.

This does align with the behaviour of calling a method with the same visibility - you can't call a protected method through the base class directly:

public class BaseClass
{
    protected BaseClass(int value)
    {
    }

    protected void SomeBaseMethod()
    {
    }
}

public class InheritingClass : BaseClass
{
    protected InheritingClass(int value) : base(value)
    {
    }

    public void Method()
    {
        var instance = new InheritingClass(1234);

        // This is allowed
        instance.SomeBaseMethod();

        // This is not allowed
        ((BaseClass)instance).SomeBaseMethod();
    }
}

[Sellorio]

Interesting. I didn't notice this before.

I suppose it's up for debate but what you say only increases the severity of the issue from my perspective. The idea of treating the visibility of an inherited member differently based on the type of the variable is odd.

I believe this is also inconsistent with other languages such as C++.

[CyrusNajmabadi]

The idea of treating the visibility of an inherited member differently based on the type of the variable is odd.

It's the exact intent of how 'protected' is supposed to work in C#. Otherwise, you could access protected members from other inheritance lines.

I believe this is also inconsistent with other languages such as C++.

C# has no desire to be consistent with C++ here. :)

[Sellorio]

C# has no desire to be consistent with C++ here. :)

Fair enough.

Shouldn't static members be treated the same in this case then? Since the member isn't technically inherited.

[bernd5]

It is defined in inheritance

A constructor is special it is not an instance member and not a static member.