# Object.GetHashCodeObject.GetHashCodeObject.GetHashCodeObject.GetHashCode Method

## Definição

Serve como a função de hash padrão.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``

#### Retornos

Um código hash do objeto atual.A hash code for the current object.

## Exemplos

Uma das maneiras mais simples para calcular um código hash para um valor numérico que tem o mesmo ou um intervalo menor que o Int32 tipo é simplesmente retornar esse 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. O exemplo a seguir mostra a tal implementação para um `Number` estrutura.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
``````

Com frequência, um tipo tem vários campos de dados que podem participar na geração do código de hash.Frequently, a type has multiple data fields that can participate in generating the hash code. Uma maneira de gerar um código hash é combinar esses campos usando um `XOR (eXclusive OR)` operação, conforme mostrado no exemplo a seguir.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
``````

O exemplo anterior retorna o mesmo código hash para (n1, n2) e (n2, n1) e, portanto, pode gerar mais colisões que são desejáveis.The previous example returns the same hash code for (n1, n2) and (n2, n1), and so may generate more collisions than are desirable. Uma série de soluções está disponível para que os códigos de hash nesses casos não são idênticos.A number of solutions are available so that hash codes in these cases are not identical. Uma é para retornar o código hash de um `Tuple` objeto que reflete a ordem de cada campo.One is to return the hash code of a `Tuple` object that reflects the order of each field. O exemplo a seguir mostra uma possível implementação que usa o Tuple<T1,T2> classe.The following example shows a possible implementation that uses the Tuple<T1,T2> class. No entanto, observe que a sobrecarga de desempenho de instanciar um `Tuple` objeto pode afetar significativamente o desempenho geral de um aplicativo que armazena um grande número de objetos em tabelas de 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
``````

Uma segunda solução alternativa envolve ponderar os códigos hash individuais por deslocamento à esquerda os códigos de hash dos campos sucessivos por dois ou mais 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 maneira ideal, em vez de ser descartado, bits deslocados além do bit 31 devem encapsular em vez de descartadas.Optimally, instead of being discarded, bits shifted beyond bit 31 should wrap around rather than be discarded. Uma vez que os bits são descartados, os operadores de deslocamento à esquerda em c# e Visual Basic, isso requer criando um método de encapsulamento shift esquerdo semelhante ao seguinte: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
``````

O exemplo a seguir, em seguida, usa esse método de shift e encapsulamento para calcular o código hash do `Point` estrutura usada nos exemplos 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
``````

## Comentários

Um código hash é um valor numérico que é usado para inserir e identificar um objeto em uma coleção baseada em hash, como o Dictionary<TKey,TValue> classe, o Hashtable classe ou um tipo derivado de 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. O GetHashCode método fornece esse código hash para algoritmos que precisam de verificações rápidas de igualdade do objeto.The GetHashCode method provides this hash code for algorithms that need quick checks of object equality.

Observação

Para obter informações sobre como os códigos de hash são usados em tabelas de hash e alguns algoritmos de código de hash adicionais, consulte o função de Hash entrada na 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.

Dois objetos que são códigos de hash de retorno iguais são iguais.Two objects that are equal return hash codes that are equal. No entanto, o inverso não é verdadeiro: códigos hash igual não implicam igualdade de objetos, como os diferentes objetos (diferentes) têm 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. Além disso, o .NET não garante a implementação padrão da GetHashCode método e o valor que este método retorna podem ser diferentes entre implementações do .NET, como diferentes versões do .NET Framework e .NET Core e plataformas, como 32 bits e 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 esses motivos, não use a implementação padrão desse método como um identificador exclusivo do objeto para fins de hash.For these reasons, do not use the default implementation of this method as a unique object identifier for hashing purposes. Execute as duas consequências deste:Two consequences follow from this:

• Você não deve presumir que os códigos hash igual implicam igualdade de objetos.You should not assume that equal hash codes imply object equality.

• Você nunca deve persistir ou usar um código de hash fora do domínio de aplicativo no qual ele foi criado, pois o mesmo objeto pode hash entre plataformas, processos e domínios de aplicativo.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.

Aviso

Um código hash destina-se de uma inserção e a pesquisa em coleções com base em uma tabela de hash.A hash code is intended for efficient insertion and lookup in collections that are based on a hash table. Um código de hash não é um valor permanente.A hash code is not a permanent value. Por esse motivo:For this reason:

