# Object.GetHashCodeObject.GetHashCodeObject.GetHashCodeObject.GetHashCode Method

## Definición

Sirve como la función hash predeterminada.Serves as the default hash function.

``````public:
virtual int GetHashCode();``````
``public virtual int GetHashCode ();``
``````abstract member GetHashCode : unit -> int
override this.GetHashCode : unit -> int``````
``Public Overridable Function GetHashCode () As Integer``

#### Devoluciones

Código hash para el objeto actual.A hash code for the current object.

## Ejemplos

Una de las maneras más sencillas para calcular un código hash para un valor numérico que tiene el mismo o un intervalo más pequeño que el Int32 tipo es simplemente devolver ese valor.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. El ejemplo siguiente muestra este tipo de implementación para un `Number` estructura.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
``````

Con frecuencia, un tipo tiene varios campos de datos que pueden participar en la generación de código hash.Frequently, a type has multiple data fields that can participate in generating the hash code. Una manera de generar un código hash consiste en combinar estos campos utilizando un `XOR (eXclusive OR)` operación, como se muestra en el ejemplo siguiente.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
``````

El ejemplo anterior devuelve el mismo código hash de (n1, n2) y (n2 n1) por lo que puede generar más colisiones que son deseables.The previous example returns the same hash code for (n1, n2) and (n2, n1), and so may generate more collisions than are desirable. Una serie de soluciones está disponible para que los códigos hash en estos casos no son idénticos.A number of solutions are available so that hash codes in these cases are not identical. Una consiste en devolver el código hash de un `Tuple` objeto que refleja el orden de cada campo.One is to return the hash code of a `Tuple` object that reflects the order of each field. El ejemplo siguiente muestra una posible implementación que usa el Tuple<T1,T2> clase.The following example shows a possible implementation that uses the Tuple<T1,T2> class. Sin embargo, tenga en cuenta que la sobrecarga de rendimiento de crear instancias de un `Tuple` objeto puede afectar significativamente al rendimiento general de una aplicación que almacena grandes cantidades de objetos en las tablas hash.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
``````

Una segunda solución alternativa implica la ponderación de los códigos hash individuales por desplazamiento hacia la izquierda los códigos hash de campos sucesivos por dos o más 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. De forma óptima, en lugar de descartarlas, bits desplazados más allá de 31 bits deben ajustarse en lugar de descartarse.Optimally, instead of being discarded, bits shifted beyond bit 31 should wrap around rather than be discarded. Puesto que se descartan los bits por los operadores de desplazamiento a la izquierda en C# y Visual Basic, esto requiere la creación de un método de encapsulado de MAYÚS izquierdo similar al siguiente: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
``````

El ejemplo siguiente utiliza, a continuación, este método de ajuste de desplazamiento para calcular el código hash de la `Point` estructura utilizada en los ejemplos anteriores.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
``````

## Comentarios

Un código hash es un valor numérico que se usa para insertar e identificar un objeto en una colección basada en hash, como el Dictionary<TKey,TValue> (clase), el Hashtable clase o un tipo derivado de la DictionaryBase clase.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. El GetHashCode método proporciona este código hash para los algoritmos que necesitan comprobaciones rápidas de igualdad de objetos.The GetHashCode method provides this hash code for algorithms that need quick checks of object equality.

Nota

Para obtener información sobre cómo se usan códigos hash en tablas hash y algunos algoritmos de código hash adicionales, consulte el función Hash entrada en Wikipedia.For information about how hash codes are used in hash tables and for some additional hash code algorithms, see the Hash Function entry in Wikipedia.

