Introduce globals for some general lambda functions/actions

[Timo-Weike]

If an API wants to consume some form of Action or Func to convert something or create a side effect, but the user does not want anything to happen and the API checks for null values. Then the way most people go is to write something like DoStuff(_ => {}). However this has the potential to create an unnecessary amount of Action or Func objects.

A similar problem existed for empty strings, arrays and IEnumerable, there the runtime got the static Empty methods to return a single empty array for each type.

This pattern would also benefit the Action and Func types.

My idea is to add (maybe more) an Empty property for Action types
and Identity for Func<T, T>.

Something like

public static class Actions
{
    private static void InternalEmpty() {}
    
    private static Action _empty = new Action(InternalEmpty);
    
    public static Action Empty => _empty;
}

public static class Actions<T>
{
    private static void InternalEmpty(T o) {}
    
    private static Action<T> _empty = new Action<T>(InternalEmpty);
    
    public static Action<T> Empty => _empty;
}

public static class Funcs<T>
{
    private static T InternalIdentity(T o) => o;
    
    private static Func<T, T> _identity = new Func<T, T>(InternalIdentity);
    
    public static Func<T, T> Identity => _identity;
}

[stephentoub]

Then the way most people go is to write something like DoStuff(_ => {}). However this has the potential to create an unnecessary amount of Action or Func objects.

If that's an issue (one cached object per call site), I'd prefer to see that addressed at the C# compiler level (one cached object per assembly) rather than creating a second way to express an empty lambda.