Runtime: ハッシュコードの組み合わせに役立つHashCodeタイプの追加

迅速で汚いものが必要な場合は、 ValueTuple.Create(field1, field2).GetHashCode()使用できます。 これは、 Tupleで使用されているものと同じアルゴリズムであり（さらに言えば、 Objectsアルゴリズムと似ています）、割り当てのオーバーヘッドはありません。

それ以外の場合は、必要なハッシュの良さ、フィールド値の可能性（どのアルゴリズムが良い結果または悪い結果をもたらすかに影響する）、hashDoS攻撃の可能性、バイナリを法として衝突を行うかどうかについて質問があります-偶数が傷つく（バイナリの場合と同様に、ハッシュテーブルも同様）など、1つの適合をすべて適用できなくなります。

@JonHannaこれらの質問は、たとえばstring.GetHashCode()も当てはまると思います。 Hashを提供することがそれより難しい理由がわかりません。

実際には、特別な要件を持つユーザーはHash使用を簡単に停止できるため、より単純なはずですが、 string.GetHashCode()使用を停止するのは困難です。

+1

ASP.NET、 https：//github.com/aspnet/Common/blob/dev/src/Microsoft.Extensions.HashCodeCombiner.Sources/HashCodeCombiner.csにこれらの1つがあり

迅速で汚いものが必要な場合は、ValueTuple.Create（field1、field2）.GetHashCode（）を使用できます。

ああ、いい考えだ、この投稿をするとき、私はValueTupleについて考えていなかった。 残念ながら、C＃7 /次のフレームワークリリースまで、またはそれがそのパフォーマンスになるかどうかさえわかりません（ EqualityComparerへのプロパティ/メソッド呼び出しはEqualityComparer可能性があります）。 しかし、私はこれを測定するためのベンチマークをとっていないので、私は本当に知りません。 タプルをハックの回避策として使用せずに使用できる、ハッシュ専用の単純なクラスが必要だと思います。

それ以外の場合は、必要なハッシュの良さ、フィールド値の可能性（どのアルゴリズムが良い結果または悪い結果をもたらすかに影響する）、hashDoS攻撃の可能性、バイナリを法として衝突を行うかどうかについて質問があります-偶数が傷つく（バイナリの場合と同様に、ハッシュテーブルも同様）など、1つの適合をすべて適用できなくなります。

絶対に同意しましたが、実装の大部分はそれを考慮に入れていないと思います。たとえば、 ArraySegmentの現在の実装はかなり単純です。 このクラスの主な目的は（割り当てを回避するとともに）、ハッシュについてあまり知らない人々に、このような愚かなことをしないようにするための頼りになる実装を提供することです。 あなたが説明した状況に対処する必要がある人々は、独自のハッシュアルゴリズムを実装することができます。

残念ながら、C＃7 /次のフレームワークリリースまで利用できるとは思いません。

組み込みのサポートではなく、C＃2で使用できると思います。

または、それがそのパフォーマンスになるかどうかさえ知っています（EqualityComparerへのプロパティ/メソッド呼び出しは合計することができます）

このクラスは何が違うのでしょうか？ obj == null ? 0 : obj.GetHashCode()明示的に呼び出す方が速い場合は、それをValueTuple移動する必要があります。

私は数週間前にこの提案を+1する傾向がありましたが、 ValueTuple TupleがこれにValueTuple使用できますが、それ以上のものが必要な場合は、このようなクラスはそれほど進んでいません。足りる。

また、C＃7を使用する場合は、さらに簡単にするために構文糖衣構文を使用します。

@JonHanna

このクラスは何が違うのでしょうか？ obj == nullを明示的に呼び出す場合？ 0：obj.GetHashCode（）は、ValueTupleに移動するよりも高速です。

ValueTupleがハッシュコードを取得するためにHashクラスを使用しないのはなぜですか？ これにより、ファイル内のLOCも大幅に削減されます（現在、約2000行です）。

編集：

特に専門的なものが必要ない場合は、ValueTupleを使用できます

本当ですが、問題は、多くの人がそれを認識しておらず、独自の劣ったナイーブハッシュ関数（上記でリンクしたものなど）を実装している可能性があることです。

私は確かに遅れることができた。

おそらくこの問題の範囲外です。 しかし、専門家によって書かれた高性能の暗号化および非暗号化ハッシュを見つけることができるハッシュ名前空間を持つことは、ここでの勝利です。

たとえば、xxHash32、xxHash64、Metro128をコーディングし、128ビットから64ビットおよび64ビットから32ビットにダウンサンプリングする必要がありました。 最適化された関数の配列があると、開発者は最適化されていない関数やバグのある関数を作成しないようにすることができます（私たち自身にもいくつかのバグが見つかりました）。 しかし、それでもニーズに応じて選択することができます。

興味があれば、実装を喜んで寄付します。そうすれば、専門家がさらにレビューして最適化することができます。

@redknightloisSpookyHashの実装をそのような取り組みに追加できれば幸いです。

@svick string.GetHashCode（）に注意してください。ただし、これは非常に具体的であり、非常に正当な理由で、ハッシュDoS攻撃です。

@terrajobst 、これはAPIトリアージ/レビューキューのどこまでですか？ これは、私たちが常にプラットフォームに追加したいと思っていた単純なAPIだと思います。おそらく、実際にそれを実行するのに十分なクリティカルマスがありますか？

cc：@ellismg

現在の状態でレビューする準備ができていると思います。

@mellinoeそれは素晴らしいです！ 提案を少し整理して簡潔にし、最後にいくつか質問を追加して、対処する必要があると思います。

@jamesqo longベースもあるはずです。

@redknightlois 、合理的に聞こえます。 Combine longオーバーロードを含めるように提案を更新しました。

@JonHannaの提案は十分ではありませんか？

C# return ValueTuple.Create(a, b, c).GetHashCode();

それが十分ではない十分な理由がない限り、私たちはそれがカットをしているとは思わない。

生成されたコードが数桁悪化する以外に、他の十分な理由は考えられません。 もちろん、この特定のケースを念頭に置いて処理する最適化が新しいランタイムにない限り、この場合、この分析は重要ではありません。 私はこれを1.0.1で試したと言っています。

例を挙げて説明しましょう。

ValueTupleに使用されている実際のコードを取得し、定数を使用してそれを呼び出すと仮定します。

        internal static class HashHelpers
        {
            public static int Combine(int h1, int h2)
            {
                // The jit optimizes this to use the ROL instruction on x86
                // Related GitHub pull request: dotnet/coreclr#1830
                uint shift5 = ((uint)h1 << 5) | ((uint)h1 >> 27);
                return ((int)shift5 + h1) ^ h2;
            }
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        public static int TryStaticCall()
        {
            return HashHelpers.Combine(10202, 2003);
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        public static int TryValueTuple()
        {
            return ValueTuple.Create(10202, 2003).GetHashCode();
        }
    }

現在、最適化コンパイラの下では、違いはないはずですが、実際には違いがあります。

これはValueTupleの実際のコードです

では、ここで何を見ることができますか？ 最初にスタックに構造体を作成し、次に実際のハッシュコードを呼び出します。

ここで、 HashHelper.Combineの使用と比較します。これは、あらゆる目的で、 Hash.Combine実際の実装である可能性があります。

知っている！！！
しかし、そこで止まらないでください...実際のパラメータを使用しましょう：

        [MethodImpl(MethodImplOptions.NoInlining)]
        public static int TryStaticCall(int h1, int h2)
        {
            return HashHelpers.Combine(h1, h2);
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        public static int TryValueTuple(int h1, int h2)
        {
            return ValueTuple.Create(h1, h2).GetHashCode();
        }

        static unsafe void Main(string[] args)
        {
            var g = new Random();
            int h1 = g.Next();
            int h2 = g.Next(); 
            Console.WriteLine(TryStaticCall(h1, h2));
            Console.WriteLine(TryValueTuple(h1, h2));
        }

良いことですが、これは非常に安定しています。 しかし、それを別の方法と比較してみましょう。

さあ、船外に出ましょう...

        internal static class HashHelpers
        {
            public static int Combine(int h1, int h2)
            {
                // The jit optimizes this to use the ROL instruction on x86
                // Related GitHub pull request: dotnet/coreclr#1830
                uint shift5 = ((uint)h1 << 5) | ((uint)h1 >> 27);
                return ((int)shift5 + h1) ^ h2;
            }
            public static int Combine(int h1, int h2, int h3, int h4)
            {
                return Combine(Combine(h1, h2), Combine(h3, h4));
            }
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        public static int TryStaticCall(int h1, int h2, int h3, int h4)
        {
            return HashHelpers.Combine(h1, h2, h3, h4);
        }

そして結果はかなり例示的です

JITが呼び出しに対して生成する実際のコードを実際に検査することはできませんが、プロローグとエピローグだけで、提案を含めることを正当化できます。

分析の要点は単純です。保持タイプがstructということは、それが無料であることを意味するわけではありません:)

会議中にパフォーマンスが持ち上がりました。 問題は、このAPIがホットパス上にある可能性が高いかどうかです。 明確にするために、私はAPIを使用すべきではないと言っているのではありません。 具体的なシナリオがない限り、「Xに必要なので、Xが使用できるかどうか」とは言えないため、APIの設計は難しいと言っているだけです。 これは、新しいことを実行できないAPIにとって重要ですが、より最適化された方法で同じことを実行します。

高速で高品質のハッシュを使用することが重要であるほど、オブジェクトに使用されるアルゴリズムと表示される可能性のある値の範囲を調整することが重要になると思います。ヘルパーが多いほど、そのようなヘルパーを使用する必要はありません。

@terrajobst 、パフォーマンスはこの提案の主な動機でしたが、それだけではありませんでした。 専用のタイプがあると、発見しやすくなります。 C＃7に組み込みのタプルサポートがある場合でも、開発者は、それらが値と同等であることを必ずしも知っているとは限りません。 たとえそうだとしても、タプルがGetHashCodeオーバーライドすることを忘れてしまう可能性があり、.NETでGetHashCodeを実装する方法をGoogleに依頼することになります。

また、 ValueTuple.Create.GetHashCode使用には微妙な正確性の問題があります。 過去8つの要素、最後の8つの要素のみがハッシュされます。 残りは無視されます。

@terrajobst RavenDBでは、GetHashCodeのパフォーマンスが収益に大きな打撃を与えたため、高度に最適化されたルーチンのセット全体を実装することになりました。 Roslynでさえ独自の内部ハッシュを持っていますhttps://github.com/dotnet/roslyn/blob/master/src/Compilers/Core/Portable/InternalUtilities/Hash.cs特にここでRoslynに関する議論をチェックしてください： https：// github .com / dotnet / coreclr / issues / 1619 ...したがって、パフォーマンスが

また、 @ jamesqoの問題は完全に有効です。 それほど多くのハッシュを組み合わせる必要はありませんが、1Mの場合、崖を越えようとしている人がいます。

@JonHanna

高速で高品質のハッシュを使用することが重要であるほど、オブジェクトに使用されるアルゴリズムと表示される可能性のある値の範囲を調整することが重要になると思います。ヘルパーが多いほど、そのようなヘルパーを使用する必要はありません。

つまり、ヘルパークラスを追加すると、適切なハッシュの実行方法を考えずにヘルパー関数を投入するようになるため、悪いことになるということですか？

実際には、逆のことが当てはまるようです。 Hash.Combineは、通常、 GetHashCode実装を改善するはずです。 ハッシュの方法を知っている人は、 Hash.Combineを評価して、それが自分のユースケースに適合するかどうかを確認できます。 ハッシュについて本当に知らない初心者は、適切なハッシュを行う方法がわからないため、構成フィールドを排他的論理和（またはさらに悪いことに追加）する代わりにHash.Combineを使用します。

私たちはこれについてもう少し議論しました、そしてあなたは私たちを納得させました:-)

さらにいくつかの質問：

1. このタイプをどこに置くかを決める必要があります。 新しい名前空間の導入は奇妙に思えます。 ただし、 System.Numericsは機能する可能性があります。 System.Collections.Genericも機能する可能性があります。これは、比較機能があり、コレクションのコンテキストでハッシュが最も頻繁に使用されるためです。
2. 未知の数のハッシュコードを組み合わせるために、割り当てのないビルダーパターンを提供する必要がありますか？

（2）について、@ Eilonは次のように述べています。

参考までに、ASP.NET Core（およびその前身と関連プロジェクト）はHashCodeCombinerを使用します： https ：

（ @David Fowlerは、数か月前にGitHubスレッドでそれについて言及しました。）

そしてこれは使用例です： https ：

`` `C＃
var hashCodeCombiner = HashCodeCombiner.Start（）;
hashCodeCombiner.Add（IsMainPage？1：0）;
hashCodeCombiner.Add（ViewName、StringComparer.Ordinal）;
hashCodeCombiner.Add（ControllerName、StringComparer.Ordinal）;
hashCodeCombiner.Add（AreaName、StringComparer.Ordinal）;

if（ViewLocationExpanderValues！= null）
{{
foreach（ViewLocationExpanderValuesのvarアイテム）
{{
hashCodeCombiner.Add（item.Key、StringComparer.Ordinal）;
hashCodeCombiner.Add（item.Value、StringComparer.Ordinal）;
}
}

hashCodeCombinerを返します。
`` `

私たちはこれについてもう少し議論しました、そしてあなたは私たちを納得させました:-)

🎉

新しい名前空間の導入は奇妙に思えます。 System.Numericsは動作するかもしれません。

新しい名前空間を追加しないことにした場合、 Hashという名前のクラスとusing System.Numericsディレクティブを持つコードは、あいまいな型エラーでコンパイルに失敗することに注意してください。

未知の数のハッシュコードを組み合わせるために、割り当てのないビルダーパターンを提供する必要がありますか？

これは素晴らしいアイデアのように聞こえます。 初期の提案のカップルとして、おそらく我々はそれに名前を付ける必要がありますHashBuilder （ラStringBuilder ）と、それを持っているreturn this 、すべての後にAddそれを容易にするための方法次のようにハッシュを追加するには：

public override int GetHashCode()
{
    return HashBuilder.Create(_field1)
        .Add(_field2)
        .Add(_field3)
        .ToHash();
}

@jamesqoスレッドでコンセンサスが得られ

新しい名前空間を追加しないことにした場合、 Hashという名前のクラスとusing System.Numericsディレクティブを持つコードは、あいまいな型エラーでコンパイルに失敗することに注意してください。

実際のシナリオによって異なります。 多くの場合、ディレクティブの使用を検討する前にコンパイル単位の定義済み名前空間階層がウォークされるため、コンパイラーはユーザーのタイプを優先します。

