# Object.GetHashCode Metoda

## Definice

Slouží jako výchozí funkce hash.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``

#### Návraty

Int32

Kód hash pro aktuální objekt.A hash code for the current object.

Jedním z nejjednodušších způsobů, jak vypočítat hash kód pro číselnou hodnotu, která má stejný nebo menší rozsah než Int32 typ, je jednoduše vrátit tuto hodnotu.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. Následující příklad ukazuje takovou implementaci `Number` struktury.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
``````

Často typ obsahuje více datových polí, které mohou být součástí generování kódu hash.Frequently, a type has multiple data fields that can participate in generating the hash code. Jedním ze způsobů, jak generovat kód hash, je kombinovat tato pole pomocí `XOR (eXclusive OR)` operace, jak je znázorněno v následujícím příkladu.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
``````

Předchozí příklad vrátí stejný kód hash pro (N1, N2) a (N2, N1), a tak může generovat větší kolizí, než je žádoucí.The previous example returns the same hash code for (n1, n2) and (n2, n1), and so may generate more collisions than are desirable. K dispozici je několik řešení, aby kódy hash v těchto případech nebyly identické.A number of solutions are available so that hash codes in these cases are not identical. Jedním z nich je vrácení kódu hash `Tuple` objektu, který odráží pořadí jednotlivých polí.One is to return the hash code of a `Tuple` object that reflects the order of each field. Následující příklad ukazuje možnou implementaci, která používá Tuple<T1,T2> třídu.The following example shows a possible implementation that uses the Tuple<T1,T2> class. Všimněte si ale, že nároky na výkon při vytváření instancí `Tuple` objektu mohou významně ovlivnit celkový výkon aplikace, která ukládá velký počet objektů v zatřiďovacích tabulkách.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)
{
Point p = (Point) obj;
return x == p.x & y == p.y;
}
else
{
return false;
}
}

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
``````

Druhé alternativní řešení zahrnuje vážení jednotlivých kódů hash na základě levého posunu kódů hash po sobě jdoucích polí o dvě nebo více bitů.A second alternative solution involves weighting the individual hash codes by left-shifting the hash codes of successive fields by two or more bits. V optimálním případě by služba BITS byla přesunuta mimo bit 31, takže by se místo toho měla zalomit.Optimally, bits shifted beyond bit 31 should wrap around rather than be discarded. Vzhledem k tomu, že bity jsou zahozeny pomocí operátorů levého posunutí v C# i Visual Basic, je nutné vytvořit levou metodu SHIFT a Wrap, například následující: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
``````

Následující příklad poté používá tuto metodu Shift-and-Wrap k výpočtu hash kódu `Point` struktury používané v předchozích příkladech.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
``````

## Poznámky

Kód hash je číselná hodnota, která se používá k vložení a identifikaci objektu v kolekci založené na hodnotě hash, jako je Dictionary<TKey,TValue> třída, Hashtable třída nebo typ odvozený z DictionaryBase třídy.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. GetHashCodeMetoda poskytuje tento kód hash pro algoritmy, které vyžadují rychlou kontrolu rovnosti objektů.The GetHashCode method provides this hash code for algorithms that need quick checks of object equality.

Poznámka

Informace o tom, jak se kódy hash používají v zatřiďovacích tabulkách a pro některé další algoritmy hash kódu, naleznete v tématu funkce hash v Wikipedii.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.

Dva objekty, které jsou stejné jako návratové kódy hash, které jsou stejné.Two objects that are equal return hash codes that are equal. Ale opak není true: stejné hodnoty hash neznamenají rovnost objektů, protože různé (nerovné) objekty můžou mít stejné kódy hash.However, the reverse is not true: equal hash codes do not imply object equality, because different (unequal) objects can have identical hash codes. Rozhraní .NET navíc nezaručuje výchozí implementaci GetHashCode metody a hodnota, kterou vrátí tato metoda, se může lišit mezi implementacemi rozhraní .NET, například různými verzemi .NET Framework a .NET Core a platformami, jako jsou 32 a 64-bitové platformy.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. Z těchto důvodů nepoužívejte výchozí implementaci této metody jako jedinečný identifikátor objektu pro účely výpočtu hodnoty hash.For these reasons, do not use the default implementation of this method as a unique object identifier for hashing purposes. Existují dvě důsledky z těchto kroků:Two consequences follow from this:

• Neměli byste předpokládat, že stejné hodnoty hash implikují rovnost objektů.You should not assume that equal hash codes imply object equality.

• Nikdy nesmíte zachovat ani použít kód hash mimo doménu aplikace, ve které byl vytvořen, protože stejný objekt může mít hodnotu hash napříč doménami aplikace, procesy a platformami.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.

Upozornění

Kód hash je určený pro efektivní vkládání a vyhledávání v kolekcích založených na zatřiďovací tabulce.A hash code is intended for efficient insertion and lookup in collections that are based on a hash table. Kód hash není trvalá hodnota.A hash code is not a permanent value. Z tohoto důvodu:For this reason:

• Neserializovat hodnoty hash kódu ani ukládat je do databází.Do not serialize hash code values or store them in databases.
• Nepoužívejte kód hash jako klíč pro načtení objektu z kolekce s klíčem.Do not use the hash code as the key to retrieve an object from a keyed collection.
• Neodesílají kódy hash napříč aplikačními doménami nebo procesy.Do not send hash codes across application domains or processes. V některých případech mohou být kódy hash vypočítány pro jednotlivé procesy nebo jednotlivé aplikační domény.In some cases, hash codes may be computed on a per-process or per-application domain basis.
• Nepoužívejte kód hash namísto hodnoty vrácené kryptografickou funkcí hash, pokud potřebujete kryptograficky silný algoritmus hash.Do not use the hash code instead of a value returned by a cryptographic hashing function if you need a cryptographically strong hash. Pro kryptografické hodnoty hash použijte třídu odvozenou z System.Security.Cryptography.HashAlgorithm třídy nebo System.Security.Cryptography.KeyedHashAlgorithm .For cryptographic hashes, use a class derived from the System.Security.Cryptography.HashAlgorithm or System.Security.Cryptography.KeyedHashAlgorithm class.
• Neprovádějte test rovnosti kódů hash k určení, zda jsou dva objekty stejné.Do not test for equality of hash codes to determine whether two objects are equal. (Nerovné objekty můžou mít stejné kódy hash.) Chcete-li otestovat rovnost, zavolejte ReferenceEquals Equals metodu nebo.(Unequal objects can have identical hash codes.) To test for equality, call the ReferenceEquals or Equals method.

GetHashCodeMetodu lze přepsat odvozeným typem.The GetHashCode method can be overridden by a derived type. Pokud GetHashCode není přepsán, kódy hash pro typy odkazů jsou vypočítány voláním Object.GetHashCode metody základní třídy, která vypočítá kód hash založený na referenci objektu; Další informace naleznete v tématu 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. Jinými slovy, dva objekty, pro které bude ReferenceEquals Metoda vracet, `true` mají stejné kódy hash.In other words, two objects for which the ReferenceEquals method returns `true` have identical hash codes. Pokud typy hodnot nepřepisují GetHashCode , ValueType.GetHashCode Metoda základní třídy používá reflexi k výpočtu kódu hash na základě hodnot polí typu.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. Jinými slovy, typy hodnot, jejichž pole mají stejné hodnoty, mají stejné kódy hash.In other words, value types whose fields have equal values have equal hash codes. Další informace o přepsání GetHashCode najdete v části "poznámky k dědicům".For more information about overriding GetHashCode, see the "Notes to Inheritors" section.

Upozornění

Pokud přepíšete GetHashCode metodu, měli byste také přepsat Equals a naopak.If you override the GetHashCode method, you should also override Equals, and vice versa. Pokud přepsaná Equals Metoda vrátí `true` , když jsou testovány dva objekty pro rovnost, přepsaná GetHashCode Metoda musí vracet stejnou hodnotu pro dva objekty.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.