Dos objetos que son los códigos hash devuelto igual que son iguales.Two objects that are equal return hash codes that are equal. Sin embargo, lo contrario no es cierto: códigos hash iguales implica la igualdad de objetos, dado que diferentes objetos (iguales) pueden tener los códigos hash idénticos.However, the reverse is not true: equal hash codes do not imply object equality, because different (unequal) objects can have identical hash codes. Además, .NET no garantiza la implementación predeterminada de la GetHashCode método y el valor que devuelve este método puede diferir entre plataformas, como 32 bits y las implementaciones de. NET, por ejemplo, distintas versiones de .NET Framework y .NET Core, y plataformas de 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. Por estas razones, no use la implementación predeterminada de este método como un identificador de objeto único para fines de hash.For these reasons, do not use the default implementation of this method as a unique object identifier for hashing purposes. Siguen dos consecuencias de esto:Two consequences follow from this:

• No debe suponer que los códigos hash iguales impliquen igualdad de objetos.You should not assume that equal hash codes imply object equality.

• Nunca debe conservar o usar un código hash fuera del dominio de aplicación en el que se creó, porque puede hash al mismo objeto a través de plataformas, procesos y dominios de aplicación.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.

Un código hash está destinado a una inserción y la búsqueda en las colecciones que se basan en una tabla hash.A hash code is intended for efficient insertion and lookup in collections that are based on a hash table. Un código hash no es un valor permanente.A hash code is not a permanent value. Por este motivo:For this reason:

• No serializar los valores de código hash o almacenarlos en las bases de datos.Do not serialize hash code values or store them in databases.
• No utilice el código hash como clave para recuperar un objeto de una colección con clave.Do not use the hash code as the key to retrieve an object from a keyed collection.
• No envíe los códigos hash entre dominios de aplicación o procesos.Do not send hash codes across application domains or processes. En algunos casos, es posible que se puede calcular códigos hash según el dominio por proceso o por aplicación.In some cases, hash codes may be computed on a per-process or per-application domain basis.
• No use el código hash en lugar de un valor devuelto por una función hash criptográfica si necesita un hash criptográficamente sólidos.Do not use the hash code instead of a value returned by a cryptographic hashing function if you need a cryptographically strong hash. Para algoritmos hash criptográficos, use una clase derivada de la System.Security.Cryptography.HashAlgorithm o System.Security.Cryptography.KeyedHashAlgorithm clase.For cryptographic hashes, use a class derived from the System.Security.Cryptography.HashAlgorithm or System.Security.Cryptography.KeyedHashAlgorithm class.
• No comprobar la igualdad de los códigos hash para determinar si dos objetos son iguales.Do not test for equality of hash codes to determine whether two objects are equal. (Objetos distintos pueden tener los códigos hash idénticos). Para comprobar la igualdad, llame a la ReferenceEquals o Equals método.(Unequal objects can have identical hash codes.) To test for equality, call the ReferenceEquals or Equals method.

El GetHashCode método puede reemplazarse por un tipo derivado.The GetHashCode method can be overridden by a derived type. Si GetHashCode es no reemplaza los códigos hash para los tipos de referencia se calculan mediante una llamada a la Object.GetHashCode método de la clase base, que calcula un código hash basado en la referencia de un objeto; para obtener más información, consulte 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 otras palabras, dos objetos para los que el ReferenceEquals devuelve del método `true` tienen códigos hash idénticos.In other words, two objects for which the ReferenceEquals method returns `true` have identical hash codes. Si los tipos de valor no reemplazan GetHashCode, el ValueType.GetHashCode método de la clase base utiliza la reflexión para calcular el código hash basado en los valores de los campos del tipo.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 otras palabras, cuyos campos tienen los mismos valores de tipos de valor tienen códigos hash iguales.In other words, value types whose fields have equal values have equal hash codes. Para obtener más información sobre cómo invalidar GetHashCode, consulte la sección "Notas para los herederos".For more information about overriding GetHashCode, see the "Notes to Inheritors" section.

Si invalida el GetHashCode método, también debe invalidar Equalsy viceversa.If you override the GetHashCode method, you should also override Equals, and vice versa. Si su invalidado Equals devuelve del método `true` cuando dos objetos se comprueban si son iguales, anulado GetHashCode método debe devolver el mismo valor para los dos objetos.If your overridden Equals method returns `true` when two objects are tested for equality, your overridden GetHashCode method must return the same value for the two objects.