ただし、それでも、APIの追加はソースを壊すような変更になる可能性があります。 ただし、これを回避することは現実的ではありません。前進したい場合は😄一般的に、あまり一般的ではない名前を使用するなどして、競合を回避するように努めています。 たとえば、タイプをHashと呼ぶべきではないと思います。 HashCode方がいいと思います。

最初のいくつかの提案として、おそらくHashBuilderという名前を付ける必要があります

最初の概算として、私は静力学とビルダーを1つのタイプに結合することを考えていました。

`` `C＃
名前空間System.Collections.Generic
{{
public struct HashCode
{{
public static int Combine（int hash1、int hash2）;
public static int Combine（int hash1、int hash2、int hash3）;
public static int Combine（int hash1、int hash2、int hash3、int hash4）;
public static int Combine（int hash1、int hash2、int hash3、int hash4、int hash5）;
public static int Combine（int hash1、int hash2、int hash3、int hash4、int hash5、int hash6）;

    public static long Combine(long hash1, long hash2);
    public static long Combine(long hash1, long hash2, long hash3);
    public static long Combine(long hash1, long hash2, long hash3, long hash4);
    public static long Combine(long hash1, long hash2, long hash3, long hash4, long hash5);
    public static long Combine(long hash1, long hash2, long hash3, long hash4, long hash5, longhash6);

    public static int CombineHashCodes<T1, T2>(T1 o1, T2 o2);
    public static int CombineHashCodes<T1, T2, T3>(T1 o1, T2 o2, T3 o3);
    public static int CombineHashCodes<T1, T2, T3, T4>(T1 o1, T2 o2, T3 o3, T4 o4);
    public static int CombineHashCodes<T1, T2, T3, T4, T5>(T1 o1, T2 o2, T3 o3, T4 o4, T5 o5);
    public static int CombineHashCodes<T1, T2, T3, T4, T5, T6>(T1 o1, T2 o2, T3 o3, T4 o4, T5 o5, T6 o6);

    public void Combine(int hashCode);
    public void Combine(long hashCode);
    public void Combine<T>(T obj);
    public void Combine(string text, StringComparison comparison);

    public int Value { get; }
}

}

This allows for code like this:

``` C#
return HashCode.Combine(value1, value2);

としても：

`` `C＃
var hashCode = new HashCode（）;
hashCode.Combine（IsMainPage？1：0）;
hashCode.Combine（ViewName、StringComparer.Ordinal）;
hashCode.Combine（ControllerName、StringComparer.Ordinal）;
hashCode.Combine（AreaName、StringComparer.Ordinal）;

if（ViewLocationExpanderValues！= null）
{{
foreach（ViewLocationExpanderValuesのvarアイテム）
{{
hashCode.Combine（item.Key、StringComparer.Ordinal）;
hashCode.Combine（item.Value、StringComparer.Ordinal）;
}
}

hashCode.Valueを返します。
`` `

考え？

@jamesqoの連鎖呼び出しのアイデアが好きCombineからthisを返します）。

静的メソッドを完全に削除し、インスタンスメソッドだけを保持することさえします...

Combine(long hashCode)はintキャストダウンされます。 本当に欲しいですか？
そもそもlongオーバーロードのユースケースは何ですか？

@karelzそれらを削除しないでください。構造体は無料ではありません。 ハッシュは非常にホットなパスで使用できます。静的メソッドが本質的に無料である場合、命令を無駄にしたくないことは確かです。 囲んでいる構造体の実際の影響を示したコードの分析を見てください。

名前の衝突を避けるためにHashing静的クラスを使用しました。コードは見栄えがします。

@redknightlois 1つのintフィールドを持つ非ジェネリック構造体の場合にも、同じ「悪い」コードを期待すべきかどうか疑問に思います。
それでも「悪い」アセンブリコードである場合は、ここで最適化をより適切に行うためにJITを改善できるかどうか疑問に思います。 いくつかの指示を保存するためだけにAPIを追加することは、私たちの最後の手段であるIMOです。

@redknightlois好奇心がHashCode ）がレジスターに収まる場合、JITはより悪いコードを生成しますか？ 大きさはintだけになります。

また、最近、構造体の周りに生成されたコードを改善するためにcoreclrで多くのプル要求が見られ、dotnet / coreclr＃8057がそれらの最適化を可能にするようです。 おそらく、この変更後、JITが生成するコードはより良くなるでしょうか？

編集： @karelzがすでにここで私のポイントについて言及しているのが

@karelz 、私はあなたに同意します-JITがintサイズの構造体に対して適切なコードを生成すると仮定すると（たとえば、 ImmutableArrayにはオーバーヘッドがないと思います）、静的なオーバーロードは冗長であり、削除することができます。

@terrajobst私が持っているいくつかのアイデア：

• 私たちはあなたと私のアイデアを少し組み合わせることができると思います。 HashCodeは良い名前のようです。 ビルダーパターンに従った可変構造体である必要はありません。 代わりに、 int周りの不変ラッパーにすることができ、すべてのCombine操作は新しいHashCode値を返すことができます。 例えば

public struct HashCode
{
    private readonly int _hash;

    public HashCode Combine(int hash) => return new HashCode(CombineCore(_hash, hash));

    public HashCode Combine<T>(T item) => Combine(EqualityComparer<T>.Default.GetHashCode(item));
}

// Usage
HashCode combined = new HashCode(_field1)
    .Combine(_field2)
    .Combine(_field3);

• intに変換するための暗黙の演算子が必要なので、最後の.Value呼び出しを行う必要はありません。
• Combine 、それは最高の名前ですか？ より説明的に聞こえますが、 Addは短く、入力が簡単です。 （ Mixは別の選択肢ですが、入力するのは少し面倒です。）
  
  
  
  • public void Combine(string text, StringComparison comparison) ：これは文字列とは無関係なので、実際には同じタイプに属しているとは思いません。 その上、あなたがそうする必要があるそれらのまれな時のためにStringComparer.XXX.GetHashCode(str)を書くことは十分に簡単です。
  
  
  • このタイプからlongオーバーロードを削除し、long用に別のHashCodeタイプを用意する必要があります。 Int64HashCode 、またはLongHashCode 。
  
  

私はTryRoslynで物事の小さなサンプル実装を作成しました： http ：//tinyurl.com/zej9yux

幸いなことに、確認は簡単です。 そして、良いニュースは、それがそのまま正しく機能することです👍

人々が最後の.Value呼び出しをする必要がないように、intに変換するための暗黙の演算子が必要です。

おそらく、コードはそれほど単純ではなく、暗黙の変換を行うと少しクリーンアップされます。 私はまだ、複数のパラメーターのインターフェースを持つことができるという考えが好きです。

        [MethodImpl(MethodImplOptions.NoInlining)]
        public static int TryHashCombiner(int h1, int h2, int h3, int h4)
        {
            var h = new HashCode(h1).Combine(h2).Combine(h3).Combine(h4);
            return h.Value;
        }

再結合、それは最高の名前ですか？ より説明的に聞こえますが、Addは短く、入力が簡単です。 （ミックスは別の選択肢ですが、入力するのは少し面倒です。）

Combineは、ハッシュコミュニティafaikで使用される実際の名前です。 そして、それはあなたにそれが何をしているのかについての明確な考えを与えるようなものです。

@jamesqoハッシュ関数はたくさんあり、RavenDBでは32ビット、64ビットから128ビットまでの非常に高速なバージョンを実装する必要がありました（そして、それぞれをさまざまな目的に使用します）。

