What are the differences between these 3 ways of calling a coroutine?

Questions & Answers
1

StartCoroutine(“ExampleCoroutine”);

StartCoroutine(ExampleCoroutine());

StartCoroutine(nameof(ExampleCoroutine));

2

The final result for each of these is exactly the same, your coroutine will start and run the same for each of these. That being said, always use the second way!

  1. The first is a leftover from old days when it was the only way to call a coroutine. It uses reflection, so it’s slower than what it should be. Also it has a string parameter meaning your IDE won’t warn you about anything related to this call. So for example if you change the name of your coroutine, IDE won’t tell you that this will fail and you will only find out in runtime. Also if you use rename on the coroutine, this string will also not change. In general avoid this at all cost!
  2. This is the way to call a coroutine, full stop, no discussion. Your IDE should give you the same support for this statement as for regular method calls, so every refactoring and every error check will work right there in the IDE. This also doesn’t have the performance overhead of reflection. Also with this call you can pass parameters to the coroutine just like to a regular method.
  3. This is exactly the same as the first one. nameof returns a string that is usually the exact same thing as what you see in the brackets. This has a single benefit over 1, which is that rename function in your IDE should also rename this call and you will get a compile time error if this coroutine doesn’t exist. Also don’t use, it’s still strictly worse than 2.