RuntimeHelpers.GetHashCode(Object) RuntimeHelpers.GetHashCode(Object) RuntimeHelpers.GetHashCode(Object) RuntimeHelpers.GetHashCode(Object) Method

Définition

Sert de fonction de hachage pour un objet particulier et convient à une utilisation dans les algorithmes et les structures de données qui utilisent les codes de hachage, comme une table de hachage.Serves as a hash function for a particular object, and is suitable for use in algorithms and data structures that use hash codes, such as a hash table.

public:
 static int GetHashCode(System::Object ^ o);
public static int GetHashCode (object o);
static member GetHashCode : obj -> int
Public Shared Function GetHashCode (o As Object) As Integer

Paramètres

o
Object Object Object Object

Objet pour lequel récupérer le code de hachage.An object to retrieve the hash code for.

Retours

Code de hachage pour l'objet identifié par le paramètre o.A hash code for the object identified by the o parameter.

Exemples

L’exemple suivant illustre la différence entre les Object.GetHashCode méthodes RuntimeHelpers.GetHashCode et.The following example demonstrates the difference between the Object.GetHashCode and RuntimeHelpers.GetHashCode methods. La sortie de l’exemple illustre ce qui suit:The output from the example illustrates the following:

  • Les deux jeux de codes de hachage pour le premier jeu de chaînes passés ShowHashCodes à la méthode sont différents, car les chaînes sont complètement différentes.Both sets of hash codes for the first set of strings passed to the ShowHashCodes method are different, because the strings are completely different.

  • Object.GetHashCodegénère le même code de hachage pour le deuxième jeu de chaînes passé à ShowHashCodes la méthode, car les chaînes sont égales.Object.GetHashCode generates the same hash code for the second set of strings passed to the ShowHashCodes method, because the strings are equal. Toutefois, la RuntimeHelpers.GetHashCode méthode ne le fait pas.However, the RuntimeHelpers.GetHashCode method does not. La première chaîne est définie à l’aide d’un littéral de chaîne et est donc internée.The first string is defined by using a string literal and so is interned. Bien que la valeur de la deuxième chaîne soit la même, elle n’est pas internée, car elle est retournée par un String.Format appel à la méthode.Although the value of the second string is the same, it is not interned, because it is returned by a call to the String.Format method.

  • Dans le cas de la troisième chaîne, les codes de hachage générés par Object.GetHashCode pour les deux chaînes sont identiques, tout comme les codes de hachage générés par. RuntimeHelpers.GetHashCodeIn the case of the third string, the hash codes produced by Object.GetHashCode for both strings are identical, as are the hash codes produced by RuntimeHelpers.GetHashCode. Cela est dû au fait que le compilateur a traité la valeur assignée aux deux chaînes comme un littéral de chaîne unique, de sorte que les variables de chaîne font référence à la même chaîne internée.This is because the compiler has treated the value assigned to both strings as a single string literal, and so the string variables refer to the same interned string.

using System;
using System.Runtime.CompilerServices;

public class Example
{
   public static void Main()
   {
      Console.WriteLine("{0,-18} {1,6} {2,18:N0}    {3,6} {4,18:N0}\n",
                        "", "Var 1", "Hash Code", "Var 2", "Hash Code");
      
      // Get hash codes of two different strings.
      String sc1 = "String #1";
      String sc2 = "String #2";
      ShowHashCodes("sc1", sc1, "sc2", sc2);
 
      // Get hash codes of two identical non-interned strings.
      String s1 = "This string";
      String s2 = String.Format("{0} {1}", "This", "string");
      ShowHashCodes("s1", s1, "s2", s2);

      // Get hash codes of two (evidently concatenated) strings.
      String si1 = "This is a string!";
      String si2 = "This " + "is " + "a " + "string!";
      ShowHashCodes("si1", si1, "si2", si2);
   }