この設計では、次のような拡張可能なメカニズムを使用して前向きに考えることができます。

        internal interface IHashCode<T> where T : struct
        {
            T Combine(T h1, T h2);
        }

        internal struct RotateHashCode : IHashCode<int>, IHashCode<long>
        {
            long IHashCode<long>.Combine(long h1, long h2)
            {
                // The jit optimizes this to use the ROL instruction on x86
                // Related GitHub pull request: dotnet/coreclr#1830
                ulong shift5 = ((ulong)h1 << 5) | ((ulong)h1 >> 27);
                return ((int)shift5 + h1) ^ h2;
            }

            int IHashCode<int>.Combine(int h1, int h2)
            {
                // The jit optimizes this to use the ROL instruction on x86
                // Related GitHub pull request: dotnet/coreclr#1830
                uint shift5 = ((uint)h1 << 5) | ((uint)h1 >> 27);
                return ((int)shift5 + h1) ^ h2;
            }
        }

        internal struct HashCodeCombiner<T, W> where T : struct, IHashCode<W>
                                               where W : struct
        {
            private static T hasher;
            public W Value;

            static HashCodeCombiner()
            {
                hasher = new T();
            }

            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            public HashCodeCombiner(W seed)
            {
                this.Value = seed;
            }

            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            public HashCodeCombiner<T,W> Combine( W h1 )
            {
                Value = hasher.Combine(this.Value, h1);
                return this;
            }
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        public static int TryHashCombinerT(int h1, int h2, int h3, int h4)
        {
            var h = new HashCodeCombiner<RotateHashCode, int>(h1).Combine(h2).Combine(h3).Combine(h4);
            return h.Value;
        }

JITがこのために非常に厄介なプロローグコードを作成している理由はわかりません。 おそらく最適化できるはずではないので、JIT開発者に依頼する必要があります。 ただし、残りの部分では、1つの命令を無駄にすることなく、必要な数の異なるコンバイナーを実装できます。 そうは言っても、この方法は、コンバイナーよりも実際のハッシュ関数の方がおそらく便利です。 cc @CarolEidt @AndyAyersMS

編集：単一のハッシュ概念の傘の下で暗号化と非暗号化ハッシュ関数を組み合わせる一般的なメカニズムについて、ここで大声で考えてください。

@jamesqo

ビルダーパターンに従った可変構造体である必要はありません

そうそう。 その場合、私はそのパターンで大丈夫です。 操作に副作用があった場合にインスタンスを返すパターンは一般的に好きではありません。 APIが不変のWithXxxパターンに従っている場合は特に悪いです。 ただし、この場合、パターンは本質的に不変のデータ構造であるため、パターンは正常に機能します。

私たちはあなたと私のアイデアを少し組み合わせることができると思います。

👍、だからどうですか：

`` `C＃
public struct HashCode
{{
public static HashCode Create（T obj）;

[Pure] public HashCode Combine(int hashCode);
[Pure] public HashCode Combine(long hashCode);
[Pure] public HashCode Combine<T>(T obj);
[Pure] public HashCode Combine(string text, StringComparison comparison);

public int Value { get; }

public static implicit operator int(HashCode hashCode);

}

This allows for code like this:

``` C#
public override int GetHashCode()
{
    return HashCode.Create(value1).Combine(value2);
}

これと同様に：

`` `C＃
var hashCode = new HashCode（）
.Combine（IsMainPage？1：0）
.Combine（ViewName、StringComparer.Ordinal）
.Combine（ControllerName、StringComparer.Ordinal）
.Combine（AreaName、StringComparer.Ordinal）;

if（ViewLocationExpanderValues！= null）
{{
foreach（ViewLocationExpanderValuesのvarアイテム）
{{
hashCode = hashCode.Combine（item.Key、StringComparer.Ordinal）;
hashCode = hashCode.Combine（item.Value、StringComparer.Ordinal）;
}
}

hashCode.Valueを返します。
`` `

@terrajobst考え：

1. Create<T>ファクトリメソッドを削除する必要があります。 そうでなければ、同じものを書く2つの方法、 HashCode.Create(_val)またはnew HashCode().Combine(_val)ます。 また、 Create / Combine異なる名前を付けると、新しい最初のフィールドを追加した場合に2行を変更する必要があるため、差分に適していません。
2. string / StringComparisonを受け入れるオーバーロードはここに属しているとは思いません。 HashCodeは文字列とは何の関係もありません。 代わりに、文字列にGetHashCode(StringComparison) apiを追加する必要がありますか？ （また、これらはすべて序数の比較であり、これはstring.GetHashCodeのデフォルトの動作です。）
3. int変換するための暗黙の演算子がすでに存在する場合、 Valueを使用する意味は何ですか？ 繰り返しますが、これはさまざまな人々がさまざまなことを書くことにつながります。
4. longオーバーロードを新しいタイプに移動する必要があります。 HashCodeは32ビット幅のみになります。 長くは収まりません。
5. ハッシュでより一般的であるため、符号なし型を使用するオーバーロードをいくつか追加しましょう。

これが私の提案するAPIです：

public struct HashCode
{
    public HashCode Combine(int hash);
    public HashCode Combine(uint hash);
    public HashCode Combine<T>(T obj);

    public static implicit operator int(HashCode hashCode);
    public static implicit operator uint(HashCode hashCode);
}

public struct Int64HashCode
{
    public Int64HashCode Combine(long hash);
    public Int64HashCode Combine(ulong hash);

    public static implicit operator long(Int64HashCode hashCode);
    public static implicit operator ulong(Int64HashCode hashCode);
}

これらのメソッドのみを使用しても、ASP.NETの例は次のように記述できます。

var hashCode = new HashCode()
    .Combine(IsMainPage ? 1 : 0)
    .Combine(ViewName)
    .Combine(ControllerName)
    .Combine(AreaName);

if (ViewLocationExpanderValues != null)
{
    foreach (var item in ViewLocationExpanderValues)
    {
        hashCode = hashCode.Combine(item.Key);
        hashCode = hashCode.Combine(item.Value);
    }
}

return hashCode;

@jamesqo

int変換するための暗黙の演算子がすでに存在する場合、 Valueを使用する意味は何ですか？ 繰り返しますが、これはさまざまな人々がさまざまなことを書くことにつながります。

演算子のオーバーロードに関するフレームワーク設計ガイドラインは次のように述べています。

オーバーロードされた各演算子に対応するフレンドリ名を持つメソッドを提供することを検討してください。

多くの言語は、演算子のオーバーロードをサポートしていません。 このため、演算子をオーバーロードする型には、同等の機能を提供する適切なドメイン固有の名前を持つセカンダリメソッドを含めることをお勧めします。

具体的には、F＃は、暗黙の変換演算子を呼び出すのが面倒な言語の1つです。

また、物事を行う方法が1つしかないことはそれほど重要ではないと思います。 私の意見では、APIを便利にすることがより重要です。 少数の値のハッシュコードを組み合わせたいだけの場合、 HashCode.CombineHashCodes(value1, value2, value3)は、 new HashCode().Combine(value1).Combine(value2).Combine(value3)よりも単純で、短く、理解しやすいと思います。

インスタンスメソッドAPIは、より複雑なケースでも役立ちますが、より一般的なケースでは、より単純な静的メソッドAPIを使用する必要があると思います。

@svick 、他の言語が演算子をサポートしていないというあなたのValue追加しましょう。

物事を行う方法が1つしかないことはそれほど重要ではないと思います。

大事です。 誰かがそれを一方の方法で行い、それを別の方法で行う人のコードを読んだ場合、その人は他の方法で何をするかをグーグルに伝えなければなりません。

少数の値のハッシュコードを結合したいだけの場合、HashCode.CombineHashCodes（value1、value2、value3）は、新しいHashCode（）。Combine（value1）.Combine（value2）.Combine（値3）。

• 静的メソッドの問題は、 params int[]オーバーロードがないため、異なるアリティごとにオーバーロードを追加する必要があることです。 1つのメソッドですべてのユースケースをカバーする方がはるかに便利です。
• 2番目の形式は、1回または2回見れば理解しやすいでしょう。 実際、垂直方向にチェーンする方が簡単なので（したがって、フィールドが追加/削除されたときの差分が最小限に抑えられるため）、より読みやすいと主張することができます。

public override int GetHashCode()
{
    return new HashCode()
        .Combine(_field1)
        .Combine(_field2)
        .Combine(_field3)
        .Combine(_field4);
}

[@svick]物事を行う方法が1つしかないことはそれほど重要ではないと思います。

混乱を避けるため、同じことができる方法の数を最小限に抑えることが重要だと思います。 同時に、発見可能性、利便性、パフォーマンス、読みやすさなどの他の目標を実現するのに役立つ場合、私たちの目標は100％重複しないことではありません。 一般的に、私たちの目標は、APIではなく概念を最小限に抑えることです。 たとえば、複数のオーバーロードは、用語がばらばらな複数の異なるメソッドを使用するよりも問題が少なくなります。

ファクトリメソッドを追加した理由は、初期ハッシュコードを取得する方法を明確にするためです。 空の構造体の後にCombine作成することは、あまり直感的ではないようです。 論理的には.ctorを追加することですが、ボックス化を回避するには、.ctorでは実行できない汎用である必要があります。 ジェネリックファクトリメソッドは次善の策です。

優れた副作用は、フレームワークで不変のデータ構造がどのように見えるかと非常によく似ていることです。 また、API設計では、他のほとんどのものよりも一貫性を強く優先します。

[@svick]少数の値のハッシュコードを結合したいだけの場合、HashCode.CombineHashCodes（value1、value2、value3）は、新しいHashCode（）。Combine（value1）.Combine（value2）よりも単純で、短く、理解しやすいと思います。 ）.Combine（value3）。

私は@jamesqoに同意し点（インライナーがどれだけ優れているかに応じて）。

[@jamesqo]文字列/ StringComparisonを受け入れるオーバーロードはここに属しているとは思いません。 HashCodeは文字列とは何の関係もありません

フェアポイント。 @Eilonのコードで参照されていたので追加しました。 経験から、文字列は非常に一般的だと思います。 一方で、比較を指定するかどうかはわかりません。 とりあえずそのままにしておきましょう。

[@jamesqo]長いオーバーロードを新しいタイプに移動する必要があります。 HashCodeは32ビット幅のみになります。 長くは収まりません。

それは良い点です。 longバージョンも必要ですか？ 上で述べたので、私はそれを残しただけで、私はそれについて本当に考えていませんでした。

私が今、32ビットだけを残す必要があるようです。それが.NET GetHashCode()です。 その意味で、 uintバージョンを追加する必要があるかどうかさえわかりません。 その領域外でハッシュを使用する場合は、 System.Security.Cryptographyにあるより汎用的なハッシュアルゴリズムをユーザーに紹介しても問題ないと思います。

`` `C＃
public struct HashCode
{{
public static HashCode Create（T obj）;

[Pure] public HashCode Combine(int hashCode);
[Pure] public HashCode Combine<T>(T obj);

public int Value { get; }

public static implicit operator int(HashCode hashCode);

}
`` `

私が今、32ビットだけを残す必要があるようです。それが.NET GetHashCode（）の目的だからです。 その意味で、uintバージョンを追加する必要があるかどうかさえわかりません。 その領域外でハッシュを使用する場合は、System.Security.Cryptographyにあるより汎用的なハッシュアルゴリズムをユーザーに紹介しても問題ないと思います。

@terrajobstハッシュアルゴリズムには非常に異なるタイプがあり、実際の動物園です。 実際、おそらく70％は設計上暗号化されていません。 そして、おそらくそれらの半分以上が64ビット以上を処理するように設計されています（一般的なターゲットは128/256です）。 フレームワークが私が賭けた32ビットを使用することを決定したのは（私はそこにいませんでした）、当時x86はまだ巨大な消費者であり、ハッシュがいたるところに使用されていたため、より少ないハードウェアでのパフォーマンスが最重要でした。

また、厳密に言うと、ほとんどのハッシュ関数は実際にはuintドメインで定義されており、シフトのルールが異なるため、 intでは定義されていません。 実際、私が以前に投稿したコードを確認すると、そのためにintはすぐにuintに変換されます（そしてror/rol最適化を使用します）。 念のために言っておきますが、厳密にしたい場合は、ハッシュはuintのみにする必要があります。これは、フレームワークがその光の下でint返すという見落としと見なすことができます。

これをint制限することは、現在の状況に勝るものはありません。 それが私の電話だった場合、私は設計チームにプッシュして、128と256のバリアントとさまざまなハッシュ関数のサポートに対応する方法を検討しました（指紋の下に考えない代替手段を投げたとしても）。

過度の単純化によって引き起こされる問題は、複雑なものを処理することを余儀なくされたときに導入される設計の問題よりも悪い場合があります。 開発者はnot being able to deal with having multiple options認識されているため、機能を大幅に簡素化すると、SIMDの現在の状態のパスに簡単につながる可能性があります。 ほとんどのパフォーマンスに敏感な開発者はそれを使用できません。また、ほとんどの開発者は、とにかくそのような細かいスループット目標を持つパフォーマンスに敏感なアプリケーションを扱っていないため、他の誰もそれを使用しません。

ハッシュの場合も同様で、32ビットを使用するドメインは非常に制限されており（ほとんどはすでにフレームワーク自体でカバーされています）、残りは運が悪いです。

また、75000を超える要素を処理する必要があるとすぐに、衝突が発生する可能性が50％になります。これは、ほとんどのシナリオで悪いことです（これは、適切に設計されたハッシュ関数があることを前提としています）。 そのため、64ビットと128ビットはランタイム構造の境界の外で使用されます。

デザインがintに固執しているので、2000年に月曜日の新聞がなかったために発生した問題のみを取り上げています（したがって、今では誰もが自分で貧弱なハッシュを書いています）が、アートも。

それは私の2セントの議論です。

@ redknightlois 、intハッシュの制限を理解していると思います。 しかし、私は@terrajobstに同意し

128ビットでハッシュ結合を実行してからintに変換し、GetHahsCodeから結果を返すことがまだ有益であると思われる場合を除きます。

@KrzysztofCwalina私はそれが2つの異なるアプローチであることに同意します。 1つは、2000で発生した問題を修正することです。 もう1つは、一般的なハッシュの問題に取り組むことです。 これが前者の解決策であることに私たち全員が同意すれば、議論は終わりです。 ただし、「将来」のマイルストーンの設計に関する議論では、それが不十分であると感じています。これは主に、ここで行うことが将来の議論に影響を与えるためです。 ここでミスをすると、影響があります。

@redknightlois 、私は次のことを提案します。将来について心配する必要がないかのようにAPIを設計しましょう。 次に、将来のAPIで問題が発生すると思われる設計の選択について説明します。 また、c2000 APIをcorfxに追加し、並行してcorfxlabの将来のAPIを試してみてください。これにより、追加に関連する問題が明らかになります。

@redknightlois

ここでミスをすると、影響があります。

将来、より高度なシナリオをサポートしたい場合は、 HashCodeとは別のタイプでサポートできると思います。 ここでの決定は、これらのケースに実際に影響を与えるべきではありません。

私はそれに取り組み始めるために別の問題を作成しました。

@redknightlois ：+1:。 ところで、コメントを編集する前にあなたは応答しましたが、実際には、ハッシュを任意の型（int、long、decimalなど）で機能させ、コアハッシュロジックを構造体にカプセル化するというあなたのアイデア（上記）を試しました： https://github.com/jamesqo/HashApi （サンプルの使用法はこちら）。 しかし、2つのジェネリック型パラメーターを持つことは非常に複雑になり、APIを使用しようとするとコンパイラー型推論が機能しなくなりました。 そうです、今のところ、より高度なハッシュを別の問題にまとめることをお勧めします。

@terrajobst APIはほぼ準備ができているようですが、変更したいことが1つか2つあります。

• HashCode.Create(x)はnew HashCode().Combine(x)と同じ効果があるため、最初は静的ファクトリメソッドは必要ありませんCreate名前をCombineませんか？ 最初のフィールドに1つ入力し、2番目のフィールドに別の入力をしなければならないのはちょっと面倒なようです。
• HashCode IEquatable<HashCode>を実装し、いくつかの等式演算子を実装する必要があると思います。 異議がある場合は、遠慮なくお知らせください。

（うまくいけば）最終的な提案：

public struct HashCode : IEquatable<HashCode>
{
    public static HashCode Combine(int hash);
    public static HashCode Combine<T>(T obj);

    public HashCode Combine(int hash);
    public HashCode Combine<T>(T obj);

    public int Value { get; }

    public static implicit operator int(HashCode hashCode);

    public static bool operator ==(HashCode left, HashCode right);
    public static bool operator !=(HashCode left, HashCode right);

    public override bool Equals(object obj);
    public override bool Equals(HashCode other);
    public override int GetHashCode();
}

// Usage:

public override int GetHashCode()
{
    return HashCode
        .Combine(_field1)
        .Combine(_field2)
        .Combine(_field3)
        .Combine(_field4);
}

@terrajobstは言った：

フェアポイント。 @Eilonのコードで参照されていたので追加しました。 経験から、文字列は非常に一般的だと思います。 一方で、比較を指定するかどうかはわかりません。 とりあえずそのままにしておきましょう。

これは実際には非常に重要です。文字列のハッシュを作成するには、その文字列の目的を考慮する必要があります。これには、文化と大文字と小文字の区別の両方が含まれます。 StringComparerは、それ自体が比較ではなく、カルチャ/ケース対応の特定のGetHashCode実装を提供することを目的としています。

このAPIがないと、次のような奇妙なことをする必要があります。

HashCode.Combine(str1.ToLowerInvariant()).Combine(str2.ToLowerInvariant())

そして、それは割り当てがぎっしり詰まっていて、文化に敏感でないパターンなどに従います。

このような場合の@Eilon私は、コードを明示的に呼び出す必要が期待されるstring.GetHashCode(StringComparison comparison)文化/ケース-認識しているととして結果を渡すintにCombine 。

c# HashCode.Combine(str1.GetHashCode(StringComparer.Ordinal)).Combine(...)

@ Eilon 、StringComparer.InvariantCultureIgnoreCase.GetHashCodeを使用できます。

これらは割り当ての点では確かに優れていますが、これらの呼び出しは見た目がよくありません...ハッシュにカルチャ/ケース対応の文字列を含める必要があるASP.NET全体で使用しています。

上で述べたことをすべて組み合わせて、この形はどうですか？

`` `C＃
名前空間System.Collections.Generic
{{
public struct HashCode：IEquatable
{{
public static HashCode Combine（int hash）;
public static HashCode Combine（T obj）;
public static HashCode Combine（string text、StringComparison Comparison）;

    public HashCode Combine(int hash);
    public HashCode Combine<T>(T obj);
    public HashCode Combine(string text, StringComparison comparison);

    public int Value { get; }

    public static implicit operator int(HashCode hashCode);

    public static bool operator ==(HashCode left, HashCode right);
    public static bool operator !=(HashCode left, HashCode right);

    public override bool Equals(object obj);
    public override bool Equals(HashCode other);
    public override int GetHashCode();
}

}

// 使用法：

public override int GetHashCode（）
{{
HashCode.Combine（_field1）を返します
.Combine（_field2）
.Combine（_field3）
.Combine（_field4）;
}
`` `

それを出荷！ :-)

@terrajobst _Hold on --_ Combine(string, StringComparison)拡張メソッドとして実装することはできませんか？

public static class HashCodeExtensions
{
    public static HashCode Combine(this HashCode hashCode, string text, StringComparison comparison)
    {
        switch (comparison)
        {
            case StringComparison.Ordinal:
                return HashCode.Combine(StringComparer.Ordinal.GetHashCode(text));
            case StringComparison.OrdinalIgnoreCase:
                ...
        }
    }
}

型アノテーションの一部ではなく、拡張メソッドである方がはるかに望ましいです。 ただし、あなたまたは@Elionがこれを組み込みの方法であると絶対に考えている場合は、この提案をブロックしません。

（編集： Collections.Genericにハッシュ関連の型がない限り、 System.Numericsがおそらくより良い名前空間です。）

LGTM。 私は延長に行きます。

はい、それは拡張メソッドである可能性がありますが、それはどのような問題を解決しますか？

@terrajobst

はい、それは拡張メソッドである可能性がありますが、それはどのような問題を解決しますか？

私はASP.NETコードで提案していました。 それらのユースケースで一般的である場合、それは問題ありませんが、他のライブラリ/アプリには当てはまらない可能性があります。 これが後で十分に一般的であることが判明した場合は、いつでも再評価して、別の提案に追加することを決定できます。

うーん、これはとにかくコアです。 定義すると、とにかく署名の一部になります。 コメントをスクラップします。 そのままでも大丈夫です。

拡張メソッドの使用は、次の場合に役立ちます。

1. これは既存のタイプであり、タイプ自体の更新を出荷することなく拡張したいと考えています。
2. レイヤリングの問題を解決する
3. 非常に一般的なAPIを、あまり使用されていないAPIから分離します。

ここでは（1）や（2）は当てはまらないと思います。 （3）は、コードをHashCodeとは異なるアセンブリに移動する場合、またはコードを別の名前空間に移動する場合にのみ役立ちます。 文字列は十分に一般的であるため、価値がないと主張します。 実際、それらは非常に一般的であるため、拡張タイプで人為的に分離しようとするよりも、ファーストクラスとして扱う方が理にかなっていると私は主張します。

@terrajobst 、明確にするために、私はstring APIを完全に捨てて、文字列の独自の拡張メソッドを作成するためにASP.NETに任せることを提案していました。

文字列は十分に一般的であるため、価値がないと主張します。 実際、それらは非常に一般的であるため、拡張タイプで人為的に分離しようとするよりも、ファーストクラスとして扱う方が理にかなっていると私は主張します。

はい。ただし、文字列の非順序ハッシュコードを取得することは一般的です。これは、既存のCombine<T>オーバーロードが処理しない唯一のシナリオです。 （たとえば、オーバーライドでStringComparer.CurrentCulture.GetHashCodeを呼び出す人はいますか？）私は間違っているかもしれませんが、多くは見ていません。

