FileSyncr

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;

namespace FileSyncr
{
    public class FileSyncr
    {
        public string PathToPrimary { get; set; }
        public string PathToSecondary { get; set; }

        public void RunSyncProccess()
        {
            CompaireDirectories();
        }

        private void CompaireDirectories()
        {
            // Create two identical or different temporary folders
            // on a local drive and change these file paths.
            string pathA = PathToPrimary;
            string pathB = PathToSecondary;

            DirectoryInfo dir1 = new DirectoryInfo(pathA);
            DirectoryInfo dir2 = new DirectoryInfo(pathB);

            // Take a snapshot of the file system.
            IEnumerable<FileInfo> list1 = dir1.GetFiles("*.*", SearchOption.AllDirectories);
            IEnumerable<FileInfo> list2 = dir2.GetFiles("*.*", SearchOption.AllDirectories);

            //A custom file comparer defined below
            FileCompare myFileCompare = new FileCompare();

            // This query determines whether the two folders contain
            // identical file lists, based on the custom file comparer
            // that is defined in the FileCompare class.
            // The query executes immediately because it returns a bool.
            bool areIdentical = list1.SequenceEqual(list2, myFileCompare);

            if (areIdentical == true)
            {
                Console.WriteLine("-----------------------------------------------------");
                Console.WriteLine("the two folders are the same");
            }
            else
            {
                Console.WriteLine("-----------------------------------------------------");
                Console.WriteLine("The two folders are not the same");
            }

            // Find the common files. It produces a sequence and doesn't
            // execute until the foreach statement.
            var queryCommonFiles = list1.Intersect(list2, myFileCompare);

            if (queryCommonFiles.Any())
            {
                Console.WriteLine("-----------------------------------------------------");
                Console.WriteLine("The following files are in both folders:");
                Console.WriteLine("-----------------------------------------------------");
                foreach (var v in queryCommonFiles)
                {
                    Console.WriteLine(v.FullName); //shows which items end up in result list
                }
            }
            else
            {
                Console.WriteLine("-----------------------------------------------------");
                Console.WriteLine("There are no common files in the two folders.");
            }

            // Find the set difference between the two folders.
            // For this example we only check one way.
            var queryList1Only = (from file in list1
                                  select file).Except(list2, myFileCompare);

            Console.WriteLine("-----------------------------------------------------");
            Console.WriteLine("The following files produce a descrepency:");
            Console.WriteLine("-----------------------------------------------------");
            foreach (var v in queryList1Only)
            {
                Console.WriteLine(v.FullName);
            }

            // Keep the console window open in debug mode.
            Console.WriteLine("Press any key to exit.");
            Console.ReadKey();
        }
    }
}

// This implementation defines a very simple comparison
// between two FileInfo objects. It only compares the name
// of the files being compared and their length in bytes.
internal class FileCompare : IEqualityComparer<FileInfo>
{
    public FileCompare()
    {
    }

    public bool Equals(FileInfo f1, FileInfo f2)
    {
        return (f1.Name == f2.Name && f1.Length == f2.Length && f1.LastWriteTime == f2.LastWriteTime);
    }

    // Return a hash that reflects the comparison criteria. According to the
    // rules for IEqualityComparer<T>, if Equals is true, then the hash codes must
    // also be equal. Because equality as defined here is a simple value equality, not
    // reference identity, it is possible that two or more objects will produce the same
    // hash code.
    public int GetHashCode(FileInfo fi)
    {
        string s = $"{fi.Name}{fi.Length}{fi.LastWriteTime}";
        return s.GetHashCode();
    }
}