/// <summary>
/// Checks that the specified values are equal. Uses the specified equality comparer calling GetHashCode and Equals.
/// </summary>
/// <typeparam name="T">The type of the values to be compared.</typeparam>
/// <param name="equalityComparer">The equality comparer used for comparison.</param>
/// <param name="first">The first value.</param>
/// <param name="second">The second value.</param>
/// <returns>True if both values are considered equal, else false.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="equalityComparer" /> is null.</exception>
public static bool EqualsWithHashCode <T>(this IEqualityComparer <T> equalityComparer, T first, T second)
{
equalityComparer.MustNotBeNull(nameof(equalityComparer));
return(equalityComparer.GetHashCode(first) == equalityComparer.GetHashCode(second) &&
equalityComparer.Equals(first, second));
}
public ConcurrentArray(int capacity, IEqualityComparer <TKey> keyComparer)
{
capacity.MustNotBeLessThan(0, nameof(capacity));
keyComparer.MustNotBeNull(nameof(keyComparer));
_internalArray = new Entry <TKey, TValue> [capacity];
KeyComparer = keyComparer;
}
public PrecompiledDictionary(LookupDelegate <TKey, TValue> lookup,
IEnumerable <KeyValuePair <TKey, TValue> > keyValuePairs,
IEqualityComparer <TValue> valueComparer)
{
lookup.MustNotBeNull();
valueComparer.MustNotBeNull();
// ReSharper disable PossibleMultipleEnumeration
keyValuePairs.MustNotBeNull();
_lookup = lookup;
_valueComparer = valueComparer;
_keyValuePairs = keyValuePairs.ToArray();
// ReSharper restore PossibleMultipleEnumeration
Keys = new ReadOnlyCollection <TKey>(_keyValuePairs.Select(kvp => kvp.Key).ToArray());
Values = new ReadOnlyCollection <TValue>(_keyValuePairs.Select(kvp => kvp.Value).ToArray());
}
public static bool Implements([ValidatedNotNull] this Type type, [ValidatedNotNull] Type interfaceType, [ValidatedNotNull] IEqualityComparer <Type> typeComparer)
{
interfaceType.MustNotBeNull(nameof(interfaceType));
typeComparer.MustNotBeNull(nameof(typeComparer));
var implementedInterfaces = type.MustNotBeNull(nameof(type)).GetInterfaces();
for (var i = 0; i < implementedInterfaces.Length; ++i)
{
if (typeComparer.Equals(implementedInterfaces[i], interfaceType))
{
return(true);
}
}
return(false);
}
public static bool DerivesFrom([ValidatedNotNull] this Type type, [ValidatedNotNull] Type baseClass, [ValidatedNotNull] IEqualityComparer <Type> typeComparer)
{
baseClass.MustNotBeNull(nameof(baseClass));
typeComparer.MustNotBeNull(nameof(typeComparer));
var currentBaseType = type.MustNotBeNull(nameof(type)).BaseType;
while (currentBaseType != null)
{
if (typeComparer.Equals(currentBaseType, baseClass))
{
return(true);
}
currentBaseType = currentBaseType.BaseType;
}
return(false);
}
public static bool IsOrInheritsFrom([ValidatedNotNull] this Type type, [ValidatedNotNull] Type otherType, [ValidatedNotNull] IEqualityComparer <Type> typeComparer) => typeComparer.MustNotBeNull(nameof(typeComparer)).Equals(type, otherType.MustNotBeNull(nameof(otherType))) || type.InheritsFrom(otherType, typeComparer);
public LookupDelegate <TKey, TValue> CompileDynamicLookupFunction <TKey, TValue>(IEnumerable <KeyValuePair <TKey, TValue> > keyValuePairs, IEqualityComparer <TKey> keyComparer)
{
// ReSharper disable once PossibleMultipleEnumeration
keyValuePairs.MustNotBeNull();
keyComparer.MustNotBeNull();
var keyType = typeof(TKey);
var keyExpression = Expression.Parameter(keyType, "key");
var valueExpression = Expression.Parameter(typeof(TValue).MakeByRefType(), "value");
var keyComparerExpression = Expression.Constant(keyComparer);
var getHashCodeMethodInfo = keyComparer.GetType().GetRuntimeMethod(nameof(IEqualityComparer <TKey> .GetHashCode), new[] { keyType });
var equalsMethodInfo = keyComparer.GetType().GetRuntimeMethod(nameof(IEqualityComparer <TKey> .Equals), new[] { keyType, keyType });
var hashCodeExpression = Expression.Variable(typeof(int), "hashCode");
var resultExpression = Expression.Variable(typeof(bool), "result");
var trueExpression = Expression.Constant(true);
// ReSharper disable once PossibleMultipleEnumeration
var switchCases = keyValuePairs
.GroupBy(kvp => keyComparer.GetHashCode(kvp.Key))
.Select(hashCodeGroup =>
{
Expression caseBody;
if (hashCodeGroup.Count() == 1)
{
var keyValuePair = hashCodeGroup.First();
EnsureKeyIsNotNull(keyValuePair);
caseBody = Expression.Block(Expression.Assign(valueExpression, Expression.Constant(keyValuePair.Value)),
Expression.Assign(resultExpression, trueExpression));
}
else
{
Expression lastIfStatement = null;
foreach (var keyValuePair in hashCodeGroup)
{
EnsureKeyIsNotNull(keyValuePair);
if (lastIfStatement == null)
{
lastIfStatement = Expression.IfThen(Expression.Call(keyComparerExpression, equalsMethodInfo, keyExpression, Expression.Constant(keyValuePair.Key)),
Expression.Block(Expression.Assign(valueExpression, Expression.Constant(keyValuePair.Value)),
Expression.Assign(resultExpression, trueExpression)));
}
else
{
lastIfStatement = Expression.IfThenElse(Expression.Call(keyComparerExpression, equalsMethodInfo, keyExpression, Expression.Constant(keyValuePair.Key)),
Expression.Block(Expression.Assign(valueExpression, Expression.Constant(keyValuePair.Value)),
Expression.Assign(resultExpression, trueExpression)),
lastIfStatement);
}
}
caseBody = lastIfStatement;
}
return(Expression.SwitchCase(caseBody,
Expression.Constant(hashCodeGroup.Key)));
})
.ToArray();
var body = Expression.Block(new[] { hashCodeExpression, resultExpression },
Expression.Assign(hashCodeExpression, Expression.Call(keyComparerExpression, getHashCodeMethodInfo, keyExpression)),
Expression.Assign(resultExpression, Expression.Constant(false)),
Expression.Switch(typeof(void), hashCodeExpression, Expression.Assign(valueExpression, Expression.Constant(default(TValue), typeof(TValue))), null, switchCases),
resultExpression);
return(Expression.Lambda <LookupDelegate <TKey, TValue> >(body, keyExpression, valueExpression).Compile());
}
public static bool IsOrDerivesFrom(this Type type, Type otherType, IEqualityComparer <Type> typeComparer) => typeComparer.MustNotBeNull(nameof(typeComparer)).Equals(type, otherType.MustNotBeNull(nameof(otherType))) || type.DerivesFrom(otherType, typeComparer);
public static bool IsOrImplements(this Type type, Type otherType, IEqualityComparer <Type> typeComparer) => typeComparer.MustNotBeNull(nameof(typeComparer)).Equals(type.MustNotBeNull(nameof(type)), otherType.MustNotBeNull(nameof(otherType))) || type.Implements(otherType, typeComparer);
