/// <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);