• Não serializar valores de hash de código ou armazená-los em bancos de dados.Do not serialize hash code values or store them in databases.
• Não use o código hash como chave para recuperar um objeto de uma coleção com chave.Do not use the hash code as the key to retrieve an object from a keyed collection.
• Não envie códigos hash em domínios de aplicativo ou processos.Do not send hash codes across application domains or processes. Em alguns casos, os códigos de hash podem ser calculados em uma base de domínio por processo ou por aplicativo.In some cases, hash codes may be computed on a per-process or per-application domain basis.
• Não use o código de hash em vez de um valor retornado por uma função de hash criptográfica, se você precisar de um hash criptograficamente forte.Do not use the hash code instead of a value returned by a cryptographic hashing function if you need a cryptographically strong hash. Para hashes criptográficos, use uma classe derivada de System.Security.Cryptography.HashAlgorithm ou System.Security.Cryptography.KeyedHashAlgorithm classe.For cryptographic hashes, use a class derived from the System.Security.Cryptography.HashAlgorithm or System.Security.Cryptography.KeyedHashAlgorithm class.
• Não teste a igualdade de códigos de hash para determinar se dois objetos são iguais.Do not test for equality of hash codes to determine whether two objects are equal. (Objetos desiguais podem ter códigos hash idênticos). Para testar a igualdade, chame o ReferenceEquals ou Equals método.(Unequal objects can have identical hash codes.) To test for equality, call the ReferenceEquals or Equals method.

O GetHashCode método pode ser substituído por um tipo derivado.The GetHashCode method can be overridden by a derived type. Se GetHashCode é não substituído, códigos hash para tipos de referência são computados chamando o Object.GetHashCode método da classe base, que calcula um código hash com base na referência do objeto; para obter mais informações, 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. Em outras palavras, dois objetos para o qual o ReferenceEquals método retorna `true` têm códigos de hash idênticos.In other words, two objects for which the ReferenceEquals method returns `true` have identical hash codes. Se os tipos de valor não substituem GetHashCode, o ValueType.GetHashCode método da classe base usa reflexão para calcular o código hash com base nos valores de campos do 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. Em outras palavras, os tipos de valor cujos campos tiverem valores iguais tem códigos hash igual.In other words, value types whose fields have equal values have equal hash codes. Para obter mais informações sobre como substituir GetHashCode, consulte a seção "Observações para Herdeiros".For more information about overriding GetHashCode, see the "Notes to Inheritors" section.

Aviso

Se você substituir a GetHashCode método, você também deverá substituir Equalse vice-versa.If you override the GetHashCode method, you should also override Equals, and vice versa. Se seu substituída Equals retorn `true` quando dois objetos são testados quanto à igualdade, seu substituída GetHashCode método deve retornar o mesmo valor para os dois 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.

Se um objeto que é usado como uma chave em uma tabela de hash não fornece uma implementação úteis da GetHashCode, você pode especificar um provedor de código de hash, fornecendo uma IEqualityComparer implementação para uma das sobrecargas do Hashtable construtor 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.

### Observações para o Tempo de Execução do WindowsWindows RuntimeNotes for the Tempo de Execução do WindowsWindows Runtime

Quando você chama o GetHashCode método em uma classe de Tempo de Execução do WindowsWindows Runtime, ele fornece o comportamento padrão para classes que não substituem GetHashCode.When you call the GetHashCode method on a class in the Tempo de Execução do WindowsWindows Runtime, it provides the default behavior for classes that don't override GetHashCode. Isso faz parte do suporte fornecido pelo .NET Framework para o Tempo de Execução do WindowsWindows Runtime (consulte tempo de execução do Windows e de aplicativos .NET Framework dão suporte para Windows Store).This is part of the support that the .NET Framework provides for the Tempo de Execução do WindowsWindows Runtime (see .NET Framework Support for Windows Store Apps and Windows Runtime). As classes a Tempo de Execução do WindowsWindows Runtime não herdam Objecte atualmente não implementam um GetHashCode.Classes in the Tempo de Execução do WindowsWindows Runtime don't inherit Object, and currently don't implement a GetHashCode. No entanto, eles parecem ter ToString, Equals(Object), e GetHashCode métodos quando usá-los em seu código c# ou Visual Basic e o .NET Framework fornece o comportamento padrão para esses 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.

Observação

Tempo de Execução do WindowsWindows Runtime as classes que são escritas em c# ou Visual Basic podem substituir o GetHashCode método.classes that are written in C# or Visual Basic can override the GetHashCode method.

## Notas aos Herdeiros

Uma função de hash é usada para gerar rapidamente um número (código de hash) que corresponde ao valor de um objeto.A hash function is used to quickly generate a number (hash code) that corresponds to the value of an object. Funções de hash são geralmente específicas para cada tipo e, de exclusividade, devem usar pelo menos um dos campos de instância como entrada.Hash functions are usually specific to each type and, for uniqueness, must use at least one of the instance fields as input. Códigos de hash não devem ser calculados usando os valores de campos estáticos.Hash codes should not be computed by using the values of static fields.

