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())));
}
