RuntimeHelpers.GetHashCode(Object) Metodo

Definizione

Viene utilizzato come funzione hash per un oggetto particolare ed è adatto per l'utilizzo in algoritmi e in strutture di dati che utilizzano i codici hash, quali una tabella hash.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

Parametri

o
Object

Oggetto per cui recuperare il codice hash.An object to retrieve the hash code for.

Restituisce

Int32

Codice hash per l'oggetto identificato dal parametro o.A hash code for the object identified by the o parameter.

Esempio

Nell'esempio seguente viene illustrata la differenza tra i metodi Object.GetHashCode e RuntimeHelpers.GetHashCode.The following example demonstrates the difference between the Object.GetHashCode and RuntimeHelpers.GetHashCode methods. Nell'output dell'esempio vengono illustrate le operazioni seguenti:The output from the example illustrates the following:

  • Entrambi i set di codici hash per il primo set di stringhe passato al metodo ShowHashCodes sono diversi, perché le stringhe sono completamente diverse.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.GetHashCode genera lo stesso codice hash per il secondo set di stringhe passato al metodo ShowHashCodes, perché le stringhe sono uguali.Object.GetHashCode generates the same hash code for the second set of strings passed to the ShowHashCodes method, because the strings are equal. Tuttavia, il metodo RuntimeHelpers.GetHashCode non lo è.However, the RuntimeHelpers.GetHashCode method does not. La prima stringa viene definita usando un valore letterale stringa ed è quindi internamente.The first string is defined by using a string literal and so is interned. Sebbene il valore della seconda stringa sia lo stesso, non viene internato, perché viene restituito da una chiamata al metodo String.Format.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.

  • Nel caso della terza stringa, i codici hash prodotti da Object.GetHashCode per entrambe le stringhe sono identici, così come i codici hash prodotti da RuntimeHelpers.GetHashCode.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. Questo perché il compilatore ha gestito il valore assegnato a entrambe le stringhe come valore letterale stringa singola, quindi le variabili di stringa fanno riferimento alla stessa stringa interna.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

Commenti

Il metodo RuntimeHelpers.GetHashCode chiama sempre il metodo di Object.GetHashCode non virtualmente, anche se il tipo dell'oggetto ha eseguito l'override del Object.GetHashCode metodo.The RuntimeHelpers.GetHashCode method always calls the Object.GetHashCode method non-virtually, even if the object's type has overridden the Object.GetHashCode method. Pertanto, l'utilizzo di RuntimeHelpers.GetHashCode potrebbe differire dalla chiamata di GetHashCode direttamente nell'oggetto con il Object.GetHashCode metodo.Therefore, using RuntimeHelpers.GetHashCode might differ from calling GetHashCode directly on the object with the Object.GetHashCode method.

Avviso

Anche se il metodo RuntimeHelpers.GetHashCode restituisce codici hash identici per i riferimenti a oggetti identici, è consigliabile non usare questo metodo per verificare l'identità dell'oggetto, perché questo codice hash non identifica in modo univoco un riferimento a un oggetto.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. Per verificare l'identificazione dell'oggetto, ovvero per verificare che due oggetti facciano riferimento allo stesso oggetto in memoria, chiamare il metodo Object.ReferenceEquals.To test for object identify (that is, to test that two objects reference the same object in memory), call the Object.ReferenceEquals method. Né usare GetHashCode per verificare se due stringhe rappresentano riferimenti a oggetti uguali, perché la stringa è interna.Nor should you use GetHashCode to test whether two strings represent equal object references, because the string is interned. Per verificare la centralizzazione delle stringhe, chiamare il metodo String.IsInterned.To test for string interning, call the String.IsInterned method.

I metodi Object.GetHashCode e RuntimeHelpers.GetHashCode si differenziano nel modo seguente:The Object.GetHashCode and RuntimeHelpers.GetHashCode methods differ as follows:

  • Object.GetHashCode restituisce un codice hash basato sulla definizione di uguaglianza dell'oggetto.Object.GetHashCode returns a hash code that is based on the object's definition of equality. Ad esempio, due stringhe con contenuto identico restituiranno lo stesso valore per Object.GetHashCode.For example, two strings with identical contents will return the same value for Object.GetHashCode.

  • RuntimeHelpers.GetHashCode restituisce un codice hash che indica l'identità dell'oggetto.RuntimeHelpers.GetHashCode returns a hash code that indicates object identity. Ovvero due variabili di stringa il cui contenuto è identico e che rappresentano una stringa interna (vedere la sezione di centralizzazione delle stringhe ) o che rappresentano una singola stringa in memoria che restituisce codici hash identici.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.

Importante

Si noti che GetHashCode restituisce sempre codici hash identici per i riferimenti a oggetti uguali.Note that GetHashCode always returns identical hash codes for equal object references. Tuttavia, il contrario non è vero: i codici hash uguali non indicano i riferimenti agli oggetti uguali.However, the reverse is not true: equal hash codes do not indicate equal object references. Un particolare valore del codice hash non è univoco per un riferimento a un oggetto specifico; riferimenti a oggetti diversi possono generare codici hash identici.A particular hash code value is not unique to a particular object reference; different object references can generate identical hash codes.

Questo metodo viene utilizzato dai compilatori.This method is used by compilers.

Centralizzazione delle stringheString Interning

Il Common Language Runtime (CLR) mantiene un pool interno di stringhe e archivia i valori letterali nel pool.The common language runtime (CLR) maintains an internal pool of strings and stores literals in the pool. Se due stringhe, ad esempio str1 e str2, vengono create da un valore letterale stringa identico, il CLR imposterà str1 e str2 in modo che puntino alla stessa posizione nell'heap gestito per conservare la memoria.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. La chiamata di RuntimeHelpers.GetHashCode su questi due oggetti stringa produrrà lo stesso codice hash, contrariamente al secondo elemento puntato nella sezione precedente.Calling RuntimeHelpers.GetHashCode on these two string objects will produce the same hash code, contrary to the second bulleted item in the previous section.

CLR aggiunge solo valori letterali al pool.The CLR adds only literals to the pool. I risultati delle operazioni di stringa come la concatenazione non vengono aggiunti al pool, a meno che il compilatore non risolva la concatenazione di stringhe come valore letterale stringa singola.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. Se pertanto str2 è stato creato come risultato di un'operazione di concatenazione e str2 è identico a str1, l'utilizzo di RuntimeHelpers.GetHashCode su questi due oggetti stringa non produrrà lo stesso codice hash.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.

Se si desidera aggiungere in modo esplicito una stringa concatenata al pool, utilizzare il metodo String.Intern.If you want to add a concatenated string to the pool explicitly, use the String.Intern method.

È anche possibile usare il metodo String.IsInterned per verificare se una stringa contiene un riferimento centralizzato.You can also use the String.IsInterned method to check whether a string has an interned reference.

Si applica a

Vedi anche