これに対する反発をお詫びします。 APIが追加されると、元に戻すことはできません。

はい、しかし誰かが文字列の非順序ハッシュコードを取得したいのはどれほど一般的ですか

私は偏見があるかもしれませんが、ケースの不変性は非常に人気があります。 確かに、カルチャ固有のハッシュコードを気にする人はそれほど多くありませんが、大文字と@ Eilonが後をようです（ StringComparison.OrdinalIgnoreCase ）。

これに対する反発をお詫びします。 APIが追加されると、元に戻すことはできません。

冗談ではありません😈同意しましたが、APIがあまり使用されていなくても、それは便利で害を及ぼすことはありません。

@terrajobstでは、追加しましょう：+1：最後の問題：これについては上記で説明しましたが、Collections.GenericではなくNumericsという名前空間を作成できますか？ @redknightloisが示唆するように、将来、ハッシュ関連のタイプをさらに追加する場合、それらはコレクションでの誤称になると思います。

私はそれを愛しています。 🍔

ハッシュが概念的にコレクションに分類されるとは思いません。 System.Runtimeはどうですか？

私は同じ、あるいはシステムさえも提案するつもりでした。 数値でもありません。

@ karelz 、System.Runtimeが機能する可能性があります。 @redknightloisシステムは、その名前空間をすでにインポートしている可能性があるため、便利です。 ただし、それが適切である場合はDunnoです（ここでも、ハッシュタイプがさらに追加されている場合）。

これは秘教的で非常に特殊なケースのためのものであるため、 System.Runtime入れるべきではありません。 @KrzysztofCwalinaと話をし

• System
• System.Collections.*

私たちは両方ともSystem傾いています。

私たちが必要としているのがSystemに行く理由の論理的根拠である場合、私は正当化を試みることができます。 私たちは、構築されたHashCodeの実装で助けにobject.GetHashCode() 、それは両方の名前空間を共有することをフィッティング音。

@terrajobstでは、 Systemを名前空間にする必要があると思います。 ：shipit：しましょう

説明のAPI仕様を更新しました。

[@redknightlois]必要なのがSystemに行く理由の論理的根拠である場合、私は正当化を試みることができます。 私たちは、構築されたHashCodeの実装で助けにobject.GetHashCode() 、それは両方の名前空間を共有することをフィッティング音。

それが@KrzysztofCwalinaと私も使用した理論的根拠でした。 売り切れました！

@jamesqo

PRにも実装を提供したいと思いますか？

@terrajobstはい、

はい、間違いなく。

甘い。 その場合、私はそれをあなたに割り当てたままにしておきます。 @karelzはいいですか？

これを確認するために時間を割いていただきありがとうございます！

APIシェイプの作成に時間を割いていただき、ありがとうございます。 行ったり来たりするのは骨の折れるプロセスです。 どうぞよろしくお願いいたします。

そして、ASP.NET Coreの実装を削除し、代わりにこれを使用することを楽しみにしています😄

public static HashCode Combine（string text、StringComparison Comparison）;
public HashCode Combine（string text、StringComparison Comparison）;

NIT：上のメソッドString取るStringComparison例えば（ Equals 、 Compare 、 StartsWith 、 EndsWithなどを、 。） comparisonではなく、パラメータの名前としてcomparisonTypeを使用します。 一貫性を保つために、ここでもパラメータにcomparisonTypeという名前を付ける必要がありますか？

@justinvp 、これはStringのメソッドの命名上の欠陥のようです。 Typeは冗長です。 新しいAPIのパラメーター名を、古いAPIの「前例に従う」ためだけに冗長にする必要はないと思います。

別のデータポイントとして、 xUnitはcomparisonTypeも使用することを選択しました。

@justinvpあなたは私を納得させました。 直感的に考えると、「大文字と小文字を区別しない」または「文化に依存する」は「タイプ」の比較です。 名前を変更します。

私はこれの形で大丈夫ですが、StringComparisonに関しては、可能な代替案は次のとおりです。

含めないでください：

`` `C＃
public static HashCode Combine（string text、StringComparison Comparison）;
public HashCode Combine（string text、StringComparison Comparison）;

Instead, add a method:

``` C#
public class StringComparer
{
    public static StringComparer FromComparison(StringComparison comparison);
    ...
}

次に、書く代わりに：

`` `C＃
public override int GetHashCode（）
{{
HashCode.Combine（_field1）を返します
.Combine（_field2）
.Combine（_field3）
.Combine（_field4、_comparison）;
}

you write:

``` C#
public override int GetHashCode()
{
    return HashCode.Combine(_field1)
                   .Combine(_field2)
                   .Combine(_field3)
                   .Combine(StringComparer.FromComparison(_comparison).GetHashCode(_field4));
}

はい、少し長くなりますが、HashCode（Systemにプロモートしたばかり）で2つの特殊なメソッドを必要とせずに同じ問題を解決し、他の無関係な状況で使用できる静的ヘルパーメソッドを取得します。 また、すでにStringComparerを使用している場合の使用方法と同じように維持されます（比較対象のオーバーロードについては説明していないため）。

C# public override int GetHashCode() { return HashCode.Combine(_field1) .Combine(_field2) .Combine(_field3) .Combine(_comparer.GetHashCode(_field4)); }

@stephentoub 、 FromComparisonは良い考えのように聞こえます。 私は実際にスレッドで上向きにstring.GetHashCode(StringComparison) apiを追加することを提案しました。これにより、例がさらに単純になります（null以外の文字列を想定）。

public override int GetHashCode()
{
    return HashCode.Combine(_field1)
                   .Combine(_field2)
                   .Combine(_field3)
                   .Combine(_field4.GetHashCode(_comparison));
}

@Elionは、電話が多すぎると言った。

（編集：APIの提案を行いました。）

また、文字列のHashCodeに2つの特殊なメソッドを追加するのも嫌いです。
@Eilonは、パターンがおっしゃいました。 外部の開発者はそれをどのくらい使用すると思いますか？

@jamesqoデザインを運転してくれてありがとう！ @terrajobstが言ったように、私たちはあなたの助けと忍耐に感謝します。 基本的な小さなAPIは、反復処理に時間がかかる場合があります:)。

この最後のAPIフィードバックでどこに到達するかを見てみましょう。そうすれば、実装を進めることができます。

あるべき：

C# public static HashCode Combine<T>(T obj, IEqualityComparer<T> cmp);

？

（それがすでに却下されていて、私がここでそれを見逃している場合は、お詫びします）。

@stephentoubは言った：

書きます：

c# public override int GetHashCode() { return HashCode.Combine(_field1) .Combine(_field2) .Combine(_field3) .Combine(StringComparer.FromComparison(_comparison).GetHashCode(_field4)); }

はい、少し長くなりますが、HashCode（Systemにプロモートしたばかり）で2つの特殊なメソッドを必要とせずに同じ問題を解決し、他の無関係な状況で使用できる静的ヘルパーメソッドを取得します。 また、すでにStringComparerを使用している場合の使用方法と同じように維持されます（比較対象のオーバーロードについては説明していないため）。

まあ、それは少し長いだけでなく、waaayのように非常に長く、発見可能性はゼロです。

この方法を追加することへの抵抗は何ですか？ それが有用であり、明確に正しく実装でき、それが何をするかについて曖昧さがない場合、それを追加してみませんか？

追加の静的ヘルパー/変換メソッドを使用することは問題ありませんが、それを使用するかどうかはわかりませんが、なぜ便利なメソッドを犠牲にするのでしょうか。

なぜ便利な方法を犠牲にして？

私にはわかりにくいので、ここでは便利なメソッドが本当に必要です。 ASP.NETはさまざまな場所でそれを行っていると思います。 場所はいくつですか？ そして、それらの場所のうち、既知の値ではなく、実際に変数StringComparisonはいくつありますか？ その場合、あなたは私が言及したヘルパーさえ必要とせず、ただすることができます：

`` `C＃
.Combine（StringComparer.InvariantCulture.GetHashCode（_field4））

which in no way seems onerous to me or any more undiscoverable than knowing about StringComparison and doing:

``` C#
.Combine(_field4, StringComparison.InvariantCulture);

開発者が記述したのとまったく同じことを行うためにCombine内で分岐する必要がないため、実際には高速です。 余分なコードは、その1つのケースに特化したオーバーロードを追加する価値があるほど不便ですか？ StringComparerをオーバーロードしてみませんか？ EqualityComparerをオーバーロードしてみませんか？ Func<T, int>かかるオーバーロードをしてみませんか？ ある時点で、線を引いて「このオーバーロードが提供する価値は価値がない」と言います。これは、メンテナンスのコスト、コードサイズのコスト、その他のコストなど、追加するすべてのコストがかかるためです。 、そして開発者が本当にこのケースを必要とする場合、開発者がより少ない特殊なケースで処理するための追加のコードはほとんどありません。 だから私はおそらく線を引くのに適切な場所はこれらのオーバーロードの後ではなく前であると提案していました（しかし、前の応答の冒頭で述べたように、「私はこれの形で大丈夫です」、そして代替案を提案していました） 。

これが私が行った検索です： https ：

〜100の一致のうち、最初の数ページからでも、ほとんどすべてのユースケースに文字列があり、いくつかのケースでは、さまざまな種類の文字列比較を使用します。

1. 序数： https ：
2. Ordinal + IgnoreCase： https ：
3. 序数： https ：
4. 序数： https ：
5. 序数： https ：
6. 序数： https ：
7. Ordinal + IgnoreCase： https ：
8. 序数： https ：
9. 序数： https ：
10. 序数： https ：

（そして他の何十も。）

したがって、確かにASP.NET Coreコードベース内では、これは非常に一般的なパターンのようです。 もちろん、他のシステムと話すことはできません。

〜100試合中

リストした10個のすべて（検索の残りの部分は調べていません）は、変数から文字列を取得するのではなく、文字列の比較を明示的に指定しているため、たとえば、次の違いについて話しているだけではありません。

`` `C＃
.Combine（Name、StringComparison.OrdinalIgnoreCase）

``` C#
.Combine(StringComparer.OrdinalIgnoreCase.GetHashCode(Name))

？ それは「waaaysuperlong」ではなく、何かが足りない場合を除いて、より効率的です。

とにかく、私が述べたように、私は単にこれらの過負荷が必要かどうかを本当に検討することを提案しています。 ほとんどの人がそうだと信じていて、私たちが独自のASP.NETコードベースを検討しているだけではありません。

関連して、ヌル入力に対して計画している動作は何ですか？ int == 0はどうですか？ StringComparer.GetHashCodeは通常null入力をスローすると信じているので、nullを渡すことを許可すると、文字列のオーバーロードにより多くのメリットが見られるようになります。したがって、これが実際に一般的である場合、呼び出し元が特殊なケースのnullに。 しかし、それはまた、nullが提供されたときの動作がどうなるかという問題を提起します。 他の値と同様に、ハッシュコードに0が混在していますか？ それはnopとして扱われ、ハッシュコードはそのままにされますか？

nullに対する最も一般的なアプローチは、ゼロを混ぜることだと思います。 追加された単一のヌル要素の場合、それをnopとして持つ方が良いでしょうが、誰かがシーケンスでフィードしている場合は、10個のヌルを20個とは異なる方法でハッシュする方が有益になります。

実際、私の投票はASP.NET Coreのコードベースの観点からのものであり、文字列対応のオーバーロードがあると非常に役立ちます。 行の長さに関することは、実際には私の主な関心事ではなく、むしろ発見可能性に関するものでした。

文字列対応のオーバーロードがシステムで利用できない場合は、ASP.NETCoreに内部拡張メソッドを追加してそれを使用します。

文字列対応のオーバーロードがシステムで利用できない場合は、ASP.NETCoreに内部拡張メソッドを追加してそれを使用します。

ASP.NET Coreコードベースの外部でも、このようなAPIが一般的に必要であるという証拠が増えるまでは、これは今のところ優れたソリューションになると思います。

string過負荷を取り除くことには価値がないと言わざるを得ません。 複雑さを軽減したり、コードを効率化したり、 StringComparisonからStringComparerを返すメソッドを提供するなど、他の領域を改善することを妨げたりすることはありません。 StringComparison 。 .NETは常に一般的なケースを簡単にすることを目的としているため、構文糖衣は重要です。 また、開発者が正しいことを行い、成功の落とし穴に陥るように指導したいと思います。

文字列は特別で非常に一般的であることを理解する必要があります。 それらを特殊化するオーバーロードを追加することにより、2つのことを実現します。

1. @Eilonのようなシナリオをはるかに簡単にします。
2. 文字列、特にケーシングの比較を考慮することが重要であることを発見できます。

また、上記の拡張メソッド@Eilonのような一般的なボイラープレートヘルパーは良いことではなく、悪いことであることも考慮する必要があります。 ヘルパーメソッドのコピーと貼り付けに何時間も無駄になり、適切に実行されないと、不要なコードの膨張やバグが発生する可能性があります。

ただし、主な関心事が特別なケーシングstringに関するものである場合、これはどうでしょうか。

`` `C＃
public struct HashCode：IEquatable
{{
public HashCode Combine（T obj、IEqualityComparer比較者）;
}

// 使用法
HashCode.Combine（_numberField）を返します
.Combine（_stringField、StringComparer.OrdinalIgnoreCase）;
`` `

@terrajobst 、あなたの妥協は賢いものです。 GetHashCode明示的に呼び出したり、カスタム比較機能を使用して余分な括弧のセットをネストしたりする必要がなくなった方法が気に入っています。

（編集：スレッドの前半で@JonHannaが言及したので、本当にクレジットする必要があると思いますか？😄）

@JonHannaはい、null入力も0としてハッシュします。

ここで会話を中断してすみません。 しかし、新しいタイプはどこに置くべきですか？ @mellinoe @ericstj @weshaggard 、 System.HashCodeようなこのタイプの新しいアセンブリ/パッケージを作成することをお勧めしますか、それともSystem.Runtime.Extensionsような既存のアセンブリに追加する必要がありますか？ ありがとう。

最近、.NETCoreのアセンブリレイアウトをかなりリファクタリングしました。 System.Runtime.Extensionsを示しているように見える、具体的な比較対象者が住んでいる場所に配置することをお勧めします。

@weshaggard？

@terrajobst提案自体に関しては、残念ながら、静的オーバーロードとインスタンスオーバーロードの両方にCombineという名前を付けることはできないことがわかりました。 😢

インスタンスメソッドと静的メソッドに同じ名前を付けることはできないため、次の結果、コンパイラエラーが発生します。

using System;
using System.Collections.Generic;

public struct HashCode
{
    public void Combine(int i)
    {
    }

