private static ICciDifferenceWriter GetDifferenceWriter(TextWriter writer, IDifferenceFilter filter)
{
CompositionHost container = GetCompositionHost();
Func <IDifferenceRuleMetadata, bool> ruleFilter =
delegate(IDifferenceRuleMetadata ruleMetadata)
{
if (ruleMetadata.OptionalRule && !s_enforceOptionalRules)
{
return(false);
}
if (ruleMetadata.MdilServicingRule && !s_mdil)
{
return(false);
}
return(true);
};
if (s_mdil && s_excludeNonBrowsable)
{
Trace.TraceWarning("Enforcing MDIL servicing rules and exclusion of non-browsable types are both enabled, but they are not compatible so non-browsable types will not be excluded.");
}
MappingSettings settings = new MappingSettings();
settings.Comparers = GetComparers();
settings.Filter = GetCciFilter(s_mdil, s_excludeNonBrowsable);
settings.DiffFilter = GetDiffFilter(settings.Filter);
settings.DiffFactory = new ElementDifferenceFactory(container, ruleFilter);
settings.GroupByAssembly = s_groupByAssembly;
settings.IncludeForwardedTypes = true;
if (filter == null)
{
filter = new DifferenceFilter <IncompatibleDifference>();
}
ICciDifferenceWriter diffWriter = new DifferenceWriter(writer, settings, filter);
ExportCciSettings.StaticSettings = settings.TypeComparer;
ExportCciSettings.StaticOperands = new DifferenceOperands()
{
Contract = s_contractOperand,
Implementation = s_implementationOperand,
};
ExportCciSettings.StaticAttributeFilter = new AttributeFilter(s_excludeAttributesList);
// Always compose the diff writer to allow it to import or provide exports
container.SatisfyImports(diffWriter);
return(diffWriter);
}
private static BaselineDifferenceFilter GetBaselineDifferenceFilter(string baselineFileName)
{
BaselineDifferenceFilter filter = null;
if (!string.IsNullOrEmpty(baselineFileName))
{
if (!File.Exists(baselineFileName))
{
throw new FileNotFoundException("Baseline file {0} was not found!", baselineFileName);
}
IDifferenceFilter incompatibleFilter = new DifferenceFilter <IncompatibleDifference>();
filter = new BaselineDifferenceFilter(incompatibleFilter, baselineFileName);
}
return(filter);
}
private static DifferenceTracker GetDifferenceWriter(TextWriter writer, IDifferenceFilter filter)
{
var container = GetCompositionHost();
bool ruleFilter(IDifferenceRuleMetadata ruleMetadata)
{
if (ruleMetadata.MdilServicingRule && !s_mdil)
{
return(false);
}
return(true);
};
if (s_mdil && s_excludeNonBrowsable)
{
Trace.TraceWarning("Enforcing MDIL servicing rules and exclusion of non-browsable types are both enabled, but they are not compatible so non-browsable types will not be excluded.");
}
var cciFilter = GetCciFilter(s_mdil, s_excludeNonBrowsable);
var settings = new MappingSettings
{
Comparers = GetComparers(),
Filter = cciFilter,
DiffFilter = new MappingDifferenceFilter(d => d != DifferenceType.Unchanged, cciFilter),
DiffFactory = new ElementDifferenceFactory(container, ruleFilter),
GroupByAssembly = s_groupByAssembly,
IncludeForwardedTypes = true
};
if (filter == null)
{
filter = new DifferenceFilter <IncompatibleDifference>();
}
var diffWriter = new DifferenceTracker(settings, filter);
ExportCciSettings.StaticSettings = settings.TypeComparer;
return(diffWriter);
}
private AbstractFilter GetFilter()
{
AbstractFilter tmpFilter = null;
if (homogenityRB.Checked)
{
tmpFilter = new HomogenityFilter();
}
if (differenceRB.Checked)
{
tmpFilter = new DifferenceFilter();
}
if (sobelRB.Checked)
{
tmpFilter = new SobelFilter();
}
if (cannyRB.Checked)
{
tmpFilter = new CannyFilter();
}
return(tmpFilter);
}
private static ICciDifferenceWriter GetDifferenceWriter(TextWriter writer,
IDifferenceFilter filter,
bool enforceOptionalRules,
bool mdil,
bool excludeNonBrowsable,
string remapFile,
bool groupByAssembly,
string leftOperand,
string rightOperand,
string excludeAttributes,
bool allowDefaultInterfaceMethods)
{
CompositionHost container = GetCompositionHost();
bool RuleFilter(IDifferenceRuleMetadata ruleMetadata)
{
if (ruleMetadata.OptionalRule && !enforceOptionalRules)
{
return(false);
}
if (ruleMetadata.MdilServicingRule && !mdil)
{
return(false);
}
return(true);
}
if (mdil && excludeNonBrowsable)
{
Trace.TraceWarning("Enforcing MDIL servicing rules and exclusion of non-browsable types are both enabled, but they are not compatible so non-browsable types will not be excluded.");
}
var settings = new MappingSettings
{
Comparers = GetComparers(remapFile),
Filter = GetCciFilter(mdil, excludeNonBrowsable)
};
settings.DiffFilter = GetDiffFilter(settings.Filter);
settings.DiffFactory = new ElementDifferenceFactory(container, RuleFilter);
settings.GroupByAssembly = groupByAssembly;
settings.IncludeForwardedTypes = true;
if (filter == null)
{
filter = new DifferenceFilter <IncompatibleDifference>();
}
var diffWriter = new DifferenceWriter(writer, settings, filter);
ExportCciSettings.StaticSettings = settings.TypeComparer;
ExportCciSettings.StaticOperands = new DifferenceOperands()
{
Contract = leftOperand,
Implementation = rightOperand
};
ExportCciSettings.StaticAttributeFilter = new AttributeFilter(excludeAttributes);
ExportCciSettings.StaticRuleSettings = new RuleSettings {
AllowDefaultInterfaceMethods = allowDefaultInterfaceMethods
};
// Always compose the diff writer to allow it to import or provide exports
container.SatisfyImports(diffWriter);
return(diffWriter);
}
private static ICciDifferenceWriter GetDifferenceWriter(TextWriter writer, IDifferenceFilter filter)
{
CompositionHost container = GetCompositionHost();
Func<IDifferenceRuleMetadata, bool> ruleFilter =
delegate (IDifferenceRuleMetadata ruleMetadata)
{
if (ruleMetadata.MdilServicingRule && !s_mdil)
return false;
return true;
};
if (s_mdil && s_excludeNonBrowsable)
{
Trace.TraceWarning("Enforcing MDIL servicing rules and exclusion of non-browsable types are both enabled, but they are not compatible so non-browsable types will not be excluded.");
}
MappingSettings settings = new MappingSettings();
settings.Comparers = GetComparers();
settings.Filter = GetCciFilter(s_mdil, s_excludeNonBrowsable);
settings.DiffFilter = GetDiffFilter(settings.Filter);
settings.DiffFactory = new ElementDifferenceFactory(container, ruleFilter);
settings.GroupByAssembly = s_groupByAssembly;
settings.IncludeForwardedTypes = true;
if (filter == null)
{
filter = new DifferenceFilter<IncompatibleDifference>();
}
ICciDifferenceWriter diffWriter = new DifferenceWriter(writer, settings, filter);
ExportCciSettings.StaticSettings = settings.TypeComparer;
// Always compose the diff writer to allow it to import or provide exports
container.SatisfyImports(diffWriter);
return diffWriter;
}
private static BaselineDifferenceFilter GetBaselineDifferenceFilter()
{
BaselineDifferenceFilter filter = null;
if (!string.IsNullOrEmpty(s_baselineFileName))
{
if (!File.Exists(s_baselineFileName))
{
throw new FileNotFoundException("Baseline file {0} was not found!", s_baselineFileName);
}
IDifferenceFilter incompatibleFilter = new DifferenceFilter<IncompatibleDifference>();
filter = new BaselineDifferenceFilter(incompatibleFilter, s_baselineFileName);
}
return filter;
}
