Object.GetHashCode Object.GetHashCode Object.GetHashCode Object.GetHashCode Method

public:
 virtual int GetHashCode();

public virtual int GetHashCode ();

abstract member GetHashCode : unit -> int
override this.GetHashCode : unit -> int

Public Overridable Function GetHashCode () As Integer

Retours

Exemples

Une des manières plus simples pour calculer un code de hachage pour une valeur numérique qui a le même ou une plage plus petite que la Int32 type consiste à simplement retourner cette valeur.One of the simplest ways to compute a hash code for a numeric value that has the same or a smaller range than the Int32 type is to simply return that value. L’exemple suivant montre une telle implémentation pour un Number structure.The following example shows such an implementation for a Number structure.

using System;

public struct Number
{
   private int n;

   public Number(int value)
   {
      n = value;
   }

   public int Value
   {
      get { return n; }
   }
   
   public override bool Equals(Object obj)
   {
      if (obj == null || ! (obj is Number)) 
         return false;
      else
         return n == ((Number) obj).n;
   }      
   
   public override int GetHashCode()
   {
      return n;
   }
   
   public override string ToString()
   {
      return n.ToString();
   }
}

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      for (int ctr = 0; ctr <= 9; ctr++) {
         int randomN = rnd.Next(Int32.MinValue, Int32.MaxValue);
         Number n = new Number(randomN);
         Console.WriteLine("n = {0,12}, hash code = {1,12}", n, n.GetHashCode());
      }   
   }
}
// The example displays output like the following:
//       n =   -634398368, hash code =   -634398368
//       n =   2136747730, hash code =   2136747730
//       n =  -1973417279, hash code =  -1973417279
//       n =   1101478715, hash code =   1101478715
//       n =   2078057429, hash code =   2078057429
//       n =   -334489950, hash code =   -334489950
//       n =    -68958230, hash code =    -68958230
//       n =   -379951485, hash code =   -379951485
//       n =    -31553685, hash code =    -31553685
//       n =   2105429592, hash code =   2105429592

Public Structure Number
   Private n As Integer

   Public Sub New(value As Integer)
      n = value
   End Sub

   Public ReadOnly Property Value As Integer
      Get
         Return n
      End Get
   End Property
   
   Public Overrides Function Equals(obj As Object) As Boolean
      If obj Is Nothing OrElse Not TypeOf obj Is Number Then
         Return False
      Else
         Return n = CType(obj, Number).n
      End If
   End Function      
   
   Public Overrides Function GetHashCode() As Integer
      Return n
   End Function
   
   Public Overrides Function ToString() As String
      Return n.ToString()
   End Function
End Structure

Module Example
   Public Sub Main()
      Dim rnd As New Random()
      For ctr As Integer = 0 To 9
         Dim randomN As Integer = rnd.Next(Int32.MinValue, Int32.MaxValue)
         Dim n As New Number(randomN)
         Console.WriteLine("n = {0,12}, hash code = {1,12}", n, n.GetHashCode())
      Next
   End Sub
End Module
' The example displays output like the following:
'       n =   -634398368, hash code =   -634398368
'       n =   2136747730, hash code =   2136747730
'       n =  -1973417279, hash code =  -1973417279
'       n =   1101478715, hash code =   1101478715
'       n =   2078057429, hash code =   2078057429
'       n =   -334489950, hash code =   -334489950
'       n =    -68958230, hash code =    -68958230
'       n =   -379951485, hash code =   -379951485
'       n =    -31553685, hash code =    -31553685
'       n =   2105429592, hash code =   2105429592

Souvent, un type a plusieurs champs de données qui peuvent participer à la génération du code de hachage.Frequently, a type has multiple data fields that can participate in generating the hash code. Permet de générer un code de hachage consiste à combiner ces champs à l’aide un XOR (eXclusive OR) opération, comme indiqué dans l’exemple suivant.One way to generate a hash code is to combine these fields using an XOR (eXclusive OR) operation, as shown in the following example.

using System;

// A type that represents a 2-D point.
public struct Point
{
    private int x;
    private int y;

    public Point(int x, int y)
    {
       this.x = x;
       this.y = y;
    }
    
    public override bool Equals(Object obj)
    {
       if (! (obj is Point)) return false;
       
       Point p = (Point) obj;
       return x == p.x & y == p.y;
    }
    
    public override int GetHashCode()
    { 
        return x ^ y;
    } 
} 