Pokud objekt, který je použit jako klíč v zatřiďovací tabulce, neposkytuje užitečnou implementaci GetHashCode , můžete zadat poskytovatele kódu hash poskytnutím IEqualityComparer implementace do jednoho z přetížení Hashtable konstruktoru třídy.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.

### Poznámky pro prostředí Windows RuntimeWindows RuntimeNotes for the prostředí Windows RuntimeWindows Runtime

Při volání GetHashCode metody pro třídu v prostředí Windows RuntimeWindows Runtime , poskytuje výchozí chování pro třídy, které nepřepisuje GetHashCode .When you call the GetHashCode method on a class in the prostředí Windows RuntimeWindows Runtime, it provides the default behavior for classes that don't override GetHashCode. Toto je součást podpory, kterou .NET Framework poskytuje prostředí Windows RuntimeWindows Runtime (viz Podpora .NET Framework pro aplikace pro Windows Store a prostředí Windows Runtime).This is part of the support that the .NET Framework provides for the prostředí Windows RuntimeWindows Runtime (see .NET Framework Support for Windows Store Apps and Windows Runtime). Třídy v prostředí Windows RuntimeWindows Runtime nedědí Object a aktuálně neimplementují GetHashCode .Classes in the prostředí Windows RuntimeWindows Runtime don't inherit Object, and currently don't implement a GetHashCode. Zdá se však, že existují ToString Equals(Object) metody, a, pokud je GetHashCode používáte v kódu C# nebo Visual Basic a .NET Framework poskytuje výchozí chování pro tyto metody.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.

Poznámka

prostředí Windows RuntimeWindows Runtime třídy, které jsou napsány v jazyce C# nebo Visual Basic mohou přepsat GetHashCode metodu.classes that are written in C# or Visual Basic can override the GetHashCode method.

## Poznámky pro dědice

Funkce hash slouží k rychlému vygenerování čísla (kódu hash), který odpovídá hodnotě objektu.A hash function is used to quickly generate a number (hash code) that corresponds to the value of an object. Funkce hash jsou obvykle specifické pro každý typ a v případě jedinečnosti musí použít alespoň jedno pole instance jako vstup.Hash functions are usually specific to each type and, for uniqueness, must use at least one of the instance fields as input. Kódy hash by se neměly vypočítávají pomocí hodnot statických polí.Hash codes should not be computed by using the values of static fields.

Pro třídy, které jsou odvozeny z Object , `GetHashCode` metoda může delegovat na implementaci základní třídy pouze v případě, že GetHashCode() odvozená třída definuje rovnost, která bude odkazovat na rovnost.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. Výchozí implementace GetHashCode() pro typ odkazu vrátí hodnotu hash, která je ekvivalentní hodnotě, kterou vrátí GetHashCode(Object) metoda.The default implementation of GetHashCode() for reference types returns a hash code that is equivalent to the one returned by the GetHashCode(Object) method. Můžete přepsat GetHashCode() pro neměnné typy odkazů.You can override GetHashCode() for immutable reference types. Obecně platí, že pro proměnlivé typy odkazů byste měli přepsat pouze v případě, že GetHashCode() :In general, for mutable reference types, you should override GetHashCode() only if: – Můžete vypočítat hodnotu hash z polí, která nejsou proměnlivá; ani- You can compute the hash code from fields that are not mutable; or -Můžete zajistit, aby se kód hash proměnlivého objektu nezměnil, dokud je objekt obsažen v kolekci, která spoléhá na jeho kód 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.

V opačném případě se můžete domnívat, že se proměnlivý objekt ztratí v zatřiďovací tabulce.Otherwise, you might think that the mutable object is lost in the hash table. Pokud se rozhodnete přepsat GetHashCode() proměnlivý typ odkazu, měla by být v dokumentaci jasné, že uživatelé vašeho typu by neměli upravovat hodnoty objektů, pokud je objekt uložen v zatřiďovací tabulce.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.

Pro typy hodnot GetHashCode() poskytuje výchozí implementaci kódu hash, která používá reflexi.For value types, GetHashCode() provides a default hash code implementation that uses reflection. Měli byste zvážit přepsání pro lepší výkon.You should consider overriding it for better performance.

