public override ExporterCollection Convert(BaseReportItem parent, BaseReportItem item)
{
if (parent == null) {
throw new ArgumentNullException("parent");
}
if (item == null) {
throw new ArgumentNullException("item");
}
ISimpleContainer simpleContainer = item as ISimpleContainer;
this.parent = parent;
simpleContainer.Parent = parent;
PrintHelper.AdjustParent(parent,simpleContainer.Items);
if (PrintHelper.IsTextOnlyRow(simpleContainer)) {
ExporterCollection myList = new ExporterCollection();
base.BaseConvert (myList,simpleContainer,parent.Location.X,
new Point(base.SectionBounds.DetailStart.X,base.SectionBounds.DetailStart.Y));
return myList;
} else {
return this.ConvertDataRow(simpleContainer);
}
}
private ExporterCollection ConvertInternal(ExporterCollection mylist)
{
Point currentPosition = new Point(base.SectionBounds.DetailStart.X,base.SectionBounds.DetailStart.Y);
Point dataAreaStart = new Point(baseTable.Items[0].Location.X,baseTable.Items[0].Location.Y + currentPosition.Y);
ISimpleContainer headerContainer = null;
int defaultLeftPos = PrintHelper.DrawingAreaRelativeToParent(this.baseTable.Parent,this.baseTable).Left;
this.baseTable.Items.SortByLocation();
foreach (ISimpleContainer simpleContainer in this.baseTable.Items)
{
if (simpleContainer.Items.Count > 0) {
simpleContainer.Location = new Point (simpleContainer.Location.X + defaultLeftPos,simpleContainer.Location.Y);
simpleContainer.Parent = (BaseReportItem)this.baseTable;
base.SaveSize( new Size (simpleContainer.Size.Width,simpleContainer.Size.Height));
// Header/FooterRow
if (PrintHelper.IsTextOnlyRow(simpleContainer) ) {
headerContainer = simpleContainer;
currentPosition = base.BaseConvert(mylist,headerContainer,defaultLeftPos,currentPosition);
}
else
{
// DataRegion
base.SaveSize(simpleContainer.Size);
do {
//
BaseSection section = this.baseTable.Parent as BaseSection;
section.Location = new Point(section.Location.X,section.SectionOffset );
base.FillAndLayoutRow(simpleContainer);
if (PrintHelper.IsPageFull(new Rectangle(new Point (simpleContainer.Location.X,currentPosition.Y),simpleContainer.Size),base.SectionBounds)) {
base.FirePageFull(mylist);
mylist.Clear();
currentPosition = base.BaseConvert(mylist,headerContainer,
defaultLeftPos,
base.SectionBounds.ReportHeaderRectangle.Location);
}
currentPosition = base.BaseConvert(mylist,simpleContainer,defaultLeftPos,currentPosition);
simpleContainer.Size = base.RestoreSize;
}
while (base.DataNavigator.MoveNext());
//Allway's reset the DataNavigator
base.DataNavigator.Reset();
base.DataNavigator.MoveNext();
SectionBounds.ReportFooterRectangle = new Rectangle(SectionBounds.ReportFooterRectangle.Left,
currentPosition.Y,
SectionBounds.ReportFooterRectangle.Width,
SectionBounds.ReportFooterRectangle.Height);
}
}
}
return mylist;
}
void CreatePageInternal(FixedPage page, ExporterCollection items)
{
foreach (var element in items)
{
var item = ItemFactory(element);
if (item != null) {
FixedPage.SetLeft(item,element.StyleDecorator.Location.X );
FixedPage.SetTop(item,element.StyleDecorator.Location.Y);
page.Children.Add(item);
}
}
}
public static void EvaluateRow(IExpressionEvaluatorFacade evaluator,ExporterCollection row)
{
foreach (BaseExportColumn column in row) {
var container = column as IExportContainer;
if (container != null) {
EvaluateRow(evaluator,container.Items);
}
IReportExpression expressionItem = column as IReportExpression;
if (expressionItem != null) {
evaluator.Evaluate(expressionItem);
}
}
}
public ExporterCollection ConvertSimpleItems (Point offset,ReportItemCollection items)
{
if (items == null) {
throw new ArgumentNullException("items");
}
ExporterCollection col = new ExporterCollection();
if (items.Count > 0) {
foreach(BaseReportItem item in items)
{
col.Add(ConvertToLineItem(offset,item));
}
}
return col;
}
protected static void DrawItems (Graphics graphics,ExporterCollection items)
{
foreach (ICSharpCode.Reports.Core.Exporter.BaseExportColumn baseExportColumn in items) {
if (baseExportColumn != null) {
ExportContainer container = baseExportColumn as ExportContainer;
if (container == null) {
baseExportColumn.DrawItem(graphics);
} else {
container.DrawItem(graphics);
DrawItems(graphics,container.Items);
}
}
}
}
public static ExporterCollection ConvertPlainCollection (ReportItemCollection items,Point offset)
{
if (items == null) {
throw new ArgumentNullException("items");
}
ExporterCollection col = new ExporterCollection();
if (items.Count > 0) {
items.SortByLocation();
foreach(BaseReportItem item in items)
{
var converteditem = ExportHelper.ConvertLineItem(item,offset);
col.Add((BaseExportColumn)converteditem);
}
}
return col;
}
public static ExporterCollection ConvertPlainCollection (ReportItemCollection items,Point offset)
{
if (items == null) {
throw new ArgumentNullException("items");
}
Console.WriteLine("Convert plain collection");
ExporterCollection col = new ExporterCollection();
if (items.Count > 0) {
items.SortByLocation();
foreach(BaseReportItem item in items)
{
var converteditem = ExportHelper.ConvertLineItem(item,offset);
Console.WriteLine("{0} - {1}",converteditem.ToString(),converteditem.StyleDecorator.DisplayRectangle);
col.Add((BaseExportColumn)converteditem);
}
}
Console.WriteLine("");
return col;
}
private ExporterCollection ConvertDataRow (ISimpleContainer simpleContainer)
{
ExporterCollection mylist = new ExporterCollection();
Point currentPosition = new Point(base.SectionBounds.DetailStart.X,base.SectionBounds.DetailStart.Y);
BaseSection section = parent as BaseSection;
int defaultLeftPos = parent.Location.X;
do {
section.Location = new Point(section.Location.X,section.SectionOffset );
section.Size = this.SectionBounds.DetailSectionRectangle.Size;
base.SaveSize(section.Items[0].Size);
base.FillAndLayoutRow(simpleContainer);
base.FireSectionRendering(section);
currentPosition = base.BaseConvert(mylist,simpleContainer,defaultLeftPos,currentPosition);
section.Items[0].Size = base.RestoreSize;
section.SectionOffset += section.Size.Height + 2 * base.SinglePage.SectionBounds.Gap;
if (PrintHelper.IsPageFull(new Rectangle(new Point (simpleContainer.Location.X,currentPosition.Y), section.Size),base.SectionBounds)) {
base.FirePageFull(mylist);
section.SectionOffset = base.SinglePage.SectionBounds.PageHeaderRectangle.Location.Y;
currentPosition = new Point(base.SectionBounds.PageHeaderRectangle.X,base.SectionBounds.PageHeaderRectangle.Y);
mylist.Clear();
}
if (section.DrawBorder == true) {
BaseRectangleItem br = BasePager.CreateDebugItem (section);
BaseExportColumn bec = br.CreateExportColumn();
bec.StyleDecorator.Location = section.Location;
mylist.Insert(0,bec);
}
}
while (base.DataNavigator.MoveNext());
SectionBounds.ReportFooterRectangle = new Rectangle(SectionBounds.ReportFooterRectangle.Left,
section.Location.Y + section.Size.Height,
SectionBounds.ReportFooterRectangle.Width,
SectionBounds.ReportFooterRectangle.Height);
return mylist;
}
protected ExporterCollection ConvertSection (BaseSection section,int dataRow)
{
Point currentBottom = Point.Empty;
bool isContainer = false;
PrepareSection(section, dataRow);
var convertedSection = new ExporterCollection();
Offset = SectionBounds.Offset;
if (section.Items.Count > 0)
{
Rectangle desiredRectangle = LayoutHelper.CalculateSectionLayout(this.Graphics,section);
LayoutHelper.FixSectionLayout(desiredRectangle,section);
section.Items.SortByLocation();
GapList gapCalculator = new GapList();
gapCalculator.CalculateGapList(section);
int i = 0;
foreach (BaseReportItem item in section.Items)
{
ISimpleContainer simpleContainer = item as ISimpleContainer;
if (simpleContainer != null)
{
isContainer = true;
Offset = new Point(Offset.X,Offset.Y + gapCalculator.GapBetweenItems[i] );
var containerSize = simpleContainer.Size;
EvaluationHelper.EvaluateReportItems(EvaluatorFacade,simpleContainer.Items);
var layouter = (ILayouter)ServiceContainer.GetService(typeof(ILayouter));
LayoutHelper.SetLayoutForRow(Graphics,layouter, simpleContainer);
section.MeasureOverride(section.Size);
Offset = BaseConverter.ConvertContainer(convertedSection,simpleContainer,Offset.X,Offset);
simpleContainer.Size = containerSize;
}
else
{
IBaseExportColumn converteditem = null;
if (isContainer)
{
item.Location = new Point(item.Location.X,Offset.Y + gapCalculator.GapBetweenItems[i]);
converteditem = ExportHelper.ConvertLineItem(item,new Point(item.Location.X,gapCalculator.GapBetweenItems[i]));
isContainer = false;
} else
{
converteditem = ExportHelper.ConvertLineItem(item,Offset);
}
if (converteditem.StyleDecorator.DisplayRectangle.Bottom > currentBottom.Y)
{
currentBottom = new Point(converteditem.StyleDecorator.Location.X,converteditem.StyleDecorator.DisplayRectangle.Bottom);
}
convertedSection.Add((BaseExportColumn)converteditem );
}
i ++;
}
Offset = new Point (Offset.X,Offset.Y + gapCalculator.LastGap);
if (currentBottom.Y > Offset.Y) {
Offset = new Point (Offset.X,currentBottom.Y);
}
}
SectionBounds.Offset = Offset;
return convertedSection;
}
protected ExporterCollection ConvertSection (BaseSection section,int dataRow)
{
Point currentBottom = Point.Empty;
FireSectionRenderEvent (section ,dataRow);
PrintHelper.AdjustParent(section,section.Items);
PrintHelper.AdjustSectionLocation(section);
var convertedSection = new ExporterCollection();
Offset = SectionBounds.Offset;
Point startOffset = Offset;
if (section.Items.Count > 0)
{
Size sectionSize = section.Size;
Rectangle desiredRectangle = LayoutHelper.CalculateSectionLayout(this.Graphics,section);
LayoutHelper.FixSectionLayout(desiredRectangle,section);
section.Items.SortByLocation();
GapList gapCalculator = new GapList();
gapCalculator.CalculateGapList(section);
int i = 0;
foreach (BaseReportItem item in section.Items)
{
ISimpleContainer simpleContainer = item as ISimpleContainer;
if (simpleContainer != null)
{
Offset = new Point(Offset.X,Offset.Y + gapCalculator.GapBetweenItems[i] );
var containerSize = simpleContainer.Size;
EvaluationHelper.EvaluateReportItems(EvaluatorFacade,simpleContainer.Items);
var layouter = (ILayouter)ServiceContainer.GetService(typeof(ILayouter));
LayoutHelper.SetLayoutForRow(Graphics,layouter, simpleContainer);
/*
* */
/*
section.Items.ForEach(delegate(BaseReportItem aitem)
{
// Console.WriteLine(item.Location);
});
var h = section.Items.FindHighestElement();
*/
section.MeasureOverride(section.Size);
/** */
Offset = BaseConverter.ConvertContainer(convertedSection,simpleContainer,Offset.X,Offset);
simpleContainer.Size = containerSize;
}
else
{
var converteditem = ExportHelper.ConvertLineItem(item,Offset);
if (converteditem != null) {
if (converteditem.StyleDecorator.DisplayRectangle.Bottom > currentBottom.Y) {
currentBottom = new Point(converteditem.StyleDecorator.Location.X,converteditem.StyleDecorator.DisplayRectangle.Bottom);
}
convertedSection.Add((BaseExportColumn)converteditem );
}
// if (converteditem.StyleDecorator.DisplayRectangle.Bottom > currentBottom.Y) {
// currentBottom = new Point(converteditem.StyleDecorator.Location.X,converteditem.StyleDecorator.DisplayRectangle.Bottom);
// }
//
// convertedSection.Add((BaseExportColumn)converteditem );
}
i ++;
}
Offset = new Point (Offset.X,Offset.Y + gapCalculator.LastGap);
// Offset = new Point (Offset.X,Offset.Y + 5);
if (currentBottom.Y > Offset.Y) {
Offset = new Point (Offset.X,currentBottom.Y);
}
// Offset = new Point (Offset.X,Offset.Y + gapCalculator.LastGap);
}
SectionBounds.Offset = Offset;
return convertedSection;
}
private static void ShouldDrawBorder (BaseSection section,ExporterCollection list)
{
if (section.DrawBorder == true) {
BaseRectangleItem br = BasePager.CreateDebugItem (section);
IBaseExportColumn bec = br.CreateExportColumn();
bec.StyleDecorator.Location = section.Location;
list.Insert(0,(BaseExportColumn)bec);
}
}
protected override Point ForcePageBreak(ExporterCollection exporterCollection, BaseSection section)
{
base.ForcePageBreak(exporterCollection,section);
return SectionBounds.Offset;
}
public static Point ConvertContainer(ExporterCollection myList,ISimpleContainer container,int leftPos,Point curPos)
{
ExporterCollection ml = BaseConverter.ConvertItems (container, curPos);
myList.AddRange(ml);
return new Point (leftPos,curPos.Y + container.Size.Height);
}
protected void AfterConverting (ExporterCollection convertedList)
{
EvaluationHelper.EvaluateRow(Evaluator,convertedList);
}
protected Point ConvertStandardRow(ExporterCollection mylist,ISimpleContainer simpleContainer)
{
Console.WriteLine("ConvertStandardRow");
var rowSize = simpleContainer.Size;
Point curPos = new Point(DefaultLeftPosition, CurrentPosition.Y);
ExporterCollection ml = BaseConverter.ConvertItems (simpleContainer, curPos);
EvaluationHelper.EvaluateRow(Evaluator,ml);
mylist.AddRange(ml);
curPos = new Point (DefaultLeftPosition,CurrentPosition.Y + simpleContainer.Size.Height + 2 * GlobalValues.GapBetweenContainer);
simpleContainer.Size = rowSize;
return curPos;
}
protected virtual Point ForcePageBreak(ExporterCollection exporterCollection, BaseSection section)
{
BuildNewPage(exporterCollection,section);
return Point.Empty;
}
protected void PageBreakAfterGroupChange(BaseSection section,ExporterCollection exporterCollection)
{
if (CheckPageBreakAfterGroupChange(section) ) {
if (DataNavigator.HasMoreData)
{
CurrentPosition = ForcePageBreak (exporterCollection,section);
}
}
}
void CheckForPageBreak(BaseSection section, ExporterCollection exporterCollection)
{
var pageBreakRect = PrintHelper.CalculatePageBreakRectangle((BaseReportItem)section.Items[0],base.CurrentPosition);
if (PrintHelper.IsPageFull(pageBreakRect,base.SectionBounds))
{
base.CurrentPosition = ForcePageBreak (exporterCollection,section);
}
}
protected void BuildNewPage(ExporterCollection myList,BaseSection section)
{
FirePageFull(myList);
section.SectionOffset = SinglePage.SectionBounds.PageHeaderRectangle.Location.Y;
myList.Clear();
}
private Point ConvertGroupHeader(ExporterCollection exportList,BaseSection section,Point offset)
{
var retVal = Point.Empty;
var rowSize = Size.Empty;
ReportItemCollection groupCollection = null;
var groupedRows = section.Items.FindGroupHeader();
if (groupedRows.Count == 0) {
groupCollection = section.Items.ExtractGroupedColumns();
base.DataNavigator.Fill(groupCollection);
base.FireSectionRendering(section);
ExporterCollection list = ExportHelper.ConvertPlainCollection(groupCollection,offset);
EvaluationHelper.EvaluateRow(base.Evaluator,list);
exportList.AddRange(list);
retVal = new Point (DefaultLeftPosition,offset.Y + groupCollection[0].Size.Height + 20 + (3 *GlobalValues.GapBetweenContainer));
} else {
FillRow(groupedRows[0],base.DataNavigator);
rowSize = groupedRows[0].Size;
base.FireGroupHeaderRendering(groupedRows[0]);
retVal = ConvertStandardRow(exportList,groupedRows[0]);
groupedRows[0].Size = rowSize;
}
return retVal;
}
protected void FirePageFull (ExporterCollection items)
{
var newPage = new NewPageEventArgs (items,SinglePage.SectionBounds);
EventHelper.Raise<NewPageEventArgs>(PageFull,this,newPage);
SinglePage.SectionBounds = newPage.SectionBounds;
}
private ExporterCollection ConvertDataRow (ISimpleContainer simpleContainer)
{
ExporterCollection exporterCollection = new ExporterCollection();
base.CurrentPosition = base.SectionBounds.Offset;
var p = base.CurrentPosition;
BaseSection section = parent as BaseSection;
DefaultLeftPosition = parent.Location.X;
Size groupSize = Size.Empty;
Size childSize = Size.Empty;
if (section.Items.FindGroupHeader().Count > 0)
{
groupSize = section.Items[0].Size;
childSize = section.Items[1].Size;
}
do {
base.SaveSectionSize(section.Size);
PrintHelper.AdjustSectionLocation (section);
section.Size = this.SectionBounds.DetailSectionRectangle.Size;
// did we have GroupedItems at all
if (section.Items.FindGroupHeader().Count > 0)
{
// GetType child navigator
IDataNavigator childNavigator = base.DataNavigator.GetChildNavigator;
base.Evaluator.SinglePage.IDataNavigator = childNavigator;
base.CurrentPosition = ConvertGroupHeader(exporterCollection,section,base.CurrentPosition);
section.Size = base.RestoreSectionSize;
section.Items[0].Size = groupSize;
section.Items[1].Size = childSize;
childNavigator.Reset();
childNavigator.MoveNext();
//Convert children
if (childNavigator != null) {
StandardPrinter.AdjustBackColor(simpleContainer);
do
{
section.Size = base.RestoreSectionSize;
section.Items[0].Size = groupSize;
section.Items[1].Size = childSize;
FillRow(simpleContainer,childNavigator);
FireRowRendering(simpleContainer,childNavigator);
PrepareContainerForConverting(section,simpleContainer);
base.CurrentPosition = ConvertStandardRow(exporterCollection,simpleContainer);
CheckForPageBreak(section,exporterCollection);
}
while ( childNavigator.MoveNext());
// GroupFooter
base.ConvertGroupFooter(section,exporterCollection);
base.PageBreakAfterGroupChange(section,exporterCollection);
base.Evaluator.SinglePage.IDataNavigator = base.DataNavigator;
}
}
else
{
// No Grouping at all, the first item in section.items is the DetailRow
Size containerSize = section.Items[0].Size;
FillRow(simpleContainer,base.DataNavigator);
FireRowRendering(simpleContainer,base.DataNavigator);
Console.WriteLine("ConvertDazaRow");
base.PrepareContainerForConverting(section,simpleContainer);
base.CurrentPosition = ConvertStandardRow (exporterCollection,simpleContainer);
section.Size = base.RestoreSectionSize;
section.Items[0].Size = containerSize;
}
CheckForPageBreak (section,exporterCollection);
ShouldDrawBorder (section,exporterCollection);
}
while (base.DataNavigator.MoveNext());
SectionBounds.ReportFooterRectangle = new Rectangle(SectionBounds.ReportFooterRectangle.Left,
section.Location.Y + section.Size.Height,
SectionBounds.ReportFooterRectangle.Width,
SectionBounds.ReportFooterRectangle.Height);
return exporterCollection;
}
protected Point BuildDetail (BaseSection section,IDataNavigator dataNavigator)
{
ExporterCollection convertedList = new ExporterCollection();
foreach (BaseReportItem item in section.Items)
{
IBaseConverter baseConverter = ConverterFactory.CreateConverter(item,dataNavigator,
this.SinglePage,
base.Layouter);
if (baseConverter != null) {
baseConverter.SectionRendering += OnSectionRendering;
baseConverter.Graphics = base.Graphics;
baseConverter.PageFull += new EventHandler<NewPageEventArgs>(OnPageFull);
convertedList = baseConverter.Convert(section,item);
base.SinglePage.Items.AddRange(convertedList);
return baseConverter.CurrentPosition;
}
}
return Point.Empty;
}
private static void EvaluateRecursive (IExpressionEvaluatorFacade evaluatorFassade,ExporterCollection items)
{
foreach (BaseExportColumn exportColumn in items) {
IExportContainer ec = exportColumn as IExportContainer;
if (ec != null)
{
if (ec.Items.Count > 0) {
EvaluateRecursive(evaluatorFassade,ec.Items);
}
}
IReportExpression expressionItem = exportColumn as IReportExpression;
if (expressionItem != null) {
evaluatorFassade.Evaluate(expressionItem);
}
}
}
public NewPageEventArgs(ExporterCollection itemsList,SectionBounds sectionBounds)
{
this.itemsList = itemsList;
SectionBounds = sectionBounds;
}
private void DrawPage (ExporterCollection items)
{
foreach (ICSharpCode.Reports.Core.Exporter.BaseExportColumn baseExportColumn in items) {
if (baseExportColumn != null) {
IExportContainer container = baseExportColumn as ExportContainer;
if (container == null) {
baseExportColumn.DrawItem(this.pdfWriter,this.pdfUnitConverter);
} else {
container.DrawItem(this.pdfWriter,this.pdfUnitConverter);
this.DrawPage(container.Items);
}
}
}
}
void CheckForPageBreak(BaseSection section, ISimpleContainer container, ISimpleContainer headerRow, ExporterCollection exporterCollection)
{
var pageBreakRect = PrintHelper.CalculatePageBreakRectangle((BaseReportItem)container, base.CurrentPosition);
if (PrintHelper.IsPageFull(pageBreakRect, base.SectionBounds))
{
base.CurrentPosition = ForcePageBreak(exporterCollection, section);
base.CurrentPosition = ConvertStandardRow(exporterCollection, headerRow);
}
}
public NewPageEventArgs(ExporterCollection itemsList)
{
this.itemsList = itemsList;
}
protected override Point ForcePageBreak(ExporterCollection exporterCollection, BaseSection section)
{
base.ForcePageBreak(exporterCollection,section);
return CalculateStartPosition();
}
/*
public static void Displaychain (ReportItemCollection items)
{
foreach(BaseReportItem i in items)
{
ISimpleContainer ic = i as ISimpleContainer;
if (ic != null) {
Console.WriteLine("recursive with <{0}> as parent",i.ToString());
Displaychain(ic.Items);
} else {
Console.WriteLine("{0}",i.ToString());
}
}
}
*/
public static void ShowLocations (ExporterCollection items)
{
foreach (BaseExportColumn element in items) {
ExportContainer cont = element as ExportContainer;
if (cont != null) {
ShowLocations(cont.Items);
}
}
}
private static int Main(string[] args)
{
var providers = new AssemblyProviderFactoryCollection(
new AssemblyProviderFactory(),
new DirectoryAssemblyProviderFactory(),
new NuGetAssemblyProviderFactory(new Providers.NuGet.NuGet()),
new PreviousNuGetAssemblyProviderFactory(new PreviousNugetLocator()),
new GitHubAssemblyProviderFactory(new Git(Environment.GetEnvironmentVariable("GIT")))
);
var exporters = new ExporterCollection(
new XmlExporter(),
new MarkdownExporter(),
new AsciiDocExporter()
);
var options = new OptionSet
{
{ "t|target=", "the assembly targets. Defaults to *all* assemblies located by the provider", AddTarget },
{ "f|format=", $"the format of the diff output. Supported formats are {exporters.SupportedFormats}. Defaults to {_format}", f => _format = f },
{ "o|output=", "the output directory. Defaults to current directory", o => _output = o },
{ "h|?|help", "show this message and exit", h => _help = h != null },
};
if (_help)
{
ShowHelp(options, providers);
return(2);
}
if (args.Length < 2)
{
ShowHelp(options, providers);
return(2);
}
List <string> unflaggedArgs;
try
{
unflaggedArgs = options.Parse(args);
}
catch (OptionException e)
{
Console.WriteLine(e.Message);
Console.WriteLine("Try 'Differ.exe --help' for more information.");
Environment.ExitCode = 1;
return(2);
}
try
{
var firstProvider = providers.GetProvider(unflaggedArgs[0]);
var secondProvider = providers.GetProvider(unflaggedArgs[1]);
if (!exporters.Contains(_format))
{
throw new Exception($"No exporter for format '{_format}'");
}
var exporter = exporters[_format];
var first = firstProvider.GetAssemblies(Targets).ToList();
var second = secondProvider.GetAssemblies(Targets).ToList();
var pairs = CreateAssemblyPairs(first, second).ToList();
foreach (var assemblyPair in pairs)
{
assemblyPair.Diff =
APIDiffHelper.GetAPIDifferences(assemblyPair.First.FullName, assemblyPair.Second.FullName);
if (assemblyPair.Diff == null)
{
Console.WriteLine($"No diff between {assemblyPair.First.FullName} and {assemblyPair.Second.FullName}");
continue;
}
Console.WriteLine($"Difference found: {firstProvider.GetType().Name}:{assemblyPair.First.Name} and {secondProvider.GetType().Name}:{assemblyPair.Second.Name}");
exporter.Export(assemblyPair, _output);
}
if (!pairs.Any())
{
Console.Error.WriteLine($"Unable to create diff!");
Console.Error.WriteLine($" {firstProvider.GetType().Name}: {first.Count()} assemblies");
Console.Error.WriteLine($" {secondProvider.GetType().Name}: {second.Count()} assemblies");
return(1);
}
}
catch (Exception e)
{
Console.Error.WriteLine(e);
return(1);
}
return(0);
}
