Hi !
I’m being curious: When we create a script, we inherit from MonoBehaviour class. This means that we can override method “Start”, “Update” and plenty more. But we cannot add the “override” word to any of those methods. So, what are we doing when we declare, for example:
void Main(){}
Are we overriding ?? Hiding ?? Or what ?
I was thinking that unity is sending a message to these scripts via ( SendMessage ) or something like that…
Unity finds those methods when the app starts. MonoBehaviour doesn’t actually implement those methods itself, so there’s nothing to override or hide. If you have some hierarchy beyond MonoBehaviour yourself you can certainly set that up and Unity will respect it.
public class A : MonoBehaviour
{
protected virtual void Start()
{
Debug.Log("A");
}
}
public class B : A
{
protected override void Start()
{
base.Start();
Debug.Log("B");
}
}
Instances of B would log A and B to the console when they are loaded.
Thank you very much for your answer !!
The technical term is magic methods. Unity finds them by reflection.
The performance of this approach is presumably greater then calling a bunch of virtual methods that might not get used.
Another way without having to use “base”, because you can forget.
public abstract class A : MonoBehaviour
{
protected void Start()
{
Debug.Log("A");
StartCall();
}
protected abstract void StartCall();
}
public class B : A
{
protected override void StartCall()
{
Debug.Log("B");
}
}
Nice explanation, finally clear my confusion.
Another question is, why unity use reflection since normally it’s more expensive since it can’t be optimized at compile time, at least in java reflection is more expensive than direct calls.
Magic.
Which is a short answer for “We really don’t know exactly know how Unity does it”. It wouldn’t surprise me if Unity does have some compile time optimizations to make it all happen.
No, there is a post from Unity Blog said that it doesn’t use reflection, because it is the slowest way… And from the documentation you can see that these methods are on the title “Message”, so actually what 2F said are correct.
I’m familiar with the blog post. I note that the blog post also doesn’t say how Unity calls the methods, just that it doesn’t call them by reflection. Calling the methods is different from finding the methods.
There is no other technique to find the methods by name. Unity definitely uses reflection, or something very similar, to initially find the magic methods. Then it probably registers the methods internally so it never has to use reflection to actually call the methods.
Note that SendMessage uses the same basic technique, and is generally considered slow.
Maybe they use some kind of metaprogram to generate all the code for the direct call, just before compile all?
Is the only answer left that makes sense to me now… Maybe they have code generated from code?
This topic is very interesting from a game engine point of view, I am curious.
Topics are Code generation and Reflection…?
From the performance optimization aspect,
My guess is almost the same to Kiwasi.
With regards to the code generation…,
I have no idea about the benefit to the coder writing callback method without override or new keywords.
If these keywords is necessary to the C# compiler, Unity might select definitely not to omit the keywords.
Then, there are no other beneficial code chunks left to generate, i think.
For anyone reading this who don’t know the blog post , it is this post : 10000 Update() calls
The blog emphasizes the fact Unity “searches” for the methods the first time a Monobehaviour class is loaded, then uses the cached result to actually call the method later.
Since this comes from the C++ side of the engine, they might have more direct methods of iterating over a type’s methods than plain C# reflection, but I’m not too familiar with the Mono plumbing to know whether it is possible like it is in Java’s C API bridge.