    public static void Combine(int i)
    {
    }
}

現在、2つのオプションがあります。

• 静的オーバーロードの名前をCreate 、 Seedなどの別の名前に変更します。
• 静的オーバーロードを別の静的クラスに移動します。

public static class Hash
{
    public static HashCode Combine(int hash);
}

public struct HashCode
{
    public HashCode Combine(int hash);
}

// Usage:
return Hash.Combine(_field1)
           .Combine(_field2)
           .Combine(_field3);

私は2番目に優先します。 この問題を回避しなければならないのは残念ですが...考えますか？

ロジックを2つのタイプに分離することは、私には奇妙に聞こえます。 HashCodeを使用するには、接続を確立し、代わりにHashクラスから開始する必要があります。

Createメソッド（またはSeedまたはInit ）を追加したいと思います。
また、引数なしのオーバーロードHashCode.Create().Combine(_field1).Combine(_field2)を追加します。

@karelz 、同じ名前でない場合はファクトリメソッドを追加する必要はないと思います。 より自然なので、パラメーターなしのコンストラクターnew提供する必要があります。 その上、eは構造体であるため、人々がnew HashCode().Combine書くのを防ぐことはできません。

public override int GetHashCode()
{
    return new HashCode()
        .Combine(_field1)
        ...
}

これにより、ハッシュコードから直接初期化する代わりに、0および_field1のハッシュコードとの追加の結合が行われます。 ただし、使用している現在のハッシュの副作用は、最初のパラメーターとして0が渡され、ゼロにローテーションされてゼロに追加されることです。 そして、0が最初のハッシュコードとxorされると、最初のハッシュコードが生成されます。 したがって、JITが定数畳み込みに優れている場合（そして、このxorを最適化すると私は信じています）、事実上、これは直接初期化と同等であるはずです。

提案されたAPI（更新された仕様）：

namespace System
{
    public struct HashCode : IEquatable<HashCode>
    {
        public HashCode Combine(int hash);
        public HashCode Combine<T>(T obj);
        public HashCode Combine<T>(T obj, IEqualityComparer<T> comparer);

        public int Value { get; }

        public static implicit operator int(HashCode hashCode);

        public static bool operator ==(HashCode left, HashCode right);
        public static bool operator !=(HashCode left, HashCode right);

        public override bool Equals(object obj);
        public override bool Equals(HashCode other);
        public override int GetHashCode();
    }
}

@redknightlois @JonHanna @stephentoub @Eilon 、ファクトリメソッドとデフォルトコンストラクタの使用について意見はありますか？ インスタンスメソッドと競合するため、コンパイラは静的なCombineオーバーロードを許可しないことがわかりました。そのため、どちらかを選択できます。

HashCode.Create(field1).Combine(field2) // ...

// or, using default constructor

new HashCode().Combine(field1).Combine(field2) // ...

最初の利点は、それが少し簡潔であるということです。 2番目の利点は、一貫した名前が付けられるため、最初のフィールドに別の名前を書く必要がないことです。

もう1つの可能性は、2つの異なるタイプです。1つはCombineファクトリを持ち、もう1つはCombineインスタンスを持ちます（または最初のタイプの拡張として2つ目）。

どちらがTBHを好むかわかりません。

@JonHanna 、インスタンスのオーバーロードが拡張メソッドであるという2番目のアイデアは素晴らしいですね。 そうは言っても、その場合のhc.Combine(obj)は、静的な過負荷を拾おうとします： TryRoslyn 。

上記のいくつかのコメントをエントリポイントとして静的クラスにすることを提案しました。これは私に思い出させます... @ karelz 、あなたは言いました

ロジックを2つのタイプに分離することは、私には奇妙に聞こえます。HashCodeを使用するには、接続を確立し、代わりにHashクラスから開始する必要があります。

人々はどのようなつながりを築く必要がありますか？ 最初にHashを紹介してから、そこからHashCode行くことができますか？ 新しい静的クラスを追加することは問題ではないと思います。

ロジックを2つのタイプに分離することは、私には奇妙に聞こえます。HashCodeを使用するには、接続を確立し、代わりにHashクラスから開始する必要があります。

トップレベルの型HashCodeを保持し、構造体をネストするだけで済みます。 これにより、APIの「エントリポイント」を1つのトップレベルタイプに維持しながら、目的の使用法が可能になります。例：

`` `c＃
名前空間システム
{{
パブリック静的クラスHashCode
{{
public static HashCodeValue Combine（int hash）;
public static HashCodeValue Combine（T obj）;
public static HashCodeValue Combine（T obj、IEqualityComparer比較者）;

    public struct HashCodeValue : IEquatable<HashCodeValue>
    {
        public HashCodeValue Combine(int hash);
        public HashCodeValue Combine<T>(T obj);
        public HashCodeValue Combine<T>(T obj, IEqualityComparer<T> comparer);

        public int Value { get; }

        public static implicit operator int(HashCodeValue hashCode);

        public static bool operator ==(HashCodeValue left, HashCodeValue right);
        public static bool operator !=(HashCodeValue left, HashCodeValue right);

        public bool Equals(HashCodeValue other);
        public override bool Equals(object obj);
        public override int GetHashCode();
    }
}

}
`` `

編集：ただし、 HashCodeValue.Valueは少し冗長であるため、このパスをたどる場合は、ネストされたタイプにHashCodeValueよりも適切な名前が必要になる可能性がありますが、 Valueが非常に使用されるわけではありません頻繁。 Valueプロパティも必要ないかもしれません。 intにキャストしたくない場合は、 GetHashCode()を介してValueを取得できます。

@justinvpそもそも、2つの別々のタイプがあることの問題は何ですか？ このシステムは、たとえばLinkedList<T>とLinkedListNode<T>で正常に機能しているようです。

しかし、そもそも2つの異なるタイプを持つことの問題は何ですか？

2つのトップレベルタイプには2つの懸念事項があります。

1. APIの「エントリポイント」はどのタイプですか？ 名前がHashとHashCode場合、どちらから始めますか？ それらの名前からは明らかではありません。 LinkedList<T>とLinkedListNode<T>すると、どちらがメインのエントリポイントであるか、 LinkedList<T>であり、どちらがヘルパーであるかが明確になります。
2. System名前空間を汚染します。 これは（1）ほど重要ではありませんが、 System名前空間で新しい機能を公開することを検討する際に留意する必要があります。

ネストは、これらの懸念を軽減するのに役立ちます。

@justinvp

APIの「エントリポイント」はどのタイプですか？ 名前がHashとHashCodeの場合、どちらから始めますか？ それらの名前からは明らかではありません。 LinkedListを使用およびLinkedListNodeどちらがメインのエントリポイントであるLinkedListであるかはかなり明確です。、そしてこれはヘルパーです。

OK、十分に公平なポイント。 ネスト型ではなく、型にHashとHashValueという名前を付けた場合はどうなりますか？ それは、2つのタイプの間の十分な従属関係を意味しますか？

そうすると、ファクトリメソッドはさらに簡潔になります： Hash.Combine(field1).Combine(field2) 。 さらに、struct型自体を使用することはまだ実用的です。 たとえば、誰かがハッシュのリストを収集し、これをリーダーに伝えるために、 List<int>代わりにList<HashValue>が使用される場合があります。 タイプをネストした場合、これはうまく機能しない可能性があります： List<HashCode.HashCodeValue> （ List<Hash.Value>さえ一見混乱します）。

システム名前空間を汚染しています。 これは（1）ほど重要ではありませんが、System名前空間で新しい機能を公開することを検討する際に留意する必要があります。

同意しますが、慣例に従い、使いやすさを犠牲にしないことも重要だと思います。 たとえば、ネストされたタイプがある場所（不変のコレクションはカウントされません。厳密にはフレームワークの一部ではありません）について考えることができる唯一のBCL APIは、ネストされたタイプを積極的に非表示にしたいList<T>.Enumeratorです。コンパイラでの使用を目的としているため、タイプします。 この場合、それは行いたくありません。

たぶん、Valueプロパティも必要ありません。intにキャストしたくない場合は、GetHashCode（）を介してValueを取得できます。

先ほど考えました。 しかし、ユーザーは、型がGetHashCodeオーバーライドすること、または暗黙の演算子があることをどのようにして知るのでしょうか。

提案されたAPI

public static class Hash
{
    public static HashValue Combine(int hash);
    public static HashValue Combine<T>(T obj);
    public static HashValue Combine<T>(T obj, IEqualityComparer<T> comparer);
}

public struct HashValue : IEquatable<HashValue>
{
    public HashValue Combine(int hash);
    public HashValue Combine<T>(T obj);
    public HashValue Combine<T>(T obj, IEqualityComparer<T> comparer);

    public int Value { get; }

    public static implicit operator int(HashValue hashValue);

    public static bool operator ==(HashValue left, HashValue right);
    public static bool operator !=(HashValue left, HashValue right);

    public override bool Equals(object obj);
    public bool Equals(HashValue other);
    public override int GetHashCode();
}

ネスト型ではなく、型にHashとHashValueという名前を付けた場合はどうなりますか？

Hashは、私にはあまりにも一般的な名前のようです。 エントリポイントAPIの名前にHashCodeを含める必要があると思います。これは、その意図された目的がGetHashCode()ではなくGetHash() GetHashCode()実装を支援することであるためです。

誰かがハッシュのリストを収集し、これを読者にリストを伝えたいと思うかもしれませんリストの代わりに使用されます。 タイプをネストした場合、これはうまく機能しない可能性があります：リスト（リストも一見混乱します）。

これはありそうもないユースケースのようです-そのために設計を最適化する必要があるかどうかはわかりません。

ネストされたタイプがある場所について考えることができる唯一のBCLAPI

TimeZoneInfo.AdjustmentRuleとTimeZoneInfo.TransitionTimeは、ネストされたタイプとして意図的に追加されたBCLの例です。

@justinvp

GetHash（）ではなくGetHashCode（）の実装を支援することを目的としているため、エントリポイントAPIの名前にHashCodeを含める必要があると思います。

👍なるほど。

もう少し考えました。 ネストされた構造体を持つことは合理的と思われます。 あなたが言ったように、ほとんどの人は実際のタイプを見ることは決してないでしょう。 ただ一つのこと：私はタイプが呼ばれるべきだと思うSeedのではなく、 HashCodeValue 。 その名前のコンテキストは、含まれているクラスによってすでに暗示されています。

提案されたAPI

namespace System
{
    public static class HashCode
    {
        public static Seed Combine(int hash);
        public static Seed Combine<T>(T obj);
        public static Seed Combine<T>(T obj, IEqualityComparer<T> comparer);

        public struct Seed : IEquatable<Seed>
        {
            public Seed Combine(int hash);
            public Seed Combine<T>(T obj);
            public Seed Combine<T>(T obj, IEqualityComparer<T> comparer);

            public int Value { get; }

            public static implicit operator int(Seed seed);

            public static bool operator ==(Seed left, Seed right);
            public static bool operator !=(Seed left, Seed right);

            public bool Equals(Seed other);
            public override bool Equals(object obj);
            public override int GetHashCode();
        }
    }
}

@jamesqo代わりにpublic readonly int Value使用することに異議や実装の問題はありますか？ Seed問題は、最初の結合後は技術的にシードではないことです。

@justinvpにも同意しHashはハッシュの処理に予約する必要があります。 これは、代わりにHashCode処理を簡素化するために導入されました。

@redknightlois明確にするために、プロパティ名ではなく、構造体名について話していました。

        public struct Seed : IEquatable<Seed>
        {
            public Seed Combine(int hash);
            public Seed Combine<T>(T obj);
            public Seed Combine<T>(T obj, IEqualityComparer<T> comparer);

            public int Value { get; }

            public static implicit operator int(Seed seed);

            public static bool operator ==(Seed left, Seed right);
            public static bool operator !=(Seed left, Seed right);

            public bool Equals(Seed other);
            public override bool Equals(object obj);
            public override int GetHashCode();
        }

使用法：
c# int hashCode = HashCode.Combine(field1).Combine(name, StringComparison.OrdinalIgnoreCase).Value; int hashCode = (int)HashCode.Combine(field1).Combine(field2);

シードの問題は、最初の結合後のシードではないことです。

これは、新しいシードを生成する次のコンバインのシードです。

代わりにpublicreadonly int Valueを使用することに異議や実装の問題はありますか？

どうして？ int Value { get; }はより慣用的で、簡単にインライン化できます。

これは、新しいシードを生成する次のコンバインのシードです。

それは苗ではないでしょうか？ ;）

@jamesqo私の経験では、複雑なコードプロパティに囲まれていると、フィールドよりも悪いコードが生成される傾向があります（その中で、インラインではありません）。 また、構造体上の単一のintの読み取り専用フィールドは、レジスター内で直接変換され、最終的にJITが最適化に読み取り専用を使用する場合（コード生成に関してはまだ使用法を見つけることができませんでした）。 読み取り専用であると推論できるため、許可される可能性のある最適化があります。 使用の観点から、実際には単一のゲッターと違いはありません。

編集：さらに、それらの構造体は本当に不変であるという考えも推し進めます。

私の経験では、複雑なコードプロパティに囲まれていると、フィールドよりも悪いコードが生成される傾向があります（その中で、インラインではありません）。

自動実装されたプロパティが常にインライン化されていない単一の非デバッグビルドを見つけた場合、それはJITの問題であり、確実に修正する必要があります。

また、構造体上の単一のintの読み取り専用フィールドは、レジスターで直接変換されます

読み取り専用であると推論できるため、許可される可能性のある最適化があります。

この構造体のバッキングフィールドは読み取り専用になります。 APIはアクセサーになります。

ここでは、プロパティを使用してもパフォーマンスが低下することはないと思います。

@jamesqoそれらを見つけたら、それを覚えておきます。 パフォーマンスに敏感なコードの場合、そのためにプロパティを使用しなくなりました（この時点では筋肉の記憶）。

ネストされた構造体を「シード」ではなく「ステート」と呼ぶことを検討できますか？

@ellismgはい、提案してくれてありがとう。 私は内部構造体の良い名前を思い付くのに苦労していました。

@karelzこのAPIはついに

@jamesqo @JonHannaなぜCombine<T>(T obj)代わりにCombine(object o) Combine<T>(T obj)が必要なのですか？

なぜコンバインが必要なのですか（T obj）Combine（object o）の代わりに？

後者は、インスタンスが構造体の場合に割り当てます。

わかりやすくしてくれてありがとう。

ネストされた型は設計が複雑に見えるため、好きではありません。 根本的な問題は、静力学と非静力学に同じ名前を付けることができないということでした。 2つのオプションがあります：統計を取り除くか、名前を変更します。 Create名前を変更すると、デフォルトのコンストラクターを使用する場合と比較して、かなり読みやすいコードが作成されるため、最も理にかなっていると思います。

