Program.cs

using System;
using System.IO;
using GroupDocs.Comparison;
using GroupDocs.Comparison.Options;

namespace CompareExcelSpreadsheets
{
    internal static class Program
    {
        static void Main()
        {
            try
            {
                ApplyLicense();

                string baseDir = AppContext.BaseDirectory;
                string samplesDir = Path.Combine(baseDir, "..", "..", "..", "sample-files");
                string outputDir = Path.Combine(baseDir, "..", "..", "..", "output");

                samplesDir = Path.GetFullPath(samplesDir);
                outputDir = Path.GetFullPath(outputDir);

                Directory.CreateDirectory(samplesDir);
                Directory.CreateDirectory(outputDir);

                string sourcePath = Path.Combine(samplesDir, "source.xlsx");
                string targetPath = Path.Combine(samplesDir, "target.xlsx");

                string basicResult = Path.Combine(outputDir, "result_basic.xlsx");
                string styledResult = Path.Combine(outputDir, "result_styled.xlsx");
                string hideInsertedResult = Path.Combine(outputDir, "result_hide_inserted.xlsx");
                string hideDeletedResult = Path.Combine(outputDir, "result_hide_deleted.xlsx");
                string leaveGapsResult = Path.Combine(outputDir, "result_leave_gaps.xlsx");
                string hideBothResult = Path.Combine(outputDir, "result_hide_both.xlsx");

                Console.WriteLine("Source file: " + sourcePath);
                Console.WriteLine("Target file: " + targetPath);
                Console.WriteLine("Output directory: " + outputDir);
                Console.WriteLine();

                Console.WriteLine("Running basic Excel comparison...");
                BasicComparison(sourcePath, targetPath, basicResult);

                Console.WriteLine("Running styled Excel comparison (highlight changes)...");
                StyledComparison(sourcePath, targetPath, styledResult);

                Console.WriteLine("Running comparison with ShowInsertedContent = false...");
                HideInsertedContentComparison(sourcePath, targetPath, hideInsertedResult);

                Console.WriteLine("Running comparison with ShowDeletedContent = false...");
                HideDeletedContentComparison(sourcePath, targetPath, hideDeletedResult);

                Console.WriteLine("Running comparison with LeaveGaps = true...");
                LeaveGapsComparison(sourcePath, targetPath, leaveGapsResult);

                Console.WriteLine("Running comparison with both ShowInsertedContent and ShowDeletedContent = false...");
                HideBothContentComparison(sourcePath, targetPath, hideBothResult);

                Console.WriteLine();
                Console.WriteLine("Done.");
                Console.WriteLine("Basic result:        " + basicResult);
                Console.WriteLine("Styled result:       " + styledResult);
                Console.WriteLine("Hide inserted result: " + hideInsertedResult);
                Console.WriteLine("Hide deleted result:  " + hideDeletedResult);
                Console.WriteLine("Leave gaps result:    " + leaveGapsResult);
                Console.WriteLine("Hide both result:     " + hideBothResult);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error: " + ex.Message);
            }
        }

        /// <summary>
        /// Applies the GroupDocs.Comparison license to enable full functionality of the comparison library.
        /// </summary>
        /// <remarks>
        /// This method initializes and applies the license file for GroupDocs.Comparison.
        /// Update the licensePath variable with the path to your license file.
        /// Without a valid license, the library will operate in evaluation mode with limitations.
        /// </remarks>
        private static void ApplyLicense()
        {
            string licensePath = "path to your license file";
            License license = new License();
            license.SetLicense(licensePath);
        }

        /// <summary>
        /// Performs a basic comparison between two Excel spreadsheets using default comparison settings,
        /// identifying and highlighting all differences including inserted, deleted, and modified cells.
        /// </summary>
        /// <param name="sourcePath">The path to the source Excel file.</param>
        /// <param name="targetPath">The path to the target Excel file to compare against.</param>
        /// <param name="resultPath">The path where the comparison result will be saved.</param>
        /// <remarks>
        /// This method uses GroupDocs.Comparison to compare two Excel files without any custom styling or options.
        /// The result file will contain all differences highlighted with default formatting.
        /// Both source and target files must exist, otherwise a FileNotFoundException will be thrown.
        /// </remarks>
        private static void BasicComparison(string sourcePath, string targetPath, string resultPath)
        {
            EnsureFileExists(sourcePath, "source Excel file");
            EnsureFileExists(targetPath, "target Excel file");

            using (var comparer = new Comparer(sourcePath))
            {
                comparer.Add(targetPath);
                comparer.Compare(resultPath);
            }

            Console.WriteLine("Basic comparison completed.");
        }