Si un objeto que se utiliza como clave en una tabla hash no proporciona una implementación útil de GetHashCode, puede especificar un proveedor de código hash proporcionando un IEqualityComparer implementación a una de las sobrecargas de los Hashtable constructor de clase.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.

### Notas de la Windows en tiempo de ejecuciónWindows RuntimeNotes for the Windows en tiempo de ejecuciónWindows Runtime

Cuando se llama a la GetHashCode método en una clase en el Windows en tiempo de ejecuciónWindows Runtime, proporciona el comportamiento predeterminado para las clases que no se invalidan GetHashCode.When you call the GetHashCode method on a class in the Windows en tiempo de ejecuciónWindows Runtime, it provides the default behavior for classes that don't override GetHashCode. Esto forma parte de la compatibilidad que .NET Framework proporciona para el Windows en tiempo de ejecuciónWindows Runtime (consulte soporte técnico para Windows Store aplicaciones de .NET Framework y Windows Runtime).This is part of the support that the .NET Framework provides for the Windows en tiempo de ejecuciónWindows Runtime (see .NET Framework Support for Windows Store Apps and Windows Runtime). Las clases en el Windows en tiempo de ejecuciónWindows Runtime no heredar Objecty actualmente no se implementa un GetHashCode.Classes in the Windows en tiempo de ejecuciónWindows Runtime don't inherit Object, and currently don't implement a GetHashCode. Sin embargo, parece que tienen ToString, Equals(Object), y GetHashCode métodos al usarlos en el código de C# o Visual Basic y .NET Framework proporciona el comportamiento predeterminado de estos métodos.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.

Nota

Windows en tiempo de ejecuciónWindows Runtime las clases que se escriben en C# o Visual Basic pueden reemplazar el GetHashCode método.classes that are written in C# or Visual Basic can override the GetHashCode method.

## Notas a los desarrolladores de herederos

Una función hash se utiliza para generar rápidamente un número (código hash) que corresponde al valor de un objeto.A hash function is used to quickly generate a number (hash code) that corresponds to the value of an object. Las funciones hash suelen ser están para cada tipo y, para la unicidad, deben utilizar al menos uno de los campos de instancia como entrada.Hash functions are usually specific to each type and, for uniqueness, must use at least one of the instance fields as input. No se deben calcular códigos hash mediante el uso de los valores de los campos estáticos.Hash codes should not be computed by using the values of static fields.

Para las clases derivadas de Object, `GetHashCode` método puede delegar a la clase base GetHashCode() implementación sólo si la clase derivada define la igualdad para que sea la igualdad de referencia.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. La implementación predeterminada de GetHashCode() para referencia tipos devuelve un código hash que es equivalente a la devuelta por la GetHashCode(Object) método.The default implementation of GetHashCode() for reference types returns a hash code that is equivalent to the one returned by the GetHashCode(Object) method. Puede invalidar GetHashCode() para tipos de referencia inmutable.You can override GetHashCode() for immutable reference types. En general, para los tipos de referencia mutable, debe invalidar GetHashCode() solo si:In general, for mutable reference types, you should override GetHashCode() only if: -Se puede calcular el código hash de campos que no son mutables; o- You can compute the hash code from fields that are not mutable; or -Puede asegurarse de que el código hash de un objeto mutable no cambia y el objeto se encuentra en una colección que se basa en su código hash.- 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.

En caso contrario, podría pensar que el objeto mutable se pierde en la tabla hash.Otherwise, you might think that the mutable object is lost in the hash table. Si opta por reemplazar GetHashCode() para un tipo de referencia mutable, la documentación debe dejar claro que los usuarios de su tipo no deben modificar los valores de objeto, mientras que el objeto se almacena en una tabla hash.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.

Para los tipos de valor, GetHashCode() proporciona una implementación de código hash de forma predeterminada que usa la reflexión.For value types, GetHashCode() provides a default hash code implementation that uses reflection. Considere la posibilidad de reemplazarlo para mejorar el rendimiento.You should consider overriding it for better performance.

