Handy C# improvements

[mvalensky]

Ideas to Improve the C# Syntax

As a 15y C# developer I was amazed how easily I can forget it and learn new syntax which improves readability and shortens the code. That is the Kotlin syntax. The Java is far from my favorite, but the Kotlin is like evolution of C#.

Here are some ideas:

Primary Constructors with Auto Properties

class Example(public Int Count)
{
 ...
}

should be equivalent of

class Example(Int count)
{
    public Int Count { get; set; } = count
}

The optional readonly modifier can introduce property with the getter only.

Benefits

• shorter syntax
• reduce boiler plate

Custom DSL syntax support

When a delegate (Action<> or Funct<>) is the last parameter of a method, the call can be simplified to move the delegate out of brackets. If the delegate is the only parameter, then even omit the brackets entirely.

A method:

public static void Also<T>(this T what, Func<T, T> func)
{
    return func(what);
}

Usage:

new Builder()
    .ConfigureConnection()
    .AddFeatures(...)
    .Build()
    .Also { b =>
        logger.debug($"Builder has been built with features {b.Features}.")
    };

Without it:

var builder = new Builder()
    .ConfigureConnection()
    .AddFeatures(...)
    .Build();
logger.debug($"Builder has been built with features {builder.Features}.");

And in addition if there is this modifier, it allows to write inline extensions:

class DependencyHandler 
{
    public void Compile(string coordinate)
    {
        // add coordinate to some collection
    }
    public void  TestCompile(string coordinate){
        // add coordinate to some collection
    }
}

class Project
{
    // This is the method accepting extension a first parameter
    public static Project Create(Action<this Project> action)
    {
        var project = new Project();
        action(project);
        return project;
    }
    public DependencyHandler Dependencies(Action<this DependencyHandler> action)
    {
        var dependencies = new DependencyHandler();
        dependencies.action();
        return dependencies;
    }
    public void Run()
    {
        // some code to execute
    }
}

static class 

And now the usage:

static class Foo
{
    public static void Bar()
    {
        Project.Create
        {
            // We don't need to use the `this`
            Dependencies
            {
                Compile("Some code to compile") ;
                TestCompile("");
            };
        }.Run();
    }
}

Benefits

• support for custom DSL syntax
• improved readability
• support for the functional style programming
• LINQ can be used like DSL language
• endless possibilities to write extensions like also, with, apply, with
• basically allows to write won using with very similar syntax
• even the ; can be omitted to have experience like using
• with default name like it for the first lambda parameter, it shortens the syntax too

Shorthand Properties

This

class Foo
{
    public val Int Count;
    public var string Name;

    void Bar()
    {
        val string text = "";
        //o r
        val text2 = "";
        var Int length = 3; //common var
        // or
        var length2 = 4;

        text="4"; //throws exception - can't be changed - constant
    }
}

is adequate to the

class Foo
{
    public Int Count { get; set; }
    public string Name { get; }

    void Bar()
    {
        val string text = "";
        var Int length = 3;
    }
}

Benefits

• shorter syntax to the readonly

Constants and Static Methods Can be Without Class

namespace Test
public const string Text = ""
public static void Foo() {}
public static void Bar<T>(this T what) {}

is equivalent to the

namespace Test
public class __Genretated_1
{
    public const string Text = ""
    public static void Foo() {}
    public static void Bar<T>(this T what) {}
}

usage:

using Test;

print(Text);
print("".Bar())

or

print(Test.Text)

Benefits

• shorter syntax
• no need to introduce wrapper/bearer classes without meaning

[huoyaoyuan]

Primary Constructors with Auto Properties

This is intended to be achieved with records. I remember there is existing discussion for this but can't find it.

Custom DSL syntax support

#1151

Shorthand Properties

It's not interesting to add an alternative syntax for the same purpose. In my opinion, the Kotlin syntax is much less readable. The current syntax is easily readable by simply looking at get and set accessors.

Constants and Static Methods Can be Without Class

Actively discussed in #9802.