| 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()));
}
}
