Xem xét mã này:

int age = 25;
short newAge = 25;
Console.WriteLine(age == newAge);  //true
Console.WriteLine(newAge.Equals(age)); //false
Console.ReadLine();

Cả hai intvà shortlà loại nguyên thủy, nhưng so sánh ==trả về true và so sánh với Equalstrả về false.

Tại sao?

Câu trả lời ngắn:

Bình đẳng là phức tạp.

Câu trả lời chi tiết:

Các kiểu nguyên thủy ghi đè lên cơ sở object.Equals(object)và trả về true nếu hộp objectđược đóng cùng loại và giá trị. (Lưu ý rằng nó cũng sẽ hoạt động đối với các loại nullable; các loại nullable null null luôn đóng hộp cho một thể hiện của loại cơ bản.)

Vì newAgelà một short, Equals(object)phương thức của nó chỉ trả về true nếu bạn vượt qua một ô ngắn có cùng giá trị. Bạn đang vượt qua một hộp int, vì vậy nó trả về sai.

Ngược lại, ==toán tử được định nghĩa là lấy hai ints (hoặc shorts hoặc longs).
Khi bạn gọi nó bằng một intvà a short, trình biên dịch sẽ ngầm chuyển đổi shortthành intvà so sánh các ints kết quả theo giá trị.

Những cách khác để làm cho nó hoạt động

Các loại nguyên thủy cũng có riêng của họ Equals() phương thức chấp nhận cùng loại.
Nếu bạn viết age.Equals(newAge), trình biên dịch sẽ chọn int.Equals(int)là quá tải tốt nhất và hoàn toàn chuyển đổi shortthành int. Sau đó nó sẽ trả về true, vì phương thức này chỉ đơn giản là so sánh inttrực tiếp s.

shortcũng có một short.Equals(short)phương thức, nhưng intkhông thể được chuyển đổi hoàn toàn thành short, vì vậy bạn không gọi nó.

Bạn có thể buộc nó gọi phương thức này bằng cách sử dụng:

Console.WriteLine(newAge.Equals((short)age)); // true

Điều này sẽ gọi short.Equals(short)trực tiếp, không có quyền anh. Nếu agelớn hơn 32767, nó sẽ ném ngoại lệ tràn.

Bạn cũng có thể gọi short.Equals(object) quá tải, nhưng rõ ràng chuyển một đối tượng được đóng hộp để nó có cùng loại:

Console.WriteLine(newAge.Equals((object)(short)age)); // true

Giống như sự thay thế trước đó, điều này sẽ tạo ra một tràn nếu nó không phù hợp với một short. Không giống như giải pháp trước đó, nó sẽ đóng hộp shortvào một đối tượng, gây lãng phí thời gian và bộ nhớ.

Mã nguồn:

Dưới đây là cả hai Equals()phương pháp từ mã nguồn thực tế:

    public override bool Equals(Object obj) {
        if (!(obj is Int16)) {
            return false;
        }
        return m_value == ((Int16)obj).m_value;
    }

    public bool Equals(Int16 obj)
    {
        return m_value == obj;
    }

Đọc thêm:

Xem Eric Lippert .

Bởi vì không có quá tải cho short.Equalsviệc chấp nhận một int. Do đó, điều này được gọi là:

public override bool Equals(object obj)
{
    return obj is short && this == (short)obj;
}

objkhông phải là một short.. do đó, nó là sai.

Khi bạn vượt qua intđến shortBằng của bạn, bạn vượt qua object:

Vì vậy, mã giả này chạy:

return obj is short && this == (short)obj;

Đối với các loại giá trị, .Equalsyêu cầu hai đối tượng phải cùng loại và có cùng giá trị, trong khi ==chỉ kiểm tra nếu hai giá trị này giống nhau.

Object.Equals
http://msdn.microsoft.com/en-us/l Library / bsc2ak47 (v = vs.110) .aspx

==được sử dụng để kiểm tra một điều kiện bằng nhau, nó có thể được coi là một toán tử (toán tử boolean), chỉ để so sánh 2 điều và ở đây kiểu dữ liệu không quan trọng vì sẽ có một kiểu truyền được thực hiện và Equalscũng được sử dụng để kiểm tra điều kiện bằng , nhưng trong trường hợp này các kiểu dữ liệu phải giống nhau. N Equals là một phương thức không phải là toán tử.