   private static void ShowHashCodes(String var1, Object value1, 
                                     String var2, Object value2)
   {
      Console.WriteLine("{0,-18} {1,6} {2,18:X8}    {3,6} {4,18:X8}",
                        "Obj.GetHashCode", var1, value1.GetHashCode(),
                        var2, value2.GetHashCode());

      Console.WriteLine("{0,-18} {1,6} {2,18:X8}    {3,6} {4,18:X8}\n",
                        "RTH.GetHashCode", var1, RuntimeHelpers.GetHashCode(value1),
                        var2, RuntimeHelpers.GetHashCode(value2));
   }
}
// The example displays output similar to the following:
//                        Var 1          Hash Code     Var 2          Hash Code
//    
//    Obj.GetHashCode       sc1           94EABD27       sc2           94EABD24
//    RTH.GetHashCode       sc1           02BF8098       sc2           00BB8560
//    
//    Obj.GetHashCode        s1           29C5A397        s2           29C5A397
//    RTH.GetHashCode        s1           0297B065        s2           03553390
//    
//    Obj.GetHashCode       si1           941BCEA5       si2           941BCEA5
//    RTH.GetHashCode       si1           01FED012       si2           01FED012
Imports System.Runtime.CompilerServices

Module Example
   Public Sub Main()
      Console.WriteLine("{0,-18} {1,6} {2,18:N0}    {3,6} {4,18:N0}",
                        "", "Var 1", "Hash Code", "Var 2", "Hash Code")
      Console.WriteLine()
      
      ' Get hash codes of two different strings.
      Dim sc1 As String = "String #1"
      Dim sc2 As String = "String #2"
      ShowHashCodes("sc1", sc1, "sc2", sc2)
 
      ' Get hash codes of two identical non-interned strings.
      Dim s1 As String = "This string"
      Dim s2 As String = String.Format("{0} {1}", "This", "string")
      ShowHashCodes("s1", s1, "s2", s2)

      ' Get hash codes of two (evidently concatenated) strings.
      Dim si1 As String = "This is a string!"
      Dim si2 As String = "This " + "is " + "a " + "string!"
      ShowHashCodes("si1", si1, "si2", si2)
   End Sub
   
   Private Sub ShowHashCodes(var1 As String, value1 As Object, 
                             var2 As String, value2 As Object)
      Console.WriteLine("{0,-18} {1,6} {2,18:X8}    {3,6} {4,18:X8}",
                        "Obj.GetHashCode", var1, value1.GetHashCode,
                        var2, value2.GetHashCode)

      Console.WriteLine("{0,-18} {1,6} {2,18:X8}    {3,6} {4,18:X8}",
                        "RTH.GetHashCode", var1, RuntimeHelpers.GetHashCode(value1),
                        var2, RuntimeHelpers.GetHashCode(value2))
      Console.WriteLine()
   End Sub
End Module
' The example displays output similar to the following:
'                        Var 1          Hash Code     Var 2          Hash Code
'    
'    Obj.GetHashCode       sc1           94EABD27       sc2           94EABD24
'    RTH.GetHashCode       sc1           02BF8098       sc2           00BB8560
'    
'    Obj.GetHashCode        s1           29C5A397        s2           29C5A397
'    RTH.GetHashCode        s1           0297B065        s2           03553390
'    
'    Obj.GetHashCode       si1           941BCEA5       si2           941BCEA5
'    RTH.GetHashCode       si1           01FED012       si2           01FED012

Remarques

La RuntimeHelpers.GetHashCode méthode appelle toujours la Object.GetHashCode méthode de manière non virtuelle, même si le type de l’objet a substitué Object.GetHashCode la méthode.The RuntimeHelpers.GetHashCode method always calls the Object.GetHashCode method non-virtually, even if the object's type has overridden the Object.GetHashCode method. Par conséquent, RuntimeHelpers.GetHashCode l’utilisation de peut GetHashCode différer de l’appel direct Object.GetHashCode de l’objet à la méthode.Therefore, using RuntimeHelpers.GetHashCode might differ from calling GetHashCode directly on the object with the Object.GetHashCode method.

Avertissement

Bien que RuntimeHelpers.GetHashCode la méthode retourne des codes de hachage identiques pour les références d’objets identiques, vous ne devez pas utiliser cette méthode pour tester l’identité de l’objet, car ce code de hachage n’identifie pas de façon unique une référence d’objet.Although the RuntimeHelpers.GetHashCode method returns identical hash codes for identical object references, you should not use this method to test for object identity, because this hash code does not uniquely identify an object reference. Pour tester l’identification d’un objet (autrement dit, pour tester que deux objets référencent le même objet en mémoire) Object.ReferenceEquals , appelez la méthode.To test for object identify (that is, to test that two objects reference the same object in memory), call the Object.ReferenceEquals method. Vous ne devez pas GetHashCode non plus utiliser pour tester si deux chaînes représentent des références d’objet égales, car la chaîne est internée.Nor should you use GetHashCode to test whether two strings represent equal object references, because the string is interned. Pour tester l’interning de chaînes, appelez String.IsInterned la méthode.To test for string interning, call the String.IsInterned method.

