What's the idea behind allowing private constant to be used as default parameters for public methods?

Question

To my surprise, this one compiles and runs:

class Program
{
    static void Main()
    {
        DoSomething();
    }

    private const int DefaultValue = 2; // <-- Here, private.

    public static void DoSomething(int value = DefaultValue)
    {
        Console.WriteLine(value);
    }
}

The method is public whereas the default value "redirects" to a constant private variable.

My question:

What is/was the idea behind this "concept"?

My understanding (until today) was, that something public can only be used if all other "referenced" elements are also public.

Update:

I just ILSpy-decompiled my class to find:

static class Program
{
    private static void Main()
    {
        Program.DoSomething(2);
    }

    private const int DefaultValue = 2;

    public static void DoSomething(int value = 2)
    {
        Console.WriteLine(value);
    }
}

So if the private constant as a default parameter is being done in e.g. a library, the user of the library still sees the default parameter.

Answer 1

What is/was the idea behind this "concept"?

The idea is that as const value is static and never changes - you can use it as default value for method's optional parameters same as you can use normal values. A quote from MSDN :

Each optional parameter has a default value as part of its definition. If no argument is sent for that parameter, the default value is used. A default value must be one of the following types of expressions:

• a constant expression;

• an expression of the form new ValType(), where ValType is a value type, such as an enum or a struct;

• an expression of the form default(ValType), where ValType is a value type.

---

My understanding (until today) was, that something public can only be used if all other "referenced" elements are also public

Well technically speaking it's correct. But in your scenario both members are accessible as they are defined in the same class however should const in our case be defined outside of class Program it'd be inaccessible inside class Program.

Answer 2

The name DefaultValue is private, but the number 2 is still the number 2.

Because DefaultValue is private, we cannot access Program.DefaultValue from outside of Program. Presumably we wouldn't particularly want to.

And because we've bothered to define DefaultValue at all, it's presumably something that we do care about when we are working on how Program works.

So when we come to define a default value for DoSomething there's presumably some logical reason why the value we want there happens to be the same as the value DefaultValue.

And as such, it's presumably beneficial to be able to use that constant there, for much the same reasons as we would find constants beneficial anywhere.

And since DefaultValue is just a Program-specific way of saying 2, there's no real reason why we can't.

Of course, the metadata would reflect this as 2 rather than the (meaningless to the outside) DefaultValue, but then that would hold if the const was public anyway (the metadata about default values gives only the value, not whether or not it related to any defined constants).

So there's no downside.

So considering that:

1. There's an advantage to the implementer.
2. There's no disadvantage to the user, over just a use of a literal 2.
3. Preventing it would have to introduce a special rule to be an exception to the rule that defined constants can be used anywhere a constant value from a literal can.

Why not?