සමානාත්මතා ක්‍රමය ඉක්මවා ගිය විට GetHashCode අභිබවා යාම වැදගත් වන්නේ ඇයි?

පහත පන්තිය ලබා දී ඇත

public class Foo
{
    public int FooId { get; set; }
    public string FooName { get; set; }

    public override bool Equals(object obj)
    {
        Foo fooItem = obj as Foo;

        if (fooItem == null) 
        {
           return false;
        }

        return fooItem.FooId == this.FooId;
    }

    public override int GetHashCode()
    {
        // Which is preferred?

        return base.GetHashCode();

        //return this.FooId.GetHashCode();
    }
}

S වගුව සඳහා පේළියක් නිරූපණය කරන Equalsනිසා මම ක්‍රමය ඉක්මවා ඇත . අභිබවා යාමට වඩාත් කැමති ක්‍රමය කුමක්ද?FooFooGetHashCode

අභිබවා යාම වැදගත් වන්නේ GetHashCodeඇයි?

ඔව්, ඔබේ අයිතමය ශබ්දකෝෂයක යතුරක් ලෙස භාවිතා කරන්නේද යන්න වැදගත් වේ, හෝ HashSet<T>, යනාදිය - මෙය (සිරිතක් නොමැති විට IEqualityComparer<T>) අයිතම බාල්දි වලට කාණ්ඩ කිරීමට භාවිතා කරන බැවින් . අයිතම දෙකක් සඳහා හැෂ් කේතය නොගැලපේ නම්, ඒවා කිසි විටෙකත් සමාන යැයි නොසැලකේ ( සමානාත්මතාවය කිසි විටෙකත් නොකියනු ඇත).

මෙම GetHashCode () ක්රමය පිළිබිඹු විය යුතුය Equalsතර්ක; නීති:

• කාරණා දෙකක් සමාන නම් ( Equals(...) == true) එවිට ඒවා සඳහා එකම අගය ලබා දිය යුතුයGetHashCode()
• GetHashCode()සමාන නම්, ඔවුන් එක හා සමාන වීම අවශ්‍ය නොවේ ; මෙය ision ට්ටනයක් වන අතර Equalsඑය සැබෑ සමානාත්මතාවයක් දැයි බැලීමට කැඳවනු ලැබේ.

මෙම අවස්ථාවේ දී, " return FooId;" සුදුසු GetHashCode()ක්රියාත්මක කිරීමක් ලෙස පෙනේ. ඔබ බහු ගුණාංග පරික්ෂා කරන්නේ නම්, විකර්ණ isions ට්ටන අඩු කිරීම සඳහා පහත දැක්වෙන කේතය භාවිතා කර ඒවා ඒකාබද්ධ කිරීම සාමාන්‍ය දෙයකි (එනම් new Foo(3,5)වෙනස් හැෂ් කේතයක් ඇති බැවින් new Foo(5,3)):

unchecked // only needed if you're compiling with arithmetic checks enabled
{ // (the default compiler behaviour is *disabled*, so most folks won't need this)
    int hash = 13;
    hash = (hash * 7) + field1.GetHashCode();
    hash = (hash * 7) + field2.GetHashCode();
    ...
    return hash;
}

අපොයි - පහසුව සඳහා, ඔබ ද ලබා සලකා බැලීමට ඉඩ ==හා !=ආධිපත්යධාරී විට ක්රියාකරුවන් Equalsහා GetHashCode.

ඔබ මෙම වැරැද්ද කළ විට කුමක් සිදුවේද යන්න නිරූපණය කිරීම මෙහි ඇත.

GetHashCode()මාක් දැනටමත් සඳහන් කර ඇති නීතිවලට අමතරව, වස්තුවක ජීවිත කාලය තුළ හැෂ් කේතය වෙනස් නොවිය යුතු නිසා එය නිවැරදිව ක්‍රියාත්මක කිරීම ඉතා අසීරු ය . එබැවින් හැෂ් කේතය ගණනය කිරීම සඳහා භාවිතා කරන ක්ෂේත්‍ර වෙනස් කළ නොහැක.

