Compare by values from unknown object types

Question

I want to do something like this question, but it isn't working as I'm expecting.

I have a list of an object's properties and their types, an unknown object, and a list of default value types that I want to ignore from the object.

public void GetOnlyNonDefault(object oObject, IgnoreValues ignoreValues)
{
    //properties is set beforehand
    for (int i = 0; i < properties.Count; i++)
    {
        object originalValue = 
            oObject
                .GetType()
                .GetProperty(properties[i].Name)
                .GetValue(oObject, null);

        //retrieving the default value I want to ignore for this property
        object ignoreValue = ignoreValues.GetDefaultOf(properties[i]);

        //Problem here

        //This doesn't work
        if (originalValue == ignoreValue) { continue; }

        //This works for nearly everything BUT enums
        if (ValueType.Equals(originalValue, ignoreValue)) { continue; }
    }
}

I've read from here that enums' default value is zero, and that's what I'm returning from GetDefaultOf when the type is an enum. How can I do a compare by values for all the value types including enums in the above code?

Edit: May be relevant, but the enums I'm using in the oObject class don't have any value set to 0, they all start at 1.

public enum UserStatus 
{
    Regular = 1, Manager = 2, Director = 3, Admin = 4
}

Edit²: Here's a basic version of the code I'm trying to do giving the results I'm experiencing: http://pastebin.com/rfJA9CGp

I can't really change the enums because that's the point of this code, I don't know what is the object at runtime nor it's properties, but I want to figure any values different from the defined default (the class IgnoreValues contains the default values for all value types).

I can't cast to int when it's an enum because then I'd ignore the case where an enum with 0 was actually defined in the code, so I'm looking for any way to compare the values.

Answer 1

When operator == is given values statically typed to object, it does a raw reference comparison. Value types must be boxed when placed into a variable typed object (and when returned from reflection calls), so the comparison will always be false, since even equal values are boxed to two different instances.

One way to compare enums would be to unbox the values to an int:

        object foo1 = Foo.A;
        object foo2 = Foo.A;
        Console.WriteLine(foo1 == foo2);              // False
        Console.WriteLine((int) foo1 == (int) foo2);  // True

This code will fail when the variable does not hold something that can be unboxed to int, so extra care is required. In particular, if the enum's underlying type is not int (which can happen), it will also result in a runtime exception. So an alernative is Enum.Equals, which supports enums of different underlying types:

        object foo = Foo.A;
        if (foo.GetType().IsEnum)
            Console.WriteLine(Enum.Equals(foo, your-default-value));

Now that you've shown how you get the default value to compare to, I see what the problem is. You pass an integer 0 to Enum.Equals. The method is written in such a way that an integer is never equal to an enum value. Getting the default value is not totally obvious:

        object foo = Foo.A;
        object defaultEnumValue = Activator.CreateInstance(foo.GetType()))

        Enum.Equals(foo, defaultEnumValue);

You may have noticed that this is relatively arcane. This is because C# is not generally very nice when your code involves processing all the possible types there are. The types are meant to be determined at compile time, but of course that isn't possible when you're writing code that inspects arbitrary objects.