        /// <summary>
        /// Performs a styled comparison between two Excel spreadsheets with custom formatting options,
        /// applying distinct visual styles to different types of changes and generating a summary page
        /// for comprehensive change tracking and analysis.
        /// </summary>
        /// <param name="sourcePath">The path to the source Excel file.</param>
        /// <param name="targetPath">The path to the target Excel file to compare against.</param>
        /// <param name="resultPath">The path where the styled comparison result will be saved.</param>
        /// <remarks>
        /// This method uses GroupDocs.Comparison with custom styling options to highlight differences.
        /// Inserted items are styled with green font, deleted items with brown font, and changed items with firebrick font.
        /// All changes are formatted with underline, bold, and italic styles.
        /// A summary page is generated at the beginning of the result document.
        /// Deleted content is hidden in the output for cleaner visualization.
        /// </remarks>
        private static void StyledComparison(string sourcePath, string targetPath, string resultPath)
        {
            EnsureFileExists(sourcePath, "source Excel file");
            EnsureFileExists(targetPath, "target Excel file");

            var compareOptions = new CompareOptions
            {
                InsertedItemStyle = new StyleSettings()
                {
                    FontColor = System.Drawing.Color.Green,
                    IsUnderline = true,
                    IsBold = true,
                    IsItalic = true
                },
                DeletedItemStyle = new StyleSettings()
                {
                    FontColor = System.Drawing.Color.Brown,
                    IsUnderline = true,
                    IsBold = true,
                    IsItalic = true
                },
                ChangedItemStyle = new StyleSettings()
                {
                    FontColor = System.Drawing.Color.Firebrick,
                    IsUnderline = true,
                    IsBold = true,
                    IsItalic = true
                },
                GenerateSummaryPage = true,
                ShowDeletedContent = false,
            };

            using (var comparer = new Comparer(sourcePath))
            {
                comparer.Add(targetPath);
                comparer.Compare(resultPath, compareOptions);
            }

            Console.WriteLine("Styled comparison completed (changes highlighted, summary page generated).");
        }

        /// <summary>
        /// Performs a comparison between two Excel spreadsheets while hiding inserted content,
        /// allowing you to focus on deletions and modifications without the visual clutter of new additions.
        /// </summary>
        /// <param name="sourcePath">The path to the source Excel file.</param>
        /// <param name="targetPath">The path to the target Excel file to compare against.</param>
        /// <param name="resultPath">The path where the comparison result will be saved.</param>
        /// <remarks>
        /// This method uses GroupDocs.Comparison with ShowInsertedContent set to false.
        /// When comparing documents, any content that was inserted in the target document will not be displayed in the result.
        /// This is useful when you only want to see deletions and changes, but not new additions.
        /// </remarks>
        private static void HideInsertedContentComparison(string sourcePath, string targetPath, string resultPath)
        {
            EnsureFileExists(sourcePath, "source Excel file");
            EnsureFileExists(targetPath, "target Excel file");

            var compareOptions = new CompareOptions
            {
                ShowInsertedContent = false
            };

            using (var comparer = new Comparer(sourcePath))
            {
                comparer.Add(targetPath);
                comparer.Compare(resultPath, compareOptions);
            }

            Console.WriteLine("Comparison completed (inserted content hidden).");
        }