強い反対がない限り、それが私たちが決めたデザインです。

`` `C＃
名前空間システム
{{
public struct HashCode：IEquatable
{{
public static HashCode Create（int hashCode）;
public static HashCode Create（T obj）;
public static HashCode Create（T obj、IEqualityComparer比較者）;

    public HashCode Combine(int hashCode);
    public HashCode Combine<T>(T obj);
    public HashCode Combine<T>(T obj, IEqualityComparer<T> comparer);

    public int Value { get; }

    public static implicit operator int(HashCode hashCode);

    public static bool operator ==(HashCode left, HashCode right);
    public static bool operator !=(HashCode left, HashCode right);

    public bool Equals(HashCode other);
    public override bool Equals(object obj);
    public override int GetHashCode();
}

}
`` `

承認された提案に強力なフィードバックがあるかどうかを確認するために、追加のフィードバックを数日待ちましょう。 それから私達はそれを「つかむために」作ることができます。

なぜそれが設計を複雑にするのですか？ コードでHashCode.Stateを実際に使用する必要がある場合（たとえば、変数の型を定義するため）、それがどのように悪いかは理解できましたが、それがよくあることだと思いますか？ ほとんどの場合、Valueを完全に返すか、intに変換して保存することになります。

CreateとCombineの組み合わせはもっと悪いと思います。

https://github.com/dotnet/corefx/issues/8034#issuecomment-262661653を参照して

@terrajobst

デフォルトのコンストラクターを使用する場合と比較して、かなり読みやすいコードを作成するため、名前をCreateに変更するのが最も理にかなっていると思います。

強い反対がない限り、それが私たちが決めたデザインです。

聞いたことがありますが、実装の作業中に土壇場で考えました...静的なZero / EmptyプロパティをHashCodeに追加するだけでいいのでしょうか。そこからCombine電話してもらいますか？ これにより、個別のCombine / Createメソッドを用意する必要がなくなります。

namespace System
{
    public struct HashCode : IEquatable<HashCode>
    {
        public static HashCode Empty { get; }

        public HashCode Combine(int hashCode);
        public HashCode Combine<T>(T obj);
        public HashCode Combine<T>(T obj, IEqualityComparer<T> comparer);

        public int Value { get; }

        public static implicit operator int(HashCode hashCode);

        public static bool operator ==(HashCode left, HashCode right);
        public static bool operator !=(HashCode left, HashCode right);

        public bool Equals(HashCode other);
        public override bool Equals(object obj);
        public override int GetHashCode();
    }
}

int GetHashCode()
{
    return HashCode.Empty
        .Combine(_1)
        .Combine(_2);
}

他の誰かがこれは良い考えだと思いますか？ （当面はPRを提出しますので、よろしければPRで変更させていただきます。）

@jamesqo 、私はEmpty / Zeroのアイデアが好きです。

私はそれで大丈夫でしょう（ EmptyとCreateファクトリの間に強い好みはありません）... @ weshaggard @bartonjs @stephentoub @terrajobst皆さんはどう思いますか？

個人的にはCreate（）の方が良いと思います。 しかし、私のようにHashCode.Emptyより良いnew HashCode() 。

これにより、演算子がないバージョンが可能になります。新しいバージョンであり、後でブートストラッパーとしてCreateが本当に必要であると判断することを妨げるものではありません... :: shrug ::。

これが私のプッシュバックの全範囲です（別名、それほど多くはありません）。

FWIW Empty / ZeroではなくCreate投票します。 Empty / Zeroすべてをぶら下げるよりも、実際の値から始めたいと思います。 それはただ奇妙に感じ/見えます。

それはまた、貧弱なシードになる傾向があるゼロでシードする人々を思いとどまらせます。

私は空よりも作成を好みます。 それは私がそれについてどう考えるかと一致します：私はハッシュコードを作成し、追加の値を混ぜたいです。 ネストされたアプローチでも問題ありません。

空と呼ぶのは良い考えではないと言うつもりでしたが（そしてそれはすでに言われています）、3番目の考えのように私はまだ悪い解決策ではないと思います。 Builderのようなものはどうですか。 ゼロを使​​用することはまだ可能ですが、単語はちょっとそれをすぐに使用することを思いとどまらせます。

@JonHanna明確にするために：あなたはそれをCreate投票として意味しましたね？

そして4番目の考えでは、Createの代わりにWithはどうでしょうか。

HashCode.With（a）.Combine（b）。 結合（c）

最新の議論に基づく使用例（ Createが代替名に置き換えられている可能性があります）：

`` `c＃
public override int GetHashCode（）=>
HashCode.Create（_field1）.Combine（_field2）.Combine（_field3）;

We went down the path of this chaining approach, but didn't reconsider earlier proposals when the static & instance `Combine` methods didn't pan out...

Are we sure we don't want something like the existing `Path.Combine` pattern, that was proposed previously, with a handful of generic `Combine` overloads? e.g.:

```c#
public override int GetHashCode() =>
    HashCode.Combine(_field1, _field2, _field3);

@justinvpコードの一貫性が失われ、より多くのジッティングが発生します。より一般的な組み合わせのb / cだと思います。 望ましいことが判明した場合は、別の問題でいつでもこれを再検討できます。

価値があるので、少なくとも使用法では、最初に提案されたバージョンを好みます（コードサイズ、ジッティングなどに関するコメントについてはわかりません）。 異なるアリティのいくつかのオーバーロードを使用して1つのメソッドとして表現できるものに対して、余分な構造と10以上の異なるメンバーを用意するのはやり過ぎのようです。 また、私は一般的に流暢なスタイルのAPIのファンではないので、おそらくそれが私の意見を彩っています。

これは少し珍しいので言及しませんでしたが、それについてどう思うかはまだわかりませんが、すべての代替案が検討されていることを確認するために、別のアイデアがあります...

ASP.NETCoreの可変HashCodeCombiner "ビルダー"に沿って、同様のAddメソッドを使用して何かを実行したが、コレクション初期化構文のサポートも含まれている場合はどうなりますか？

使用法：

`` `c＃
public override int GetHashCode（）=>
新しいHashCode {_field1、_field2、_field3};

With a surface area something like:

```c#
namespace System
{
    public struct HashCode : IEquatable<HashCode>, IEnumerable
    {
        public void Add(int hashCode);
        public void Add<T>(T obj);
        public void Add<T>(T obj, IEqualityComparer<T> comparer);

        public int Value { get; }

        public static implicit operator int(HashCode hashCode);

        public static bool operator ==(HashCode left, HashCode right);
        public static bool operator !=(HashCode left, HashCode right);

        public bool Equals(HashCode other);
        public override bool Equals(object obj);
        public override int GetHashCode();

        IEnumerator IEnumerable.GetEnumerator();
    }
}

コレクション初期化構文を有効にするには、少なくとも1つのAddメソッドとともに、少なくともIEnumerableを実装する必要があります。 IEnumerable明示的に実装してインテリセンスから隠すことができ、 GetEnumeratorはNotSupportedExceptionスローするか、ハッシュコード値を列挙可能な単一の結合アイテムとして返すことができます。それを使用します（これはまれです）。

@justinvp 、あなたは面白いアイデアを持っています。 しかし、私は敬意を表して反対します。 HashCodeは、可変構造体の落とし穴を避けるために不変に保つ必要があると思います。 また、これのためにIEnumerableを実装する必要があるのは、ちょっと人工的で不安定なようです。 誰かがファイルにusing System.Linqディレクティブを持っている場合、 HashCode横にドットを置くと、 Cast<>とOfType<>が拡張メソッドとして表示されます。 私たちは現在の提案にもっと近づくべきだと思います。

@jamesqo 、私は同意します-したがって、それについて言及することさえ躊躇します。 私が気に入っているのは、使用法が連鎖よりもクリーンであるということだけですが、サンプルの使用法を見ずにコレクション初期化子を使用できるかどうかが明確でないため、それ自体が別の欠点です。

@ MadsTorgersen 、 @ jaredpar 、コレクション初期化子がIEnumerable \の実装を必要とする理由上記の@justinvpの3番目のコメント。

@jamesqo 、私はこれを不変に保つ方が良いことに同意します（IEnumerableではありません\

@mellinoeこれにより、単純なケースが少し単純になると思いますが、それ以上のことはさらに複雑になります（そして、何をするのが正しいかについてはあまり明確ではありません）。

これには以下が含まれます：

1. あなたが過負荷を持っているよりも多くのアイテム
2. 条件
3. ループ
4. 比較器を使用する

このトピックについて以前に投稿されたASP.NETのコード（現在の提案に更新）について考えてみます。

`` `c＃
var hashCode = HashCode
.Create（IsMainPage）
.Combine（ViewName、StringComparer.Ordinal）
.Combine（ControllerName、StringComparer.Ordinal）
.Combine（AreaName、StringComparer.Ordinal）;

if（ViewLocationExpanderValues！= null）
{{
foreach（ViewLocationExpanderValuesのvarアイテム）
{{
hashCode = hashCode
.Combine（item.Key、StringComparer.Ordinal）
.Combine（item.Value、StringComparer.Ordinal）;
}
}

hashCodeを返します。

How would this look with the original `Hash.CombineHashCodes`? I think it would be:

```c#
var hashCode = Hash.CombineHashCodes(
    IsMainPage,
    StringComparer.Ordinal.GetHashCode(ViewName),
    StringComparer.Ordinal.GetHashCode(ControllerName),
    StringComparer.Ordinal.GetHashCode(AreaName));

if (ViewLocationExpanderValues != null)
{
    foreach (var item in ViewLocationExpanderValues)
    {
        hashCode = Hash.CombineHashCodes(
            hashCode
            StringComparer.Ordinal.GetHashCode(item.Key),
            StringComparer.Ordinal.GetHashCode(item.Value));
    }
}

return hashCode;

カスタム比較子に対してGetHashCode()を呼び出すことを無視しても、最初のパラメーターとしてhashCode以前の値を渡す必要があることがわかります。

@KrzysztofCwalina C＃プログラミング言語^1の@ericlippertのメモによると、コレクション初期化子は（当然のことながら）コレクション作成のためのシンタックスシュガーであり、算術演算（ Addという名前のメソッドの他の一般的な使用法）ではないためです

¹ Googleブックスの仕組みにより、そのリンクがすべての人に役立つとは限りません。

@KrzysztofCwalina、およびノートでは、それは非ジェネリック必要ですIEnumerable 、ないIEnumerable<T> 。

@ svick 、上記の最初の例のマイナーニット： .Combineへの最初の呼び出しは、現在の提案では.Createになります。 ネストされたアプローチを使用しない限り。

@svick

それはまた、それを超えるものをより複雑にするでしょう（そして何をするのが正しいかについてはあまり明確ではありません）

わかりません。2番目の例は最初の例と全体的にほとんど違いがなく、IMOはそれほど複雑ではありません。 2番目/元のアプローチでは、一連のハッシュコードを渡すだけなので（最初のパラメーターは実際にはIsMainPage.GetHashCode()必要があると思います）、私には簡単に思えます。 しかし、私はここでは少数派のようですので、元のアプローチを推し進めるつもりはありません。 私には強い意見はありません。 これらの例はどちらも私には十分合理的に見えます。

@justinvpありがとう、更新されました。 （私は最初の投稿で最初の提案を行いましたが、それが古くなっていることに気づいていませんでした。誰かがおそらくそれを更新する必要があります。）

@mellinoe問題は、実際には2番目が微妙なバグを生成する可能性があることです。 これは、私たちのプロジェクトの1つからの実際のコードです。

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public int GetHashCode(PageFromScratchBuffer obj)
        {
            int v = Hashing.Combine(obj.NumberOfPages, obj.ScratchFileNumber);
            int w = Hashing.Combine(obj.Size.GetHashCode(), obj.PositionInScratchBuffer.GetHashCode());
            return Hashing.Combine(v, w);            
        }

私たちはそれと一緒に暮らしていますが、私たちは毎日非常に低レベルのものを扱っています。 確かに平均的な開発者ではありません。 ただし、ここでは、vとwを組み合わせるよりもvとwを組み合わせるのは同じではありません... vとwの組み合わせの間で同じです。 ハッシュの組み合わせは可換ではないため、次々にチェーンすることで、APIレベルで一連のエラー全体を実際に取り除くことができます。

私は最初の投稿で最初の提案を行いましたが、それが古くなっていることに気づいていませんでした。おそらく誰かがそれを更新する必要があります。

終わり。
ところで：この提案は、特に投票を追跡するのが非常に難しいです...非常に多くのバリエーション（私は良いと思います;-)）

@karelz Create APIを追加しても、 Empty追加できると思います。 @bartonjsが言ったように、どちらかである必要はありません。 提案

namespace System
{
    public struct HashCode : IEquatable<HashCode>
    {
        public HashCode();

        public static HashCode Empty { get; }

        public static HashCode Create(int hashCode);
        public static HashCode Create<T>(T value);
        public static HashCode Create<T>(T value, IEqualityComparer<T> comparer);

        public HashCode Combine(int hashCode);
        public HashCode Combine<T>(T value);
        public HashCode Combine<T>(T value, IEqualityComparer<T> comparer);

        public int Value { get; }

        public static implicit operator int(HashCode hashCode);

        public static bool operator ==(HashCode left, HashCode right);
        public static bool operator !=(HashCode left, HashCode right);

        public bool Equals(HashCode other);
        public override bool Equals(object obj);
        public override int GetHashCode();
        public override string ToString();
    }
}

@JonHanna

それはまた、貧弱なシードになる傾向があるゼロでシードする人々を思いとどまらせます。

選択するハッシュアルゴリズムは、今日HashHelpers使用されているものと同じであり、 hash(0, x) == xという効果があります。 HashCode.Empty.Combine(x)は、 HashCode.Create(x)とまったく同じ結果を生成するため、客観的に違いはありません。

@jamesqo最後の提案に追加のZeroを含めるのを忘れました。 それが省略だった場合、更新できますか？ その後、最新の提案に投票するように人々に依頼することができます。 他の選択肢（私が更新したトップの投稿を参照）はそれほどフォローされていないようです...

@karelz発見してくれてありがとう、修正。

@KrzysztofCwalinaは、他の意味ではなく、コレクションに追加するという意味で「追加」を意味していることを確認します。 この制限が好きかどうかはわかりませんが、それが当時私たちが決めたものです。

public static HashCode Create(int hash);
public HashCode Combine(int hash);

パラメータは名前を付ける必要がありますhashCodeの代わりにhash渡された値は、おそらく呼び出しから取得したハッシュコードになるだろうされているのでGetHashCode() ？

Empty / Zero

