RuntimeHelpers.GetHashCode(Object) Methode

Definition

Fungiert als Hashfunktion für ein bestimmtes Objekt und eignet sich für die Verwendung in Hashalgorithmen und Hashdatenstrukturen, die Hashcodes verwenden, z. B. in einer Hashtabelle.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

Parameter

o
Object

Ein Objekt, für das der Hash abgerufen werden soll.An object to retrieve the hash code for.

Gibt zurück

Ein Hashcode für das Objekt , das vom o-Parameter bezeichnet wird.A hash code for the object identified by the o parameter.

Beispiele

Das folgende Beispiel veranschaulicht den Unterschied zwischen Object.GetHashCode der RuntimeHelpers.GetHashCode -Methode und der-Methode.The following example demonstrates the difference between the Object.GetHashCode and RuntimeHelpers.GetHashCode methods. Die Ausgabe des Beispiels veranschaulicht Folgendes:The output from the example illustrates the following:

  • Beide Sätze von Hashcodes für die erste Gruppe von Zeichen folgen, die ShowHashCodes an die-Methode übermittelt werden, unterscheiden sich, da die Zeichen folgen vollständig abweichen.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.GetHashCodegeneriert den gleichen Hashcode für den zweiten Satz von Zeichen folgen, die ShowHashCodes an die-Methode übermittelt werden, da die Zeichen folgen gleich sind.Object.GetHashCode generates the same hash code for the second set of strings passed to the ShowHashCodes method, because the strings are equal. Die RuntimeHelpers.GetHashCode -Methode jedoch nicht.However, the RuntimeHelpers.GetHashCode method does not. Die erste Zeichenfolge wird mithilfe eines Zeichenfolgenliterals definiert und wird daher interniert.The first string is defined by using a string literal and so is interned. Obwohl der Wert der zweiten Zeichenfolge identisch ist, wird er nicht interniert, da er durch einen-Rückruf der String.Format -Methode zurückgegeben wird.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.

  • Im Fall der dritten Zeichenfolge sind die von Object.GetHashCode für beide Zeichen folgen erstellten Hashcodes identisch, ebenso wie die von RuntimeHelpers.GetHashCodeerzeugten Hashcodes.In 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. Dies liegt daran, dass der Compiler den Wert, der beide Zeichen folgen zugewiesen ist, als einzelnes Zeichenfolgenliteralwert behandelt hat, sodass die Zeichen folgen Variablen auf dieselbe Internpool vorhanden Zeichenfolge verweisen.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

Hinweise

Die RuntimeHelpers.GetHashCode -Methode ruft die Object.GetHashCode -Methode immer nicht virtuell auf, auch wenn der Objekttyp die Object.GetHashCode -Methode überschrieben hat.The RuntimeHelpers.GetHashCode method always calls the Object.GetHashCode method non-virtually, even if the object's type has overridden the Object.GetHashCode method. Daher unterscheidet RuntimeHelpers.GetHashCode sich die Verwendung von GetHashCode möglicherweise vom Aufrufen von direkt Object.GetHashCode auf dem-Objekt mit der-Methode.Therefore, using RuntimeHelpers.GetHashCode might differ from calling GetHashCode directly on the object with the Object.GetHashCode method.

Warnung

Obwohl die RuntimeHelpers.GetHashCode -Methode identische Hashcodes für identische Objekt Verweise zurückgibt, sollten Sie diese Methode nicht verwenden, um die Objekt Identität zu testen, da dieser Hashcode einen Objekt Verweis nicht eindeutig identifiziert.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. Um die Objekt Identifizierung zu testen (d. h. zu testen, ob zwei Objekte auf das gleiche Objekt im Arbeitsspeicher Object.ReferenceEquals verweisen), müssen Sie die-Methode aufzurufen.To test for object identify (that is, to test that two objects reference the same object in memory), call the Object.ReferenceEquals method. Sie können auch nicht GetHashCode verwenden, um zu testen, ob zwei Zeichen folgen gleiche Objekt Verweise darstellen, da die Zeichenfolge interniert ist.Nor should you use GetHashCode to test whether two strings represent equal object references, because the string is interned. Um das Interning von Zeichen folgen zu testen String.IsInterned , wird die-Methode aufgerufen.To test for string interning, call the String.IsInterned method.

