Why is it that I’m still able to call a coroutine from another script, even though I marked it as private?

Question

I have this private coroutine in my WinDialogue script:

private IEnumerator ActivateStars(int count)
{
    for (int i = 0; i < count; i++)
    {
        _stars[i].SetActive(true);
        yield return new WaitForSeconds(.3f);
    }
}

And somehow I’m still able to call it from my UIManager script:

_winDialogue.GetComponent<WinDialogue>().StartCoroutine("ActivateStars", starCount);

How can that be if I marked it as private?

Answer 1

When you start a coroutine by providing the method name as a string, then the Unity engine uses reflection to find the method at runtime, which doesn't care about the visibility of methods. This is not unusual for Unity. You might have noticed that methods like Start and Update are declared private, yet the Unity engine invokes them from outside the class.

If you would prefer proper software engineering principles - like names being resolved at compile-time and visibility rules being respected - use the variant of StartCoroutine which takes an IEnumerator instead of a string to denote the method.

WinDialogue dialogue = _winDialogue.GetComponent<WinDialogue>()
dialogue.StartCoroutine(dialogue.ActivateStars(starCount));

This will give you a compile-time error if WinDialogue.ActivateStars is private (or does not return an IEnumerator... or gets called with the wrong arguments... or is misspelled...).

Answer 2

The answer from Philipp is correct; I'd like to extend it slightly by addressing directly your statement:

somehow I’m still able to call it ... how can that be if I marked it as private?

The question indicates an important but subtle misunderstanding of what "private" applies to. "Private" does NOT mean "cannot be called from outside". Consider:

class C 
{
  private static void M() { whatever }
  public static Action A() { return M; }
}

Any code can call M() by invoking C.A()(). Notice that in this scenario the call to M is made from code outside C; there is no call to M() inside C, merely returning a delegate to it.

And as Philipp's answer notes, there are other ways that code can access C.M, such as having been granted sufficient permissions to do private reflection.

What then does private mean, if not "this code can only be called from inside C?"

private means the name of the thing declared may only be legally referred to by an identifier within the accessibility domain of a private member. That is, use of the identifier M to refer to the private member C.M is only legal inside the accessibility domain of C.M.

The private accessibility domain for a method of a class is the region of program text that falls within the outer { } braces for the class (including partial class declarations and nested classes).

The thing that I'm emphasizing here is that private gives a restriction on the source code of a legal program. It says that the actual program text M may only be used to refer to member C.M if that program text appears somewhere inside the braces of the class declaration. An attempt to use the program text M outside of the accessibility domain will result in either binding to a different thing named M, or an error.

But the key thing to understand here is that private is all about the legality of the text of the program's source code. It is not a fact about behaviour at runtime! You can still call a private member; you just can't do it by writing source code that uses identifier M outside of the declaration of C.