private ConstructorInfoCache(Type type) { Constructors = type.AllConstructors(); _constructors = new Dictionary <Type[], ConstructorInfo>(EqualityComparerEx.Array <Type>()); foreach (var constructorInfo in Constructors) { _constructors[constructorInfo.GetParameters().Select(x => x.ParameterType).ToArray()] = constructorInfo; } }
public void CompareInts() { var comparer = EqualityComparerEx.Key((int a) => a); Assert.True(comparer.Equals(1, 1)); Assert.False(comparer.Equals(1, 2)); Assert.Equal(comparer.GetHashCode(1), comparer.GetHashCode(1)); Assert.NotEqual(comparer.GetHashCode(1), comparer.GetHashCode(2)); }
public void CompareInts() { var comparer = EqualityComparerEx.Func((int a, int b) => a == b); Assert.True(comparer.Equals(1, 1)); Assert.False(comparer.Equals(1, 2)); // ReSharper disable once EqualExpressionComparison Assert.True(comparer.GetHashCode(1) == comparer.GetHashCode(1)); Assert.False(comparer.GetHashCode(1) == comparer.GetHashCode(2)); }
public void ComparerWorksByReferenceNonGeneric() { var comparer = (IEqualityComparer)EqualityComparerEx.Reference(); var str1 = 5.ToString(); var str2 = 5.ToString(); Assert.False(comparer.Equals(str1, str2)); Assert.NotEqual(comparer.GetHashCode(str1), comparer.GetHashCode(str2)); var str3 = str1; Assert.True(comparer.Equals(str1, str3)); Assert.Equal(comparer.GetHashCode(str1), comparer.GetHashCode(str3)); Assert.True(comparer.Equals(null, null)); Assert.False(comparer.Equals(str1, null)); Assert.False(comparer.Equals(null, str1)); Assert.Equal(comparer.GetHashCode(null), comparer.GetHashCode(null)); }
public void NonGenericCompareInts() { var comparer = (IEqualityComparer)EqualityComparerEx.Key((int a) => a); object one = 1; object two = 2; Assert.True(comparer.Equals(one, 1)); Assert.False(comparer.Equals(one, two)); // ReSharper disable ReturnValueOfPureMethodIsNotUsed Assert.Throws <ArgumentException>(() => comparer.Equals(one, "1")); Assert.Equal(comparer.GetHashCode(one), comparer.GetHashCode(1)); Assert.NotEqual(comparer.GetHashCode(one), comparer.GetHashCode(two)); Assert.Throws <ArgumentException>(() => comparer.GetHashCode("1")); // ReSharper restore ReturnValueOfPureMethodIsNotUsed }
public void NonGenericCompareInts() { var comparer = EqualityComparerEx.Func <int>((a, b) => a == b); object one = 1; object two = 2; var comparerObj = comparer as IEqualityComparer; Assert.True(comparerObj.Equals(one, 1)); Assert.False(comparerObj.Equals(one, two)); // ReSharper disable once EqualExpressionComparison // ReSharper disable once ReturnValueOfPureMethodIsNotUsed Assert.Throws <ArgumentException>(() => comparerObj.Equals(one, "1")); Assert.True(comparerObj.GetHashCode(one) == comparer.GetHashCode(1)); Assert.False(comparerObj.GetHashCode(one) == comparerObj.GetHashCode(two)); // ReSharper disable once ReturnValueOfPureMethodIsNotUsed Assert.Throws <ArgumentException>(() => comparerObj.GetHashCode("1")); }
public void CompareIntsUsingSignComparer() { var array1 = new[] { 1, 2, 3 }; var array2 = new[] { 2, 3, 5 }; var array3 = new[] { 1, 3, -3 }; var array4 = new[] { 1, 2, 3, 4 }; var comparer = EqualityComparerEx.Array(EqualityComparerEx.Func <int>((x, y) => Math.Sign(x) == Math.Sign(y), Math.Sign)); var hashCode1 = comparer.GetHashCode(array1); var hashCode2 = comparer.GetHashCode(array2); var hashCode3 = comparer.GetHashCode(array3); var hashCode4 = comparer.GetHashCode(array4); Assert.Equal(hashCode1, hashCode2); Assert.NotEqual(hashCode1, hashCode3); Assert.NotEqual(hashCode1, hashCode4); Assert.True(comparer.Equals(array1, array1)); Assert.True(comparer.Equals(array1, array2)); Assert.False(comparer.Equals(array1, array3)); Assert.False(comparer.Equals(array1, array4)); }
public void CompareTestClassBySecondProp() { var o1 = new ComparersTestClass { A = "test1", B = 1 }; var oe1 = new ComparersTestClass { A = "test1", B = 1 }; var o2 = new ComparersTestClass { A = "test1", B = 2 }; var comparer = EqualityComparerEx.Key((ComparersTestClass a) => a.B); Assert.True(comparer.Equals(o1, o1)); Assert.True(comparer.Equals(o1, oe1)); Assert.False(comparer.Equals(o1, o2)); Assert.Equal(comparer.GetHashCode(o1), comparer.GetHashCode(o1)); Assert.Equal(comparer.GetHashCode(o1), comparer.GetHashCode(oe1)); Assert.NotEqual(comparer.GetHashCode(o1), comparer.GetHashCode(o2)); }
public void CompareTestClassByOneProp() { var o1 = new ComparersTestClass { A = "test1", B = 1 }; var oe1 = new ComparersTestClass { A = "test1", B = 2 }; var o2 = new ComparersTestClass { A = "test2", B = 2 }; var comparer = EqualityComparerEx.Func <ComparersTestClass>((a, b) => a.A == b.A, a => a.A.GetHashCode()); Assert.True(comparer.Equals(o1, o1)); Assert.True(comparer.Equals(o1, oe1)); Assert.False(comparer.Equals(o1, o2)); // ReSharper disable once EqualExpressionComparison Assert.True(comparer.GetHashCode(o1) == comparer.GetHashCode(o1)); Assert.True(comparer.GetHashCode(o1) == comparer.GetHashCode(oe1)); Assert.False(comparer.GetHashCode(o1) == comparer.GetHashCode(o2)); }
private static IEqualityComparer <byte[]> GetArrayComparer() { return(EqualityComparerEx.Array <byte>()); }
private static IEqualityComparer <T[]> GetArrayComparer <T>() { return(EqualityComparerEx.Array <T>()); }
private static IEqualityComparer <T[]> GetCollectionComparer <T>() { return(EqualityComparerEx.Collection <T[], T>()); }
private static IReadOnlyDictionary <string, (Variance variance, IReadOnlyCollection <IResType>)> ResolveGenericStructs(Resolver resolver, dnlib.DotNet.TypeDef source, dnlib.DotNet.TypeDef?parent) { IResType ResolveType(GenericParamConstraint x, IReadOnlyDictionary <string, string> generics) => resolver.Resolve(x.Constraint.ToTypeSig(), generics); (Variance, IReadOnlyCollection <IResType>) ResolveParameter(GenericParam parameter, IReadOnlyDictionary <string, string> generics) { // If the parameter has no generic constraints.. if (!parameter.HasGenericParamConstraints) { // return default return(Variance.NonVariant, Enumerable.Empty <IResType>().ToArray()); } // Otherwise return the list of constraints return(Variance.NonVariant, parameter.GenericParamConstraints.Select(x => ResolveType(x, generics)).ToReadOnlyCollection()); } return(source.GenericParameters // Exclude generic parameters from the parent .Except(parent?.GenericParameters ?? Enumerable.Empty <GenericParam>(), EqualityComparerEx <GenericParam> .Create(x => x.Name, x => x.Name)) // Materialize the result as a dictionary .ToDictionary(param => param.Name.String, param => ResolveParameter(param, source.ResolveTypeGenerics()))); }