Allow optional omission of class name from constructor

[datvm]

Currently we need to write something like this:

    public class SomeVeryLongLongClassName
    {

        public SomeVeryLongLongClassName()
        {
            // Implementation
        }

        private SomeVeryLongLongClassName(int foo)
        {
            // Implementation
        }

        internal SomeVeryLongLongClassName(int foo, string bar)
        {
            // Implementation
        }

        public SomeVeryLongLongClassName(int foo, string bar, long xyz)
        {
            // Implementation
        }

    }

I really like the new C# 9 Target-typed new, and wonder if it can be applied for these too, so it would become:

    public class SomeVeryLongLongClassName
    {

        public()
        {
            // Implementation
        }

        private(int foo)
        {
            // Implementation
        }

        internal(int foo, string bar)
        {
            // Implementation
        }

        public(int foo, string bar, long xyz)
        {
            // Implementation
        }

    }

Right now the syntax isn't working (syntax error) so I don't think there will be any conflict. Probably can be applied to static constructors too but you don't have above scenario for static constructors.

[JustNrik]

I'd rather use new to define a ctor, like

public class SomeLongNameThatWeAreAllLazyToTypeAndRead
{
    public new()
    {
        // ctor
    }
}

something similar to vb's Sub New(), nameless ctor look kinda weird tbh.

[datvm]

While I would still be happy if this is the final solution, I think new keyword there is quite... redundant. But still better than writing the whole class name tbh. Yes everything new will look weird at first. I meant, this still look weird to me (but I am getting used to it):

Point a = new(0, 0);

[acaly]

Remember new operator in C++ means a completely different thing from constructor. Since C# borrows much of its syntax from C++, I would expect we don't change that.

Another consideration: constructors and destructors are kind of symmetric. Should we only change constructors?

[erik-kallen]

Should we only change constructors?
Why not? constructors are probably used somewhere between 1000x-1000000x more than destructors so their symmetry is only academic.