Proposal: Named Constructors

[aquartulli]

Right now AFAIK the solution to constructors that share signatures is to use the named constructor idiom:

class CacheReadResult
{
    public static CacheReadResultSuccess(object value) => new CacheReadResult(value, false);
    public static CacheReadResultError(object sourceValue) => new CacheReadResult(sourceValue, true);

    public object Value { get; }
    public bool IsReadError { get; }

    private CacheReadResult(object value, bool isReadError)
    {
        Value = value;
        IsReadError = isReadError;
    }
}

This works fine until inheritance comes in. Even though CacheReadResult has two "public constructors", neither of them can be used as base constructors.

It would be nice to do something like this instead:

class CacheReadResult
{
    public object Value { get; }
    public bool IsReadError { get; }

    public CacheReadResult.Success(object value) : this(value, false) { }
    public CacheReadResult.Error(object sourceValue) : this(sourceValue, true) { }

    private CacheResultResult(object value, bool isReadError)
    {
        Value = value;
        IsReadError = isReadError;
    }
}

class ClassResultResultWithMetadata : CacheReadResult
{
    public Metadata Metadata { get; }

    public CacheReadResultWithMetadata.Success(object value, Metadata metadata)
        : base.Success(value)
    {
        Metadata = metadata;
    }

    public CacheReadResultWithMetadata.Error(object sourceValue)
        : base.Error(sourceValue)
    {
        Metadata = null;
    }
}

I'm aware that this is a particularly trivial example that has other simple solutions (like just making CacheReadResult's private constructor public and removing the static methods), but the point stands. In some cases I've encountered, the only solution is to put all parameters on the constructor and check that whatever arguments used are valid in combination. It works, but it's not very elegant and a compile-time solution would be nicer.

[svick]

How would named constructors be encoded in IL? How would you use named constructors from a language that doesn't support them (like F# or an older version of C#)?

[HaloFour]

Sounds like something better addressed via ADTs or DUs.

[yaakov-h]

@HaloFour Would you mind expanding on that alphabet soup?

[HaloFour]

@yaakov-h

Algebraic Data Types or Discriminated Unions. Someone from a functional programming background could probably explain the details better than I, but in short it allows the definition of a data class represented by a set of named options. The use case illustrated above feels very similar to the Option, although that doesn't really handle the inheritance scenarios. I'd feel that there are probably better ways to address that.

That said, the use case is exceedingly simple to solve simply by defining the constructor as protected:

class CacheReadResult
{
    public static CacheReadResultSuccess(object value) => new CacheReadResult(value, false);
    public static CacheReadResultError(object sourceValue) => new CacheReadResult(sourceValue, true);

    public object Value { get; }
    public bool IsReadError { get; }

    protected CacheReadResult(object value, bool isReadError)
    {
        Value = value;
        IsReadError = isReadError;
    }
}

class CacheReadResultWithMetadata : CacheReadResult {
    public static CacheReadResultWithMetadata Success(object value, Metadata metadata) => new CacheReadResultWithMetadata(value, false, metadata);
    public static CacheReadResultWithMetadata Error(object sourceValue, Metadata metadata) => new CacheReadResultWithMetadata(sourceValue, true, metadata);

    public Metadata Metadata { get; }

    protected CacheReadResult(object value, bool isReadError, Metadata metadata)
        : base(value, isReadError)
    {
        Metadata = metadata;
    }
}

[Joe4evr]

the named constructor idiom

I never heard this one before. 🤔 And the example you proceed to give is called the Factory Pattern, last I checked.

[yaakov-h]

@Joe4evr It seems to be a C++ term for this... though only when the factory method is a part of the class being constructed.

[aluanhaddad]

When I see

new CachedReadResult.Success(value)

I think it looks like it's creating an instance of a nested type.

Dart has this feature but I don't know if it has nested classes so maybe it doesn't look odd to Dart programmers.

[MkazemAkhgary]

with c# 7.2 you even have private protected so there are No excuses!

[aquartulli]

@MkazemAkhgary private protected constructors imply you don't want you class to be derived outside of the defining assembly. That's not always the case, especially when writing libraries. Just protected opens your constructor up to be used improperly unless you add runtime checks (not that my example shows that). Being able to have constructors that share signatures mean you don't need to perform those checks. If it's not clear what I mean I can come up with a less trivial example.

[aquartulli]

@aluanhaddad Could be new CachedReadResult:Success(value) or whatever else, or even a completely different solution to allow constructors to have the same signature. The syntax is just an example.

[aluanhaddad]

@aquartulli gotcha. I was just remarking on how it looks in Dart, but I understand it is the expressiveness and semantics that you want, not any specific syntax.
I actually think this could be quite useful.

[jveselka]

How would you disambiguate which named constructor to call in Activator.CreateInstance and new() generic constraint?

[aquartulli]

@zippec Could add overloads to Activator.CreateInstance to include a name. Nameless overloads could either just not support named constructors (in the sense that it won't consider them as constructor candidates) or throw only if there's ambiguity. In either case it could throw MissingMethodException which fits the scenario.

The new() generic constraint could require that the constructor be unnamed. Could also use the default keyword that's only valid to use on a single parameterless constructor. If there are multiple parameterless constructors then the new() constraint chooses the one with the default keyword. If there are multiple parameterless constructors and none have default then it doesn't fulfill the constraint.

I believe both of these solutions are backwards compatible in regard to these two issues.

[jveselka]

@aquartulli

[Activator] Nameless overloads could either just not support named constructors

[Generics] The new() generic constraint could require that the constructor be unnamed

This basically argues that current API / language constructs would not treat those methods as constructors. (What is left to differentiate them from factory methods?)

[Activator] or throw only if there's ambiguity

[Generics] If there are multiple parameterless constructors and none have default then it doesn't fulfill the constraint

This means that adding named constructor could be a breaking change for the consumers of said class.

[CodeSetting]

What is left to differentiate them from factory methods?

Late to this discussion, but presumably a named constructor would be able to initialize a readonly field where a factory method would not be able to do the same.

For example, I have a class now where I would like to have an internal constructor that bypasses parameter validation since internally this has been done elsewhere. I am currently forced to add a dummy parameter to change its signature. I would much prefer to give the constructor a descriptive name instead of using a dummy parameter.

[aquartulli]

@zippec Your first point is only true with respect to solutions for that particular use case. You still get to use them as base constructors, and the other proposed solutions don't suffer from that problem.

As for the second point, if you're using an existing, unnamed, parameterless constructor already and you add a new named constructor, then there's no ambiguity. It can prefer an unnamed, parameterless constructor (of which there can only be one) over a named parameterless constructor. I should have said "If there are multiple named, parameterless constructors and none have default then it doesn't fulfill the constraint. Conceptually, default is implicit on the namesless, parameterless constructor.