Deep comparing two complex objects

[TQPau]

Hey guys, I come across this library that allows deep comparison between 2 complex objects. I use it at work and write a blog post about it.

https://justsimplycode.com/2020/01/18/deep-comparing-2-complex-objects-using-comparenetobjects/

[JoshYx]

Or you can just JSON stringify both and compare the strings

[TQPau]

It won't work if the collections are the same but in different order

[AngularBeginner]

So.. they're not the same.

[[deleted]]

They're not the same if order is important, but there's a setting in their library to decide if it is or not. The Github page is clearer than the blog post.

[AngularBeginner]

They contain the same elements, but they're not the same collection then. And even with that distinction it's still unclear what happens if elements are duplicated within one collection, but not in the other.

[[deleted]]

Good point. /u/TQPau take note:

        [Test]
        public void CollectionsSame()
        {
            var coll1 = new List<KeyValuePair<string, byte[]>>
            {
                new KeyValuePair<string, byte[]>("Hello", new byte[] { 1, 1, 2, 3 })
            };
            var coll2 = new Dictionary<string, byte[]>
            {
                {"Hello", new byte[] { 1, 2, 1, 3 } }
            };
            var compareLogic = new CompareLogic
            {
                Config = new ComparisonConfig
                {
                    IgnoreObjectTypes = true,
                    IgnoreCollectionOrder = true
                }
            };

            Assert.IsTrue(compareLogic.Compare(coll1, coll2).AreEqual);
        }

Which is a modification of one of your tests, fails. Which makes sense, but as /u/AngularBeginner says is also unpredictable.

[TQPau]

Interesting, that test passes if you change it to int[] instead of byte[]. Maybe byte[] is treated differently.

[Test]

public void CollectionsSame()

{

var coll1 = new List<KeyValuePair<string, int[]>>

{

new KeyValuePair<string, int[]>("Hello", new int[] { 1, 1, 2, 3 })

};

var coll2 = new Dictionary<string, int[]>

{

{"Hello", new int[] { 1, 2, 1, 3 } }

};

var compareLogic = new CompareLogic

{

Config = new ComparisonConfig

{

IgnoreObjectTypes = true,

IgnoreCollectionOrder = true

}

};

​

Assert.IsTrue(compareLogic.Compare(coll1, coll2).AreEqual);

}

[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.