මම අවසානයේ NHibernate සමඟ වැඩ කරන විට මෙම ගැටලුවට විසඳුමක් සොයා ගතිමි. මගේ ප්‍රවේශය වන්නේ වස්තුවේ හැඳුනුම්පතෙන් හැෂ් කේතය ගණනය කිරීමයි. හැඳුනුම්පත සැකසිය හැක්කේ ඉදිකිරීම්කරු වුවද ඔබට හැඳුනුම්පත වෙනස් කිරීමට අවශ්‍ය නම් එය ඉතා අසීරු නම්, ඔබට නව හැඳුනුම්පතක් ඇති නව වස්තුවක් නිර්මාණය කළ යුතු අතර එබැවින් නව හැෂ් කේතයක් ඇත. අහඹු ලෙස හැඳුනුම්පතක් ජනනය කරන පරාමිති රහිත ඉදිකිරීම්කරුවෙකු ඔබට ලබා දිය හැකි බැවින් මෙම ප්‍රවේශය GUID සමඟ වඩාත් හොඳින් ක්‍රියා කරයි.

සමානාත්මතාවය ඉක්මවා යාමෙන් ඔබ මූලිකවම කියා සිටින්නේ යම් වර්ගයක අවස්ථා දෙකක් සංසන්දනය කරන්නේ කෙසේද යන්න වඩා හොඳින් දන්නා තැනැත්තා ඔබ බවය, එබැවින් ඔබ හොඳම හැෂ් කේතය ලබා දීමට හොඳම අපේක්ෂකයා වනු ඇත.

ReSharper ඔබ වෙනුවෙන් GetHashCode () ශ්‍රිතයක් ලියන ආකාරය පිළිබඳ උදාහරණය මෙයයි:

public override int GetHashCode()
{
    unchecked
    {
        var result = 0;
        result = (result * 397) ^ m_someVar1;
        result = (result * 397) ^ m_someVar2;
        result = (result * 397) ^ m_someVar3;
        result = (result * 397) ^ m_someVar4;
        return result;
    }
}

ඔබට පෙනෙන පරිදි එය පන්තියේ සියලුම ක්ෂේත්‍ර මත පදනම්ව හොඳ හැෂ් කේතයක් අනුමාන කිරීමට උත්සාහ කරයි, නමුත් ඔබේ වස්තුවේ වසම හෝ අගය පරාසයන් ඔබ දන්නා බැවින් ඔබට තවමත් වඩා හොඳ එකක් ලබා දිය හැකිය.

අභිබවා යන nullවිට විරුද්ධ පරාමිතිය පරීක්ෂා කිරීමට කරුණාකර අමතක නොකරන්න Equals(). තවද වර්ගය සංසන්දනය කරන්න.

public override bool Equals(object obj)
{
    Foo fooItem = obj as Foo;

    if (fooItem == null)
    {
       return false;
    }

    return fooItem.FooId == this.FooId;
}

මෙයට හේතුව: Equalsසාපේක්ෂව සාවද්‍ය ලෙස ආපසු යා යුතුය null. Http://msdn.microsoft.com/en-us/library/bsc2ak47.aspx ද බලන්න

කොහොමද:

public override int GetHashCode()
{
    return string.Format("{0}_{1}_{2}", prop1, prop2, prop3).GetHashCode();
}

කාර්ය සාධනය උපකල්පනය කිරීමක් නොවේ :)

අපට මුහුණ දීමට ගැටලු දෙකක් තිබේ.

1. GetHashCode()වස්තුවෙහි කිසියම් ක්ෂේත්‍රයක් වෙනස් කළ හැකි නම් ඔබට සංවේදීතාවයක් ලබා දිය නොහැක . බොහෝ විට වස්තුවක් රඳා පවතින එකතුවක කිසි විටෙකත් භාවිතා නොකරනු ඇත GetHashCode(). එබැවින් ක්‍රියාත්මක කිරීමේ පිරිවැය GetHashCode()බොහෝ විට එය වටින්නේ නැත, නැතහොත් එය කළ නොහැකි ය.

2. කවුරුහරි ඔබේ වස්තුව ඇමතුමකට එකතු කර නිවැරදි ආකාරයකින් හැසිරීමට GetHashCode()ඉඩ Equals()නොදී ඔබ ඉක්මවා ගියහොත් GetHashCode(), එම පුද්ගලයා ගැටලුව සොයා ගැනීමට දින ගණනක් ගත කළ හැකිය.

එබැවින් පෙරනිමියෙන් මම එසේ කරමි.

public class Foo
{
    public int FooId { get; set; }
    public string FooName { get; set; }

    public override bool Equals(object obj)
    {
        Foo fooItem = obj as Foo;

        if (fooItem == null)
        {
           return false;
        }

        return fooItem.FooId == this.FooId;
    }

    public override int GetHashCode()
    {
        // Some comment to explain if there is a real problem with providing GetHashCode() 
        // or if I just don't see a need for it for the given class
        throw new Exception("Sorry I don't know what GetHashCode should do for this class");
    }
}

