Inconsistent naming conventions for delegate instances

[Vaskaran]

Here the delegate instances are following the pascal casing naming convention. But the following link: https://learn.microsoft.com/en-us/dotnet/api/system.func-1?view=net-7.0 shows the use of the camel casing naming convention. Which one should we follow?Any thoughts?

---

Document Details

⚠ Do not edit this section. It is required for learn.microsoft.com ➟ GitHub issue linking.

• ID: 40f42506-f4a5-859a-0266-ded002056d83
• Version Independent ID: f940f2ad-e13d-4d37-6439-f8afcbc4e4c7
• Content: C# Coding Conventions
• Content Source: docs/csharp/fundamentals/coding-style/coding-conventions.md
• Product: dotnet-csharp
• Technology: csharp-fundamentals
• GitHub Login: @BillWagner
• Microsoft Alias: wiwagn

---

Associated WorkItem - 123092

[BillWagner]

The text is correct in both places, but should be clarified. Delegate types and methods that are delegate targets are PascalCased. variables that are instances of a delegate type are camelCased.

I'll add this as an enhancement to udpate this article.

[Vaskaran]

etho

Thanks for the response. "variables that are instances of a delegate type are camelCased." -This is clear. For example, the following is clear:
Del exampleDel2 = DelMethod;

The confusion arises for the following examples. Please note the following two cases:
Case-1(PascalCase is used ):
[Taken from :https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/coding-style/coding-conventions]

public static Func<int, int, int> FuncExample2 = (x, y) => x + y;

Case-2(camelCase is used ):
[Taken from https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/lambda-expressions]

Func<int, int, bool> testForEquality = (x, y) => x == y;

or, see the following line:

Func<int, int, int> constant = (_, _) => 42;

Additional Example/info:
Consider the following code. Visual Studio IDE shows the name violation for the method "show" [which is correct behavior], but it is silent about the delegate method:

namespace Test
{
    class Sample
    {
        // IDE shows the name Violation in this case(correct behavior)
        public static void show(int A) { WriteLine(A); }

        public static Func<int, int, int> FuncExample1 = (x, y) => x + y;
        // IDE does not show name violation about the following...
        public static Func<int, int, int> funcExample2 = (x, y) => x + y;

    }
}

So, a littlebit info on this issue can help us.

Finally, I have formulated a question with a simple case-study that can help to clear the confusion:
Consider the following program[I am using top-level statement]:

using static System.Console;
Action<int, int> adder =
    (x, y) => WriteLine($"{x} + {y} = {x + y}");
Func<Action<int, int>> totalMaker = () =>
{
   WriteLine("The totalMaker is called.");
    return adder;
};
totalMaker()(10, 15);

-Does this program follow the intended and correct naming convention?

[BillWagner]

Adding to the July sprint as I'm updating this article.