Allow hide parameterless struct ctor.

[nathan130200]

I'm working on a library where there are certain predefined actions, you invoke a function, pass which action and its parameters.

Could enums be used? Yes, of course, but to add metadata with attributes, it will be annoying as you have to do reflection or cache it somewhere.

So I had the idea of implementing readonly struct with the necessary data for each action. But then we came to a problem, for some bizarre reason, .NET or C# doesn't allow us to declare parameterless struct constructors as private...

And I can't understand why. I can't use EditorBrowsable to hide the constructor. It's an unpleasant and very irritating situation.

// act as Enum like. I can attach extra data and don't need to be restricted to only Int and Long base type.

public readonly struct CommandType
{
  public readonly int Id { get; init; }
  public readonly int ArgumentCount { get; init; }

  CommandType() {} // compile error, must be public
  CommandType(int id, int argc){ Id = id, ArgumentCount = argc; }

  public static readonly CommandType RequestUserInfo = new(0, 1);
}

Another example like in my xmpp library:

namespace XmppSharp.Protocol;

[RunStaticCtor]
public readonly struct IqType : IXmppEnum<IqType>
{
    static readonly Dictionary<string, IqType> s_cache = [];

    public string Value { get; init; }
    public bool HasValue => Value != null;

    IqType(string s)
        => s_cache[Value = s] = this;

    public static IqType Parse(string value)
        => s_cache[value];

    public static IEnumerable<IqType> Values
        => s_cache.Values;

    #region Values

    // ONLY THESE VALUES ARE OK, I CANNOT ENFORCE STRUCT CTOR BE PRIVATE, 
    // SO I MUST DECLARE EXTRA PROPERTY `HasValue` TO CHECK IF THIS 
    // WAS CREATED WITH PRIVATE CTOR OR `= default`
    public static IqType Get { get; } = new("get");
    public static IqType Set { get; } = new("set");
    public static IqType Result { get; } = new("result");
    public static IqType Error { get; } = new("error");

    #endregion

    #region Equality Operators

    public override bool Equals(object? obj)
        => obj is IqType other && Equals(other);

    public bool Equals(IqType other)
    {
        if (!HasValue || !other.HasValue)
            return false;

        return Value.Equals(other.Value);
    }

    public static bool operator ==(IqType lhs, IqType rhs)
        => lhs.Equals(rhs);

    public static bool operator !=(IqType lhs, IqType rhs)
        => !(lhs == rhs);

    #endregion

    #region Default Members

    public override int GetHashCode()
            => Value?.GetHashCode() ?? -1;

    public static implicit operator string(IqType obj)
        => obj.Value;

    #endregion
}

Would there be a possibility of allowing us to set the struct ctor private? Since there is no other way to declare enums with extra data. Without needing to use reflections, attributes or dictionary to map key/value of each enum.

In IqType example, i just used one field, but there's another example, that i must save also extra variable + one method for utility:

using System.Xml.Linq;

namespace XmppSharp;

[RunStaticCtor]
public readonly struct Namespaces
{
    private readonly string _value;
    private readonly string? _prefix;

    // this is horrible design.
    public Namespaces() => throw new InvalidOperationException("Don't use ctor.");

    Namespaces(string value, string? prefix = default)
    {
        _value = value;
        _prefix = prefix;
    }

    public XElement CreateElement(string tagName)
    {
        var result = new XElement(XName.Get(tagName, _value));

        if (!string.IsNullOrWhiteSpace(_prefix))
            result.Add(new XAttribute(XNamespace.Xmlns + _prefix, _value));

        return result;
    }

    public static implicit operator string(Namespaces ns)
        => ns._value;

    /// <summary>
    /// XMLNS: <c>http://etherx.jabber.org/streams</c>
    /// </summary>
    public static Namespaces Stream { get; } = new("http://etherx.jabber.org/streams", "stream");

    /// <summary>
    /// XMLNS: <c>jabber:client</c>
    /// </summary>
    public static Namespaces Client { get; } = new("jabber:client"); // dont have a prefix

// ...
}

[HaloFour]

In the absence of a public parameterless constructor, new T() on a struct is the same as default(T).

[HaloFour]

Given when the spec was updated to require parameterless constructors to be public I believe it came from either of these two meetings, although neither seems to explicitly call out this resolution:

https://github.com/dotnet/csharplang/blob/318bfca8a800d57acd1be54024919ef36b6ac3ae/meetings/2021/LDM-2021-03-10.md#parameterless-struct-constructors
https://github.com/dotnet/csharplang/blob/318bfca8a800d57acd1be54024919ef36b6ac3ae/meetings/2021/LDM-2021-03-29.md#parameterless-struct-constructors

Seemingly there are too many cases where new T() would accidentally fallback to default(T), this was likely one of them.

[huoyaoyuan]

.NET runtime has employed an analyzer that prevents you to invoke new T(). SA1129

But nothing can really prevent default(T) to be invoked. There are generics and empty arrays. Non-defaultable value types is needed to solve that.