රාමුවට අවශ්‍ය වන්නේ එකම වස්තු දෙකක් එකම හැෂ් කේතයක් තිබිය යුතු බැවිනි. වස්තූන් දෙකක විශේෂ සංසන්දනයක් කිරීම සඳහා ඔබ සමාන ක්‍රමය ඉක්මවා ගියහොත් සහ එම වස්තූන් දෙක ක්‍රමවේදය එක හා සමාන යැයි සලකන්නේ නම්, එම වස්තු දෙකේ හැෂ් කේතය ද සමාන විය යුතුය. (ශබ්ද කෝෂ සහ හැෂ්ටේබල් මෙම මූලධර්මය මත රඳා පවතී).

ඉහත පිළිතුරු එකතු කිරීම සඳහා:

ඔබ සමානකම් ඉක්මවා නොයන්නේ නම් පෙරනිමි හැසිරීම නම් වස්තූන්ගේ යොමු කිරීම් සැසඳීමයි. හැෂ්කෝඩ් සඳහාද එය අදාළ වේ - පෙරනිමි implmentation සාමාන්‍යයෙන් යොමු කිරීමේ මතක ලිපිනය මත පදනම් වේ. ඔබ සමානාත්මතාවය ඉක්මවා ගිය නිසා එයින් අදහස් කරන්නේ නිවැරදි හැසිරීම යනු ඔබ සමානාත්මතාවයේ ක්‍රියාත්මක කළ ඕනෑම දෙයක් සැසඳීම මිස යොමු කිරීම් නොවේ, එබැවින් ඔබ හැෂ් කේතය සඳහාද එසේ කළ යුතුය.

ඔබේ පන්තියේ සේවාදායකයින් හැෂ් කේතයට සමාන ක්‍රමයට සමාන තර්කනයක් බලාපොරොත්තු වනු ඇත, උදාහරණයක් ලෙස IEqualityComparer භාවිතා කරන ලින්ක් ක්‍රම පළමුව හැෂ් කේත සංසන්දනය කරන අතර ඒවා සමාන නම් පමණක් ඔවුන් වඩා මිල අධික විය හැකි සමාන () ක්‍රමය සංසන්දනය කරයි. ධාවනය කිරීමට, අපි හැෂ්කෝඩ් ක්‍රියාත්මක නොකළේ නම්, සමාන වස්තුවකට විවිධ හැෂ් කේත ඇත (ඒවාට වෙනස් මතක ලිපිනයක් ඇති නිසා) සහ සමාන නොවන බව වැරදියට තීරණය වේ (සමාන () පහර දෙන්නේ නැත).

