compare two objects if type is same

figured it out.  I have to use Object.Equals.  For reference types it will compare references.   for value types it will compare the values.   the "=" sign won't work, that just compares the references.

Note that Equals does not check for two object to be the same when they are of the same type, unless they also refer to the same object in memory. This doesn't happen often, normally you want to know equality of the fields of the type.

The first answer you received is comparing the types as you said in the beginning of your question  (if the objects are of different types, then comparison should return false).

Anyway, I hopped on this train after your request for closing, so I won't object. I just feel that your current Object.Equals is too light for your requirement and that you should add the first comment to your method and add a field-comparison to that (not provided here yet).

-- Abel --

Hi Abel,

thanks so much for jumping in here.  I absolutely want a complete solution.  Are you sure about this behavior for Object.Equals?  I just ran a test where the "=" failed for two doubles that weren't strongly typed, but held the same value.  Object.Equals compared just fine.  

I got this from the MSDN: The default implementation of Equals supports reference equality for reference types, and bitwise equality for value types. Reference equality means the object references that are compared refer to the same object. Bitwise equality means the objects that are compared have the same binary representation.

does this explain the behavior I saw?

Should use the GetType() which is available to all objects.
If x.GetType() == y.GetType()

then you willl use reflection to extract the values.

if (i.GetType().ToString() == j.GetType().ToString())
            {
i.GetType().GetMethods()[0].Invoke(i, new object[]{j})

}

u can try with
int i = 0;
int j = 0;

it will return 0 is similar.

jvios - why isn't Object.Equals() a valid solution?  Where will that fail?

PS: as I said, I would love to help you out here, but I don't really like doing that while a time is ticking away to close the q. If you want me to explain these issues, please stop the auto-close process :)

Please re-open this question.  it is still in discussion

done!  I was meaning to re-open, but didn't realize that I had to press the "object" button...which would be objecting to my own cancel request I guess =)

Thanks :)

The point that I wanted to make is that Equals may not always yield the result you expect (or perhaps it is what you expect, but let me explain anyway). The problem is with boxing and with strings. When boxing is in place, Equals returns true, but "==" returns false depending on the situation. When you use objects, two objects that are of the same type, can still yield false with Equals and with strings, the same content will always yield true. Example:

-- Abel --

PS: comparing the string value of the type is never a good thing. If you want type equality (I know, you don't, but if), just compare the two types: the type (from GetType or typeof(..)) is a shared static object, which will return true always, both with "==" and "Equals", if both are of the same type.

// integer (any value type or struct)
int i = 10;
object i_obj1 = i;
object i_obj2 = 10;
i.Equals(i_obj2);        // true
i_obj1.Equals(i_obj2);   // true
i_obj1 == i_obj2;        // false
 
// objects: many objects overload the Equals, be aware of that
// some objects overload the operator==
object obj1 = new object();
object obj2 = new object();
object obj3 = obj1;
obj1.Equals(obj2);       // false
obj2 == obj1;            // false
obj3.Equals(obj1);       // true
obj3 == obj1;            // true
 
string strFull1 = "hello";
string strFull2 = "hello";
string strFull3 = strFull1;
// any which way these three strings: always equal
// which is not the same with reference equality: they point
// to different objects. Strings are treated especially
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:

Hi Abel,

Thanks so much for the explanation.  Its sounds like Equals really is the best way to compare two objects?

For reference types, if an object doesn't overload Equals then two objects are equal if they point to the same object.  All common value types override Equals (I believe...correct?) so two objects will be equals if their values are equal.