これを維持することになった場合、考慮すべき別の名前はDefaultです。

@justinvp

渡される値はGetHashCode（）の呼び出しから取得される可能性が高いハッシュコードになるため、パラメーターにはハッシュではなくハッシュコードという名前を付ける必要がありますか？

intパラメーターにhashとHashCodeパラメーターにhashCodeという名前を付けたいと思いました。 しかし、考え直してみると、あなたが言ったように、 hashはちょっと漠然としているので、 hashCode方が良いと思います。 APIを更新します。

これを維持することになった場合、考慮すべき別の名前はDefaultです。

Defaultと聞いたとき、「構造体のデフォルト値」ではなく、「選択するオプションがわからないときに何かをする通常の方法」だと思います。 たとえば、 Encoding.Defaultようなものは、まったく異なる意味合いを持っています。

選択するハッシュアルゴリズムは、今日のHashHelpersで使用されているものと同じであり、hash（0、x）== xという効果があります。 HashCode.Empty.Combine（x）は、HashCode.Create（x）とまったく同じ結果を生成するため、客観的に違いはありません。

この内部についてあまり知らない人として、私はHashCode.Create(x).Combine(...)シンプルさが本当に好きです。 Createは他の多くの場所で使用されているため、非常に明白です。

Empty / Zero / Defaultがアルゴリズムの使用法を提供しない場合、IMOは存在しないはずです。

PS：非常に興味深いスレッド!! よくできた！ 👍

@ cwe1ss

Empty / Zero / Defaultがアルゴリズムの使用法を提供しない場合、IMOは存在しないはずです。

Emptyフィールドがあると、アルゴリズムを使用できます。 これは、ハッシュを組み合わせることができる「開始値」を表します。 たとえば、 Create厳密に使用してハッシュの配列を結合する場合、かなり苦痛になります。

int CombineRange(int[] hashes)
{
    if (hashes.Length == 0)
    {
        return 0;
    }

    var result = HashCode.Create(hashes[0]);

    for (int i = 1; i < hashes.Length; i++)
    {
        result = result.Combine(hashes[i]);
    }

    return result;
}

Empty場合、それははるかに自然になります。

int CombineRange(int[] hashes)
{
    var result = HashCode.Empty;

    for (int i = 0; i < hashes.Length; i++)
    {
        result = result.Combine(hashes[i]);
    }

    return result;
}

// or

int CombineRange(int[] hashes)
{
    return hashes.Aggregate(HashCode.Empty, (hc, next) => hc.Combine(next));
}

@terrajobstこのタイプは、私にとってImmutableArray<T>によく似ています。 空の配列自体はあまり役に立ちませんが、他の操作の「開始点」として非常に役立ちます。そのため、 Emptyプロパティがあります。 HashCodeでCreate保持しています。

@jamesqo提案https://github.com/dotnet/corefx/issues/8034#issuecomment-262661653で、あなたが黙って/誤って引数名objをvalueに変更したことに気づきました。 私はそれをobjに戻しました。これにより、IMOはあなたが得たものをよりよく捉えます。 名前valueは、このコンテキストでは「int」ハッシュ値自体とより関連性があります。
必要に応じてarg名についてさらに議論することもできますが、意図的に変更して、最後に承認された提案との差分を追跡しましょう。

上部の提案を更新しました。 また、提案の最後に承認されたバージョンに対する差分を呼び出しました。

私たちが選択するハッシュアルゴリズムは、今日のHashHelpersで使用されているものと同じになります

どこでも使用する必要があるアルゴリズムとして選択するのが良いアルゴリズムであるのはなぜですか？ 結合されているハッシュコードについてどのような仮定をしますか？ どこでも使用されている場合、DDoS攻撃の新しい道が開かれるのでしょうか。 （過去に文字列ハッシュのためにこれによって焼かれたことに注意してください。）

ASP.NETCoreの可変HashCodeCombiner「ビルダー」に沿って何かをした場合はどうなりますか

これが正しいパターンだと思います。 優れたユニバーサルハッシュコードコンバイナーは、通常、ハッシュコード自体に適合する状態よりも多くの状態を使用できますが、より大きな構造体を渡すことはパフォーマンスの問題であるため、流暢なパターンは崩壊します。

どこでも使用する必要があるアルゴリズムとして選択するのが良いアルゴリズムであるのはなぜですか？

どこでも使用するべきではありません。 https://github.com/dotnet/corefx/issues/8034#issuecomment-260790829で私のコメントを参照して

結合されているハッシュコードについてどのような仮定をしますか？ どこでも使用されている場合、DDoS攻撃の新しい道が開かれるのでしょうか。

現在のハッシュの問題の1つは、 hash(0, x) == xです。 したがって、一連のnullまたはゼロがハッシュに供給された場合、それは0のままになります。ここのようます。これにより、ゼロからゼロへのマッピングを回避するための魔法の定数が追加されます。

これが正しいパターンだと思います。 優れたユニバーサルハッシュコードコンバイナーは、通常、ハッシュコード自体に適合する状態よりも多くの状態を使用できますが、より大きな構造体を渡すことはパフォーマンスの問題であるため、流暢なパターンは崩壊します。

すべてのユースケースに適合しようとする大きな構造体サイズのユニバーサルコンバイナーがあるべきではないと思います。 代わりに、すべてintサイズ（ FnvHashCodeなど）で、すべて独自のCombineメソッドを持つ個別のハッシュコードタイプを想定していました。 その上、これらの「ビルダー」タイプは、とにかく同じメソッドで保持され、渡されません。

すべてのユースケースに適合しようとする大きな構造体サイズのユニバーサルコンバイナーがあるべきではないと思います。

ASP.NET Coreは、独自のハッシュコードコンバイナー（現在64ビットの状態）をこれに置き換えることができますか？

私は、すべてintサイズの個別のハッシュコードタイプ（FnvHashCodeなど）を想定していました。

これは組み合わせ爆発につながりませんか？ このAPI設計が何につながるかを明確にすることは、API提案の一部である必要があります。

@jkotas私は議論の始めに同様の反対意見を述べました。 ハッシュ関数を扱うには、主題に関する知識が必要です。 しかし、私は、フレームワークの根底にハッシュコードを導入することで、2001年に発生した問題の修正を理解し、サポートします。ハッシュを組み合わせるレシピを規定していません。 この設計は、99％のケースでそれを解決することを目的としています（ハッシュの統計的特性が十分であるため、主題の知識が利用できないか、必要でさえありません）。 ASP.Net Coreは、このようなコンバイナーを、ここで説明するために提案されているような非システムアセンブリ上の汎用フレームワークに含めることができるはずです： https ：

99％のケースで簡単に使用できるハッシュコードコンバイナーを用意することをお勧めします。 ただし、32ビットだけでなくより多くの内部状態を考慮に入れる必要があります。

ところで：ASP.NETは元々ハッシュコードの結合に流暢なパターンを使用していましたが、バグを見逃しやすいため、それをやめました： https ：

ハッシュフラッディングセキュリティに関する@jkotas 。
免責事項：専門家ではありません（専門家に相談する必要があります。MSはこの問題について数人以上います） 。

私は周りを見回しており、この問題に関する一般的なコンセンサスはありませんが、最近注目を集めている議論があります。 ハッシュコードは32ビットサイズです。セットのサイズが与えられた場合の衝突の確率を示すグラフの前に投稿しました。 つまり、アルゴリズムがどれほど優れていても（たとえば、SipHashを見ると）、妥当な時間（1時間未満で話す）で大量のハッシュを生成して衝突を見つけることがかなり実行可能です。 これらの問題は、ハッシュを保持するデータ構造で対処する必要があり、ハッシュ関数レベルでは解決できません。 基になるデータ構造を修正せずにハッシュフラッディングから保護するために非暗号化で追加のパフォーマンスを支払っても、問題は解決されません。

編集：あなたは私が書いている間に投稿しました。 これに照らして、64ビット状態はあなたにとって何を得るのですか？

@jkotasあなたがリンクしている問題を調べました。 それは言う：

aspnet / Common＃40への反応

https://github.com/aspnet/Common/issues/40の説明：

バグを見つける：

public class TagBuilder
{
    private Dictionary<string, string> _attributes;
    private string _tagName;
    private string _innerContent;

    public override int GetHashCode()
    {
        var hash = HashCodeCombiner.Start()
            .Add(_tagName, StringComparer.Ordinal)
            .Add(_innerContent, StringComparer.Ordinal);

        foreach (var kvp in _attributes)
        {
            hash.Add(kvp.Key, StringComparer.Ordinal).Add(kvp.Value, StringComparer.Ordinal);
        }

        return hash.Build();
    }
}

来て。 その引数は、 Substringが新しい文字列を返すことに人々が気付いていないため、 stringは変更可能である必要があると言っているようなものです。 可変構造体は、落とし穴の点ではるかに悪いです。 構造体を不変に保つべきだと思います。

ハッシュフラッディングセキュリティに関して。

これには2つの側面があります。構築による修正設計（堅牢なデータ構造など）。 既存の設計の問題の軽減。 どちらも重要です。

@karelzパラメータの命名について

あなたが黙って/偶然にあなたの提案dotnet / corefx＃8034（コメント）でarg nameobjをvalueに変更したことに気づきました。 私はそれをobjに戻しました。これは、IMOが取得したものをより適切にキャプチャします。 このコンテキストでは、名前の値は「int」ハッシュ値自体とより関連性があります。
必要に応じてarg名についてさらに議論することもできますが、意図的に変更して、最後に承認された提案との差分を追跡しましょう。

将来の提案では、値をまとめて組み合わせるためのAPIを追加することを検討しています。 例： CombineRange(ReadOnlySpan<T>) 。 これにobjという名前を付けた場合、パラメータにobjsという名前を付ける必要がありますが、これは非常に厄介に聞こえます。 したがって、代わりにitemという名前を付ける必要があります。 将来的には、スパンパラメータにitemsという名前を付けることができます。 提案を更新しました。

@jkotasは同意しますが、ここでのポイントは、コンバイナーレベルでは何も軽減していないということです...

私たちができる唯一のことは、ランダムシードを持つことです。これは、すべての状態と目的で、コードをstringで見たことを覚えており、ビルドごとに固定されています。 （それはずっと前だったので、それについて間違っている可能性があります）。 ランダムシードを適切に実装することが、ここで適用できる唯一の緩和策です。

これは課題です。固定のランダムシードを使用した最高の文字列やメモリハッシュ関数を教えてください。衝突のみを生成する32ビットハッシュコードのセットを作成します。 非常に簡単にできるので、私はそのような挑戦をすることを恐れません。確率論は私の側にあります。 私も行って賭けをしますが、私はそれに勝つことを知っているので、それは本質的にもう賭けではありません。

さらに...より深い分析では、軽減策が実行ごとにこれらの「ランダムシード」​​を組み込む機能であっても、より複雑なコンバイナーは必要ないことが示されています。 基本的に、ソースで問題を軽減したためです。

M1とM2 、ランダムシードが異なるrs1とrs2ます。
M1はh1 = hash('a', rs1)とh2=hash('b', rs1)を発行します
M2はh1' = hash('a', rs2)とh2'=hash('b', rs2)を発行します
ここで重要な点は、 h1とh1'は確率1/ (int.MaxInt-1) （ hashで十分な場合）で異なり、すべての目的で次のようになることです。それが得られるので良い。
したがって、（十分に良い場合）使用することにしたc(x,y)は、ソースに組み込まれている緩和策をすでに考慮に入れています。

編集：私はコードを見つけました、あなたは今各ドメインで変わるMarvin32を使用しています。 したがって、文字列の緩和策は、実行ごとにランダムシードを使用することです。 私が述べたように、これは十分な緩和策です。

@jkotas

ASP.NET Coreは、独自のハッシュコードコンバイナー（現在64ビットの状態）をこれに置き換えることができますか？

絶対; 同じハッシュアルゴリズムを使用します。 このテストアプリを作成し

私は、すべてintサイズの個別のハッシュコードタイプ（FnvHashCodeなど）を想定していました。

これは組み合わせ爆発につながりませんか？ このAPI設計が何につながるかを明確にすることは、API提案の一部である必要があります。

@jkotas 、そうではありません。 このクラスの設計は、将来のハッシュAPIの設計を決定するものではありません。 これらは、より高度なシナリオと見なす必要があり、dotnet / corefx＃13757などの別の提案を行う必要があり、別の設計に関する議論が行われます。 GetHashCodeオーバーライドに苦労している初心者のために、一般的なハッシュアルゴリズム用のシンプルなAPIを用意することがはるかに重要だと思います。

99％のケースで簡単に使用できるハッシュコードコンバイナーを用意することをお勧めします。 ただし、32ビットだけでなくより多くの内部状態を考慮に入れる必要があります。

32ビットよりも多くの内部状態が必要になるのはいつですか？ 編集：人々がカスタムハッシュロジックをプラグインできるようにする場合、それは（再び）高度なシナリオと見なされ、dotnet / corefx＃13757で説明されるべきだと思います。

現在、各ドメインで変更されているMarvin32を使用しています

そうです、文字列ハッシュコードのランダム化の軽減は、.NETCoreではデフォルトで有効になっています。 互換性があるため、完全な.NETFrameworkのスタンドアロンアプリではデフォルトで有効になっていません。 癖を介してのみ有効になります（たとえば、リスクの高い環境で）。

.NET Coreには、ランダム化されていないハッシュのコードがまだありますが、削除しても問題ありません。 再び必要になるとは思いません。 また、ランダム化されていないパスを使用するかどうかのチェックが行われないため、文字列ハッシュコードの計算が少し速くなります。

ランダム化された文字列ハッシュコードの計算に使用されるMarvin32アルゴリズムには、64ビットの内部状態があります。 これは、MSの対象分野の専門家によって選ばれました。 私は彼らが64ビットの内部状態を使用する正当な理由を持っていたと確信しています、そして彼らは物事を遅くするためだけにそれを使用していません。

汎用ハッシュコンバイナーは、この緩和策を進化させ続ける必要があります。ランダムシードと十分に強力なハッシュコード結合アルゴリズムを使用する必要があります。 理想的には、ランダム化された文字列ハッシュと同じMarvin32を使用します。

ランダム化された文字列ハッシュコードの計算に使用されるMarvin32アルゴリズムには、64ビットの内部状態があります。 これは、MSの対象分野の専門家によって選ばれました。 私は彼らが64ビットの内部状態を使用する正当な理由を持っていたと確信しています、そして彼らは物事を遅くするためだけにそれを使用していません。

@jkotas 、リンクしたハッシュコードコンバイナーはMarvin32を使用していません。 ランダム化されていないstring.GetHashCode使用されているのと同じ単純なDJBx33xアルゴリズムを使用します。

