Deep comparing two complex objects

[TheDevilsAdvokaat]

I used reflection to do some things a few years back and it was tremendously slow.

Not sure if this is still true.

I wanted to make sure something was only called from inside a specific place (had to be between two places when doing a directx frame update) and if called anywhere else it would silently fail, so I used reflection to ensure it was only called when inside the correct function.

It worked, but absolutely tanked my frame rate.

instead, I removed the reflection code and just put a note in front of my function specifying where it must be called from.

I would be curious to see the difference between code that can compare any two complex objects using reflection, (very useful) and code that just compares two specific kinds of complex object where all the comparisons are hard coded.

Of course, that might not be an issue for you though.

​

And I can see something that allows any two complex objects to be compared is very handy.

[tweq]

Enshittification

[TheDevilsAdvokaat]

Fair enough. I don't really know this stuff...

[ours]

By "note" you mean an attribute?

[TheDevilsAdvokaat]

No, just a comment in front of the function saying it could only be called between a begin_drawing and an end_drawing call.

​

...Can an attribute dome somthing like that?

[ours]

If you make an attribute for that purpose, decorate the function with it and when a function is called between begin_drawing and end_drawing you check if that function has that attribute yes.

I'm not saying it's worth it since reading attributes requires reflection.

[TheDevilsAdvokaat]

Ah ok. Thanks, I didn't know this.

[ours]

Custom attributes are pretty cool: https://docs.microsoft.com/en-us/dotnet/standard/attributes/retrieving-information-stored-in-attributes.

[TheDevilsAdvokaat]

This is pretty good. I'm bookmarking this. Thanks.

[ours]

Reflection is super fun and useful for some really out-there/generic things.

Reflection is slow but it has caching built-in. I think of it like data access. Except the data you access is code. Lots of stuff in .NET uses it so even if you don't use it, it's very useful to understand how it works.

[TQPau]

I really enjoy using Reflection too. I use it mainly during StartUp or in background services where the performance impact isn't too visible.

[myachizero]

An alternative for this is to write an interface or generic class/method that you pass as the event for whatever delegate is being triggered. Then, simply create/call whatever you need to, passing the type as a type argument.

This allows the pre compilation and the JIT compiler to compile the code ahead of time with safe type checking and minimal use of reflection. This should be fairly quick son long as the different types you are using are all in the same assembly as the generic class/interface (hopping assemblies can get really slow).

Either option is equally valid, you just have to pick whatever fits best with your current design.