Die Object.GetHashCode Methoden RuntimeHelpers.GetHashCode und unterscheiden sich wie folgt:The Object.GetHashCode and RuntimeHelpers.GetHashCode methods differ as follows:

  • Object.GetHashCodeGibt einen Hashcode zurück, der auf der Definition der Gleichheit des Objekts basiert.Object.GetHashCode returns a hash code that is based on the object's definition of equality. Beispielsweise wird für zwei Zeichen folgen mit identischem Inhalt der gleiche Wert Object.GetHashCodefür zurückgegeben.For example, two strings with identical contents will return the same value for Object.GetHashCode.

  • RuntimeHelpers.GetHashCodeGibt einen Hashcode zurück, der die Objekt Identität angibt.RuntimeHelpers.GetHashCode returns a hash code that indicates object identity. Das heißt, zwei Zeichen folgen Variablen, deren Inhalt identisch ist und eine Zeichenfolge darstellt (siehe den Abschnitt " Zeichen folgen interning ") oder eine einzelne Zeichenfolge im Arbeitsspeicher darstellen, geben identische Hashcodes zurück.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.

Wichtig

Beachten Sie GetHashCode , dass immer identische Hashcodes für gleiche Objekt Verweise zurückgibt.Note that GetHashCode always returns identical hash codes for equal object references. Umgekehrt ist dies jedoch nicht der Fall: gleiche Hashcodes geben keine gleichen Objekt Verweise an.However, the reverse is not true: equal hash codes do not indicate equal object references. Ein bestimmter Hashcodewert ist nicht eindeutig für einen bestimmten Objekt Verweis. unterschiedliche Objekt Verweise können identische Hashcodes generieren.A particular hash code value is not unique to a particular object reference; different object references can generate identical hash codes.

Diese Methode wird von Compilern verwendet.This method is used by compilers.

Zeichen folgen interningString Interning

Der Common Language Runtime (CLR) verwaltet einen internen Pool von Zeichen folgen und speichert Literale im Pool.The common language runtime (CLR) maintains an internal pool of strings and stores literals in the pool. Wenn zwei Zeichen folgen ( str1 z. b. und str2) aus einem identischen Zeichenfolgenliteralzeichen gebildet werden str2 , legt die CLR und auf den gleichen Speicherort auf dem verwalteten Heap fest str1 , um Speicherplatz zu sparen.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. Wenn RuntimeHelpers.GetHashCode Sie für diese beiden Zeichen folgen Objekte aufrufen, wird derselbe Hashcode erstellt, im Gegensatz zum zweiten Element im vorherigen Abschnitt.Calling RuntimeHelpers.GetHashCode on these two string objects will produce the same hash code, contrary to the second bulleted item in the previous section.

Die CLR fügt dem Pool nur Literale hinzu.The CLR adds only literals to the pool. Ergebnisse von Zeichen folgen Operationen, wie z. b. Verkettung, werden dem Pool nicht hinzugefügt, es sei denn, der Compiler löst die Zeichen folgen Verkettung als einzelnes ZeichenfolgenliteralResults of string operations such as concatenation are not added to the pool, unless the compiler resolves the string concatenation as a single string literal. Wenn str2 daher als Ergebnis eines Verkettungs Vorgangs erstellt wurde und str2 mit identisch str1ist, führt die Verwendung RuntimeHelpers.GetHashCode von für diese beiden Zeichen folgen Objekte nicht zum gleichen Hashcode.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.

Wenn Sie eine verketteten Zeichenfolge explizit zum Pool hinzufügen möchten, verwenden Sie String.Intern die-Methode.If you want to add a concatenated string to the pool explicitly, use the String.Intern method.

Sie können auch die String.IsInterned -Methode verwenden, um zu überprüfen, ob eine Zeichenfolge über einen Internpool vorhanden Verweis verfügt.You can also use the String.IsInterned method to check whether a string has an interned reference.

Gilt für:

Siehe auch