public class Example
{
   public static void Main()
   {
      Point pt = new Point(5, 8);
      Console.WriteLine(pt.GetHashCode());
        
      pt = new Point(8, 5);
      Console.WriteLine(pt.GetHashCode());
   }
}
// The example displays the following output:
//       13
//       13

' A type that represents a 2-D point.
Public Structure Point
    Private x As Integer
    Private y As Integer

    Public Sub New(x As Integer, y As Integer)
       Me.x = x
       Me.y = y
    End Sub
    
    Public Overrides Function Equals(obj As Object) As Boolean
       If Not TypeOf obj Is Point Then Return False
       
       Dim p As Point = CType(obj, Point)
       Return x = p.x And y = p.y
    End Function
    
    Public Overrides Function GetHashCode() As Integer 
        Return x Xor y
    End Function 
End Structure 

Public Module Example
   Public Sub Main() 
      Dim pt As New Point(5, 8)
      Console.WriteLine(pt.GetHashCode())
        
      pt = New Point(8, 5)
      Console.WriteLine(pt.GetHashCode())
   End Sub 
End Module   

L’exemple précédent retourne le même code de hachage pour (n1, n2) et (n2, n1) et par conséquent, peut générer des collisions que sont souhaitables.The previous example returns the same hash code for (n1, n2) and (n2, n1), and so may generate more collisions than are desirable. Plusieurs solutions sont disponibles afin que les codes de hachage dans ces cas ne sont pas identiques.A number of solutions are available so that hash codes in these cases are not identical. Une consiste à retourner le code de hachage d’un Tuple objet qui reflète l’ordre de chaque champ.One is to return the hash code of a Tuple object that reflects the order of each field. L’exemple suivant montre une implémentation possible qui utilise le Tuple<T1,T2> classe.The following example shows a possible implementation that uses the Tuple<T1,T2> class. Notez, cependant, que la surcharge de performances de l’instanciation d’un Tuple objet peut affecter considérablement les performances globales d’une application qui stocke un grand nombre d’objets dans les tables de hachage.Note, though, that the performance overhead of instantiating a Tuple object may significantly impact the overall performance of an application that stores large numbers of objects in hash tables.

using System;

public struct Point
{
    private int x;
    private int y;

    public Point(int x, int y)
    {
       this.x = x;
       this.y = y;
    }
    
    public override bool Equals(Object obj)
    {
       if (!(obj is Point)) return false;
       
       Point p = (Point) obj;
       return x == p.x & y == p.y;
    }
    
    public override int GetHashCode()
    { 
        return Tuple.Create(x, y).GetHashCode();
    } 
} 

public class Example
{
   public static void Main()
   {
        Point pt = new Point(5, 8);
        Console.WriteLine(pt.GetHashCode());
        
        pt = new Point(8, 5);
        Console.WriteLine(pt.GetHashCode());
   }
}
// The example displays the following output:
//       173
//       269

Public Structure Point
    Private x As Integer
    Private y As Integer

    Public Sub New(x As Integer, y As Integer)
       Me.x = x
       Me.y = y
    End Sub
    
    Public Overrides Function Equals(obj As Object) As Boolean
       If Not TypeOf obj Is Point Then Return False
       
       Dim p As Point = CType(obj, Point)
       Return x = p.x And y = p.y
    End Function
    
    Public Overrides Function GetHashCode() As Integer 
        Return Tuple.Create(x, y).GetHashCode()
    End Function 
End Structure 

Public Module Example
    Public Sub Main() 
        Dim pt As New Point(5, 8)
        Console.WriteLine(pt.GetHashCode())
        
        pt = New Point(8, 5)
        Console.WriteLine(pt.GetHashCode())
    End Sub 
End Module         
' The example displays the following output:
'       173
'       269

Une autre solution de remplacement implique les codes de hachage individuels de pondération en décalant les codes de hachage des champs successives à gauche par deux ou plusieurs bits.A second alternative solution involves weighting the individual hash codes by left-shifting the hash codes of successive fields by two or more bits. Idéalement, au lieu d’être ignorés, les bits décalés au-delà de bit 31 doivent habiller plutôt qu’ignorées.Optimally, instead of being discarded, bits shifted beyond bit 31 should wrap around rather than be discarded. Étant donné que les bits sont ignorés par les opérateurs de décalage vers la gauche en c# et Visual Basic, cela requiert la création d’une méthode MAJ-wrap gauche comme suit :Since bits are discarded by the left-shift operators in both C# and Visual Basic, this requires creating a left shift-and-wrap method like the following:

public int ShiftAndWrap(int value, int positions)
{
    positions = positions & 0x1F;
  
    // Save the existing bit pattern, but interpret it as an unsigned integer.
    uint number = BitConverter.ToUInt32(BitConverter.GetBytes(value), 0);
    // Preserve the bits to be discarded.
    uint wrapped = number >> (32 - positions);
    // Shift and wrap the discarded bits.
    return BitConverter.ToInt32(BitConverter.GetBytes((number << positions) | wrapped), 0);
}

Public Function ShiftAndWrap(value As Integer, positions As Integer) As Integer
   positions = positions And &h1F
   
   ' Save the existing bit pattern, but interpret it as an unsigned integer.
   Dim number As UInteger = BitConverter.ToUInt32(BitConverter.GetBytes(value), 0)
   ' Preserve the bits to be discarded.
   Dim wrapped AS UInteger = number >> (32 - positions)
   ' Shift and wrap the discarded bits.
   Return BitConverter.ToInt32(BitConverter.GetBytes((number << positions) Or wrapped), 0)
End Function

L’exemple suivant utilise ensuite cette méthode MAJ-wrap pour calculer le code de hachage de la Point structure utilisée dans les exemples précédents.The following example then uses this shift-and-wrap method to compute the hash code of the Point structure used in the previous examples.

using System;

public struct Point
{
    private int x;
    private int y;

    public Point(int x, int y)
    {
       this.x = x;
       this.y = y;
    }
    
    public override bool Equals(Object obj)
    {
       if (!(obj is Point)) return false;
       
       Point p = (Point) obj;
       return x == p.x & y == p.y;
    }
    
    public override int GetHashCode()
    { 
        return ShiftAndWrap(x.GetHashCode(), 2) ^ y.GetHashCode();
    } 
    
    private int ShiftAndWrap(int value, int positions)
    {
        positions = positions & 0x1F;
      
        // Save the existing bit pattern, but interpret it as an unsigned integer.
        uint number = BitConverter.ToUInt32(BitConverter.GetBytes(value), 0);
        // Preserve the bits to be discarded.
        uint wrapped = number >> (32 - positions);
        // Shift and wrap the discarded bits.
        return BitConverter.ToInt32(BitConverter.GetBytes((number << positions) | wrapped), 0);
    }
} 

public class Example
{
   public static void Main()
   {
        Point pt = new Point(5, 8);
        Console.WriteLine(pt.GetHashCode());
        
        pt = new Point(8, 5);
        Console.WriteLine(pt.GetHashCode());
   }
}
// The example displays the following output:
//       28
//       37 

Public Structure Point
    Private x As Integer
    Private y As Integer

    Public Sub New(x As Integer, y As Integer)
       Me.x = x
       Me.y = y
    End Sub
    
    Public Overrides Function Equals(obj As Object) As Boolean
       If Not TypeOf obj Is Point Then Return False
       
       Dim p As Point = CType(obj, Point)
       Return x = p.x And y = p.y
    End Function
    
    Public Overrides Function GetHashCode() As Integer 
        Return ShiftAndWrap(x.GetHashCode(), 2) XOr y.GetHashCode()
    End Function 
    
    Private Function ShiftAndWrap(value As Integer, positions As Integer) As Integer
        positions = positions And &h1F
      
        ' Save the existing bit pattern, but interpret it as an unsigned integer.
        Dim number As UInteger = BitConverter.ToUInt32(BitConverter.GetBytes(value), 0)
        ' Preserve the bits to be discarded.
        Dim wrapped AS UInteger = number >> (32 - positions)
        ' Shift and wrap the discarded bits.
        Return BitConverter.ToInt32(BitConverter.GetBytes((number << positions) Or wrapped), 0)
    End Function
End Structure 

Module Example
   Public Sub Main()
        Dim pt As New Point(5, 8)
        Console.WriteLine(pt.GetHashCode())
        
        pt = New Point(8, 5)
        Console.WriteLine(pt.GetHashCode())
   End Sub
End Module
' The example displays the following output:
'       28
'       37

Remarques

Un code de hachage est une valeur numérique qui est utilisée pour insérer et identifier un objet dans une collection basée sur le hachage comme le Dictionary<TKey,TValue> (classe), le Hashtable classe ou un type dérivé la DictionaryBase classe.A hash code is a numeric value that is used to insert and identify an object in a hash-based collection such as the Dictionary<TKey,TValue> class, the Hashtable class, or a type derived from the DictionaryBase class. Le GetHashCode méthode fournit ce code de hachage pour les algorithmes nécessitant des contrôles rapides de l’égalité d’objet.The GetHashCode method provides this hash code for algorithms that need quick checks of object equality.

