equals

While disassembling the .Net Source Code using Reflector, I came upon the Equals implementation in the Object Class and it refers to bool InternalEquals(object objA, object objB); Which again refers to internal static extern bool InternalEquals(object objA, object objB); I am now confused regarding where to find the implementation of this InternalEquals(object objA, object objB) function and how is it using this function and in which .Net assembly is this function defined and also if each and everything is written from scratch for the .Net Source Code, then why am I unable to find this

What is the difference between == and Equals() with example? I know that == is used to compare operator and Equals() method is used to compare content of string.So i tried // first example string s1 = "a"; string s2 = "a"; Console.Write(a.Equals(s2)); // returns true, but if I assign "b" to s2, // then result will be false // second example string s1 ="a"; string s2 ="a"; Console.Write(s1 == s2); // returns true How this is so? Both are different object references. Suppose we consider that these are reference. But I tried to use like this string s1 = new string("ab"); string s2 = new string(

I have the following code: object val1 = 1; object val2 = 1; bool result1 = (val1 == val2);//Equals false bool result2 = val1.Equals(val2); //Equals true What's up with that? Is the only way to fix this to go with .Equals() method? The operator == is static, not virtual, so the behaviour is determined by the static type and not the runtime type. The default implementation for == on objects of reference type is to compare the references (although types can implement a different behaviour, for example string ). You have two different objects and they don't have the same reference so == returns

I stumbled across the source of AtomicInteger and realized that new AtomicInteger(0).equals(new AtomicInteger(0)) equals false . Why is this? Is it some "defensive" design choice related to concurrency issues? If so, what could go wrong if it was implemented differently? (I do realize I could use get and == instead.) Vineet Reynolds This is partly because an AtomicInteger is not a general purpose replacement for an Integer . The java.util.concurrent.atomic package summary states: Atomic classes are not general purpose replacements for java.lang.Integer and related classes. They do not define

I have two classes defined such that they both contain references to the other object. They look similar to this (this is simplified; in my real domain model class A contains a list of B and each B has a reference back to parent A): public class A { public B b; public String bKey; @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((b == null) ? 0 : b.hashCode()); result = prime * result + ((bKey == null) ? 0 : bKey.hashCode()); return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return

Why in this situation ReferenceEquals method of object behaves differently? string a= "fg"; string b= "fg"; Console.WriteLine(object.ReferenceEquals(a, b)); So in this situation it's get a result true . In case, it compares values of my strings and not references. But when I write something like: StringBuilder c = new StringBuilder("fg"); string d = c.ToString(); Console.WriteLine(object.ReferenceEquals(a, d)); In this case it works fine and result is false , because it compares references of my objects. Anthony Pegram The first example has a compile time constant "fg" that is referenced by