1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
//------------------------------------------------------------------------------
// <copyright file="LinqQueryCacheKey.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//
// @owner Microsoft
// @backupOwner venkatja
//------------------------------------------------------------------------------
namespace System.Data.Common.QueryCache
{
using System;
using System.Data.Objects;
using System.Diagnostics;
/// <summary>
/// Represents an ELinq-based ObjectQuery Cache key context
/// </summary>
internal sealed class LinqQueryCacheKey : QueryCacheKey
{
/// <summary>
/// Aggregate hashcode based the hashcode of the properties of this cache key
/// </summary>
private readonly int _hashCode;
/// <summary>
/// DbExpression key
/// </summary>
private readonly string _expressionKey;
/// <summary>
/// Parameter collection token
/// </summary>
private readonly string _parametersToken;
/// <summary>
/// Number of parameters
/// </summary>
private readonly int _parameterCount;
/// <summary>
/// Concatenated representation of the Include span paths
/// </summary>
private readonly string _includePathsToken;
/// <summary>
/// The merge option in effect
/// </summary>
private readonly MergeOption _mergeOption;
/// <summary>
/// Result type affects assembly plan.
/// </summary>
private readonly Type _resultType;
/// <summary>
/// Flag indicating if the C# behavior should be used for null comparisons
/// </summary>
private readonly bool _useCSharpNullComparisonBehavior;
/// <summary>
/// Creates a new instance of LinqQueryCacheKey.
/// </summary>
/// <param name="expressionKey">The DbExpression key of the linq query</param>
/// <param name="parameterCount">The number of parameters to the query</param>
/// <param name="parametersToken">A string representation of the parameters to the query (may be null)</param>
/// <param name="includePathsToken">A string representation of the Include span paths in effect (may be null)</param>
/// <param name="mergeOption">The merge option in effect. Required for result assembly.</param>
/// <param name="useCSharpNullComparisonBehavior">Flag indicating if the C# behavior should be used for null comparisons</param>
/// <param name="resultType">The type of each result item - for a given query as a CLR type instance</param>
internal LinqQueryCacheKey(string expressionKey,
int parameterCount,
string parametersToken,
string includePathsToken,
MergeOption mergeOption,
bool useCSharpNullComparisonBehavior,
Type resultType)
: base()
{
Debug.Assert(null != expressionKey, "expressionKey must not be null");
_expressionKey = expressionKey;
_parameterCount = parameterCount;
_parametersToken = parametersToken;
_includePathsToken = includePathsToken;
_mergeOption = mergeOption;
_resultType = resultType;
_useCSharpNullComparisonBehavior = useCSharpNullComparisonBehavior;
int combinedHash = _expressionKey.GetHashCode() ^
_mergeOption.GetHashCode();
if (_parametersToken != null)
{
combinedHash ^= _parametersToken.GetHashCode();
}
if (_includePathsToken != null)
{
combinedHash ^= _includePathsToken.GetHashCode();
}
combinedHash ^= _useCSharpNullComparisonBehavior.GetHashCode();
_hashCode = combinedHash;
}
/// <summary>
/// Determines equality of two cache keys based on cache context values
/// </summary>
public override bool Equals(object otherObject)
{
Debug.Assert(null != otherObject, "otherObject must not be null");
if (typeof(LinqQueryCacheKey) != otherObject.GetType())
{
return false;
}
LinqQueryCacheKey otherObjectQueryCacheKey = (LinqQueryCacheKey)otherObject;
// also use result type...
return (_parameterCount == otherObjectQueryCacheKey._parameterCount) &&
(_mergeOption == otherObjectQueryCacheKey._mergeOption) &&
Equals(otherObjectQueryCacheKey._expressionKey, _expressionKey) &&
Equals(otherObjectQueryCacheKey._includePathsToken, _includePathsToken) &&
Equals(otherObjectQueryCacheKey._parametersToken, _parametersToken) &&
Equals(otherObjectQueryCacheKey._resultType, _resultType) &&
Equals(otherObjectQueryCacheKey._useCSharpNullComparisonBehavior, _useCSharpNullComparisonBehavior);
}
/// <summary>
/// Returns the hashcode for this cache key
/// </summary>
public override int GetHashCode()
{
return _hashCode;
}
/// <summary>
/// Returns a string representation of the state of this cache key
/// </summary>
public override string ToString()
{
return String.Join("|", new string[] { _expressionKey, _parametersToken, _includePathsToken, Enum.GetName(typeof(MergeOption), _mergeOption), _useCSharpNullComparisonBehavior.ToString() });
}
}
}
|