Deux objets qui sont des codes de hachage de retour égale sont égaux.Two objects that are equal return hash codes that are equal. Toutefois, l’inverse n’est pas vrai : codes de hachage égales n’impliquent pas de l’égalité d’objet, car différents objets (inégaux) peuvent avoir des codes de hachage identiques.However, the reverse is not true: equal hash codes do not imply object equality, because different (unequal) objects can have identical hash codes. En outre, .NET ne garantit pas l’implémentation par défaut de la GetHashCode méthode et la valeur de cette méthode est retournée peut varier entre les implémentations de .NET, telles que les différentes versions de .NET Framework et .NET Core et les plateformes, telles que 32 bits et plateformes 64 bits.Furthermore, .NET does not guarantee the default implementation of the GetHashCode method, and the value this method returns may differ between .NET implementations, such as different versions of .NET Framework and .NET Core, and platforms, such as 32-bit and 64-bit platforms. Pour ces raisons, n’utilisez pas l’implémentation par défaut de cette méthode comme un identificateur d’objet unique à des fins hachage.For these reasons, do not use the default implementation of this method as a unique object identifier for hashing purposes. Suivent les deux conséquences de cela :Two consequences follow from this:

• Vous ne devez pas supposer que les codes de hachage égales impliquent l’égalité d’objet.You should not assume that equal hash codes imply object equality.

• Vous ne devez jamais conserver ou utiliser un code de hachage en dehors du domaine d’application dans lequel il a été créé, car le même objet peuvent être hachées sur les plateformes, processus et domaines d’application.You should never persist or use a hash code outside the application domain in which it was created, because the same object may hash across application domains, processes, and platforms.

Le GetHashCode méthode peut être substituée par un type dérivé.The GetHashCode method can be overridden by a derived type. Si GetHashCode est ne pas substituée, codes de hachage pour les types référence sont calculées en appelant le Object.GetHashCode méthode de la classe de base, qui calcule un code de hachage basée sur la référence d’un objet ; pour plus d’informations, consultez RuntimeHelpers.GetHashCode.If GetHashCode is not overridden, hash codes for reference types are computed by calling the Object.GetHashCode method of the base class, which computes a hash code based on an object's reference; for more information, see RuntimeHelpers.GetHashCode. En d’autres termes, deux objets pour lesquels le ReferenceEquals méthode retourne true ont des codes de hachage identiques.In other words, two objects for which the ReferenceEquals method returns true have identical hash codes. Si les types valeur ne substituent pas GetHashCode, le ValueType.GetHashCode méthode de la classe de base utilise la réflexion pour calculer le code de hachage basé sur les valeurs des champs du type.If value types do not override GetHashCode, the ValueType.GetHashCode method of the base class uses reflection to compute the hash code based on the values of the type's fields. En d’autres termes, les types de valeur dont les champs ont des valeurs égales ont des codes de hachage égales.In other words, value types whose fields have equal values have equal hash codes. Pour plus d’informations sur la substitution de GetHashCode, consultez la section « Remarques à l’attention des héritiers ».For more information about overriding GetHashCode, see the "Notes to Inheritors" section.

Si un objet qui est utilisé en tant que clé dans une table de hachage ne fournit pas une implémentation utile de GetHashCode, vous pouvez spécifier un fournisseur de code de hachage en fournissant un IEqualityComparer implémentation à une des surcharges de la Hashtable constructeur de classe.If an object that is used as a key in a hash table does not provide a useful implementation of GetHashCode, you can specify a hash code provider by supplying an IEqualityComparer implementation to one of the overloads of the Hashtable class constructor.

Notes pour le Windows RuntimeWindows RuntimeNotes for the Windows RuntimeWindows Runtime

