public DifferenceWriter(TextWriter writer, MappingSettings settings, IDifferenceFilter filter, bool usesMSBuildLog = false)
: base(settings, filter)
{
_writer = writer;
_differences = new List <Difference>();
_usesMSBuildLog = usesMSBuildLog;
}
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 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);
}
public DifferenceTraverser(MappingSettings settings, IDifferenceFilter filter)
: base(settings)
{
_filter = filter;
}
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);
}
public BaselineDifferenceFilter(IDifferenceFilter filter, string baselineFile)
{
_filter = filter;
_ignoreDifferences = ReadBaselineFile(baselineFile);
}
public DifferenceTraverser(MappingSettings settings, IDifferenceFilter filter)
: base(settings)
{
_filter = filter;
}
public BaselineDifferenceFilter(IDifferenceFilter filter, bool treatUnusedDifferencesAsIssues)
{
_filter = filter;
_treatUnusedDifferencesAsIssues = treatUnusedDifferencesAsIssues;
}
public BaselineDifferenceFilter(IDifferenceFilter filter, string baselineFile)
{
_filter = filter;
_ignoreDifferences = ReadBaselineFile(baselineFile);
}
public DifferenceWriter(TextWriter writer, MappingSettings settings, IDifferenceFilter filter)
: base(settings, filter)
{
_writer = writer;
_differences = new List <Difference>();
}
public DifferenceWriter(TextWriter writer, MappingSettings settings, IDifferenceFilter filter)
: base(settings, filter)
{
_writer = writer;
_differences = new List<Difference>();
}
public DifferenceTracker(MappingSettings settings, IDifferenceFilter filter)
: base(settings, filter)
{
_differences = new List <Microsoft.Cci.Differs.Difference>();
}
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;
}