汎用ハッシュコンバイナーは、この緩和策を進化させ続ける必要があります。ランダムシードと十分に強力なハッシュコード結合アルゴリズムを使用する必要があります。 理想的には、ランダム化された文字列ハッシュと同じMarvin32を使用します。

このタイプは、ハッシュDoS攻撃を受けやすい場所での使用を目的としたものではありません。 これは、add / xorをよく知らない人を対象としており、 https：//github.com/dotnet/coreclr/pull/4654のようなものを防ぐのに役立ち

汎用ハッシュコンバイナーは、この緩和策を進化させ続ける必要があります。ランダムシードと十分に強力なハッシュコード結合アルゴリズムを使用する必要があります。 理想的には、ランダム化された文字列ハッシュと同じMarvin32を使用します。

次に、C＃チームと話し合って、軽減されたValueTupleハッシュアルゴリズムを実装する必要があります。 そのコードはリスクの高い環境でも使用されるためです。 そしてもちろん、 Tuple https://github.com/dotnet/coreclr/blob/master/src/mscorlib/src/System/Tuple.cs#L60またはSystem.Numerics.HashHelpers （場所）。

さて、それを実装する方法を決定する前に、完全にランダム化されたハッシュコード結合アルゴリズムのコストを支払う価値があるかどうか（もちろん存在する場合）、APIの方法を変更しない場合でも、同じ対象分野の専門家を調べますどちらかを設計しました（提案されたAPIの下では、512ビットの状態を使用できますが、もちろん、そのコストを支払う意思がある場合は、同じパブリックAPIを使用できます）。

これは、追加/排他的論理和をよく知らない人を対象としています

それが堅牢であることが重要である理由です。 .NETの重要な価値は、よく知らない人々の問題に対処することです。

そして、私たちがそれに取り組んでいる間、 IntPtr忘れないでくださいhttps://github.com/dotnet/coreclr/blob/master/src/mscorlib/src/System/IntPtr.cs#L119
badはdabと衝突するため、これは特に厄介です。xorはおそらく最悪です。

軽減されたValueTupleハッシュアルゴリズムを実装する

いい視点ね。 ValueTupleが出荷されたのか、それともまだこれを行う時期なのかはわかりません。 https://github.com/dotnet/corefx/issues/14046を開きました

IntPtrを忘れないでください

これらは過去の過ちです...それらを修正するための基準ははるかに高くなっています。

@jkotas

これらは過去の過ちです...それらを修正するための基準ははるかに高くなっています。

.Net Coreのポイントの1つは、そのような「小さな」変更の基準がはるかに低くなるはずだということです。 誰かがIntPtr.GetHashCodeの実装に依存している場合（実際にはそうすべきではありません）、. NetCoreのバージョンをアップグレードしないことを選択できます。

そのような「小さな」変化のバーははるかに低くなるはずです

はい、それは-完全な.NETFrameworkと比較してです。 ただし、変更をシステムにプッシュするための作業を行う必要があり、苦労するだけの価値がないことに気付く場合があります。 最近の例は、F＃が壊れたために元に戻されたTuple<T>ハッシュアルゴリズムの変更です： https ：

@jkotas

HashCode 64ビットにする場合、不変の設計で32ビット環境のパフォーマンスが低下すると思いますか？ 私は他の読者に同意します、ビルダーパターンははるかに悪いようです。

パフォーマンスを殺す-いいえ。 シンタックスシュガーに支払われるパフォーマンスペナルティ-はい。

シンタックスシュガーに支払われるパフォーマンスペナルティ-はい。

将来、JITによって最適化できるものですか？

パフォーマンスを殺します-いいえ。
シンタックスシュガーに支払われるパフォーマンスペナルティ-はい。

糖衣構文以上のものです。 HashCodeをクラスにすることをいとわないのであれば、それはシンタックスシュガーになります。 しかし、可変値型はバグファームです。

以前からの引用：

それが堅牢であることが重要である理由です。 .NETの重要な価値は、よく知らない人々の問題に対処することです。

可変値型は、よく知らない大多数の人々にとって堅牢なAPIではないと私は主張します。

可変値型は、よく知らない大多数の人々にとって堅牢なAPIではないと私は主張します。

同意。 とはいえ、可変構造体ビルダータイプの場合は残念だと思います。 私が使用し、それらをすべての時間を、彼らは素晴らしく、締まっているのです。 [MustNotCopy]注釈は誰ですか？

MustNotCopyは、構造体愛好家の夢が叶うものです。 @jaredpar？

MustNotCopyはスタックのみのようなものですが、使用するのはさらに困難です😄

クラスを作成せずに、ハッシュを組み合わせるための拡張メソッドを作成することをお勧めします

static class HashHelpers
{
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static int CombineHash(this int hash1, int hash2);
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static int CombineHash<T>(this int hash, T value);
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static int CombineHash<T>(this int hash, T value, IEqualityComparer<T> comparer);
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static int CombineHash<T>(this int hash, IEnumerable<T> values);
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static int CombineHash<T>(this int hash, IEnumerable<T> values, IEqualityComparer<T> comparer);
}

以上です！ 高速で使いやすいです。

@AlexRadchハッシュとして意図されたものだけでなく、すべての整数のメソッドリストを汚染するのは好きではありません。

また、ハッシュコードの計算のチェーンを継続するメソッドがありますが、どのように開始しますか？ ゼロから始めるなど、自明ではないことをする必要がありますか？ つまり、 0.CombineHash(this.FirstName).CombineHash(this.LastName) 。

更新：dotnet / corefx＃14046のコメントによると、既存のハッシュ式はValueTuple保持されることが決定されました：

@jamesqo助けてくれてありがとう。
@jkotasと進めてもかまいませんが、より高価なハッシュ関数の採用を控えたいと
ランダム化を行うことで、必要が生じた場合に将来ハッシュ関数を変更するための扉が開かれます。

@jkotas 、現在のROL 5ベースのハッシュをHashCodeままにして、4バイトに縮小することはできますか？ これにより、構造体のコピーに関するすべての問題が解消されます。 HashCode.Emptyランダム化されたハッシュ値を表すことができます。

@svick
はい、これはすべての整数のメソッドを汚染しますが、分離された名前空間に配置することができ、ハッシュを使用しない場合は、それを含めず、表示されません。

0.CombineHash(this.FirstName).CombineHash(this.LastName)はthis.FirstName.GetHash().CombineHash(this.LastName)と書く必要があります

シードから開始して実装するには、次の静的メソッドを使用できます

static class HashHelpers
{
    public static int ClassSeed<T>();
}

class SomeClass
{
    int GetHash()
    {
        return HashHelpers.ClassSeed<SomeClass>().CombineHash(value1).CombineHash(value2);
    }
}

したがって、各クラスには、ハッシュをランダム化するための異なるシードがあります。

@ jkotas 、

パブリックプラットフォームのハッシュコード構築ヘルパーは、堅牢にするために64ビット状態を使用する必要があると思います。 32ビットのみの場合、特により多くの要素、配列、またはコレクションをハッシュするために使用すると、悪い結果が生じる傾向があります。 使用するのが良いのか、使用しないのが良いのかについて、どのようにドキュメントを作成しますか？ はい、それはビットを混合するために費やされる余分な指示ですが、私はそれが重要であるとは思いません。 これらの種類の命令は超高速で実行されます。 私の経験では、ビットミキシングが少なすぎると、多すぎるよりもはるかに深刻になるため、ビットミキシングを少なくするよりも多くする方がよいと思います。

また、提案されているAPIの形状についても懸念があります。 問題はハッシュコードの組み合わせではなく、ハッシュコードの構築として考えるべきだと思います。 これをプラットフォームAPIとして追加するのは時期尚早かもしれません。むしろ、これに対してより良いパターンが出現するかどうかを確認する必要があります。 これは、誰かがこのAPIを使用して（ソース）nugetパッケージを公開したり、corefxがそれを内部ヘルパーとして使用したりすることを妨げるものではありません。

64ビット状態の64ビット状態を使用するように設計する必要があります。 また、結合機能が良ければ（統計的に言えば）、混合が少ないということはありません。 ハッシュにランダム化、アバランシェ、およびその他の関心のある統計的特性がある場合、技術的には特別に細工されたハッシュ関数であるため、混合が考慮されます。

優れたハッシュ関数を作成するものを確認してください（明らかにxorようなものもあります： http ： https://research.neustar.biz/2012/02/02/choosing-a-good-hash-function-part-3/

@jamesqoところで、「シードは毎回変更されるため、実際には（ランタイムハッシュではなく）ハッシュを結合している」場合には、コンバイナーが機能しないことに気付きました。 ...シードを持つパブリックコンストラクタ？

@jkotas

パブリックプラットフォームのハッシュコード構築ヘルパーは、堅牢にするために64ビット状態を使用する必要があると思います。 32ビットのみの場合、特により多くの要素、配列、またはコレクションをハッシュするために使用すると、悪い結果が生じる傾向があります。

最終的に単一のintに凝縮される場合、これは重要ですか？

@jamesqo実際には、状態のサイズは機能のみに依存し、堅牢性には依存しません。 実際、コンバインがそのように機能するように設計されていない場合、ハッシュ関数を実際に悪化させる可能性があります。強制からランダム性を取得できないため、せいぜいリソースを浪費しています。

当然の結果：関数が統計的に優れていることを確認する必要があります。そうしないと、関数が悪化することがほぼ保証されます。

これは、アイテム間に相関関係があるかどうかによって異なります。 相関関係がない場合は、32ビット状態と単純なrotl（またはxor）で問題なく動作します。 相関関係があるかどうかによります。

誰かがこれを使用して、個々の文字から文字列ハッシュコードを作成したかどうかを検討してください。 誰かが実際に文字列に対してこれを行う可能性が高いというわけではありませんが、問題を示しています。

for (int i = 0; i < str.Length; i++)
   hashCodeBuilder.Add(str[i]);

実世界の文字列の文字は相関する傾向があるため、32ビット状態の文字列と単純なrotlの結果は良くありません。 これが相関するために使用されるアイテムはどのくらいの頻度で、どのくらい悪い結果になりますか？ 実生活では物事は予想外の方法で相関する傾向がありますが、わかりにくいです。

APIサポートハッシュランダム化に次のメソッドを追加するのは素晴らしいことです。

namespace System
{
    public struct HashCode : IEquatable<HashCode>
    {
       // add this
       public static HashCode CreateRandomized(Type type);
       // or add this
       public static HashCode CreateRandomized<T>();
    }
}

@jkotasまだテストしていないので、テストしたと思います。 しかし、それは間違いなく私たちが使用しようとしている関数について何かを言っています。 速度と信頼性を交換したい場合は、少なくとも十分ではありません（誰もそれを使って愚かなことをすることはできません）。 私はかつて、これは非暗号化ハッシュ関数ではなく、無相関のハッシュコード（取得するのと同じくらいランダム）を組み合わせるための高速な方法であるという設計を支持しています。

私たちが目指しているのは、誰もそれで愚かなことをしないということです。64ビット状態を使用しても何も修正されません。問題を隠しているだけです。 その相関関係を利用する入力を作成することは引き続き可能です。 これは、私が18日前に行ったのとまったく同じ議論をもう一度指摘します。 参照： https ：

私はかつて、これは非暗号化ハッシュ関数ではなく、無相関のハッシュコードを組み合わせるための高速な方法であるという設計を支持しています

無相関のハッシュコードを組み合わせる最速の方法は、xor ...です。

本当ですが、前回はあまりうまく機能しなかったことを私たちは知っています（IntPtrが私の頭に浮かびます）。 回転とXOR（現在）は同じくらい高速で、誰かが何らかの相関関係のあるものを入れても損失はありません。

public static HashCode CreateRandomized(Type type);またはpublic static HashCode CreateRandomized<T>();メソッド、あるいはその両方を使用してハッシュコードのランダム化を追加します。

@jkotas私はこれのためのより良いパターンを見つけたかもしれないと思います。 C＃7 ref returnを使用した場合はどうなりますか？ 毎回HashCodeを返す代わりに、レジスターに収まるref HashCodeを返します。

public struct HashCode
{
    private readonly long _value;

    public ref HashCode Combine(int hashCode)
    {
        CombineCore(ref _value, hashCode); // note: modifies the struct in-place
        return ref this;
    }
}

使用法は以前と同じです。

return HashCode.Combine(1)
    .Combine(2).Combine(3);

唯一の欠点は、再び可変構造体に戻ることです。 しかし、コピーと不変性の両方を同時に持たない方法はないと思います。

（ ref thisはまだ機能していませんが、ここで有効にするためのPRがRoslynにあり

@AlexRadch型のハッシュコードを取得するにはコストがかかるため、ハッシュを型とさらに組み合わせるのは賢明ではないと思います。

@jamesqo public static HashCode CreateRandomized<T>();は型ハッシュコードを取得しません。 このタイプのランダム化されたHashCodeを作成します。

@jamesqo 「 ref thisはまだ機能していません」。 Roslynの問題が修正された後でも、しばらくの間、corefxリポジトリでref thisを使用できなくなります（ @ stephentoubが期待を設定できる期間は

設計の議論はここでは収束していません。 さらに、200のコメントをフォローするのは非常に困難です。
来週は@jkotasを取得し、

一方で、この問題を閉じて、来週の「祝福された提案」で新しい問題を作成し、長い議論を続ける負担を軽減することをお勧めします。 悪い考えだと思われる場合はお知らせください。

@jcouvリリース時にこのデザインに従うことができる限り、まだ機能していなくても大丈夫です。 （ Unsafeを使用して一時的にこれを回避することも可能かもしれないと思います。）

@karelz OK：smile：後で時間があるときにこの提案を閉じて、新しい提案を開きます。 同意します; 私のブラウザは200以上のコメントをうまく処理できません。

@karelz私はref this戻り値を有効にしようとしていたことがわかりました。 ref thisは構造体から安全に返すことはできません。 理由については、こちらをご覧ください。 したがって、ref-returningの妥協は機能しません。

とにかく、私はこの問題を閉じます。 ここで別の問題を開きました： https ：

C＃vNext ...を想定していますが、値型拡張メソッドの投稿

@benaadams

C＃vNextを想定していますが、値型拡張メソッドpost dotnet / roslyn＃15650からref "this"を返すことができるはずです...

正しい。 ref this拡張メソッドからthisを返すことができます。 ただし、通常のstructインスタンスメソッドからthisを返すことはできません。 なぜそうなるのかについては、生涯の詳細がたくさんあります:(

@redknightlois

厳密にしたい場合、ハッシュはuintのみである必要があります。これは、フレームワークがその光の下でint返すという見落としと見なすことができます。

CLS準拠？ 符号なし整数はCLSに準拠していません。