691 lines
27 KiB
C#
691 lines
27 KiB
C#
using System.Buffers;
|
||
|
||
namespace FluidExplorer.Services.Operations;
|
||
|
||
/// <summary>单个条目（文件/目录）处理后的结果。</summary>
|
||
internal enum EntryOutcome
|
||
{
|
||
Success,
|
||
Skipped,
|
||
Failed,
|
||
Cancelled
|
||
}
|
||
|
||
/// <summary>
|
||
/// 拷贝引擎与作业运行器之间的回调边界。
|
||
/// 引擎本身不认识 FileOperationJob / UI，只通过这个接口上报进度、询问冲突、请求取消，
|
||
/// 因此可以脱离队列单独测试与复用。
|
||
/// </summary>
|
||
internal interface IJobSink
|
||
{
|
||
CancellationToken Token { get; }
|
||
|
||
bool IsCancellationRequested { get; }
|
||
|
||
/// <summary>若作业处于暂停态则挂起，直到继续或取消。每个拷贝块之间调用。</summary>
|
||
Task WaitIfPausedAsync();
|
||
|
||
void AddBytes(long delta);
|
||
|
||
void AddCompletedItems(int delta);
|
||
|
||
void SetCurrentItem(string path);
|
||
|
||
/// <summary>记录一条非致命警告（重解析点跳过、时间戳设置失败等），进 job.Error。</summary>
|
||
void Warn(string message);
|
||
|
||
/// <summary>记录一个失败条目；引擎会继续处理其余文件，绝不中止整批。</summary>
|
||
void AddFailed(string path, string reason);
|
||
|
||
void AddSkipped(int delta = 1);
|
||
|
||
/// <summary>
|
||
/// 记录一次真实的"搬运"以便撤销。
|
||
/// 语义：<paramref name="newPath"/> 是搬运后的当前位置，<paramref name="originalPath"/> 是原位置；
|
||
/// 撤销时把 newPath 搬回 originalPath。（同卷移动是 1 条；目录合并移动会产生多条。）
|
||
/// </summary>
|
||
void RecordMoveForUndo(string newPath, string originalPath);
|
||
|
||
/// <summary>向 UI 询问冲突处理方式。未设置回调 / 非 Ask 策略时由运行器按 Policy 直接决定，不阻塞。</summary>
|
||
Task<ConflictResolution> ResolveConflictAsync(ConflictInfo info);
|
||
|
||
/// <summary>用户选择了"取消"，终止整个作业（已完成的部分保留，不回滚）。</summary>
|
||
void RequestCancel();
|
||
}
|
||
|
||
/// <summary>
|
||
/// 文件复制 / 移动 / 删除的核心实现。
|
||
///
|
||
/// 关键设计：
|
||
/// - 所有 Win32 文件 IO 走 \\?\ 长路径前缀（见 <see cref="PathHelper"/>）；
|
||
/// - 1MB 缓冲 + SequentialScan + 异步 IO，块与块之间检查暂停/取消；
|
||
/// - 单文件失败只重试 3 次（100/300/900ms）后计入失败列表并继续，绝不因单个文件中断整批；
|
||
/// - 同卷 Move 走 File.Move/Directory.Move（瞬时、不搬字节），跨卷才 Copy+Delete；
|
||
/// 之所以不用 MoveFileEx/直接调 API：那样虽然也能跨卷搬，但拿不到字节级进度，
|
||
/// 而"精确进度 + 可暂停/取消"是本引擎的核心诉求。
|
||
/// </summary>
|
||
internal static class CopyEngine
|
||
{
|
||
/// <summary>拷贝块大小：1MB。</summary>
|
||
internal const int BufferSize = 1024 * 1024;
|
||
|
||
/// <summary>重试间隔（毫秒）：共重试 3 次。</summary>
|
||
private static readonly int[] RetryDelaysMs = [100, 300, 900];
|
||
|
||
// ---------------------------------------------------------------- 测量
|
||
|
||
/// <summary>
|
||
/// 递归统计总字节数与总条目数（目录本身也算 1 个条目，和执行阶段的计数口径一致）。
|
||
/// 不跟随重解析点；无法访问的项跳过。可取消。
|
||
/// </summary>
|
||
internal static (long Bytes, int Items) Measure(IReadOnlyList<string> paths, CancellationToken cancellationToken, Action<string>? onWarning = null)
|
||
{
|
||
long bytes = 0;
|
||
var items = 0;
|
||
|
||
foreach (var path in paths)
|
||
{
|
||
if (cancellationToken.IsCancellationRequested) return (bytes, items);
|
||
|
||
var attrs = PathHelper.TryGetAttributes(path);
|
||
if (attrs is null)
|
||
{
|
||
onWarning?.Invoke($"测量时跳过无法访问的项：{path}");
|
||
continue;
|
||
}
|
||
|
||
if ((attrs & FileAttributes.ReparsePoint) != 0)
|
||
{
|
||
onWarning?.Invoke($"测量时跳过重解析点：{path}");
|
||
continue;
|
||
}
|
||
|
||
if ((attrs & FileAttributes.Directory) == 0)
|
||
{
|
||
bytes += PathHelper.TryGetLength(path);
|
||
items++;
|
||
continue;
|
||
}
|
||
|
||
var stack = new Stack<string>();
|
||
stack.Push(path);
|
||
while (stack.Count > 0)
|
||
{
|
||
if (cancellationToken.IsCancellationRequested) return (bytes, items);
|
||
|
||
var dir = stack.Pop();
|
||
items++;
|
||
|
||
foreach (var child in PathHelper.EnumerateChildrenSafe(dir, onWarning))
|
||
{
|
||
var childAttrs = PathHelper.TryGetAttributes(child);
|
||
if (childAttrs is null) continue;
|
||
if ((childAttrs & FileAttributes.ReparsePoint) != 0) continue; // 不跟随，避免无限递归
|
||
|
||
if ((childAttrs & FileAttributes.Directory) != 0) stack.Push(child);
|
||
else
|
||
{
|
||
bytes += PathHelper.TryGetLength(child);
|
||
items++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return (bytes, items);
|
||
}
|
||
|
||
// ---------------------------------------------------------------- 复制
|
||
|
||
/// <summary>复制一个条目（文件或目录），内部处理冲突策略。</summary>
|
||
internal static async Task<EntryOutcome> CopyEntryAsync(string source, string destination, IJobSink sink)
|
||
{
|
||
if (sink.IsCancellationRequested) return EntryOutcome.Cancelled;
|
||
|
||
var attrs = PathHelper.TryGetAttributes(source);
|
||
if (attrs is null)
|
||
{
|
||
sink.AddFailed(source, "源不存在或无法访问。");
|
||
return EntryOutcome.Failed;
|
||
}
|
||
|
||
if ((attrs & FileAttributes.ReparsePoint) != 0)
|
||
{
|
||
sink.Warn($"跳过重解析点（符号链接 / Junction），不跟随：{source}");
|
||
sink.AddSkipped();
|
||
return EntryOutcome.Skipped;
|
||
}
|
||
|
||
var sourceIsDir = (attrs & FileAttributes.Directory) != 0;
|
||
|
||
if (PathHelper.Exists(destination))
|
||
{
|
||
var resolution = await sink.ResolveConflictAsync(BuildConflictInfo(source, destination)).ConfigureAwait(false);
|
||
switch (resolution)
|
||
{
|
||
case ConflictResolution.Cancel:
|
||
sink.RequestCancel();
|
||
return EntryOutcome.Cancelled;
|
||
|
||
case ConflictResolution.Skip:
|
||
sink.AddSkipped();
|
||
return EntryOutcome.Skipped;
|
||
|
||
case ConflictResolution.KeepBoth:
|
||
destination = PathHelper.MakeUniquePath(destination);
|
||
break;
|
||
|
||
default: // Replace：目录对目录 = 合并；文件对文件 = 先删目标再复制
|
||
var destinationIsDir = PathHelper.DirectoryExists(destination);
|
||
if (sourceIsDir && destinationIsDir) break; // 合并，保留目标目录
|
||
if (sourceIsDir != destinationIsDir)
|
||
{
|
||
sink.AddFailed(source, sourceIsDir
|
||
? "目标位置存在同名文件，无法用文件夹替换文件。"
|
||
: "目标位置存在同名文件夹，无法用文件替换文件夹。");
|
||
return EntryOutcome.Failed;
|
||
}
|
||
|
||
var removed = await DeletePermanentAsync(destination, sink, countAsItem: false).ConfigureAwait(false);
|
||
if (removed != EntryOutcome.Success) return removed;
|
||
break;
|
||
}
|
||
}
|
||
|
||
return sourceIsDir
|
||
? await CopyDirectoryAsync(source, destination, sink).ConfigureAwait(false)
|
||
: await CopyFileAsync(source, destination, sink).ConfigureAwait(false);
|
||
}
|
||
|
||
private static async Task<EntryOutcome> CopyFileAsync(string source, string destination, IJobSink sink)
|
||
{
|
||
long attemptBytes = 0;
|
||
var ok = await RetryAsync(
|
||
async () =>
|
||
{
|
||
attemptBytes = 0;
|
||
sink.SetCurrentItem(source);
|
||
PathHelper.EnsureParentDirectory(destination);
|
||
await CopyFileCoreAsync(source, destination, sink,
|
||
n =>
|
||
{
|
||
attemptBytes += n; // 重试时用于回退已上报的字节数
|
||
sink.AddBytes(n); // 真正的进度上报（限频由 sink 负责）
|
||
}).ConfigureAwait(false);
|
||
},
|
||
source,
|
||
sink,
|
||
onRetry: () => { if (attemptBytes > 0) sink.AddBytes(-attemptBytes); }).ConfigureAwait(false);
|
||
|
||
if (ok)
|
||
{
|
||
sink.AddCompletedItems(1);
|
||
return EntryOutcome.Success;
|
||
}
|
||
|
||
return sink.IsCancellationRequested ? EntryOutcome.Cancelled : EntryOutcome.Failed;
|
||
}
|
||
|
||
private static async Task CopyFileCoreAsync(string source, string destination, IJobSink sink, Action<long> reportBytes)
|
||
{
|
||
var sourceExtended = PathHelper.ToExtended(source);
|
||
var destinationExtended = PathHelper.ToExtended(destination);
|
||
|
||
// 目标已存在且只读：必须先去只读，否则 Create 会抛 UnauthorizedAccessException。
|
||
PathHelper.ClearReadOnly(destination);
|
||
|
||
var buffer = ArrayPool<byte>.Shared.Rent(BufferSize);
|
||
try
|
||
{
|
||
await using (var input = new FileStream(sourceExtended, FileMode.Open, FileAccess.Read, FileShare.Read,
|
||
bufferSize: 1, FileOptions.Asynchronous | FileOptions.SequentialScan))
|
||
await using (var output = new FileStream(destinationExtended, FileMode.Create, FileAccess.Write, FileShare.None,
|
||
bufferSize: 1, FileOptions.Asynchronous | FileOptions.SequentialScan))
|
||
{
|
||
while (true)
|
||
{
|
||
await sink.WaitIfPausedAsync().ConfigureAwait(false);
|
||
if (sink.IsCancellationRequested) throw new OperationCanceledException(sink.Token);
|
||
|
||
var read = await input.ReadAsync(buffer.AsMemory(0, BufferSize), sink.Token).ConfigureAwait(false);
|
||
if (read <= 0) break;
|
||
|
||
await output.WriteAsync(buffer.AsMemory(0, read), sink.Token).ConfigureAwait(false);
|
||
reportBytes(read);
|
||
}
|
||
|
||
await output.FlushAsync(sink.Token).ConfigureAwait(false);
|
||
}
|
||
}
|
||
finally
|
||
{
|
||
ArrayPool<byte>.Shared.Return(buffer);
|
||
}
|
||
|
||
// 保留时间戳与属性（只读属性最后设置）。
|
||
try
|
||
{
|
||
var sourceAttrs = PathHelper.TryGetAttributes(source) ?? FileAttributes.Normal;
|
||
File.SetLastWriteTimeUtc(destinationExtended, File.GetLastWriteTimeUtc(sourceExtended));
|
||
File.SetCreationTimeUtc(destinationExtended, File.GetCreationTimeUtc(sourceExtended));
|
||
File.SetAttributes(destinationExtended,
|
||
sourceAttrs & ~(FileAttributes.Directory | FileAttributes.ReparsePoint | FileAttributes.Device));
|
||
}
|
||
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
|
||
{
|
||
sink.Warn($"已复制但无法保留时间戳/属性：{destination}（{ex.Message}）");
|
||
}
|
||
}
|
||
|
||
private static async Task<EntryOutcome> CopyDirectoryAsync(string source, string destination, IJobSink sink)
|
||
{
|
||
if (IsSameOrSubPathOf(destination, source))
|
||
{
|
||
sink.AddFailed(source, "目标路径位于源目录内部，已拒绝执行（会造成无限递归）。");
|
||
return EntryOutcome.Failed;
|
||
}
|
||
|
||
// 用显式栈做迭代式递归，避免极深目录树耗尽调用栈。
|
||
var stack = new Stack<(string Source, string Destination)>();
|
||
stack.Push((source, destination));
|
||
|
||
while (stack.Count > 0)
|
||
{
|
||
await sink.WaitIfPausedAsync().ConfigureAwait(false);
|
||
if (sink.IsCancellationRequested) return EntryOutcome.Cancelled;
|
||
|
||
var (currentSource, currentDestination) = stack.Pop();
|
||
|
||
var created = await RetryAsync(
|
||
() =>
|
||
{
|
||
PathHelper.EnsureParentDirectory(currentDestination);
|
||
Directory.CreateDirectory(PathHelper.ToExtended(currentDestination));
|
||
return Task.CompletedTask;
|
||
},
|
||
currentDestination,
|
||
sink).ConfigureAwait(false);
|
||
|
||
if (!created) return EntryOutcome.Failed;
|
||
|
||
sink.SetCurrentItem(currentDestination);
|
||
sink.AddCompletedItems(1);
|
||
|
||
foreach (var child in PathHelper.EnumerateChildrenSafe(currentSource, sink.Warn))
|
||
{
|
||
await sink.WaitIfPausedAsync().ConfigureAwait(false);
|
||
if (sink.IsCancellationRequested) return EntryOutcome.Cancelled;
|
||
|
||
var childAttrs = PathHelper.TryGetAttributes(child);
|
||
if (childAttrs is null)
|
||
{
|
||
sink.AddFailed(child, "无法读取属性（可能已被删除或拒绝访问）。");
|
||
continue;
|
||
}
|
||
|
||
if ((childAttrs & FileAttributes.ReparsePoint) != 0)
|
||
{
|
||
sink.Warn($"跳过重解析点（符号链接 / Junction），不跟随：{child}");
|
||
sink.AddSkipped();
|
||
continue;
|
||
}
|
||
|
||
var target = PathHelper.Combine(currentDestination, PathHelper.GetFileName(child));
|
||
if ((childAttrs & FileAttributes.Directory) != 0)
|
||
{
|
||
stack.Push((child, target));
|
||
}
|
||
else
|
||
{
|
||
var outcome = await CopyEntryAsync(child, target, sink).ConfigureAwait(false);
|
||
if (outcome == EntryOutcome.Cancelled) return EntryOutcome.Cancelled;
|
||
}
|
||
}
|
||
}
|
||
|
||
return EntryOutcome.Success;
|
||
}
|
||
|
||
// ---------------------------------------------------------------- 移动
|
||
|
||
/// <summary>移动一个条目，内部处理冲突策略。</summary>
|
||
internal static async Task<EntryOutcome> MoveEntryAsync(string source, string destination, IJobSink sink)
|
||
{
|
||
if (sink.IsCancellationRequested) return EntryOutcome.Cancelled;
|
||
|
||
var attrs = PathHelper.TryGetAttributes(source);
|
||
if (attrs is null)
|
||
{
|
||
sink.AddFailed(source, "源不存在或无法访问。");
|
||
return EntryOutcome.Failed;
|
||
}
|
||
|
||
if ((attrs & FileAttributes.ReparsePoint) != 0)
|
||
{
|
||
sink.Warn($"跳过重解析点（符号链接 / Junction），不跟随：{source}");
|
||
sink.AddSkipped();
|
||
return EntryOutcome.Skipped;
|
||
}
|
||
|
||
var sourceIsDir = (attrs & FileAttributes.Directory) != 0;
|
||
|
||
if (PathHelper.Exists(destination))
|
||
{
|
||
var resolution = await sink.ResolveConflictAsync(BuildConflictInfo(source, destination)).ConfigureAwait(false);
|
||
switch (resolution)
|
||
{
|
||
case ConflictResolution.Cancel:
|
||
sink.RequestCancel();
|
||
return EntryOutcome.Cancelled;
|
||
|
||
case ConflictResolution.Skip:
|
||
sink.AddSkipped();
|
||
return EntryOutcome.Skipped;
|
||
|
||
case ConflictResolution.KeepBoth:
|
||
destination = PathHelper.MakeUniquePath(destination);
|
||
break;
|
||
|
||
default:
|
||
var destinationIsDir = PathHelper.DirectoryExists(destination);
|
||
if (sourceIsDir && destinationIsDir) break; // 目录对目录：合并（递归搬运子项）
|
||
if (sourceIsDir != destinationIsDir)
|
||
{
|
||
sink.AddFailed(source, sourceIsDir
|
||
? "目标位置存在同名文件，无法用文件夹替换文件。"
|
||
: "目标位置存在同名文件夹，无法用文件替换文件夹。");
|
||
return EntryOutcome.Failed;
|
||
}
|
||
|
||
var removed = await DeletePermanentAsync(destination, sink, countAsItem: false).ConfigureAwait(false);
|
||
if (removed != EntryOutcome.Success) return removed;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (sourceIsDir && PathHelper.DirectoryExists(destination))
|
||
return await MoveDirectoryMergedAsync(source, destination, sink).ConfigureAwait(false);
|
||
|
||
return await MoveSingleAsync(source, destination, sourceIsDir, sink).ConfigureAwait(false);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 不做冲突询问的移动（重命名、撤销还原用）：
|
||
/// 调用方必须已经保证目标路径不冲突，或已经自行决定好冲突处理方式。
|
||
/// </summary>
|
||
internal static async Task<EntryOutcome> MoveDirectAsync(string source, string destination, IJobSink sink)
|
||
{
|
||
if (sink.IsCancellationRequested) return EntryOutcome.Cancelled;
|
||
|
||
var attrs = PathHelper.TryGetAttributes(source);
|
||
if (attrs is null)
|
||
{
|
||
sink.AddFailed(source, "源不存在或无法访问。");
|
||
return EntryOutcome.Failed;
|
||
}
|
||
|
||
if ((attrs & FileAttributes.ReparsePoint) != 0)
|
||
{
|
||
sink.Warn($"跳过重解析点（符号链接 / Junction），不跟随：{source}");
|
||
sink.AddSkipped();
|
||
return EntryOutcome.Skipped;
|
||
}
|
||
|
||
var sourceIsDir = (attrs & FileAttributes.Directory) != 0;
|
||
|
||
if (sourceIsDir && PathHelper.DirectoryExists(destination))
|
||
return await MoveDirectoryMergedAsync(source, destination, sink).ConfigureAwait(false);
|
||
|
||
return await MoveSingleAsync(source, destination, sourceIsDir, sink).ConfigureAwait(false);
|
||
}
|
||
|
||
private static async Task<EntryOutcome> MoveSingleAsync(string source, string destination, bool sourceIsDir, IJobSink sink)
|
||
{
|
||
// 同卷：File.Move / Directory.Move 是纯元数据操作，瞬时完成，不产生任何字节流量。
|
||
if (PathHelper.SameVolume(source, destination))
|
||
{
|
||
var moved = await RetryAsync(
|
||
() =>
|
||
{
|
||
sink.SetCurrentItem(source);
|
||
PathHelper.EnsureParentDirectory(destination);
|
||
var s = PathHelper.ToExtended(source);
|
||
var d = PathHelper.ToExtended(destination);
|
||
if (sourceIsDir) Directory.Move(s, d);
|
||
else File.Move(s, d);
|
||
return Task.CompletedTask;
|
||
},
|
||
source,
|
||
sink).ConfigureAwait(false);
|
||
|
||
if (moved)
|
||
{
|
||
sink.AddCompletedItems(1);
|
||
sink.RecordMoveForUndo(destination, source);
|
||
return EntryOutcome.Success;
|
||
}
|
||
|
||
if (sink.IsCancellationRequested) return EntryOutcome.Cancelled;
|
||
|
||
// 同卷判定失败（例如跨卷挂载点/Junction）时退化：复制成功后删源，仍有字节级进度。
|
||
sink.Warn($"同卷移动失败，自动改用“复制后删除”：{source}");
|
||
}
|
||
|
||
var copied = sourceIsDir
|
||
? await CopyDirectoryAsync(source, destination, sink).ConfigureAwait(false)
|
||
: await CopyEntryAsync(source, destination, sink).ConfigureAwait(false);
|
||
|
||
if (copied != EntryOutcome.Success) return copied;
|
||
|
||
sink.RecordMoveForUndo(destination, source);
|
||
|
||
var deleted = await DeletePermanentAsync(source, sink, countAsItem: false).ConfigureAwait(false);
|
||
return deleted == EntryOutcome.Success ? EntryOutcome.Success : deleted;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 目录合并移动：目标目录已存在时，逐个搬子项。
|
||
/// 同卷时每个子项都是瞬时的 File.Move；同名子项按冲突策略处理。
|
||
/// </summary>
|
||
private static async Task<EntryOutcome> MoveDirectoryMergedAsync(string source, string destination, IJobSink sink)
|
||
{
|
||
Directory.CreateDirectory(PathHelper.ToExtended(destination));
|
||
|
||
foreach (var child in PathHelper.EnumerateChildrenSafe(source, sink.Warn))
|
||
{
|
||
await sink.WaitIfPausedAsync().ConfigureAwait(false);
|
||
if (sink.IsCancellationRequested) return EntryOutcome.Cancelled;
|
||
|
||
var target = PathHelper.Combine(destination, PathHelper.GetFileName(child));
|
||
var outcome = await MoveEntryAsync(child, target, sink).ConfigureAwait(false);
|
||
if (outcome == EntryOutcome.Cancelled) return EntryOutcome.Cancelled;
|
||
}
|
||
|
||
TryDeleteEmptyDirectory(source);
|
||
return EntryOutcome.Success;
|
||
}
|
||
|
||
// ---------------------------------------------------------------- 删除
|
||
|
||
/// <summary>永久删除（不进回收站）。目录采用"后序迭代删除"，逐个条目上报进度。</summary>
|
||
internal static async Task<EntryOutcome> DeletePermanentAsync(string path, IJobSink sink, bool countAsItem)
|
||
{
|
||
var attrs = PathHelper.TryGetAttributes(path);
|
||
if (attrs is null)
|
||
{
|
||
if (countAsItem) sink.AddFailed(path, "路径不存在或无法访问。");
|
||
return countAsItem ? EntryOutcome.Failed : EntryOutcome.Success;
|
||
}
|
||
|
||
if ((attrs & FileAttributes.Directory) == 0)
|
||
{
|
||
var ok = await RetryAsync(
|
||
() =>
|
||
{
|
||
sink.SetCurrentItem(path);
|
||
PathHelper.ClearReadOnly(path);
|
||
File.Delete(PathHelper.ToExtended(path));
|
||
return Task.CompletedTask;
|
||
},
|
||
path,
|
||
sink).ConfigureAwait(false);
|
||
|
||
if (!ok) return sink.IsCancellationRequested ? EntryOutcome.Cancelled : EntryOutcome.Failed;
|
||
if (countAsItem) sink.AddCompletedItems(1);
|
||
return EntryOutcome.Success;
|
||
}
|
||
|
||
var stack = new Stack<(string Path, bool Expanded)>();
|
||
stack.Push((path, false));
|
||
|
||
while (stack.Count > 0)
|
||
{
|
||
await sink.WaitIfPausedAsync().ConfigureAwait(false);
|
||
if (sink.IsCancellationRequested) return EntryOutcome.Cancelled;
|
||
|
||
var (current, expanded) = stack.Pop();
|
||
|
||
if (!expanded)
|
||
{
|
||
stack.Push((current, true));
|
||
foreach (var child in PathHelper.EnumerateChildrenSafe(current, sink.Warn))
|
||
{
|
||
var childAttrs = PathHelper.TryGetAttributes(child);
|
||
if (childAttrs is null) continue;
|
||
|
||
// 重解析点：只删链接本身，绝不递归进去（否则会删掉链接目标的内容）。
|
||
if ((childAttrs & FileAttributes.ReparsePoint) != 0 || (childAttrs & FileAttributes.Directory) == 0)
|
||
stack.Push((child, true));
|
||
else
|
||
stack.Push((child, false));
|
||
}
|
||
|
||
continue;
|
||
}
|
||
|
||
var isDirectory = PathHelper.DirectoryExists(current);
|
||
var deleted = await RetryAsync(
|
||
() =>
|
||
{
|
||
sink.SetCurrentItem(current);
|
||
PathHelper.ClearReadOnly(current);
|
||
var extended = PathHelper.ToExtended(current);
|
||
if (isDirectory) Directory.Delete(extended, recursive: false);
|
||
else File.Delete(extended);
|
||
return Task.CompletedTask;
|
||
},
|
||
current,
|
||
sink).ConfigureAwait(false);
|
||
|
||
if (deleted && countAsItem) sink.AddCompletedItems(1);
|
||
}
|
||
|
||
return EntryOutcome.Success;
|
||
}
|
||
|
||
// ---------------------------------------------------------------- 通用
|
||
|
||
/// <summary>重试包装：IOException / UnauthorizedAccessException 重试 3 次（100/300/900ms），
|
||
/// 仍失败则计入失败列表并返回 false，由调用方继续处理其余文件。</summary>
|
||
private static async Task<bool> RetryAsync(Func<Task> action, string path, IJobSink sink, Action? onRetry = null)
|
||
{
|
||
for (var attempt = 0; ; attempt++)
|
||
{
|
||
try
|
||
{
|
||
await action().ConfigureAwait(false);
|
||
return true;
|
||
}
|
||
catch (OperationCanceledException)
|
||
{
|
||
return false;
|
||
}
|
||
catch (Exception ex) when (attempt < RetryDelaysMs.Length && IsTransient(ex))
|
||
{
|
||
onRetry?.Invoke();
|
||
try
|
||
{
|
||
await Task.Delay(RetryDelaysMs[attempt], sink.Token).ConfigureAwait(false);
|
||
}
|
||
catch (OperationCanceledException)
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
onRetry?.Invoke();
|
||
sink.AddFailed(path, Describe(ex));
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
|
||
private static bool IsTransient(Exception ex) => ex is IOException or UnauthorizedAccessException;
|
||
|
||
private static string Describe(Exception ex) => ex switch
|
||
{
|
||
UnauthorizedAccessException => "拒绝访问（文件可能被占用或权限不足）。",
|
||
DirectoryNotFoundException => "目录不存在（可能已被移动或删除）。",
|
||
FileNotFoundException => "文件不存在（可能已被移动或删除）。",
|
||
PathTooLongException => "路径过长。",
|
||
_ => ex.Message
|
||
};
|
||
|
||
internal static ConflictInfo BuildConflictInfo(string source, string destination)
|
||
{
|
||
var sourceAttrs = PathHelper.TryGetAttributes(source) ?? 0;
|
||
var destinationAttrs = PathHelper.TryGetAttributes(destination) ?? 0;
|
||
var sourceIsDir = (sourceAttrs & FileAttributes.Directory) != 0;
|
||
var destinationIsDir = (destinationAttrs & FileAttributes.Directory) != 0;
|
||
|
||
return new ConflictInfo
|
||
{
|
||
SourcePath = source,
|
||
DestinationPath = destination,
|
||
SourceIsDirectory = sourceIsDir,
|
||
SourceSize = sourceIsDir ? 0 : PathHelper.TryGetLength(source),
|
||
DestinationSize = destinationIsDir ? 0 : PathHelper.TryGetLength(destination),
|
||
SourceModifiedUtc = TryGetModifiedUtc(source),
|
||
DestinationModifiedUtc = TryGetModifiedUtc(destination)
|
||
};
|
||
}
|
||
|
||
private static DateTime TryGetModifiedUtc(string path)
|
||
{
|
||
try
|
||
{
|
||
return File.GetLastWriteTimeUtc(PathHelper.ToExtended(path));
|
||
}
|
||
catch (Exception)
|
||
{
|
||
return DateTime.MinValue;
|
||
}
|
||
}
|
||
|
||
/// <summary>candidate 是否等于 root 或位于 root 之内（用于拒绝"复制到自身内部"）。</summary>
|
||
internal static bool IsSameOrSubPathOf(string candidate, string root)
|
||
{
|
||
var c = (PathHelper.TryGetFullPath(candidate) ?? candidate)
|
||
.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
|
||
var r = (PathHelper.TryGetFullPath(root) ?? root)
|
||
.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
|
||
|
||
if (string.Equals(c, r, StringComparison.OrdinalIgnoreCase)) return true;
|
||
return c.StartsWith(r + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase);
|
||
}
|
||
|
||
private static void TryDeleteEmptyDirectory(string path)
|
||
{
|
||
try
|
||
{
|
||
var extended = PathHelper.ToExtended(path);
|
||
if (Directory.Exists(extended)) Directory.Delete(extended, recursive: false);
|
||
}
|
||
catch (Exception)
|
||
{
|
||
// 目录里还有没搬走的项（例如同名冲突被 Skip 了）：保留，不算失败。
|
||
}
|
||
}
|
||
}
|