Para classes derivadas de Object, o `GetHashCode` método pode delegar para a classe base GetHashCode() implementação somente se a classe derivada define igualdade para ser a igualdade de referência.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. A implementação padrão de GetHashCode() para referência de tipos retorna um código hash que é equivalente àquele retornado pelo 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. Você pode substituir GetHashCode() para tipos de referência imutável.You can override GetHashCode() for immutable reference types. Em geral, para tipos de referência mutável, você deve substituir GetHashCode() somente se:In general, for mutable reference types, you should override GetHashCode() only if: -Você pode calcular o código de hash de campos que não são mutáveis; ou- You can compute the hash code from fields that are not mutable; or -Você pode garantir que o código hash de um objeto mutável não será alterada enquanto o objeto está contido em uma coleção que se baseia em seu código de 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.

Caso contrário, você pode pensar que o objeto mutável é perdido na tabela de hash.Otherwise, you might think that the mutable object is lost in the hash table. Se você optar por substituir GetHashCode() para um tipo de referência mutável, a documentação deve deixar claro que os usuários do seu tipo não devem modificar os valores de objeto enquanto o objeto é armazenado em uma tabela de 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 tipos de valor, GetHashCode() fornece uma implementação de código de hash padrão que usa a reflexão.For value types, GetHashCode() provides a default hash code implementation that uses reflection. Você deve considerar a ignorá-lo para melhorar o desempenho.You should consider overriding it for better performance.

Para obter mais informações e exemplos de códigos de hash em uma variedade de formas de computação, consulte a seção de exemplos.For more information and examples that compute hash codes in a variety of ways, see the Examples section.

Uma função de hash deve ter as seguintes propriedades:A hash function must have the following properties: -Se dois objetos comparam como iguais, o GetHashCode() método para cada objeto deve retornar o mesmo valor.- If two objects compare as equal, the GetHashCode() method for each object must return the same value. No entanto, se dois objetos não são comparados como iguais, o GetHashCode() métodos para os dois objetos não precisa retornar 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.

-A GetHashCode() método para um objeto consistentemente deve retornar o mesmo código hash, desde que não há nenhuma modificação para o estado do objeto que determina o valor retornado do objeto 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. Observe que isso seja verdadeiro apenas para a execução atual de um aplicativo e que um código hash diferente pode ser retornado se o aplicativo for executado novamente.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 o melhor desempenho, uma função de hash deve gerar uma distribuição uniforme para todas as entradas, incluindo entrada intensamente em cluster.- For the best performance, a hash function should generate an even distribution for all input, including input that is heavily clustered. Uma implicação é que as pequenas modificações para o estado do objeto devem resultar em grandes modificações no código de hash resultante para um melhor desempenho de tabela de hash.An implication is that small modifications to object state should result in large modifications to the resulting hash code for best hash table performance.

– Funções de hash devem ser baixo custo de computação.- Hash functions should be inexpensive to compute.

-O GetHashCode() método não deve lançar exceções.- The GetHashCode() method should not throw exceptions.

Por exemplo, a implementação do GetHashCode() método fornecido pelo String classe retorna códigos de hash idênticos para os valores de cadeia de caracteres idêntica.For example, the implementation of the GetHashCode() method provided by the String class returns identical hash codes for identical string values. Portanto, dois String objetos retornam o mesmo código hash se eles representarem o mesmo valor de cadeia de caracteres.Therefore, two String objects return the same hash code if they represent the same string value. Além disso, o método usa todos os caracteres na cadeia de caracteres para gerar a saída distribuída razoavelmente aleatoriamente, mesmo quando a entrada for clusterizada em determinados intervalos (por exemplo, muitos usuários podem ter cadeias de caracteres que contêm somente inferior 128 caracteres ASCII, embora um cadeia de caracteres pode conter nenhum dos caracteres 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).

Fornecer uma boa função de hash em uma classe pode afetar significativamente o desempenho de adicionar esses objetos em uma tabela de hash.Providing a good hash function on a class can significantly affect the performance of adding those objects to a hash table. Em uma tabela de hash com as chaves que fornecem uma boa implementação de uma função de hash, procurando por um elemento leva um tempo constante (por exemplo, uma operação de (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). Em uma tabela de hash com uma implementação inadequada de uma função de hash, o desempenho de uma pesquisa depende do número de itens na tabela de hash (por exemplo, um O (`n`) a operação, onde `n` é o número de itens na tabela de 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). Um usuário mal-intencionado pode inserir dados que aumenta o número de conflitos, o que pode afetar significativamente o desempenho de aplicativos que dependem de tabelas de hash, sob as seguintes condições: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: -Quando as funções de hash produzem colisões frequentes.- When hash functions produce frequent collisions.

-Quando uma grande proporção de objetos em uma tabela de hash produzir códigos de hash que são iguais ou aproximadamente iguais um ao outro.- When a large proportion of objects in a hash table produce hash codes that are equal or approximately equal to one another.

-Quando os usuários os dados do qual o código hash é calculado de entrada.- When users input the data from which the hash code is computed.

As classes derivadas que substituem GetHashCode() também deve substituir Equals(Object) para garantir que dois objetos considerados iguais têm o mesmo código hash; caso contrário, o Hashtable tipo pode não funcionar corretamente.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.