        /// <summary>
        /// Performs a comparison between two Excel spreadsheets while hiding deleted content,
        /// enabling you to focus on new additions and modifications without displaying removed elements.
        /// </summary>
        /// <param name="sourcePath">The path to the source Excel file.</param>
        /// <param name="targetPath">The path to the target Excel file to compare against.</param>
        /// <param name="resultPath">The path where the comparison result will be saved.</param>
        /// <remarks>
        /// This method uses GroupDocs.Comparison with ShowDeletedContent set to false.
        /// When comparing documents, any content that was deleted from the source document will not be displayed in the result.
        /// This is useful when you only want to see insertions and changes, but not deletions.
        /// </remarks>
        private static void HideDeletedContentComparison(string sourcePath, string targetPath, string resultPath)
        {
            EnsureFileExists(sourcePath, "source Excel file");
            EnsureFileExists(targetPath, "target Excel file");

            var compareOptions = new CompareOptions
            {
                ShowDeletedContent = false
            };

            using (var comparer = new Comparer(sourcePath))
            {
                comparer.Add(targetPath);
                comparer.Compare(resultPath, compareOptions);
            }

            Console.WriteLine("Comparison completed (deleted content hidden).");
        }

        /// <summary>
        /// Performs a comparison between two Excel spreadsheets while leaving gaps for deleted content,
        /// preserving the original document structure and layout to make it easier to identify where content was removed.
        /// </summary>
        /// <param name="sourcePath">The path to the source Excel file.</param>
        /// <param name="targetPath">The path to the target Excel file to compare against.</param>
        /// <param name="resultPath">The path where the comparison result will be saved.</param>
        /// <remarks>
        /// This method uses GroupDocs.Comparison with LeaveGaps set to true.
        /// When content is deleted from the source document, empty cells or gaps will be left in the result document
        /// to maintain the original structure and make it easier to identify where content was removed.
        /// This helps preserve the document layout and makes deletions more visible.
        /// </remarks>
        private static void LeaveGapsComparison(string sourcePath, string targetPath, string resultPath)
        {
            EnsureFileExists(sourcePath, "source Excel file");
            EnsureFileExists(targetPath, "target Excel file");

            var compareOptions = new CompareOptions
            {
                LeaveGaps = true
            };

            using (var comparer = new Comparer(sourcePath))
            {
                comparer.Add(targetPath);
                comparer.Compare(resultPath, compareOptions);
            }

            Console.WriteLine("Comparison completed (gaps left for deleted content).");
        }

        /// <summary>
        /// Performs a comparison between two Excel spreadsheets while hiding both inserted and deleted content,
        /// displaying only modified cells to provide a focused view of actual changes while maintaining document structure.
        /// </summary>
        /// <param name="sourcePath">The path to the source Excel file.</param>
        /// <param name="targetPath">The path to the target Excel file to compare against.</param>
        /// <param name="resultPath">The path where the comparison result will be saved.</param>
        /// <remarks>
        /// This method uses GroupDocs.Comparison with ShowInsertedContent and ShowDeletedContent both set to false,
        /// and LeaveGaps set to true. This configuration hides both inserted and deleted content while leaving gaps
        /// where deletions occurred. This is useful when you only want to see modified content (changes) without
        /// the clutter of insertions and deletions, while still maintaining the document structure.
        /// </remarks>
        private static void HideBothContentComparison(string sourcePath, string targetPath, string resultPath)
        {
            EnsureFileExists(sourcePath, "source Excel file");
            EnsureFileExists(targetPath, "target Excel file");

            var compareOptions = new CompareOptions
            {
                ShowInsertedContent = false,
                ShowDeletedContent = false,
                LeaveGaps = true
            };

            using (var comparer = new Comparer(sourcePath))
            {
                comparer.Add(targetPath);
                comparer.Compare(resultPath, compareOptions);
            }

            Console.WriteLine("Comparison completed (both inserted and deleted content hidden, gaps left).");
        }

        /// <summary>
        /// Ensures that a file exists at the specified path, throwing a FileNotFoundException with a descriptive
        /// error message if the file is not found, to prevent comparison operations on non-existent files.
        /// </summary>
        /// <param name="path">The file path to check.</param>
        /// <param name="description">A description of the file for error messages.</param>
        /// <exception cref="FileNotFoundException">Thrown when the file does not exist at the specified path.</exception>
        /// <remarks>
        /// This helper method validates that a file exists before attempting to use it in comparison operations.
        /// If the file is not found, a FileNotFoundException is thrown with a descriptive error message.
        /// </remarks>
        private static void EnsureFileExists(string path, string description)
        {
            if (!File.Exists(path))
            {
                throw new FileNotFoundException($"The {description} was not found. Path:", path);
            }
        }
    }
}