Method Chaining

[TonyValenti]

I would like to request that C# allow additional invocations on methods that return void. Related, I would like to be able to call Setter members as if they were functions.

If the Method is an instance method, the instance method should be "returned" by void.
If the Method is a static method, the static class should be "returned" by void.

For example:

Console.WriteLine("Hello World");
Console.BackgroundColor = ConsoleColor.Green;
Console.WriteLine("Hello Green World");

should be able to be written as:

Console
    .WriteLine("Hello World")
    .BackgroundColor(ConsoleColor.Green)
    .WriteLine("Hello Green World")
    ;

This would bring Fluent APIs to the existing C# codebases.
This would not break existing code because in existing code, you cannot "dot" off of void returns.

[svick]

I would like to be able to call Setter members as if they were functions

What happens when the type of the property is a delegate?

static class C
{
    public static Action<object> P { get; set; }
}

…

Action<object> a = o => {};
C.P(a);

This is already valid syntax, which gets the property and then invokes the delegate, passing a as parameter (implicitly converting from Action<object> to object). But you would want to use the same syntax to set the property?

[YaakovDavis]

Proposed here with a slightly different syntax.

[YaakovDavis]

And here.

[DavidArno]

I really don't see how:

Console
    .WriteLine("Hello World")
    .BackgroundColor(ConsoleColor.Green)
    .WriteLine("Hello Green World")
    ;

is more readable, or in any way offers any other benefits over existing code:

using static System.Console;
...
WriteLine("Hello World");
BackgroundColor = ConsoleColor.Green;
WriteLine("Hello Green World");

Further, to my mind at least, the purpose of method chaining isn't just to save typing and to join up a set of methods via .'s. It's purpose is to flow a value through various transformation methods. Ideally those methods should either be side-effect free, or the side effects should be limited to the internal state of the value passed through them. So using this technique to chain a series of methods together, that share no data between them and that only have side effects is to seek to misuse this feature in my view.