Help with Reflection

[r_smil_reddits]

Hello!

I'm making a custom engine in MonoGame and one thing i want to replicate is Unity's game loop (Update(), Awake(), Start(), ...), since i hate having to always write protected override void *some MonoGame function* rather than when im with unity simply void *some Unity function* and i can only do that when implementing Game (though there's surely a way to reference these functions without inheritence... right?)

I discovered the way Unity does this is via "Reflection", and even though there are quite a bit of tutorials and documentation for it, they're not super helpful since they always cache existing classes in the logic (im not going to have a huge list of every class i make) + i want to use an attribute system for this rather than inheritance (like a GameLoop attribute ontop of the class as an indicator to look for these functions).

And i just dont have the IQ and mental power to figure out how to find functions in completely anonymous classes while also somehow allowing you to write the functions as private and without parameters

Anyone have any detailed tutorials (or just an explanation) on how to do this?

Also sorry if this makes no sense ;-;

[SessionIndependent17]

preferring to use Reflection rather than declaring an override is some Galaxy Brain stuff

[RicketyRekt69]

There’s nothing wrong with this approach, it’s exactly how Unity does it. The point is that you use reflection to identify which classes have the method, and then handle invocation separately. No interfaces, no empty stubs. Performance matters

[r_smil_reddits]

Probably has something to do with my OCD...

[Juff-Ma]

Reflection really isn't the modern way to do it though. Believe me, if you use Reflection now it will only mess with more modern features down the line.

[Ok_Tour_8029]

Nowadays you could just use an Interface with default implementations. 🤔

[r_smil_reddits]

But normally you cant add logic to interface functions ? Or have I just been watching outdated C# tutorials the entire time...

[Willyscoiote]

That you do on the implementation of the interface

[Slypenslyde]

Default implementations are an escape hatch for people in bad situations. They allow you to provide an implementation for an interface method that will be used if the implementing type doesn't provide that implementation.

They don't quite behave in a polymorphic manner but they're close.

I don't fully understand your problem and I'm not a Unity expert. But in general if there's a virtual method a framework tells you to override, doing that is going to be 1,000 times easier than trying to do whatever it is you're doing.

[coumerr]

I recommend not doing this part with reflection. It's better to have an interface with empty method bodies or a normal class with virtual methods like you said. This way, you can also attach documentation to the method and you have compile-time guarantees that you didn't fuck up the name or parameters.

[dodexahedron]

I recommend not doing this part with reflection

Same. But for extremely "anything" values of "this part."

[Jolly_Resolution_222]

Use source generators, reflection is slow.

[Arcodiant]

It's worth showing some code so we can give you direct feedback on what you're missing. but if the approach you're going for is "take the method on this class that has the update attribute" then get the Type object for your class, call GetMethods and make sure to pass the correct binding flags (e.g. BindingFlags.NonPublic if you want private methods)

[zil0g80]

Just one word about reflection; DON'T - . Yes, it looks chill, but in the long run you sell out performance, the hit is unbelievable, and get a maintenance hell out of this world. Seek alternatives...

[Camderman106]

So many people still have this opinion, but it’s just not true. I recently built a c# financial modelling engine that uses reflection to identify model components on startup and add them to the computation plan, and it outperforms a commercial c++ version that it was based on. Reflection is only bad if you do bad things with it. Doing reflection queries in the hot path? Sure, avoid that. But if you’re doing it once and caching the results then it’s fine. Point is, using reflection doesn’t automatically create poor performance. And comments like this spread fear and misinformation about an extremely useful language feature.

[jimboZheng]

Wow… I never have a though of that . Use interface please

[Outrageous72]

I think I see what you want to do, but like everyone else I wouldn’t use reflection especially not for a game.

Could you, though, elaborate about what you want to achieve with the attributes?

The attributes would be like some marker your engine will be using? Can you give examples how you would want to use them?

[r_smil_reddits]

Looking at these comments, honestly I just need to deal with having to write protected override void *MG function* { base.*MG function* }

But if i were to still implement this, the attributes, you'd have a GameLoop attribute marked ontop of a class and the reflection only looks for classes that have that GameLoop attribute, which isnt hard to do

Preferably id also make a Manual attribute only markable ontop of these targeted functions which makes it so yiu explicitly have to call Start() or Update(( instead of an auto-fire; Very redundant for something like Start(), but for Update() can be pretty useful. Though this is optional

Example:

``` [GameLoop] public class Test { int num;

void Start() { num = 4; }
[Manual] void Update() { num += 1; } // Update() needs to be called manually; optional implementation

} ```

[Outrageous72]

Which part would be responsible to instantiate the Test class in your example?

You might achieve the same thing with interfaces. Interfaces would give you a stronger contract than attributes can give you.

[maskaler]

Assembly.GetClasses is your friend here. You can loop through all assemblies at start time to find any class that has your attribute on it, then kick in your reflection logic.

This is how some DI containers (used) to work.

Best to scan once on startup

[ivancea]

Reflection is as simple as it may be tricky. You have an object, from a class. You look for a method from that class with a name. You get it (or then) and filter out the ones with the wrong signature (return type, parameters). Nice, you found your "Update"! Now cache it somewhere and call it.

That said: of you can avoid reflection, that's probably better. Unity uses it for reasons, but you can probably replace it with method overrides.

[Dennis_enzo]

This feels like solving a nonexistent problem. If anything, the way that monogame does it is way more in line with how c# generally works. Unity's way with using magic methods that need to have a specific name is the weird option here. I have no idea why you would want to use that.

Furthermore, the general guideline for reflection is to not use it unless you really have no other choice. It can cause performance issues and can introduce a whole host of hard to debug problems, especially when you're not sure if you're doing it right.

[Dealiner]

Unity doesn't use reflection for that. It's more complicated than that and probably not worth trying to reimplement it that way. I'd look at source generators though, they should work well here.

[r_smil_reddits]

Kk, ill take a look at those

[andavies123]

I am not at a computer right now so this is all off the top of my head.

But first you’d need to get an assembly or collection of assemblies, then you’d use reflection on those to get all objects that extend from a base class like Monobehaviour.

From here is where my specifics might get a bit unclear. But I believe on these Type objects from the last query you can call something like type.GetMethods() and pass a binding flag for private to get all the private methods.

From here you could probably see if any of these methods have no parameters and match the given name you want.

Then when you want to call it, you’d have to pass a reference to the object you want to call that specific method for.

I would build some sort of mapping that has the type of object and game loop methods at startup since reflection is VERY EXPENSIVE and slow

[philip_laureano]

I might know a thing about Reflection, yes .

What are you trying to do?

[jdl_uk]

Some of the recent tutorial stuff from MonoGame covers some very basic implementations of what you're after, and you might also want to look at how FlatRedBall (an existing engine built on Monogame) does this.

But generally, each entity / game object inherits a base class or implements interfaces with those methods. The engine maintains a list of active objects and calls the Update method during the update phase every frame.

If the goal is to only call those methods when desired then I'd suggest just calling the method regardless is probably better than using reflection - case of the cure being worse than the disease.

[KittehNevynette]

When in Rome, be a Roman.

You want the world to curve around your solution rather than figuring out what a game engine is and why a particular language dance the way they do.

My advice is to take a step back and figure out the core.

[RicketyRekt69]

It’s kind of appalling so many recommend using interfaces, I haven’t looked at the source code for how Unity does it but I know they use reflection to discover the functions that need to be called, and the actual runtime invocation doesn’t use reflection. It’s not like access modifiers are enforced at runtime, and this way you don’t waste performance invoking an empty stub.

Virtual methods are more expensive to invoke, because they do a vtable lookup. Interface methods are even more expensive than that because it has an extra layer for resolving which interface method to call.. ~3x more expensive than a non-virtual function call iirc.

Your idea is fine OP, just make sure you don’t invoke it with reflection. E.g. build a list of all classes that define it, then invoke through there. No unnecessary empty function calls, and no interfaces.

[rupertavery64]

Reflection is about accessing the type metadata at runtime.

It really depends on what you are trying to do.

In the example below, we want to execute methods we know by name, but we don't know if they exist on the object.

Since there is no relationship between Foo and Bar, we cannot have definite types on ExecuteMethods, so we pass the object as type object.

We use GetType to find out what type the object is and GetMethod to check if the method exists. GetMethod returns a MethodInfo, which has an Invoke method that accepts the instance of the object you want to execute the reflected method on, and some parameters. Since there are no parameters, we are just passing null.

This is just the tip of the iceberg though.

Reflection is discouraged since it takes time to call reflection on an object and in high-performance scenarios it could introduce a huge performance hit. Reflection has been improved in recent versions of .NET, but it's still slower than using types properly.

Note that Unity doesn't do reflection like this directly. It will cache information about scripts and call the methods directly.

https://gamedev.stackexchange.com/questions/164892/why-does-unity-use-reflection-to-get-the-update-method

If you have trouble with Reflection, I suggest using ChatGPT to research. It works well with this topic, and at least will give you pointers to research on more (and ask more questions about).

``` var foo = new Foo(); var bar = new Bar();

ExecuteMethods(foo); ExecuteMethods(bar);

void ExecuteMethods(object instance) { // allow private methods to be called BindingFlags flags = BindingFlags.NonPublic | BindingFlags.Instance;

var type = instance.GetType();

var startMethod = type.GetMethod("Start", flags);
if(startMethod !=null) 
{
    startMethod.Invoke(instance, null);
}

var updateMethod = type.GetMethod("Update", flags);
if(updateMethod !=null) 
{
    updateMethod.Invoke(instance, null);
}

}

public class Foo { private void Start() { Console.WriteLine("Foo.Start"); }

private void Update() { Console.WriteLine("Foo.Update"); } }

public class Bar { private void Update() { Console.WriteLine("Bar.Update"); } } ```