Dưới đây là một ví dụ nhỏ được lấy từ một trong những bạn đã cung cấp và điều này sẽ làm rõ sự khác biệt ngắn gọn ,.

int x=1;
short y=1;
x==y;//true
y.Equals(x);//false

trong ví dụ trên, X và Y có cùng các giá trị tức là 1 và khi chúng ta sử dụng ==, nó sẽ trả về true, như trong trường hợp ==, loại ngắn được chuyển đổi thành int bởi trình biên dịch và kết quả được đưa ra.

và khi chúng ta sử dụng Equals, việc so sánh được thực hiện, nhưng việc truyền kiểu không được thực hiện bởi trình biên dịch, do đó false được trả về.

Các bạn, xin vui lòng cho tôi biết nếu tôi sai.

Trong nhiều bối cảnh trong đó một đối số phương thức hoặc toán tử không thuộc loại được yêu cầu, trình biên dịch C # sẽ cố gắng thực hiện chuyển đổi kiểu ẩn. Nếu trình biên dịch có thể làm cho tất cả các đối số thỏa mãn toán tử và phương thức của chúng bằng cách thêm các chuyển đổi ngầm định, nó sẽ làm như vậy mà không có khiếu nại, mặc dù trong một số trường hợp (đặc biệt là với các bài kiểm tra đẳng thức!), Kết quả có thể gây ngạc nhiên.

Hơn nữa, mỗi loại giá trị như inthoặc shortthực sự mô tả cả một loại giá trị và một loại đối tượng (*). Chuyển đổi ngầm định tồn tại để chuyển đổi giá trị sang các loại giá trị khác và để chuyển đổi bất kỳ loại giá trị nào sang loại đối tượng tương ứng, nhưng các loại đối tượng khác nhau không thể chuyển đổi lẫn nhau.

Nếu một người sử dụng == toán tử để so sánh a shortvà an int, thì shortnó sẽ được chuyển đổi hoàn toàn thành một int. Nếu giá trị số của nó là tương đương với các int, các intmà nó đã được chuyển đổi sẽ bằng intmà nó được so sánh. Tuy nhiên, nếu người ta cố gắng sử dụng Equalsphương thức ngắn để so sánh nó với một phương thức int, thì chuyển đổi ngầm định duy nhất đáp ứng quá tải của Equalsphương thức sẽ là chuyển đổi sang loại đối tượng tương ứng int. Khi shortđược hỏi liệu nó có khớp với đối tượng truyền vào hay không, nó sẽ quan sát rằng đối tượng trong câu hỏi là một intchứ không phải là một shortvà do đó kết luận rằng nó không thể bằng nhau.

Nói chung, mặc dù trình biên dịch sẽ không phàn nàn về nó, nhưng ta nên tránh so sánh những thứ không cùng loại; nếu một người quan tâm đến việc chuyển đổi mọi thứ sang một hình thức phổ biến sẽ cho kết quả tương tự, thì người ta nên thực hiện chuyển đổi đó một cách rõ ràng. Hãy xem xét, ví dụ,

int i = 16777217;
float f = 16777216.0f;

Console.WriteLine("{0}", i==f);

Có ba cách mà người ta có thể muốn so sánh intvới a float. Người ta có thể muốn biết:

1. Liệu floatgiá trị gần nhất có thể intphù hợp với float?
2. Có phải toàn bộ phần số của floatkhớp với int?
3. Làm intvà floatđại diện cho cùng một giá trị số.

Nếu một người cố gắng so sánh một intvà floattrực tiếp, mã được biên dịch sẽ trả lời câu hỏi đầu tiên; cho dù đó là những gì lập trình viên dự định, tuy nhiên, sẽ không rõ ràng. Thay đổi so sánh để (float)i == flàm rõ rằng ý nghĩa đầu tiên được dự định, hoặc(double)i == (double)f sẽ khiến mã trả lời câu hỏi thứ ba (và làm rõ nó là ý định gì).

(*) Ngay cả khi C # đặc tả coi một giá trị kiểu ví dụ System.Int32như là một đối tượng kiểu System.Int32, một cái nhìn như vậy là mâu thuẫn với yêu cầu rằng một mã chạy trên một nền tảng có liên quan giá trị và các đối tượng như sinh sống vũ trụ khác nhau spec. Hơn nữa, nếu Tlà một loại tham chiếu, và xlà một T, thì một tham chiếu của loại Tsẽ có thể tham chiếu x. Vì vậy, nếu một biến vloại và nội dung của nó thực sự là một .Int32 giữ một Object, tham chiếu kiểu Objectsẽ có thể giữ tham chiếu đến vhoặc nội dung của nó. Trong thực tế, một tham chiếu loại Objectsẽ có thể trỏ đến một đối tượng đang giữ dữ liệu được sao chép từ đóv , nhưng không phải cho vchính nó cũng như nội dung của nó. Điều đó sẽ gợi ý rằng khôngvObject

