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