public static AreContentsIdentical ( string filePath1, string filePath2 ) : bool | ||
filePath1 | string | |
filePath2 | string | |
리턴 | bool |
/// <summary> /// Assumes leftRoot is an existing folder. rightRoot may not exist if operating in speculative mode. /// </summary> public static FolderDiffResults DiffFolders( string leftRoot, string rightRoot, Log log, CancellationToken token, bool compareContents = true, bool respectDate = true) { var leftRelativePaths = new ConcurrentBag <string>(); using (log.MeasureTime("Scanning source directory")) { GetRelativePathsOfAllFiles(leftRoot, leftRelativePaths, token); } var rightRelativePaths = new ConcurrentBag <string>(); if (Directory.Exists(rightRoot)) { using (log.MeasureTime("Scanning destination directory")) { GetRelativePathsOfAllFiles(rightRoot, rightRelativePaths, token); } } var leftOnlyFiles = new HashSet <string>(StringComparer.OrdinalIgnoreCase); var identicalFiles = new HashSet <string>(StringComparer.OrdinalIgnoreCase); var changedFiles = new HashSet <string>(StringComparer.OrdinalIgnoreCase); var rightOnlyFiles = new HashSet <string>(rightRelativePaths, StringComparer.OrdinalIgnoreCase); using (log.MeasureTime("Comparing")) { leftRelativePaths .Distinct(StringComparer.OrdinalIgnoreCase) .ForEach(AnalyzeFile); } using (log.MeasureTime("Sorting")) { var leftOnlyFilesList = leftOnlyFiles.ToList(); leftOnlyFilesList.Sort(); var identicalFilesList = identicalFiles.ToList(); identicalFilesList.Sort(); var changedFilesList = changedFiles.ToList(); changedFilesList.Sort(); return(new FolderDiffResults( leftOnlyFilesList, identicalFilesList, changedFilesList, rightOnlyFiles.OrderBy(s => s).ToArray())); } void AnalyzeFile(string path) { var leftFullPath = leftRoot + path; var rightFullPath = rightRoot + path; var rightContains = rightRelativePaths.Contains(path); if (rightContains) { var areSame = true; try { areSame = !compareContents || Files.AreContentsIdentical(leftFullPath, rightFullPath, token) || respectDate ? File.GetLastWriteTimeUtc(leftFullPath) <= File.GetLastWriteTimeUtc(rightFullPath) : true; } catch (Exception ex) { log.WriteError(ex.ToString()); return; } if (areSame) { identicalFiles.Add(path); } else { changedFiles.Add(path); } } else { leftOnlyFiles.Add(path); } rightOnlyFiles.Remove(path); } }
/// <summary> /// Assumes leftRoot is an existing folder. rightRoot may not exist if operating in speculative mode. /// </summary> public static FolderDiffResults DiffFolders( string leftRoot, string rightRoot, string pattern, bool recursive = true, bool compareContents = true) { HashSet <string> leftRelativePaths = new HashSet <string>(StringComparer.OrdinalIgnoreCase); HashSet <string> leftOnlyFolders = new HashSet <string>(StringComparer.OrdinalIgnoreCase); using (Log.MeasureTime("Scanning source directory")) { GetRelativePathsOfAllFiles(leftRoot, pattern, recursive, leftRelativePaths, leftOnlyFolders); } HashSet <string> rightRelativePaths = new HashSet <string>(StringComparer.OrdinalIgnoreCase); HashSet <string> rightOnlyFolders = new HashSet <string>(StringComparer.OrdinalIgnoreCase); if (Directory.Exists(rightRoot)) { using (Log.MeasureTime("Scanning destination directory")) { GetRelativePathsOfAllFiles(rightRoot, pattern, recursive, rightRelativePaths, rightOnlyFolders); } } var leftOnlyFiles = new List <string>(); var identicalFiles = new List <string>(); var changedFiles = new List <string>(); var rightOnlyFiles = new HashSet <string>(rightRelativePaths, StringComparer.OrdinalIgnoreCase); var commonFolders = leftOnlyFolders.Intersect(rightOnlyFolders, StringComparer.OrdinalIgnoreCase).ToArray(); leftOnlyFolders.ExceptWith(commonFolders); rightOnlyFolders.ExceptWith(commonFolders); int current = 0; int total = leftRelativePaths.Count; using (Log.MeasureTime("Comparing")) { Parallel.ForEach( leftRelativePaths, new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount * 2 }, left => { var leftFullPath = leftRoot + left; var rightFullPath = rightRoot + left; bool rightContains = rightRelativePaths.Contains(left); if (rightContains) { bool areSame; try { areSame = !compareContents || Files.AreContentsIdentical(leftFullPath, rightFullPath); } catch (Exception ex) { Log.WriteError(ex.ToString()); return; } if (areSame) { lock (identicalFiles) { identicalFiles.Add(left); } } else { lock (changedFiles) { changedFiles.Add(left); } } } else { lock (leftOnlyFiles) { leftOnlyFiles.Add(left); } } lock (rightOnlyFiles) { rightOnlyFiles.Remove(left); } Interlocked.Increment(ref current); }); } using (Log.MeasureTime("Sorting")) { leftOnlyFiles.Sort(); identicalFiles.Sort(); changedFiles.Sort(); return(new FolderDiffResults( leftOnlyFiles, identicalFiles, changedFiles, rightOnlyFiles.OrderBy(s => s).ToArray(), leftOnlyFolders.OrderBy(s => s).ToArray(), rightOnlyFolders.OrderBy(s => s).ToArray())); } }
/// <summary> /// Assumes both leftRoot and rightRoot are existing folders. /// </summary> public static FolderDiffResults DiffFolders(string leftRoot, string rightRoot) { var leftRelativePaths = GetRelativePathsOfAllFiles(leftRoot); var leftOnlyFolders = GetRelativePathsOfAllFolders(leftRoot); var rightRelativePaths = GetRelativePathsOfAllFiles(rightRoot); var rightOnlyFolders = GetRelativePathsOfAllFolders(rightRoot); var leftOnlyFiles = new List <string>(); var identicalFiles = new List <string>(); var changedFiles = new List <string>(); var rightOnlyFiles = new HashSet <string>(rightRelativePaths, StringComparer.OrdinalIgnoreCase); var commonFolders = leftOnlyFolders.Intersect(rightOnlyFolders, StringComparer.OrdinalIgnoreCase).ToArray(); leftOnlyFolders.ExceptWith(commonFolders); rightOnlyFolders.ExceptWith(commonFolders); int current = 0; int total = leftRelativePaths.Count; using (Log.MeasureTime("Comparing")) { Parallel.ForEach( leftRelativePaths, new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount * 2 }, left => { var leftFullPath = leftRoot + left; var rightFullPath = rightRoot + left; bool rightContains = rightRelativePaths.Contains(left); if (rightContains) { bool areSame = Files.AreContentsIdentical(leftFullPath, rightFullPath); if (areSame) { lock (identicalFiles) { identicalFiles.Add(left); } } else { lock (changedFiles) { changedFiles.Add(left); } } } else { lock (leftOnlyFiles) { leftOnlyFiles.Add(left); } } lock (rightOnlyFiles) { rightOnlyFiles.Remove(left); } Interlocked.Increment(ref current); }); } using (Log.MeasureTime("Sorting")) { leftOnlyFiles.Sort(); identicalFiles.Sort(); changedFiles.Sort(); return(new FolderDiffResults( leftOnlyFiles, identicalFiles, changedFiles, rightOnlyFiles.OrderBy(s => s).ToArray(), leftOnlyFolders.OrderBy(s => s).ToArray(), rightOnlyFolders.OrderBy(s => s).ToArray())); } }