Lorsque vous appelez le GetHashCode méthode sur une classe dans le Windows RuntimeWindows Runtime, il fournit le comportement par défaut pour les classes qui ne remplacent pas GetHashCode.When you call the GetHashCode method on a class in the Windows RuntimeWindows Runtime, it provides the default behavior for classes that don't override GetHashCode. Cela fait partie de la prise en charge le .NET Framework fournit pour la Windows RuntimeWindows Runtime (consultez applications .NET Framework prend en charge pour Windows Store et Windows Runtime).This is part of the support that the .NET Framework provides for the Windows RuntimeWindows Runtime (see .NET Framework Support for Windows Store Apps and Windows Runtime). Classes dans le Windows RuntimeWindows Runtime n’héritent pas Objectet n’implémentent pas actuellement un GetHashCode.Classes in the Windows RuntimeWindows Runtime don't inherit Object, and currently don't implement a GetHashCode. Toutefois, ils semblent avoir ToString, Equals(Object), et GetHashCode méthodes lorsque vous les utilisez dans votre code c# ou Visual Basic et le .NET Framework fournit le comportement par défaut pour ces méthodes.However, they appear to have ToString, Equals(Object), and GetHashCode methods when you use them in your C# or Visual Basic code, and the .NET Framework provides the default behavior for these methods.

Notes pour les héritiers

Une fonction de hachage est utilisée pour générer rapidement un nombre (code de hachage) qui correspond à la valeur d’un objet.A hash function is used to quickly generate a number (hash code) that corresponds to the value of an object. Fonctions de hachage sont généralement spécifiques à chaque type et, pour l’unicité, doivent utiliser au moins un des champs d’instance en tant qu’entrée.Hash functions are usually specific to each type and, for uniqueness, must use at least one of the instance fields as input. Codes de hachage ne doivent pas être calculées en utilisant les valeurs des champs statiques.Hash codes should not be computed by using the values of static fields.

Pour les classes dérivées à partir de Object, le GetHashCode méthode permettre déléguer à la classe de base GetHashCode() implémentation uniquement si la classe dérivée définit l’égalité à une égalité de référence.For classes derived from Object, the GetHashCode method can delegate to the base class GetHashCode() implementation only if the derived class defines equality to be reference equality. L’implémentation par défaut de GetHashCode() pour référence types retourne un code de hachage qui est équivalent à celui retourné par la GetHashCode(Object) (méthode).The default implementation of GetHashCode() for reference types returns a hash code that is equivalent to the one returned by the GetHashCode(Object) method. Vous pouvez remplacer GetHashCode() pour les types référence immuable.You can override GetHashCode() for immutable reference types. En règle générale, pour les types référence mutables, vous devez substituer GetHashCode() uniquement si :In general, for mutable reference types, you should override GetHashCode() only if: -Vous pouvez calculer le code de hachage à partir des champs qui ne sont pas mutables ; ou- You can compute the hash code from fields that are not mutable; or -Vous pouvez vous assurer que le code de hachage d’un objet mutable ne change pas pendant que l’objet est contenu dans une collection qui s’appuie sur son code de hachage.- You can ensure that the hash code of a mutable object does not change while the object is contained in a collection that relies on its hash code.

Sinon, vous pourriez penser que l’objet mutable est perdue au cours de la table de hachage.Otherwise, you might think that the mutable object is lost in the hash table. Si vous choisissez de remplacer GetHashCode() pour un type référence mutable, la documentation doit indiquer clairement que les utilisateurs de votre type ne devraient pas modifier les valeurs d’objet tandis que l’objet est stocké dans une table de hachage.If you do choose to override GetHashCode() for a mutable reference type, your documentation should make it clear that users of your type should not modify object values while the object is stored in a hash table.

Pour les types valeur, GetHashCode() fournit une implémentation de code de hachage par défaut qui utilise la réflexion.For value types, GetHashCode() provides a default hash code implementation that uses reflection. Vous devez envisager de substitution pour de meilleures performances.You should consider overriding it for better performance.

Pour plus d’informations et des exemples de codes de hachage de plusieurs façons de calcul, consultez la section Exemples.For more information and examples that compute hash codes in a variety of ways, see the Examples section.

Une fonction de hachage doit avoir les propriétés suivantes :A hash function must have the following properties: -Si deux objets sont considérés comme égaux, la GetHashCode() méthode pour chaque objet doit retourner la même valeur.- If two objects compare as equal, the GetHashCode() method for each object must return the same value. Toutefois, si deux objets ne sont pas considérés comme égaux, la GetHashCode() méthodes pour les deux objets n’ont pas à retourner des valeurs différentes.However, if two objects do not compare as equal, the GetHashCode() methods for the two objects do not have to return different values.

