public IEnumerable <TypeDefinition> GetSubTypes(TypeDefinition type) { var comparer = new TypeEqualityComparer(); return(Types.Where(t => !comparer.Equals(t, type) && GetBaseTypes(t).Contains(type, comparer))); }
private static void AssertNotEqual(Type x, Type y) { var eq = new TypeEqualityComparer(); Assert.IsFalse(eq.Equals(x, y)); Assert.IsFalse(eq.Equals(y, x)); Assert.AreNotEqual(eq.GetHashCode(x), eq.GetHashCode(y)); }
/// <summary> /// <para> /// Do a strict validation upon the configuration. /// It means that every events need to be dispatched in at least one bus. /// </para> /// <para> /// If the configuration was not build with the strict flag, this will returns true in all cases. /// </para> /// </summary> /// <returns>True if the configuration is stricly valid, false otherwise.</returns> public bool ValidateStrict() { if (_strict) { var typeComparer = new TypeEqualityComparer(); var allTypes = ReflectionTools.GetAllTypes().Where(t => (typeof(IDomainEvent).IsAssignableFrom(t) || typeof(ICommand).IsAssignableFrom(t)) && t.IsClass).ToList(); return(allTypes.All(t => EventDispatchersConfiguration.Any(cfg => cfg.BusesTypes.WhereNotNull().Any()))); } return(true); }
internal void Patch(ModuleDef module) { List <TypeDependency> owned = PatchDependency(module, typeDependencies.Concat(typeMixins.Select(m => m.Dependency))); typeDependencies.RemoveAll(owned.Contains); typeMixins.RemoveAll(m => owned.Contains(m.Dependency)); HashSet <MethodSig> originals = new HashSet <MethodSig>(); foreach (MethodSig original in typeDependencies.SelectMany(t => t.Originals.Select(module.ToSig))) { originals.Add(original); } foreach (KeyValuePair <MethodSignature, List <Action <MethodDef> > > method in mixins) { MethodDef methodDef = Resolve(module, method.Key); foreach (Action <MethodDef> action in method.Value) { action(methodDef); } } PatchModule?.Invoke(module); TypeEqualityComparer typeComparer = new TypeEqualityComparer(ComparerOptions); SignatureEqualityComparer comparer = new SignatureEqualityComparer(ComparerOptions); Dictionary <TypeSig, TypeSig> typeSubstitutions = this.typeSubstitutions.GroupBy(p => module.ToSig(p.Key), p => module.ToSig(p.Value), typeComparer).Where(g => !typeComparer.Equals(g.Key, g.First())).ToDictionary(g => g.Key, Enumerable.First, typeComparer); Dictionary <FieldSig, FieldSig> fieldSubstitutions = this.fieldSubstitutions.GroupBy(p => module.ToSig(p.Key), p => module.ToSig(p.Value), comparer).Where(g => !comparer.Equals(g.Key, g.First())).ToDictionary(g => g.Key, Enumerable.First, comparer); Dictionary <MethodSig, MethodSig> methodSubstitutions = this.methodSubstitutions.GroupBy(p => module.ToSig(p.Key), p => module.ToSig(p.Value), comparer).Where(g => !comparer.Equals(g.Key, g.First())).ToDictionary(g => g.Key, Enumerable.First, comparer); foreach (TypeDef type in module.GetTypes()) { foreach (FieldDef field in type.Fields) { while (fieldSubstitutions.TryGetValue(field.FieldSig, out FieldSig newFieldSig)) { field.FieldSig = newFieldSig; } field.FieldType = field.FieldType.ApplyToLeaf(typeSubstitutions.Substitute); } foreach (MethodDef method in type.Methods) { method.MethodSig = methodSubstitutions.Substitute(method.MethodSig); foreach (Parameter parameter in method.Parameters) { parameter.Type = parameter.Type.ApplyToLeaf(typeSubstitutions.Substitute); } method.ReturnType = method.ReturnType.ApplyToLeaf(typeSubstitutions.Substitute); } } }
public void TypeEquality_ProtectedNulls() { var eq = new TypeEqualityComparer(); foreach (var equals in eq.GetType().GetMethods(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance).Where(m => m.Name.StartsWith("Equals"))) { var t = default(object); var ps = equals.GetParameters(); if (ps.Length == 2) { if (ps[0].ParameterType == typeof(Type) && ps[1].ParameterType == typeof(Type)) { t = typeof(int); } else if (ps[0].ParameterType == typeof(IEnumerable <Type>) && ps[1].ParameterType == typeof(IEnumerable <Type>)) { t = new[] { typeof(int) }; } else { continue; } Assert.IsTrue((bool)equals.Invoke(eq, new object[] { null, null })); Assert.IsFalse((bool)equals.Invoke(eq, new object[] { t, null })); Assert.IsFalse((bool)equals.Invoke(eq, new object[] { null, t })); } } foreach (var getHashCode in eq.GetType().GetMethods(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance).Where(m => m.Name.StartsWith("GetHashCode"))) { var ps = getHashCode.GetParameters(); if (ps.Length == 1) { if (ps[0].ParameterType == typeof(Type)) { Assert.AreNotEqual(0, (int)getHashCode.Invoke(eq, new object[] { null })); } } } }
public void TypeSlimExtensions_KnownTypes() { var d = new Dictionary <Type, TypeSlim> { { typeof(Action), TypeSlimExtensions.ActionType }, { typeof(bool), TypeSlimExtensions.BooleanType }, { typeof(Expression <>), TypeSlimExtensions.GenericExpressionType }, { typeof(int), TypeSlimExtensions.IntegerType }, { typeof(void), TypeSlimExtensions.VoidType }, }; var eqt = new TypeEqualityComparer(); var eqs = new TypeSlimEqualityComparer(); foreach (var kv in d) { Assert.IsTrue(eqt.Equals(kv.Key, kv.Value.ToType())); Assert.IsTrue(eqs.Equals(kv.Key.ToTypeSlim(), kv.Value)); } }
public void StructuralTypeEqualityComparer_StructuralEquals() { var rt1 = RuntimeCompiler.CreateRecordType(new Dictionary <string, Type> { { "Foo", typeof(int) }, { "Bar", typeof(string) } }, true); var rt2 = RuntimeCompiler.CreateRecordType(new Dictionary <string, Type> { { "Foo", typeof(int) }, { "Bar", typeof(string) }, }, true); var at1 = RuntimeCompiler.CreateAnonymousType(new Dictionary <string, Type> { { "Foo", typeof(int) }, { "Bar", typeof(string) } }, null); var at2 = RuntimeCompiler.CreateAnonymousType(new Dictionary <string, Type> { { "Foo", typeof(int) }, { "Bar", typeof(string) } }, null); var eq = new StructuralTypeEqualityComparer(); var orig = new TypeEqualityComparer(); Assert.IsFalse(orig.Equals(rt1, rt2)); Assert.IsTrue(eq.Equals(rt1, rt2)); Assert.IsFalse(orig.Equals(at1, at2)); Assert.IsTrue(eq.Equals(at1, at2)); }
private static void AdaptEncodingOperators(IEncoding oldEncoding, IEncoding newEncoding) { if (oldEncoding.GetType() != newEncoding.GetType()) { return; } if (oldEncoding.GetType() == typeof(MultiEncoding)) { var oldMultiEncoding = (MultiEncoding)oldEncoding; var newMultiEncoding = (MultiEncoding)newEncoding; if (!oldMultiEncoding.Encodings.SequenceEqual(newMultiEncoding.Encodings, new TypeEqualityComparer <IEncoding>())) { return; } var nestedEncodings = oldMultiEncoding.Encodings.Zip(newMultiEncoding.Encodings, (o, n) => new { oldEnc = o, newEnc = n }); foreach (var multi in nestedEncodings) { AdaptEncodingOperators(multi.oldEnc, multi.newEnc); } } var comparer = new TypeEqualityComparer <IOperator>(); var cloner = new Cloner(); var oldOperators = oldEncoding.Operators; var newOperators = newEncoding.Operators; cloner.RegisterClonedObject(oldEncoding, newEncoding); var operators = oldOperators.Intersect(newOperators, comparer) .Select(cloner.Clone) .Union(newOperators, comparer).ToList(); newEncoding.ConfigureOperators(operators); newEncoding.Operators = operators; }
public override bool Execute() { if (string.IsNullOrWhiteSpace(DestinationDirectory)) { Log.LogMessageFromText(nameof(DestinationDirectory) + " is an empty string", MessageImportance.High); return(false); } using (var assemblyFactory = new AssemblyFactory(ReferencePath.Select(a => a.ItemSpec))) { AssemblyRef netstandardAsmRef = null; AssemblyDef netstandardAsm = null; var typeComparer = new TypeEqualityComparer(SigComparerOptions.DontCompareTypeScope); var netstandardTypes = new HashSet <IType>(typeComparer); OutputReferencePath = new ITaskItem[ReferencePath.Length]; for (int i = 0; i < ReferencePath.Length; i++) { var file = ReferencePath[i]; OutputReferencePath[i] = file; var filename = file.ItemSpec; var fileExt = Path.GetExtension(filename); var asmSimpleName = Path.GetFileNameWithoutExtension(filename); if (!ShouldPatchAssembly(asmSimpleName)) { continue; } if (!File.Exists(filename)) { Log.LogMessageFromText($"File does not exist: {filename}", MessageImportance.High); return(false); } var patchDir = DestinationDirectory; Directory.CreateDirectory(patchDir); var fileInfo = new FileInfo(filename); long filesize = fileInfo.Length; long writeTime = fileInfo.LastWriteTimeUtc.ToBinary(); var extraInfo = $"_{VERSION} {filesize} {writeTime}_"; var patchedFilename = Path.Combine(patchDir, asmSimpleName + extraInfo + fileExt); if (StringComparer.OrdinalIgnoreCase.Equals(patchedFilename, filename)) { continue; } if (!File.Exists(patchedFilename)) { var asm = assemblyFactory.Resolve(asmSimpleName); if (asm == null) { throw new Exception($"Couldn't resolve assembly {filename}"); } var mod = (ModuleDefMD)asm.ManifestModule; if (!ShouldPatchAssembly(mod)) { continue; } if (netstandardAsm == null) { netstandardAsm = assemblyFactory.Resolve("netstandard"); if (netstandardAsm == null) { throw new Exception("Couldn't find a netstandard file"); } netstandardAsmRef = netstandardAsm.ToAssemblyRef(); foreach (var type in netstandardAsm.ManifestModule.GetTypes()) { if (type.IsGlobalModuleType) { continue; } if (IsPublic(type)) { netstandardTypes.Add(type); } } foreach (var type in netstandardAsm.ManifestModule.ExportedTypes) { netstandardTypes.Add(type); } } for (uint rid = 1; ; rid++) { var tr = mod.ResolveTypeRef(rid); if (tr == null) { break; } if (!netstandardTypes.Contains(tr)) { continue; } if (tr.ResolutionScope is AssemblyRef asmRef && CanReplaceAssemblyRef(asmRef)) { tr.ResolutionScope = netstandardAsmRef; } } var options = new ModuleWriterOptions(mod); mod.Write(patchedFilename, options); var xmlDocFile = Path.ChangeExtension(filename, "xml"); if (File.Exists(xmlDocFile)) { var newXmlDocFile = Path.ChangeExtension(patchedFilename, "xml"); if (File.Exists(newXmlDocFile)) { File.Delete(newXmlDocFile); } File.Copy(xmlDocFile, newXmlDocFile); } } OutputReferencePath[i] = new TaskItem(patchedFilename); } return(true); } }
public void StructuralTypeEqualityComparer_ManOrBoy2_Success() { var rtc = new RuntimeCompiler(); var rt1 = rtc.GetNewRecordTypeBuilder(); var rt2 = rtc.GetNewRecordTypeBuilder(); var at1 = rtc.GetNewAnonymousTypeBuilder(); var at2 = rtc.GetNewAnonymousTypeBuilder(); rtc.DefineRecordType( rt1, new Dictionary <string, Type> { { "Self", rt1 }, { "Copy", rt2 }, { "Other", typeof(int) } }, true); rtc.DefineRecordType( rt2, new Dictionary <string, Type> { { "Self", rt2 }, { "Copy", rt1 }, { "Other", typeof(int) } }, true); rtc.DefineAnonymousType( at1, new Dictionary <string, Type> { { "Self", at1 }, { "Copy", at2 }, { "Other", typeof(int) } }, null); rtc.DefineAnonymousType( at2, new Dictionary <string, Type> { { "Self", at2 }, { "Copy", at1 }, { "Other", typeof(int) } }, null); var rt1c = rt1.CreateType(); var rt2c = rt2.CreateType(); var at1c = at1.CreateType(); var at2c = at2.CreateType(); var eq = new StructuralTypeEqualityComparer(); var orig = new TypeEqualityComparer(); Assert.IsFalse(orig.Equals(rt1c, rt2c)); Assert.IsTrue(eq.Equals(rt1c, rt2c)); Assert.IsFalse(orig.Equals(at1c, at2c)); Assert.IsTrue(eq.Equals(at1c, at2c)); }
public TestScope(Dictionary <Type, object> instances) { _instances = new ReadOnlyDictionary <Type, object>(instances); _typeComparer = new TypeEqualityComparer(); }
public void EqualsWithEqualObjects() { var comparer = new TypeEqualityComparer(); Assert.IsTrue(comparer.Equals(typeof(string), typeof(string))); }
public void EqualsWithBothObjectsNull() { var comparer = new TypeEqualityComparer(); Assert.IsFalse(comparer.Equals(null, null)); }
public void EqualsWithSecondObjectNull() { var comparer = new TypeEqualityComparer(); Assert.IsFalse(comparer.Equals(typeof(object), null)); }
public void EqualsWithFirstObjectNull() { var comparer = new TypeEqualityComparer(); Assert.IsFalse(comparer.Equals(null, typeof(object))); }
public GenericParamComparer(TypeEqualityComparer typeComparer = null) => this.typeComparer = typeComparer ?? new TypeEqualityComparer(default);