{"id":1155,"date":"2018-03-30T11:53:11","date_gmt":"2018-03-30T03:53:11","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/seteplia\/?p=1155"},"modified":"2019-06-11T21:54:03","modified_gmt":"2019-06-12T04:54:03","slug":"nullable-types-arithmetic-and-null-coalescing-operator-precedence","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/premier-developer\/nullable-types-arithmetic-and-null-coalescing-operator-precedence\/","title":{"rendered":"Nullable types arithmetic and null-coalescing operator precedence"},"content":{"rendered":"

Here is a simple question for you: which version of a GetHashCode()<\/code> is correct and what performance impact does the incorrect version have?<\/p>\n

public struct Struct1\r\n{\r\n    public int N { get; }\r\n    public string S { get; }\r\n    public Struct1(int n, string s = null) { N = n; S = s; }\r\n\r\n    public override int GetHashCode() => \r\n        N ^ \r\n        S?.GetHashCode() ?? 0;\r\n\r\n    public override bool Equals(object obj) => \r\n        obj is Struct1 other && N == other.N && string.Equals(S, other.S);\r\n}\r\n\r\npublic struct Struct2\r\n{\r\n    public int N { get; }\r\n    public string S { get; }\r\n    public Struct2(int n, string s = null) { N = n; S = s; }\r\n\r\n    public override int GetHashCode() => \r\n        S?.GetHashCode() ?? 0 ^\r\n        N;\r\n\r\n    public override bool Equals(object obj) => \r\n        obj is Struct1 other && N == other.N && string.Equals(S, other.S);\r\n}<\/pre>\n
The structs are not perfect (they don’t implement IEquatable<T><\/code>) but this is not the point. The only difference between the two is the GetHashCode()<\/code> implementation:<\/p>\n
\/\/ Struct 1\r\npublic override int GetHashCode() =>\r\n    N ^\r\n    S?.GetHashCode() ?? 0;\r\n\r\n\/\/ Struct 2\r\npublic override int GetHashCode() =>\r\n    S?.GetHashCode() ?? 0 ^\r\n    N;<\/pre>\n
Let’s check the behavior using the following simple benchmark:<\/p>\n
private const int count = 10000;\r\nprivate static Struct1[] _arrayStruct1 =\r\n    Enumerable.Range(1, count).Select(n => new Struct1(n)).ToArray();\r\nprivate static Struct2[] _arrayStruct2 =\r\n    Enumerable.Range(1, count).Select(n => new Struct2(n)).ToArray();\r\n\r\n[Benchmark]\r\npublic int Struct1() => new HashSet<Struct1>(_arrayStruct1).Count;\r\n\r\n[Benchmark]\r\npublic int Struct2() => new HashSet<Struct2>(_arrayStruct2).Count;<\/pre>\n
The results are:<\/p>\n
  Method |         Mean |        Error |       StdDev | \r\n-------- |-------------:|-------------:|-------------:| \r\n Struct1 | 736,298.4 us | 4,224.637 us | 3,745.030 us | \r\n Struct2 |     353.8 us |     2.382 us |     1.989 us |<\/pre>\n
Wow! The Struct2<\/code> is 2000 times faster! This definitely means that the second implementation is correct and the first one is not! Right? Actually, not.<\/p>\n
Both implementations are incorrect and just by an accident the second one “works better” in this particular case. Let’s take closer look at the GetHashCode<\/code> method for Struct1<\/code>:<\/p>\n
public override int GetHashCode() => N ^ S?.GetHashCode() ?? 0;<\/pre>\n
You may think that this statement is equivalent to N ^ (S?.GetHashCode() ?? 0)<\/code>but it is actually equivalent to (N ^ S?.GetHashCode()) ?? 0<\/code>:<\/p>\n
public override int GetHashCode()\r\n{\r\n    int? num = N ^ ((S != null) ? new int?(S.GetHashCode()) : null);\r\n\r\n    if (num == null)\r\n        return 0;\r\n\r\n    return num.GetValueOrDefault();\r\n}<\/pre>\n
Now it is way more obvious why the Struct1<\/code> is so slow: when S<\/code> property is null<\/code>(which is always the case in this example), the hash code is 0<\/code> regardless of the N<\/code>because N ^ (int?)null<\/code> is null<\/code>. And trying to add 10000 values with the same hash code effectively converts the hash set into a linked list drastically affecting the performance.<\/p>\n
But the second implementation is also wrong:<\/p>\n
public override int GetHashCode() => S?.GetHashCode() ?? 0 ^ N;<\/pre>\n
Is equivalent to:<\/p>\n
public override int GetHashCode()\r\n{\r\n    if (S == null)\r\n    {\r\n        return 0 ^ N;\r\n    }\r\n\r\n    return S.GetHashCode();\r\n}<\/pre>\n
In this particular case, this implementation gives us way better distribution, but just because the S<\/code> is always null. In other scenarios, this hash function could be terrible and could give the same value for a large set of instances as well.<\/p>\n
Conclusion<\/h4>\n
There are two reasons why the expression N ^ S?.GetHashCode()??0<\/code> gives us not what we could expect. C# supports the notion of lifted operators that allows mixing nullable and non-nullable values together in one expression: 42 ^ (int?)null<\/code> is null<\/code>. Second, the priority of null-coalescing operator (??<\/code>) is lower than the priority of ^<\/code>.<\/p>\n
Operator precedence for some operators is so obvious that we can omit explicit parens around them. In case of the null-coalescing operator, the precedence could be tricky so use parenthesis to clarify your meaning.<\/p>\n
Additional references<\/h4>\n