-Le GetHashCode() méthode pour un objet doit constamment retourner le même code de hachage tant qu’il n’existe aucune modification de l’état de l’objet qui détermine la valeur de retour de l’objet System.Object.Equals (méthode).- The GetHashCode() method for an object must consistently return the same hash code as long as there is no modification to the object state that determines the return value of the object's System.Object.Equals method. Notez que cela est vrai uniquement pour l’exécution en cours d’une application, et qu’un code de hachage différent peut être retourné si l’application est exécutée à nouveau.Note that this is true only for the current execution of an application, and that a different hash code can be returned if the application is run again.

-Pour des performances optimales, une fonction de hachage doit générer une distribution uniforme pour toutes les entrées, y compris les entrées qui sont largement mis en cluster.- For the best performance, a hash function should generate an even distribution for all input, including input that is heavily clustered. Une conséquence est que les petites modifications à l’état de l’objet doivent entraîner de modifications importantes apportées au code de hachage qui en résulte pour de meilleures performances de table de hachage.An implication is that small modifications to object state should result in large modifications to the resulting hash code for best hash table performance.

-Fonctions de hachage doivent être peu coûteuses à calculer.- Hash functions should be inexpensive to compute.

-Le GetHashCode() méthode lever d’exceptions.- The GetHashCode() method should not throw exceptions.

Par exemple, l’implémentation de la GetHashCode() méthode fournie par le String classe retourne des codes de hachage identiques pour les valeurs de chaîne identiques.For example, the implementation of the GetHashCode() method provided by the String class returns identical hash codes for identical string values. Par conséquent, deux String objets retournent le même code de hachage si elles représentent la même valeur de chaîne.Therefore, two String objects return the same hash code if they represent the same string value. En outre, la méthode utilise tous les caractères dans la chaîne pour générer la sortie distribuée de manière raisonnablement aléatoire, même lorsque l’entrée est ordonnée en clusters dans certaines plages (par exemple, les nombreux utilisateurs peuvent posséder des chaînes qui contiennent uniquement les 128 caractères ASCII inférieurs, même si un chaîne peut contenir les caractères Unicode 65 535).Also, the method uses all the characters in the string to generate reasonably randomly distributed output, even when the input is clustered in certain ranges (for example, many users might have strings that contain only the lower 128 ASCII characters, even though a string can contain any of the 65,535 Unicode characters).

En fournissant une bonne fonction de hachage sur une classe peut affecter considérablement les performances de l’ajout de ces objets à une table de hachage.Providing a good hash function on a class can significantly affect the performance of adding those objects to a hash table. Dans une table de hachage avec des clés qui fournissent une implémentation correcte d’une fonction de hachage, la recherche d’un élément prend un temps constant (par exemple, il s’agit d’une opération o (1)).In a hash table with keys that provide a good implementation of a hash function, searching for an element takes constant time (for example, an O(1) operation). Dans une table de hachage avec une mauvaise implémentation d’une fonction de hachage, les performances d’une recherche varie selon le nombre d’éléments dans la table de hachage (par exemple, un O (n) opération, où n est le nombre d’éléments dans la table de hachage).In a hash table with a poor implementation of a hash function, the performance of a search depends on the number of items in the hash table (for example, an O(n) operation, where n is the number of items in the hash table). Un utilisateur malveillant peut entrer des données qui augmente le nombre de collisions, ce qui peut dégrader considérablement les performances des applications qui dépendent des tables de hachage, dans les conditions suivantes :A malicious user can input data that increases the number of collisions, which can significantly degrade the performance of applications that depend on hash tables, under the following conditions: -Lorsque les fonctions de hachage produisent des collisions fréquentes.- When hash functions produce frequent collisions.

-Lorsque une proportion importante des objets dans une table de hachage à générer des codes de hachage qui sont égales ou approximativement égal à l’autre.- When a large proportion of objects in a hash table produce hash codes that are equal or approximately equal to one another.

-Lorsque les utilisateurs d’entrée les données à partir de laquelle le code de hachage est calculé.- When users input the data from which the hash code is computed.

Classes dérivées qui substituent GetHashCode() doivent également substituer Equals(Object) afin de garantir que les deux objets sont considérés comme égaux ont le même code de hachage ; sinon, le Hashtable type peuvent ne pas fonctionne correctement.Derived classes that override GetHashCode() must also override Equals(Object) to guarantee that two objects considered equal have the same hash code; otherwise, the Hashtable type might not work correctly.

S’applique à

Voir aussi

• Hashtable
• Equals(Object) Equals(Object) Equals(Object) Equals(Object)
• GetHashCode(Object)