Para obtener más información y ejemplos que calculan códigos hash en una variedad de formas, vea la sección ejemplos.For more information and examples that compute hash codes in a variety of ways, see the Examples section.

Una función hash debe tener las siguientes propiedades:A hash function must have the following properties: -Si dos objetos se consideran iguales, la GetHashCode() método para cada objeto debe devolver el mismo valor.- If two objects compare as equal, the GetHashCode() method for each object must return the same value. Sin embargo, si no se pueden comparar dos objetos como iguales, la GetHashCode() métodos para los dos objetos no tienen que devolver valores diferentes.However, if two objects do not compare as equal, the GetHashCode() methods for the two objects do not have to return different values.

-El GetHashCode() método para un objeto constantemente debe devolver el mismo código hash siempre y cuando no hay ninguna modificación en el estado del objeto que determina el valor devuelto por el objeto System.Object.Equals método.- 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. Tenga en cuenta que esto es cierto solo para la ejecución actual de una aplicación y que se puede devolver un código hash diferente si se vuelve a ejecutar la aplicación.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.

-Para un rendimiento óptimo, una función hash debe generar una distribución uniforme para todas las entradas, incluidas la entrada que está agrupado mucho.- For the best performance, a hash function should generate an even distribution for all input, including input that is heavily clustered. Una implicación es que realizar grandes modificaciones en el código hash resultante para un mejor rendimiento de la tabla de hash deberían producir pequeñas modificaciones en el estado del objeto.An implication is that small modifications to object state should result in large modifications to the resulting hash code for best hash table performance.

-Las funciones hash deben ser económicas calcular.- Hash functions should be inexpensive to compute.

-El GetHashCode() método no debería producir excepciones.- The GetHashCode() method should not throw exceptions.

Por ejemplo, la implementación de la GetHashCode() método proporcionado por el String clase devuelve los códigos hash idénticos para los valores de cadena idénticos.For example, the implementation of the GetHashCode() method provided by the String class returns identical hash codes for identical string values. Por lo tanto, dos String objetos devuelven el mismo código hash si representan el mismo valor de cadena.Therefore, two String objects return the same hash code if they represent the same string value. Además, el método utiliza todos los caracteres en la cadena para generar la salida de distribución aleatoria razonable, incluso cuando la entrada está en clúster en determinados intervalos (por ejemplo, muchos usuarios podrían tener cadenas que contienen solo los 128 caracteres ASCII inferiores, aunque un cadena puede contener ninguno de los 65.535 caracteres Unicode).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).

Proporcionar una función hash adecuada en una clase significativamente puede afectar al rendimiento de la adición de esos objetos en una tabla hash.Providing a good hash function on a class can significantly affect the performance of adding those objects to a hash table. En una tabla hash con claves que proporcionan una buena implementación de una función hash, la búsqueda de un elemento toma tiempo constante (por ejemplo, una operación 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). En una tabla hash con una mala implementación de una función hash, el rendimiento de una búsqueda depende del número de elementos de la tabla hash (por ejemplo, una E/s (`n`) operación, donde `n` es el número de elementos de la tabla hash).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 usuario malintencionado puede escribir datos que aumenta el número de colisiones, lo que puede degradar significativamente el rendimiento de las aplicaciones que dependen las tablas hash, en las siguientes condiciones: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: -Cuando las funciones hash producen colisiones frecuentes.- When hash functions produce frequent collisions.

-Cuando una gran proporción de objetos en una tabla hash genera códigos hash son iguales o aproximadamente igual a uno del otro.- When a large proportion of objects in a hash table produce hash codes that are equal or approximately equal to one another.

-Cuando los usuarios introducir los datos desde el que se calcula el código hash.- When users input the data from which the hash code is computed.

Las clases derivadas que invalidarán GetHashCode() también debe invalidar Equals(Object) para garantizar que dos objetos que se consideran iguales tengan el mismo código hash; en caso contrario, el Hashtable tipo podría no funcionar correctamente.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.