protected virtual void ExecuteOperation(FileMatch fileMatch, string destinationPath, bool isDirectory)
{
string sourcePath = fileMatch.Path;
bool fileExists = File.Exists(destinationPath);
bool directoryExists = !fileExists && Directory.Exists(destinationPath);
bool ask = false;
if (isDirectory)
{
if (fileExists)
{
ask = true;
}
else if (directoryExists)
{
if (File.GetAttributes(sourcePath) == File.GetAttributes(destinationPath))
{
return;
}
ask = true;
}
}
else if (fileExists)
{
if (CopyOptions.CompareOptions != FileCompareOptions.None &&
FileSystemHelpers.FileEquals(sourcePath, destinationPath, CopyOptions.CompareOptions))
{
return;
}
ask = true;
}
else if (directoryExists)
{
ask = true;
}
if (ask &&
ConflictResolution == ConflictResolution.Skip)
{
return;
}
if (!isDirectory &&
fileExists &&
ConflictResolution == ConflictResolution.Suffix)
{
destinationPath = FileSystemHelpers.CreateNewFilePath(destinationPath);
}
if (ask &&
ConflictResolution == ConflictResolution.Ask)
{
DialogResult dialogResult = DialogProvider !.GetResult(new OperationProgress(fileMatch, destinationPath, OperationKind));
switch (dialogResult)
{
case DialogResult.Yes:
{
break;
}
case DialogResult.YesToAll:
{
ConflictResolution = ConflictResolution.Overwrite;
break;
}
case DialogResult.No:
case DialogResult.None:
{
return;
}
case DialogResult.NoToAll:
{
ConflictResolution = ConflictResolution.Skip;
return;
}
case DialogResult.Cancel:
{
throw new OperationCanceledException();
}
default:
{
throw new InvalidOperationException($"Unknown enum value '{dialogResult}'.");
}
}
}
Report(fileMatch, destinationPath);
if (isDirectory)
{
if (directoryExists)
{
if (!DryRun)
{
FileSystemHelpers.UpdateAttributes(sourcePath, destinationPath);
}
}
else
{
if (fileExists &&
!DryRun)
{
File.Delete(destinationPath);
}
if (!DryRun)
{
Directory.CreateDirectory(destinationPath);
}
}
Telemetry.ProcessedDirectoryCount++;
}
else
{
if (fileExists)
{
if (!DryRun)
{
File.Delete(destinationPath);
}
}
else if (directoryExists)
{
if (!DryRun)
{
Directory.Delete(destinationPath, recursive: true);
}
}
else if (!DryRun)
{
Directory.CreateDirectory(Path.GetDirectoryName(destinationPath));
}
if (!DryRun)
{
ExecuteOperation(sourcePath, destinationPath);
}
Telemetry.ProcessedFileCount++;
}
}
protected virtual void ExecuteOperation(SearchContext context, string sourcePath, string destinationPath, bool isDirectory, string indent)
{
bool fileExists = File.Exists(destinationPath);
bool directoryExists = !fileExists && Directory.Exists(destinationPath);
bool ask = false;
if (isDirectory)
{
if (fileExists)
{
ask = true;
}
else if (directoryExists)
{
if (File.GetAttributes(sourcePath) == File.GetAttributes(destinationPath))
{
return;
}
ask = true;
}
}
else if (fileExists)
{
if (Options.CompareOptions != FileCompareOptions.None &&
FileSystemHelpers.FileEquals(sourcePath, destinationPath, Options.CompareOptions))
{
return;
}
ask = true;
}
else if (directoryExists)
{
ask = true;
}
if (ask &&
ConflictResolution == ConflictResolution.Skip)
{
return;
}
if (!isDirectory &&
fileExists &&
ConflictResolution == ConflictResolution.Suffix)
{
destinationPath = FileSystemHelpers.CreateNewFilePath(destinationPath);
}
if (!Options.OmitPath)
{
LogHelpers.WritePath(destinationPath, basePath: Target, relativePath: Options.DisplayRelativePath, colors: Colors.Matched_Path, indent: indent, verbosity: Verbosity.Minimal);
WriteLine(Verbosity.Minimal);
}
if (ask &&
ConflictResolution == ConflictResolution.Ask)
{
string question;
if (directoryExists)
{
question = (isDirectory) ? "Update directory attributes?" : "Overwrite directory?";
}
else
{
question = "Overwrite file?";
}
DialogResult dialogResult = ConsoleHelpers.Ask(question, indent);
switch (dialogResult)
{
case DialogResult.Yes:
{
break;
}
case DialogResult.YesToAll:
{
ConflictResolution = ConflictResolution.Overwrite;
break;
}
case DialogResult.No:
case DialogResult.None:
{
return;
}
case DialogResult.NoToAll:
{
ConflictResolution = ConflictResolution.Skip;
return;
}
case DialogResult.Cancel:
{
context.TerminationReason = TerminationReason.Canceled;
return;
}
default:
{
throw new InvalidOperationException($"Unknown enum value '{dialogResult}'.");
}
}
}
if (isDirectory)
{
if (directoryExists)
{
if (!Options.DryRun)
{
FileSystemHelpers.UpdateAttributes(sourcePath, destinationPath);
}
}
else
{
if (fileExists &&
!Options.DryRun)
{
File.Delete(destinationPath);
}
if (!Options.DryRun)
{
Directory.CreateDirectory(destinationPath);
}
}
context.Telemetry.ProcessedDirectoryCount++;
}
else
{
if (fileExists)
{
if (!Options.DryRun)
{
File.Delete(destinationPath);
}
}
else if (directoryExists)
{
if (!Options.DryRun)
{
Directory.Delete(destinationPath, recursive: true);
}
}
else if (!Options.DryRun)
{
Directory.CreateDirectory(Path.GetDirectoryName(destinationPath));
}
if (!Options.DryRun)
{
ExecuteOperation(sourcePath, destinationPath);
}
context.Telemetry.ProcessedFileCount++;
}
}
protected override void ExecuteMatch(
FileMatch fileMatch,
string directoryPath)
{
List <ReplaceItem> replaceItems = ReplaceHelpers.GetReplaceItems(
fileMatch.NameMatch !,
RenameOptions,
NameFilter?.Predicate,
CancellationToken);
string path = fileMatch.Path;
string newPath = ReplaceHelpers.GetNewPath(fileMatch, replaceItems);
ListCache <ReplaceItem> .Free(replaceItems);
if (string.Equals(path, newPath, StringComparison.Ordinal))
{
return;
}
if (FileSystemHelpers.ContainsInvalidFileNameChars(newPath, FileSystemHelpers.GetFileNameIndex(path)))
{
Report(fileMatch, newPath, new IOException("New file name contains invalid characters."));
return;
}
if (File.Exists(newPath))
{
if (ConflictResolution == ConflictResolution.Skip)
{
return;
}
else if (ConflictResolution == ConflictResolution.Suffix)
{
newPath = FileSystemHelpers.CreateNewFilePath(newPath);
}
else if (ConflictResolution == ConflictResolution.Ask)
{
if (!AskToOverwrite(fileMatch, newPath))
{
return;
}
}
}
var renamed = false;
try
{
if (!DryRun)
{
if (fileMatch.IsDirectory)
{
Directory.Move(path, newPath);
}
else
{
File.Move(path, newPath);
}
renamed = true;
}
Report(fileMatch, newPath);
Telemetry.IncrementProcessedCount(fileMatch.IsDirectory);
}
catch (Exception ex) when(ex is IOException ||
ex is UnauthorizedAccessException)
{
Report(fileMatch, newPath, ex);
}
if (fileMatch.IsDirectory &&
renamed)
{
OnDirectoryChanged(new DirectoryChangedEventArgs(path, newPath));
}
}
protected virtual DialogResult? ExecuteOperation(
SearchContext context,
string sourcePath,
string destinationPath,
bool isDirectory,
string indent)
{
bool fileExists = File.Exists(destinationPath);
bool directoryExists = !fileExists && Directory.Exists(destinationPath);
var ask = false;
if (isDirectory)
{
if (fileExists)
{
ask = true;
}
else if (directoryExists)
{
if (Options.StructureOnly
&& File.GetAttributes(sourcePath) == File.GetAttributes(destinationPath))
{
return null;
}
ask = true;
}
}
else if (fileExists)
{
if (Options.CompareOptions != FileCompareOptions.None
&& FileSystemHelpers.FileEquals(sourcePath, destinationPath, Options.CompareOptions))
{
return null;
}
ask = true;
}
else if (directoryExists)
{
ask = true;
}
if (ask
&& ConflictResolution == ConflictResolution.Skip)
{
return null;
}
if (ConflictResolution == ConflictResolution.Suffix
&& ((isDirectory && directoryExists)
|| (!isDirectory && fileExists)))
{
destinationPath = FileSystemHelpers.CreateNewFilePath(destinationPath);
}
if (!Options.OmitPath)
{
LogHelpers.WritePath(
destinationPath,
basePath: Target,
relativePath: Options.DisplayRelativePath,
colors: default,