Další informace a příklady výpočetních kódů hash v různých způsobech naleznete v části příklady.For more information and examples that compute hash codes in a variety of ways, see the Examples section.

Funkce hash musí mít následující vlastnosti:A hash function must have the following properties: – Pokud dva objekty jsou porovnány jako stejné, GetHashCode() metoda pro každý objekt musí vracet stejnou hodnotu.- If two objects compare as equal, the GetHashCode() method for each object must return the same value. Nicméně pokud dva objekty neodpovídají jako stejné, GetHashCode() metody pro dva objekty nemusejí vracet jiné hodnoty.However, if two objects do not compare as equal, the GetHashCode() methods for the two objects do not have to return different values.

- GetHashCode() Metoda pro objekt musí konzistentně vracet stejný kód hash, pokud není nijak upravován stav objektu, který určuje návratovou hodnotu metody System. Object. Equals objektu.- 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. Všimněte si, že to platí pouze pro aktuální spuštění aplikace a že pokud je aplikace spuštěna znovu, může být vrácen jiný kód hash.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.

– Pro nejlepší výkon by funkce hash měla generovat rovnoměrné rozdělení pro všechny vstupy, včetně vstupu, který je intenzivně clusterovaný.- For the best performance, a hash function should generate an even distribution for all input, including input that is heavily clustered. Nepředvídatelným řešením je, že malé úpravy stavu objektu by měly být výsledkem velkých úprav výsledného kódu hash pro nejlepší výkon zatřiďovací tabulky.An implication is that small modifications to object state should result in large modifications to the resulting hash code for best hash table performance.

– Funkce hash by měly být pro výpočetní výkon levné.- Hash functions should be inexpensive to compute.

- GetHashCode() Metoda by neměla vyvolat výjimky.- The GetHashCode() method should not throw exceptions.

Například implementace GetHashCode() metody poskytované String třídou vrátí stejné kódy hash pro identické řetězcové hodnoty.For example, the implementation of the GetHashCode() method provided by the String class returns identical hash codes for identical string values. Proto dva String objekty vrátí stejný kód hash, pokud představují stejnou hodnotu řetězce.Therefore, two String objects return the same hash code if they represent the same string value. Metoda také používá všechny znaky v řetězci k vygenerování rozumně náhodného distribuovaného výstupu, i když je vstup clusterovaný v určitých oblastech (například mnoho uživatelů může mít řetězce, které obsahují pouze nižší 128 znaků ASCII, i když řetězec může obsahovat znaky 65 535 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).

Poskytnutí dobré funkce hash pro třídu může významně ovlivnit výkon přidávání těchto objektů do zatřiďovací tabulky.Providing a good hash function on a class can significantly affect the performance of adding those objects to a hash table. V zatřiďovací tabulce s klíči, které poskytují správnou implementaci funkce hash, hledání prvku trvá konstantní čas (například operace 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). V zatřiďovací tabulce se špatnou implementací funkce hash závisí výkon hledání na počtu položek v zatřiďovací tabulce (například v operaci O ( `n` ), kde `n` je počet položek v zatřiďovací tabulce).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). Uživatel se zlými úmysly může zadat data, která zvyšují počet kolizí, což může výrazně snížit výkon aplikací závislých na zatřiďovacích tabulkách, a to za následujících podmínek: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: – Když funkce hash vyprodukuje časté kolize.- When hash functions produce frequent collisions.

– Když velký podíl objektů v zatřiďovací tabulce vytváří kódy hash rovnající se druhé nebo jiné.- When a large proportion of objects in a hash table produce hash codes that are equal or approximately equal to one another.

– Když uživatelé zadáte data, ze kterých se počítá kód hash.- When users input the data from which the hash code is computed.

Odvozené třídy, které Přepisuje, GetHashCode() musí také přepsat, Equals(Object) aby bylo zaručeno, že dva objekty považované za stejné mají stejný kód hash; v opačném případě Hashtable typ nemusí správně fungovat.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.