internal QueryGenerationContext(QueryAggregator queryAggregator, VariableAggregator variableAggregator, IMemberNameResolver memberResolver) { QueryAggregator = queryAggregator; Variables = variableAggregator; MemberResolver = memberResolver; }
private void DiffEvents(QueryAggregator diffQueries) { var eventsV1 = diffQueries.ExecuteAndAggregateEventQueries(this.TypeV1); var eventsV2 = diffQueries.ExecuteAndAggregateEventQueries(this.TypeV2); var differ = new ListDiffer <EventDefinition>(this.CompareEvents); differ.Diff(eventsV1, eventsV2, added => { this.Events.Add(new DiffResult <EventDefinition>(added, new DiffOperation(true))); }, removed => { this.Events.Add(new DiffResult <EventDefinition>(removed, new DiffOperation(false))); }); }
private void DiffMethods(QueryAggregator diffQueries) { var methodsV1 = diffQueries.ExecuteAndAggregateMethodQueries(this.TypeV1); var methodsV2 = diffQueries.ExecuteAndAggregateMethodQueries(this.TypeV2); var differ = new ListDiffer <MethodDefinition>(this.CompareMethodByNameAndTypesIncludingGenericArguments); differ.Diff(methodsV1, methodsV2, added => { this.Methods.Add(new DiffResult <MethodDefinition>(added, new DiffOperation(true))); }, removed => { this.Methods.Add(new DiffResult <MethodDefinition>(removed, new DiffOperation(false))); }); }
private void DiffFields(QueryAggregator diffQueries) { var fieldsV1 = diffQueries.ExecuteAndAggregateFieldQueries(this.TypeV1); var fieldsV2 = diffQueries.ExecuteAndAggregateFieldQueries(this.TypeV2); var fieldDiffer = new ListDiffer <FieldDefinition>(this.CompareFieldsByTypeAndName); fieldDiffer.Diff(fieldsV1, fieldsV2, addedField => { this.Fields.Add(new DiffResult <FieldDefinition>(addedField, new DiffOperation(true))); }, removedField => { this.Fields.Add(new DiffResult <FieldDefinition>(removedField, new DiffOperation(false))); }); }
public void GenerateSelectiveQueries() { myQueries = new QueryAggregator(); myQueries.MethodQueries.Add(MethodQuery.PublicMethods); myQueries.MethodQueries.Add(MethodQuery.ProtectedMethods); myQueries.FieldQueries.Add(FieldQuery.PublicFields); myQueries.FieldQueries.Add(FieldQuery.ProtectedFields); myQueries.EventQueries.Add(EventQuery.PublicEvents); myQueries.EventQueries.Add(EventQuery.ProtectedEvents); }
private void DoDiff(QueryAggregator diffQueries) { // Interfaces have no base type if (!this.TypeV1.IsInterface) { this.HasChangedBaseType = !this.IsSameBaseType(this.TypeV1, this.TypeV2); } this.DiffImplementedInterfaces(); this.DiffFields(diffQueries); this.DiffMethods(diffQueries); this.DiffEvents(diffQueries); }
public void GenerateSelectiveQueries() { myQueries = new QueryAggregator(); myQueries.TypeQueries.Add(new TypeQuery(TypeQueryMode.ApiRelevant, "BaseLibrary.ApiChanges")); myQueries.MethodQueries.Add(MethodQuery.PublicMethods); myQueries.MethodQueries.Add(MethodQuery.ProtectedMethods); myQueries.FieldQueries.Add(FieldQuery.PublicFields); myQueries.FieldQueries.Add(FieldQuery.ProtectedFields); myQueries.EventQueries.Add(EventQuery.PublicEvents); myQueries.EventQueries.Add(EventQuery.ProtectedEvents); }
public AssemblyDiffCollection GenerateTypeDiff(QueryAggregator queries) { if (queries == null || queries.TypeQueries.Count == 0) { throw new ArgumentNullException("queries is null or contains no queries"); } var typesV1 = queries.ExeuteAndAggregateTypeQueries(this.myV1); var typesV2 = queries.ExeuteAndAggregateTypeQueries(this.myV2); var differ = new ListDiffer <TypeDefinition>(this.ShallowTypeComapare); differ.Diff(typesV1, typesV2, this.OnAddedType, this.OnRemovedType); this.DiffTypes(typesV1, typesV2, queries); return(this.myDiff); }
internal QueryGenerationContext Clone(QueryAggregator queryAggregator) { return(new QueryGenerationContext(queryAggregator, Variables, MemberResolver)); }
public void CreateAggregator() { _aggregator = new QueryAggregator(); }
private void DiffTypes(List <TypeDefinition> typesV1, List <TypeDefinition> typesV2, QueryAggregator queries) { TypeDefinition typeV2; foreach (var typeV1 in typesV1) { typeV2 = this.GetTypeByDefinition(typeV1, typesV2); if (typeV2 != null) { var diffed = TypeDiff.GenerateDiff(typeV1, typeV2, queries); if (TypeDiff.None != diffed) { this.myDiff.ChangedTypes.Add(diffed); } } } }
/// <summary> /// Checks if the type has changes /// On type level /// Base Types, implemented interfaces, generic parameters /// On method level /// Method modifiers, return type, generic parameters, parameter count, parameter types (also generics) /// On field level /// Field types /// </summary> /// <param name="typeV1">The type v1.</param> /// <param name="typeV2">The type v2.</param> /// <param name="diffQueries">The diff queries.</param> /// <returns></returns> public static TypeDiff GenerateDiff(TypeDefinition typeV1, TypeDefinition typeV2, QueryAggregator diffQueries) { if (typeV1 == null) { throw new ArgumentNullException("typeV1"); } if (typeV2 == null) { throw new ArgumentNullException("typeV2"); } if (diffQueries == null || diffQueries.FieldQueries.Count == 0 || diffQueries.MethodQueries.Count == 0) { throw new ArgumentException("diffQueries was null or the method or field query list was emtpy. This will not result in a meaningful diff result"); } var diff = new TypeDiff(typeV1, typeV2); diff.DoDiff(diffQueries); if (!diff.HasChangedBaseType && diff.Events.Count == 0 && diff.Fields.Count == 0 && diff.Interfaces.Count == 0 && diff.Methods.Count == 0) { return(None); } return(diff); }