Les Object.GetHashCode méthodes RuntimeHelpers.GetHashCode et diffèrent comme suit:The Object.GetHashCode and RuntimeHelpers.GetHashCode methods differ as follows:

  • Object.GetHashCoderetourne un code de hachage basé sur la définition d’égalité de l’objet.Object.GetHashCode returns a hash code that is based on the object's definition of equality. Par exemple, deux chaînes avec un contenu identique renverront la même valeur pour Object.GetHashCode.For example, two strings with identical contents will return the same value for Object.GetHashCode.

  • RuntimeHelpers.GetHashCoderetourne un code de hachage qui indique l’identité de l’objet.RuntimeHelpers.GetHashCode returns a hash code that indicates object identity. Autrement dit, deux variables de chaîne dont le contenu est identique et qui représentent une chaîne internée (voir la section interne de chaîne ) ou qui représentent une chaîne unique en mémoire retournent des codes de hachage identiques.That is, two string variables whose contents are identical and that represent a string that is interned (see the String Interning section) or that represent a single string in memory return identical hash codes.

Important

Notez que GetHashCode retourne toujours des codes de hachage identiques pour des références d’objet égales.Note that GetHashCode always returns identical hash codes for equal object references. Toutefois, l’inverse n’est pas vrai: les codes de hachage égaux n’indiquent pas des références d’objet égales.However, the reverse is not true: equal hash codes do not indicate equal object references. Une valeur de code de hachage particulière n’est pas unique à une référence d’objet particulière; différentes références d’objet peuvent générer des codes de hachage identiques.A particular hash code value is not unique to a particular object reference; different object references can generate identical hash codes.

Cette méthode est utilisée par les compilateurs.This method is used by compilers.

Internement des chaînesString Interning

Le common language runtime (CLR) gère un pool interne de chaînes et stocke les littéraux dans le pool.The common language runtime (CLR) maintains an internal pool of strings and stores literals in the pool. Si deux chaînes (par exemple, str1 et str2) sont formées à partir d’un littéral de chaîne identique, str1 le str2 CLR définit et pointe vers le même emplacement sur le tas managé pour économiser de la mémoire.If two strings (for example, str1 and str2) are formed from an identical string literal, the CLR will set str1 and str2 to point to the same location on the managed heap to conserve memory. L' RuntimeHelpers.GetHashCode appel de sur ces deux objets String produira le même code de hachage, contrairement au deuxième élément à puces de la section précédente.Calling RuntimeHelpers.GetHashCode on these two string objects will produce the same hash code, contrary to the second bulleted item in the previous section.

Le CLR ajoute uniquement des littéraux au pool.The CLR adds only literals to the pool. Les résultats des opérations de chaînes telles que la concaténation ne sont pas ajoutés au pool, sauf si le compilateur résout la concaténation de chaînes en tant que littéral de chaîne unique.Results of string operations such as concatenation are not added to the pool, unless the compiler resolves the string concatenation as a single string literal. Par conséquent, str2 si a été créé à la suite d’une opération de concaténation et str2 est str1identique à RuntimeHelpers.GetHashCode , l’utilisation de sur ces deux objets String ne produira pas le même code de hachage.Therefore, if str2 was created as the result of a concatenation operation, and str2 is identical to str1, using RuntimeHelpers.GetHashCode on these two string objects will not produce the same hash code.

Si vous souhaitez ajouter explicitement une chaîne concaténée au pool, utilisez la String.Intern méthode.If you want to add a concatenated string to the pool explicitly, use the String.Intern method.

Vous pouvez également utiliser la String.IsInterned méthode pour vérifier si une chaîne a une référence interne.You can also use the String.IsInterned method to check whether a string has an interned reference.

S’applique à

Voir aussi