Umbrella: Leftovers for local functions

[bkoelman]

Similar to methods, local functions should probably be constrained in their maximum number of parameters (AV1561) and maximum number of statements (AV1500). Tracked by #140.

Likewise, mentions in other rules may need to be expanded to include local functions. In most cases, it should be sufficient to replace "methods" or "members" with: "methods/members and local functions".

• [x] A method or property should do only one thing (AV1115) #148
• [x] Properties, methods and arguments representing strings or collections should never be null (AV1135) #149
• [x] Define parameters as specific as possible (AV1137) #150
• [x] Be reluctant with multiple return statements (AV1540) #151
• [x] Encapsulate complex expressions in a method or property (AV1547) #152
• [x] Avoid methods that take a bool flag (AV1564) #156
• [x] Use US-English (AV1701) #157
• [x] Use proper casing for language elements (AV1702) #115
• [x] Don't include numbers in variables, parameters and type members (AV1704)
• [x] Name a member, parameter or variable according to its meaning and not its type (AV1707)
• [x] Name methods using a verb or a verb-object pair (AV1720) #108
• [x] Post-fix asynchronous methods with Async or TaskAsync (AV1755) #153
• [x] Consider using Any() to determine whether an IEnumerable<T> is empty (AV1800) #154
• [x] Avoid inline comments (AV2310) #155
• [x] Use a common layout (AV2400) #111

Additionally, we may want to provide guidance on when to (not) use local functions:

• [x] Say something about the relative declaration location in AV2406 (Place members in a well-defined order). Options for consideration: #111
  • At the end of its containing method
  • Above its first usage
  • Below its first usage

Discussed in https://github.com/dennisdoomen/CSharpGuidelines/issues/96#issuecomment-335619190:

• Resharper suggests to convert delegate and Func variables into local functions.
• I have seen it being suggested to use for non-deferred parameter validation in yield-based deferred execution methods:

public IEnumerable<T> Enumerate<T>(IEnumerable<T> items)
{
    if (items == null)
    {
        throw new ArgumentException(nameof(items));
    }

    return InnerEnumerate(items);

    IEnumerable<T> InnerEnumerate(IEnumerable<T> array)
    {
        foreach (var item in array)
        {
            yield return item;
        }
    }
}

[dennisdoomen]

Isn't this already done?

[bkoelman]

We may have occasionally added local functions as part of other work. This issue tracks all potential locations.

I recall you're not such a big fan of them, so I thinks it's best for me to create individual PRs for the places they may make sense. Then you can accept/reject as you see fit.