Equals () là một phương thức của System.Object Class
Syntax: Public virtual bool Equals ()
Khuyến nghị nếu chúng ta muốn so sánh trạng thái của hai đối tượng thì chúng ta nên sử dụng phương thức Equals ()

như đã nêu ở trên câu trả lời == toán tử so sánh các giá trị là như nhau.

Xin đừng nhầm lẫn với ReferenceEqual

Reference Equals ()
Cú pháp: public static bool ReferenceEquals ()
Nó xác định xem các đối tượng được chỉ định có thuộc cùng một thể hiện không

Những gì bạn cần nhận ra là làm ==sẽ luôn luôn gọi một phương thức. Câu hỏi là liệu gọi ==và Equalskết thúc cuộc gọi / làm những điều tương tự.

Với các loại tham chiếu, ==sẽ luôn kiểm tra thứ nhất xem các tham chiếu có giống nhau không ( Object.ReferenceEquals). Equalsmặt khác có thể được ghi đè và có thể kiểm tra xem một số giá trị có bằng nhau không.

EDIT: để trả lời svick và thêm vào bình luận SLaks, đây là một số mã IL

int i1 = 0x22; // ldc.i4.s ie pushes an int32 on the stack
int i2 = 0x33; // ldc.i4.s 
short s1 = 0x11; // ldc.i4.s (same as for int32)
short s2 = 0x22; // ldc.i4.s 

s1 == i1 // ceq
i1 == s1 // ceq
i1 == i2 // ceq
s1 == s2 // ceq
// no difference between int and short for those 4 cases,
// anyway the shorts are pushed as integers.

i1.Equals(i2) // calls System.Int32.Equals
s1.Equals(s2) // calls System.Int16.Equals
i1.Equals(s1) // calls System.Int32.Equals: s1 is considered as an integer
// - again it was pushed as such on the stack)
s1.Equals(i1) // boxes the int32 then calls System.Int16.Equals
// - int16 has 2 Equals methods: one for in16 and one for Object.
// Casting an int32 into an int16 is not safe, so the Object overload
// must be used instead.

== Nguyên thủy

Console.WriteLine(age == newAge);          // true

Trong so sánh nguyên thủy == toán tử hoạt động khá rõ ràng, Trong C # có rất nhiều == toán tử quá tải có sẵn.

• chuỗi == chuỗi
• int == int
• uint == uint
• dài == dài
• nhiều hơn nữa

Vì vậy, trong trường hợp này không có chuyển đổi ngầm từ intđến shortnhưng shortđể intlà có thể. Vì vậy, newAge được chuyển đổi thành int và so sánh xảy ra trả về giá trị true vì cả hai đều giữ cùng một giá trị. Vì vậy, nó tương đương với:

Console.WriteLine(age == (int)newAge);          // true

.Equals () trong Nguyên thủy

Console.WriteLine(newAge.Equals(age));         //false

Ở đây chúng ta cần xem phương thức Equals () là gì, chúng ta gọi Equals bằng một biến loại ngắn. Vì vậy, có ba khả năng:

• Bằng (đối tượng, đối tượng) // phương thức tĩnh từ đối tượng
• Bằng (đối tượng) // phương thức ảo từ đối tượng
• Bằng (ngắn) // Triển khai IEquitable.Equals (ngắn)

Loại đầu tiên không phải là trường hợp ở đây vì số lượng đối số là khác nhau, chúng tôi gọi chỉ với một đối số của loại int. Thứ ba cũng được loại bỏ như đã đề cập ở trên chuyển đổi ngầm định của int thành ngắn là không thể. Vì vậy, ở đây Loại thứ hai Equals(object)được gọi là. Các short.Equals(object)là:

bool Equals(object z)
{
  return z is short && (short)z == this;
}

Vì vậy, ở đây điều kiện đã được kiểm tra z is shortlà sai vì z là một int nên nó trả về false.

Dưới đây là bài viết chi tiết từ Eric Lippert