IEqualityComparer<T> Interface


같음에 대해 개체 비교를 지원하는 메서드를 정의합니다.Defines methods to support the comparison of objects for equality.

generic <typename T>
public interface class IEqualityComparer
public interface IEqualityComparer<in T>
public interface IEqualityComparer<T>
type IEqualityComparer<'T> = interface
Public Interface IEqualityComparer(Of In T)
Public Interface IEqualityComparer(Of T)

Type Parameters


비교할 개체의 형식입니다.The type of objects to compare.

This type parameter is contravariant. That is, you can use either the type you specified or any type that is less derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics.


다음 예제에서는 사용자 지정 Box 개체를 사전 컬렉션에 추가 합니다.The following example adds custom Box objects to a dictionary collection. Box 개체는 해당 차원이 동일한 경우 같은 것으로 간주 됩니다.The Box objects are considered equal if their dimensions are the same.

using System;
using System.Collections.Generic;

class Example
   static void Main()
      BoxEqualityComparer boxEqC = new BoxEqualityComparer();

      var boxes = new Dictionary<Box, string>(boxEqC);

      var redBox = new Box(4, 3, 4);
      AddBox(boxes, redBox, "red");

      var blueBox = new Box(4, 3, 4);
      AddBox(boxes, blueBox, "blue");

      var greenBox = new Box(3, 4, 3);
      AddBox(boxes, greenBox, "green");

      Console.WriteLine("The dictionary contains {0} Box objects.",

   private static void AddBox(Dictionary<Box, String> dict, Box box, String name)
      try {
         dict.Add(box, name);
      catch (ArgumentException e) {
         Console.WriteLine("Unable to add {0}: {1}", box, e.Message);

public class Box
    public Box(int h,  int l, int w)
        this.Height = h;
        this.Length = l;
        this.Width = w;

    public int Height { get; set; }
    public int Length { get; set; }
    public int Width { get; set; }

    public override String ToString()
       return String.Format("({0}, {1}, {2})", Height, Length, Width);

class BoxEqualityComparer : IEqualityComparer<Box>
    public bool Equals(Box b1, Box b2)
        if (b2 == null && b1 == null)
           return true;
        else if (b1 == null || b2 == null)
           return false;
        else if(b1.Height == b2.Height && b1.Length == b2.Length
                            && b1.Width == b2.Width)
            return true;
            return false;

    public int GetHashCode(Box bx)
        int hCode = bx.Height ^ bx.Length ^ bx.Width;
        return hCode.GetHashCode();
// The example displays the following output:
//    Unable to add (4, 3, 4): An item with the same key has already been added.
//    The dictionary contains 2 Box objects.
Imports System.Collections.Generic

Module Example
   Public Sub Main()

      Dim boxEqC As New BoxEqualityComparer()

      Dim boxes As New Dictionary(Of Box, String)(boxEqC)

      Dim redBox = New Box(4, 3, 4)
      AddBox(boxes, redBox, "red")

      Dim blueBox = new Box(4, 3, 4)
      AddBox(boxes, blueBox, "blue")

      Dim greenBox = new Box(3, 4, 3)
      AddBox(boxes, greenBox, "green")

      Console.WriteLine("The dictionary contains {0} Box objects.",
   End Sub

   Private Sub AddBox(dict As Dictionary(Of Box, String), box As Box, name As String)
         dict.Add(box, name)
      Catch e As ArgumentException
         Console.WriteLine("Unable to add {0}: {1}", box, e.Message)
      End Try
   End Sub
End Module

Public Class Box
    Private _Height As Integer
    Private _Length As Integer
    Private _Width As Integer

    Public Sub New(ByVal h As Integer, ByVal l As Integer,
                                        ByVal w As Integer)
        Me.Height = h
        Me.Length = l
        Me.Width = w
    End Sub

    Public Property Height() As Integer
            Return _Height
        End Get
        Set(ByVal value As Integer)
            _Height = value
        End Set
    End Property

    Public Property Length() As Integer
            Return _Length
        End Get
        Set(ByVal value As Integer)
            _Length = value
        End Set
    End Property

    Public Property Width() As Integer
            Return _Width
        End Get
        Set(ByVal value As Integer)
            _Width = value
        End Set
    End Property

    Public Overrides Function ToString() As String
       Return String.Format("({0}, {1}, {2})", _Height, _Length, _Width)
    End Function
End Class

Class BoxEqualityComparer
    Implements IEqualityComparer(Of Box)

    Public Overloads Function Equals(ByVal b1 As Box, ByVal b2 As Box) _
                   As Boolean Implements IEqualityComparer(Of Box).Equals

        If b1 Is Nothing AndAlso b2 Is Nothing Then
            Return True
        ElseIf b1 Is Nothing Or b2 Is Nothing Then
            Return False
        ElseIf b1.Height = b2.Height AndAlso b1.Length =
                b2.Length AndAlso b1.Width = b2.Width Then
            Return True
            Return False
        End If
    End Function

    Public Overloads Function GetHashCode(ByVal bx As Box) _
                As Integer Implements IEqualityComparer(Of Box).GetHashCode
        Dim hCode As Integer = bx.Height Xor bx.Length Xor bx.Width
        Return hCode.GetHashCode()
    End Function

End Class
' The example displays the following output:
'    Unable to add (4, 3, 4): An item with the same key has already been added.
'    The dictionary contains 2 Box objects.


이 인터페이스는 컬렉션에 대 한 사용자 지정 된 같음 비교를 구현할을 수 있습니다.This interface allows the implementation of customized equality comparison for collections. 즉, T형식에 대 한 고유한 같음 정의를 만들고 IEqualityComparer<T> 제네릭 인터페이스를 허용 하는 컬렉션 형식에이 정의를 사용 하도록 지정할 수 있습니다.That is, you can create your own definition of equality for type T, and specify that this definition be used with a collection type that accepts the IEqualityComparer<T> generic interface. .NET Framework에서 Dictionary<TKey,TValue> 제네릭 컬렉션 형식의 생성자는이 인터페이스를 허용 합니다.In the .NET Framework, constructors of the Dictionary<TKey,TValue> generic collection type accept this interface.

이 인터페이스의 기본 구현은 EqualityComparer<T> 제네릭 클래스의 Default 속성에서 제공 됩니다.A default implementation of this interface is provided by the Default property of the EqualityComparer<T> generic class. StringComparer 클래스는 String형식의 IEqualityComparer<T>을 구현 합니다.The StringComparer class implements IEqualityComparer<T> of type String.

이 인터페이스는 같음 비교만 지원합니다.This interface supports only equality comparisons. 정렬 및 정렬에 대 한 비교의 사용자 지정은 IComparer<T> 제네릭 인터페이스에 의해 제공 됩니다.Customization of comparisons for sorting and ordering is provided by the IComparer<T> generic interface.

EqualityComparer<T> 클래스가 Object.Equals 메서드 대신 IEquatable<T>.Equals 메서드를 사용 하 여 같은지 테스트 하므로 IEqualityComparer<T> 인터페이스를 구현 하는 대신 EqualityComparer<T> 클래스에서 파생 하는 것이 좋습니다.We recommend that you derive from the EqualityComparer<T> class instead of implementing the IEqualityComparer<T> interface, because the EqualityComparer<T> class tests for equality using the IEquatable<T>.Equals method instead of the Object.Equals method. 이는 Dictionary<TKey,TValue> 클래스 및 기타 제네릭 컬렉션의 Contains, IndexOf, LastIndexOfRemove 메서드와 일치 합니다.This is consistent with the Contains, IndexOf, LastIndexOf, and Remove methods of the Dictionary<TKey,TValue> class and other generic collections.


Equals(T, T)

지정한 개체가 같은지 여부를 확인합니다.Determines whether the specified objects are equal.


지정한 개체의 해시 코드를 반환합니다.Returns a hash code for the specified object.

Applies to

See also