ඊට අමතරව, ඔබ ඔබේ වස්තුව ශබ්දකෝෂයක භාවිතා කළේ නම් එය සොයා ගැනීමට නොහැකි වනු ඇත (එය එක් හැෂ් කේතයක් මඟින් ඇතුළත් කර ඇති නිසා සහ ඔබ එය සොයන විට පෙරනිමි හැෂ් කේතය බොහෝ විට වෙනස් වන අතර නැවත සමාන වේ () මාක් ග්‍රෙවෙල් ඔහුගේ පිළිතුරෙහි පැහැදිලි කර ඇති පරිදි, ඔබ සමාන ශබ්ද වලට ඉඩ නොදිය යුතු ශබ්ද කෝෂය හෝ හැෂ්සෙට් සංකල්පය උල්ලං violation නය කිරීමක් හඳුන්වා දෙයි - ඔබ දැනටමත් ප්‍රකාශ කර ඇත්තේ ඔබ සමානකම් ඉක්මවා යන විට එම වස්තූන් එක හා සමාන බවයි. අද්විතීය යතුරක් ඇතැයි සිතන දත්ත ව්‍යුහයක මේ දෙකම වෙනස් යතුරු ලෙස අවශ්‍ය නොවේ.නමුත් ඒවාට වෙනස් හැෂ් කේතයක් ඇති බැවින් “එකම” යතුර වෙනස් එකක් ලෙස ඇතුළත් වේ.

ශබ්ද කෝෂය ශබ්දකෝෂය, හැෂ්ටබල්, හැෂ්සෙට් වැනි හැෂ් මත පදනම් වූ එකතු කිරීම් සඳහා භාවිතා කරයි. මෙම කේතයේ අරමුණ විශේෂිත වස්තුවකට නිශ්චිත කාණ්ඩයකට (බාල්දියට) ඇතුළත් කිරීමෙන් ඉතා ඉක්මණින් පූර්ව වර්ග කිරීම ය. මෙම වස්තුව ඔබට හැෂ්-එකතුවෙන් නැවත ලබා ගැනීමට අවශ්‍ය වූ විට එය සොයා ගැනීමට මෙම පෙර-වර්ග කිරීම බෙහෙවින් උපකාරී වේ, මන්ද කේතයට ඔබේ වස්තුව එහි ඇති සියලුම වස්තූන් වෙනුවට එක් බාල්දියකින් සෙවිය යුතු බැවිනි. හැෂ් කේත වඩා හොඳින් බෙදා හැරීම (වඩා හොඳ සුවිශේෂත්වය) වේගයෙන් ලබා ගැනීම. සෑම වස්තුවකටම අද්විතීය හැෂ් කේතයක් ඇති පරිපූර්ණ තත්වයකදී, එය සොයා ගැනීම O (1) මෙහෙයුමකි. බොහෝ අවස්ථාවල එය O (1) වෙත ළඟා වේ.

එය අනිවාර්යයෙන්ම වැදගත් නොවේ; එය ඔබගේ එකතු කිරීම්වල ප්‍රමාණය සහ කාර්ය සාධන අවශ්‍යතා මත රඳා පවතී සහ කාර්ය සාධන අවශ්‍යතා ඔබ නොදන්නා පුස්තකාලයක ඔබේ පන්තිය භාවිතා කරන්නේද යන්න මත රඳා පවතී. මගේ එකතු කිරීමේ ප්‍රමාණය ඉතා විශාල නොවන බව මම නිතරම දනිමි. පරිපූර්ණ හැෂ් කේතයක් නිර්මාණය කිරීමෙන් ලබාගත් කාර්යසාධනයේ මයික්‍රෝ තත්පර කිහිපයකට වඩා මගේ කාලය වටිනවා; එබැවින් (සම්පාදකයාගේ කරදරකාරී අනතුරු ඇඟවීමෙන් මිදීමට) මම සරලවම භාවිතා කරන්නේ:

   public override int GetHashCode()
   {
      return base.GetHashCode();
   }

(ඇත්ත වශයෙන්ම මට අනතුරු ඇඟවීම ක්‍රියා විරහිත කිරීමට # ප්‍රාග්මා එකක් භාවිතා කළ හැකි නමුත් මම මේ ආකාරයට කැමැත්තෙමි.)

මෙහි සිටින අනෙක් අය සඳහන් කර ඇති සියලුම ගැටළු වලට වඩා ඔබට කාර්ය සාධනය අවශ්‍ය යැයි ඔබ සිතන විට, ඇත්ත වශයෙන්ම. වැදගත්ම දේ - එසේ නොමැතිනම් හැෂ් කට්ටලයකින් හෝ ශබ්ද කෝෂයකින් අයිතම ලබා ගැනීමේදී ඔබට වැරදි ප්‍රති results ල ලැබෙනු ඇත: හැෂ් කේතය වස්තුවක ආයු කාලය සමඟ වෙනස් නොවිය යුතුය (වඩාත් නිවැරදිව, හැෂ් කේතය අවශ්‍ය වන කාලය තුළ, එනම් සිටියදී ශබ්දකෝෂයක යතුරක්): නිදසුනක් ලෙස, අගය පොදු බැවින් පහත සඳහන් දේ වැරදියි, එම නිසා නිදසුනෙහි ජීවිත කාලය තුළ පන්තියට බාහිරව වෙනස් කළ හැකිය, එබැවින් ඔබ එය හැෂ් කේතයේ පදනම ලෙස භාවිතා නොකළ යුතුය:

   class A
   {
      public int Value;

      public override int GetHashCode()
      {
         return Value.GetHashCode(); //WRONG! Value is not constant during the instance's life time
      }
   }    

අනෙක් අතට, අගය වෙනස් කළ නොහැකි නම් එය භාවිතා කිරීම සුදුසු ය:

   class A
   {
      public readonly int Value;

      public override int GetHashCode()
      {
         return Value.GetHashCode(); //OK  Value is read-only and can't be changed during the instance's life time
      }
   }

සමාන () මගින් අර්ථ දක්වා ඇති පරිදි වස්තු දෙකක් සමාන නම් ඒවා එකම හැෂ් කේතය ආපසු ලබා දිය යුතු බවට ඔබ සැමවිටම සහතික විය යුතුය. වෙනත් සමහර අදහස් දැක්වෙන පරිදි, න්‍යාය අනුව මෙය හැෂ්සෙට් හෝ ශබ්ද කෝෂය වැනි හැෂ් පදනම් කරගත් බහාලුමක් තුළ කිසි විටෙකත් භාවිතා නොකරන්නේ නම් මෙය අනිවාර්ය නොවේ. සෑම විටම මෙම රීතිය අනුගමනය කරන ලෙස මම ඔබට උපදෙස් දෙමි. හේතුව හුදෙක් කාර්ය සාධනය වැඩි දියුණු කිරීම හෝ කේත අර්ථ නිරූපණය වඩා හොඳ ආකාරයකින් ගෙන ඒමේ හොඳ අභිප්‍රාය ඇතිව එක් වර්ගයක සිට තවත් වර්ගයකට එකතුවක් වෙනස් කිරීම කෙනෙකුට පහසු නොවන බැවිනි.

උදාහරණයක් ලෙස, අපි සමහර වස්තු ලැයිස්තුවක තබා ඇතැයි සිතමු. කලකට පසු යමෙකුට වැටහෙන්නේ නිදසුනක් ලෙස වඩා හොඳ සෙවුම් ලක්ෂණ නිසා හැෂ්සෙට් වඩා හොඳ විකල්පයක් බවයි. මෙය අපට කරදරයකට පත්විය හැකි අවස්ථාවකි. ලැයිස්තුව අභ්‍යන්තරව සුපුරුදු සමානාත්මතා සංසන්දකය භාවිතා කරයි, එයින් අදහස් වන්නේ ඔබේ නඩුවේ සම සමාන වන අතර හැෂ්සෙට් GetHashCode () භාවිතා කරයි. දෙදෙනා වෙනස් ලෙස හැසිරෙන්නේ නම්, ඔබේ වැඩසටහනද එසේමය. එවැනි ගැටළු නිරාකරණය සඳහා පහසුම නොවන බව මතක තබා ගන්න.

මම මෙම හැසිරීම වෙනත් GetHashCode () අන්තරායන් සමඟ සාරාංශ කොට ඇත බ්ලොග් අතර එහිදී ඔබට තවත් උදාහරණ සහ පැහැදිලි කිරීම් සොයාගත හැකිය.

අභිබවා .NET 4.7යාමේ වඩාත් කැමති ක්‍රමය අනුව GetHashCode()පහත දැක්වේ. පැරණි .NET අනුවාදයන් ඉලක්ක කරන්නේ නම්, System.ValueTuple nuget පැකේජය ඇතුළත් කරන්න .

// C# 7.0+
public override int GetHashCode() => (FooId, FooName).GetHashCode();

කාර්ය සාධනය අනුව, මෙම ක්‍රමය බොහෝ සංයුක්ත හැෂ් කේත ක්‍රියාත්මක කිරීම් අභිබවා යනු ඇත . මෙම ValueTuple යනු structඑසේ ඕනෑම කුණු නැති වෙන්නේ නැහැ, සහ යටින් ඇල්ගොරිතමය වේගයෙන් එය ලැබෙන පරිදි වේ.

මුල් GetHashCode () මඟින් වස්තුවේ මතක ලිපිනය ලබා දෙන බව මගේ වැටහීමයි, එබැවින් ඔබට විවිධ වස්තු දෙකක් සංසන්දනය කිරීමට අවශ්‍ය නම් එය අභිබවා යාම අත්‍යවශ්‍ය වේ.

සංස්කරණය කරන ලදි: එය වැරදියි, මුල් GetHashCode () ක්‍රමයට අගයන් 2 ක සමානාත්මතාවය සහතික කළ නොහැක. සමාන වස්තූන් එකම හැෂ් කේතය ලබා දුන්නද.

පරාවර්තනය භාවිතා කිරීමට පහළින් මට වඩා හොඳ විකල්පයක් ලෙස පෙනේ පොදු දේපල සලකා බැලීමේදී ඔබට දේපල එකතු කිරීම / ඉවත් කිරීම ගැන කරදර විය යුතු නැත (එතරම් පොදු තත්වයක් නොතිබුණද). මෙය වඩාත් හොඳින් ක්‍රියාත්මක වන බව මට පෙනී ගියේය. (විකර්ණ නැවතුම් ඔරලෝසුව භාවිතා කරන කාලය හා සසඳන විට).

    public int getHashCode()
    {
        PropertyInfo[] theProperties = this.GetType().GetProperties();
        int hash = 31;
        foreach (PropertyInfo info in theProperties)
        {
            if (info != null)
            {
                var value = info.GetValue(this,null);
                if(value != null)
                unchecked
                {
                    hash = 29 * hash ^ value.GetHashCode();
                }
            }
        }
        return hash;  
    }