693 lines
24 KiB
C#
693 lines
24 KiB
C#
namespace Common;
|
||
|
||
/// <summary>
|
||
/// Dir比较方法
|
||
/// </summary>
|
||
public static class DirExtension
|
||
{
|
||
/// <summary>
|
||
/// 比较两个目录文件树是否相同,不相同返回差异部分,左侧是右侧的下一个版本,任何一个节点的nextop != null，即所有
|
||
/// 节点都会打上标记
|
||
/// 文件夹的 NextOp 只有新增和删除
|
||
///
|
||
/// </summary>
|
||
/// <param name="otherRootDir"></param>
|
||
/// <returns>右侧版本接下来进行的操作</returns>
|
||
public static Dir Diff(this Dir thisDir, Dir other)
|
||
{
|
||
var ldir = thisDir;
|
||
var rdir = other;
|
||
Dir? cDir = new() { Path = rdir.FormatedPath, Children = [] };
|
||
//分别对文件和文件夹分组
|
||
List<File> lFiles = [];
|
||
List<File> rFiles = [];
|
||
List<Dir> lDirs = [];
|
||
List<Dir> rDirs = [];
|
||
var lGroups = ldir.Children.GroupBy(x => x.Type);
|
||
var rGroups = rdir.Children.GroupBy(x => x.Type);
|
||
foreach (var g in lGroups)
|
||
{
|
||
if (g.Key == DirOrFile.Dir)
|
||
{
|
||
lDirs = g.AsEnumerable()
|
||
.Select(n =>
|
||
{
|
||
if (n is Dir dir)
|
||
{
|
||
return dir;
|
||
}
|
||
throw new Exception("cannot be here");
|
||
})
|
||
.ToList();
|
||
}
|
||
else
|
||
{
|
||
lFiles = g.AsEnumerable()
|
||
.Select(n =>
|
||
{
|
||
if (n is File file)
|
||
{
|
||
return file;
|
||
}
|
||
throw new Exception("cannot be here");
|
||
})
|
||
.ToList();
|
||
}
|
||
}
|
||
|
||
foreach (var g in rGroups)
|
||
{
|
||
if (g.Key == DirOrFile.Dir)
|
||
{
|
||
rDirs = g.AsEnumerable()
|
||
.Select(n =>
|
||
{
|
||
if (n is Dir dir)
|
||
{
|
||
return dir;
|
||
}
|
||
throw new Exception("cannot be here");
|
||
})
|
||
.ToList();
|
||
}
|
||
else
|
||
{
|
||
rFiles = g.AsEnumerable()
|
||
.Select(n =>
|
||
{
|
||
if (n is File file)
|
||
{
|
||
return file;
|
||
}
|
||
throw new Exception("cannot be here");
|
||
})
|
||
.ToList();
|
||
}
|
||
}
|
||
|
||
//排序，然后对比
|
||
int lIndex_f = 0;
|
||
int rIndex_f = 0;
|
||
int lIndex_d = 0;
|
||
int rIndex_d = 0;
|
||
lFiles.Sort(AFileOrDir.Compare);
|
||
rFiles.Sort(AFileOrDir.Compare);
|
||
lDirs.Sort(AFileOrDir.Compare);
|
||
rDirs.Sort(AFileOrDir.Compare);
|
||
//对比文件
|
||
while (true)
|
||
{
|
||
//当两个线性表都走到最后时，退出循环
|
||
if (lIndex_f == lFiles.Count && rIndex_f == rFiles.Count)
|
||
{
|
||
break;
|
||
}
|
||
//左侧先到底，右侧都是将要删除的
|
||
if (lIndex_f == lFiles.Count)
|
||
{
|
||
var er = rFiles[rIndex_f];
|
||
cDir.Children.Add(
|
||
new File
|
||
{
|
||
Path = er.FormatedPath,
|
||
MTime = er.MTime,
|
||
NextOp = NextOpType.Del
|
||
}
|
||
);
|
||
rIndex_f++;
|
||
continue;
|
||
}
|
||
//右侧先到底，左侧都是要添加的
|
||
if (rIndex_f == rFiles.Count)
|
||
{
|
||
var el = lFiles[lIndex_f];
|
||
|
||
cDir.Children.Add(
|
||
new File
|
||
{
|
||
Path = el.FormatedPath.Replace(ldir.FormatedPath, rdir.FormatedPath),
|
||
MTime = el.MTime,
|
||
NextOp = NextOpType.Add
|
||
}
|
||
);
|
||
lIndex_f++;
|
||
continue;
|
||
}
|
||
var l = lFiles[lIndex_f];
|
||
var r = rFiles[rIndex_f];
|
||
//将根路径差异抹平
|
||
var lreativePath = l.FormatedPath.Replace(ldir.FormatedPath, "");
|
||
var rreativePath = r.FormatedPath.Replace(rdir.FormatedPath, "");
|
||
//两文件相同，对比文件修改时间，不同增加到diff内容
|
||
if (lreativePath == rreativePath)
|
||
{
|
||
lIndex_f++;
|
||
rIndex_f++;
|
||
// 如果最新版的时间大于旧版时间超过5s才更新，文件时间在传输过程中产生了精度损失。
|
||
// Warrning 如果旧版文件的最后修改时间大于新版文件，将不会更新
|
||
if ((l.MTime - r.MTime).TotalSeconds > 5)
|
||
{
|
||
cDir.Children.Add(
|
||
new File
|
||
{
|
||
Path = r.FormatedPath,
|
||
MTime = l.MTime,
|
||
NextOp = NextOpType.Modify
|
||
}
|
||
);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//因为已经按照文件路径排过序了，当左侧文件名大于右侧，那么将根据右侧,添加一个删除diff
|
||
if (lreativePath.CompareTo(rreativePath) > 0)
|
||
{
|
||
rIndex_f++;
|
||
cDir.Children.Add(
|
||
new File
|
||
{
|
||
Path = r.FormatedPath,
|
||
MTime = r.MTime,
|
||
NextOp = NextOpType.Del
|
||
}
|
||
);
|
||
}
|
||
//相反，根据左侧，添加一个新增diff
|
||
else
|
||
{
|
||
lIndex_f++;
|
||
cDir.Children.Add(
|
||
new File
|
||
{
|
||
Path = l.FormatedPath.Replace(ldir.FormatedPath, rdir.FormatedPath),
|
||
MTime = l.MTime,
|
||
NextOp = NextOpType.Add
|
||
}
|
||
);
|
||
}
|
||
}
|
||
}
|
||
|
||
//文件夹的比较和文件类似，但是他会递归调用文件夹的diff函数，直至文件停止
|
||
|
||
while (true)
|
||
{
|
||
if (lIndex_d == lDirs.Count && rIndex_d == rDirs.Count)
|
||
{
|
||
break;
|
||
}
|
||
if (lIndex_d == lDirs.Count)
|
||
{
|
||
var er = rDirs[rIndex_d];
|
||
cDir.Children.Add(er.Clone(NextOpType.Del, true));
|
||
rIndex_d++;
|
||
continue;
|
||
}
|
||
if (rIndex_d == rDirs.Count)
|
||
{
|
||
var el = lDirs[lIndex_d];
|
||
cDir.Children.Add(
|
||
el.Clone(NextOpType.Add, true)
|
||
.ResetRootPath(ldir.FormatedPath, rdir.FormatedPath)
|
||
);
|
||
lIndex_d++;
|
||
continue;
|
||
}
|
||
var l = lDirs[lIndex_d];
|
||
var r = rDirs[rIndex_d];
|
||
var lreativePath = l.FormatedPath.Replace(ldir.FormatedPath, "");
|
||
var rreativePath = r.FormatedPath.Replace(rdir.FormatedPath, "");
|
||
if (lreativePath == rreativePath)
|
||
{
|
||
lIndex_d++;
|
||
rIndex_d++;
|
||
var rDir = l.Diff(r);
|
||
//而等于0，这表示此文件夹的内容没有变化
|
||
if (rDir.Children.Count != 0)
|
||
{
|
||
cDir.Children.Add(rDir);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//文件夹重命名将会触发整个文件夹的删除和新增操作，这里没有办法定位到操作是修改文件夹(?) 和git类似。
|
||
//潜在的问题是，修改文件夹名，此文件夹包含大量的文件，将触发大量操作。
|
||
|
||
if (lreativePath.CompareTo(rreativePath) > 0)
|
||
{
|
||
cDir.Children.Add(r.Clone(NextOpType.Del, true));
|
||
rIndex_d++;
|
||
}
|
||
else
|
||
{
|
||
cDir.Children.Add(
|
||
l.Clone(NextOpType.Add, true)
|
||
.ResetRootPath(ldir.FormatedPath, rdir.FormatedPath)
|
||
);
|
||
lIndex_d++;
|
||
}
|
||
}
|
||
}
|
||
return cDir;
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 根据Dirobject记录的信息，写入磁盘
|
||
/// </summary>
|
||
/// <param name="thisDir"></param>
|
||
/// <param name="fileDirOp"> 文件操作类,它是如何写入文件的方法</param>
|
||
/// <exception cref="ArgumentException"></exception>
|
||
public static void WriteByThisInfo(this Dir thisDir, FileDirOpStra fileDirOp)
|
||
{
|
||
static void f(Dir dir, FileDirOpStra fileDirOp)
|
||
{
|
||
dir.AccessCheck();
|
||
foreach (var child in dir.Children)
|
||
{
|
||
if (child.Type == DirOrFile.Dir)
|
||
{
|
||
if (child is Dir childDir)
|
||
{
|
||
if (childDir.NextOp != NextOpType.Del)
|
||
{
|
||
fileDirOp.DirCreate(childDir, false);
|
||
f(childDir, fileDirOp);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (child is File childFile)
|
||
{
|
||
if (childFile.NextOp != NextOpType.Del)
|
||
{
|
||
fileDirOp.FileCreate(child.FormatedPath, childFile.MTime);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
throw new ArgumentException("child is not File!");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
f(thisDir, fileDirOp);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 从文件夹中提取文件信息
|
||
/// </summary>
|
||
/// <param name="thisDir"></param>
|
||
/// <param name="cherryPicks">只提取这些信息，最高级别</param>
|
||
/// <param name="exculdes">忽略这些文件信息</param>
|
||
/// <exception cref="NotSupportedException"></exception>
|
||
public static void ExtractInfo(
|
||
this Dir thisDir,
|
||
List<string>? cherryPicks = null,
|
||
List<string>? exculdes = null
|
||
)
|
||
{
|
||
bool filter(string path)
|
||
{
|
||
var relativePath = path.Replace('\\', '/').Replace(thisDir.FormatedPath, "");
|
||
if (cherryPicks != null)
|
||
{
|
||
return cherryPicks.Contains(relativePath);
|
||
}
|
||
|
||
if (exculdes != null)
|
||
{
|
||
return !exculdes.Contains(relativePath);
|
||
}
|
||
return true;
|
||
}
|
||
|
||
if (thisDir.Children.Count != 0)
|
||
{
|
||
throw new NotSupportedException("this dir is not empty.");
|
||
}
|
||
if (Directory.Exists(thisDir.FormatedPath))
|
||
{
|
||
string[] files = Directory.GetFiles(thisDir.FormatedPath);
|
||
string[] dirs = Directory.GetDirectories(thisDir.FormatedPath);
|
||
foreach (var file in files)
|
||
{
|
||
if (filter(file))
|
||
{
|
||
thisDir.Children.Add(
|
||
new File { Path = file, MTime = System.IO.File.GetLastWriteTime($"{file}") }
|
||
);
|
||
}
|
||
}
|
||
foreach (var dir in dirs)
|
||
{
|
||
if (filter(dir))
|
||
{
|
||
var ndir = new Dir { Path = dir, Children = [] };
|
||
ndir.ExtractInfo(cherryPicks, exculdes);
|
||
thisDir.Children.Add(ndir);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
/// <summary>
|
||
/// 添加一个子对象,这个不包含文件或文件夹的创建
|
||
/// </summary>
|
||
/// <param name="thisDir"></param>
|
||
/// <param name="child"></param>
|
||
/// <exception cref="ArgumentException"></exception>
|
||
public static void AddChild(this Dir thisDir, AFileOrDir child)
|
||
{
|
||
if (child.FormatedPath[..thisDir.FormatedPath.Length] != thisDir.FormatedPath)
|
||
{
|
||
throw new ArgumentException("their rootpath are not same!");
|
||
}
|
||
var filtedChildren = thisDir.Children.Where(x => x.Type == child.Type);
|
||
|
||
var mached = filtedChildren.Where(x => x.FormatedPath == child.FormatedPath);
|
||
|
||
if (mached.Any())
|
||
{
|
||
if (child is File)
|
||
{
|
||
throw new ArgumentException(
|
||
$"there are same path in the children:{child.FormatedPath}"
|
||
);
|
||
}
|
||
else if (child is Dir dir)
|
||
{
|
||
var tdir = mached.FirstOrDefault();
|
||
if (tdir is Dir ndir)
|
||
{
|
||
foreach (var d in dir.Children)
|
||
{
|
||
ndir.AddChild(d);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
thisDir.Children.Add(child);
|
||
}
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 合并diffdir中的内容
|
||
/// </summary>
|
||
/// <param name="thisDir"></param>
|
||
/// <param name="diffdir"></param>
|
||
/// <param name="IsUpdateObject">是否更新对象</param>
|
||
/// <param name="IsUpdateDirFile">是否更新文件夹和文件</param>
|
||
/// <exception cref="ArgumentException"></exception>
|
||
/// <exception cref="NotImplementedException"></exception>
|
||
public static void Combine(
|
||
this Dir thisDir,
|
||
FileDirOpStra? fileDirOp,
|
||
Dir diffdir,
|
||
bool IsUpdateObject = true,
|
||
bool IsUpdateDirFile = false
|
||
)
|
||
{
|
||
///验证 target 文件或者文件夹是否具备相关文件权限。
|
||
if (IsUpdateDirFile)
|
||
{
|
||
diffdir.AccessCheck();
|
||
}
|
||
if (thisDir.FormatedPath != diffdir.FormatedPath)
|
||
{
|
||
throw new ArgumentException("their path is not same");
|
||
}
|
||
else
|
||
{
|
||
var ldir = thisDir;
|
||
var rdir = diffdir;
|
||
|
||
foreach (var oc in diffdir.Children)
|
||
{
|
||
if (oc is File rfile)
|
||
{
|
||
if (rfile.NextOp != null)
|
||
{
|
||
if (oc.NextOp == NextOpType.Add)
|
||
{
|
||
if (IsUpdateObject)
|
||
{
|
||
ldir.AddChild(
|
||
new File { Path = rfile.FormatedPath, MTime = rfile.MTime }
|
||
);
|
||
}
|
||
if (IsUpdateDirFile)
|
||
{
|
||
fileDirOp?.FileCreate(rfile.FormatedPath, rfile.MTime);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
var n = ldir
|
||
.Children.Where(x =>
|
||
x.FormatedPath == oc.FormatedPath && x.Type == DirOrFile.File
|
||
)
|
||
.FirstOrDefault();
|
||
if (n is not null)
|
||
{
|
||
if (oc.NextOp == NextOpType.Del)
|
||
{
|
||
if (IsUpdateObject)
|
||
{
|
||
ldir.Children.Remove(n);
|
||
}
|
||
if (IsUpdateDirFile)
|
||
{
|
||
fileDirOp?.FileDel(rfile.FormatedPath);
|
||
}
|
||
}
|
||
else if (oc.NextOp == NextOpType.Modify)
|
||
{
|
||
if (n is File lfile)
|
||
{
|
||
if (IsUpdateObject)
|
||
{
|
||
lfile.MTime = rfile.MTime;
|
||
}
|
||
if (IsUpdateDirFile)
|
||
{
|
||
fileDirOp?.FileModify(rfile.FormatedPath, rfile.MTime);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else if (oc is Dir rrdir)
|
||
{
|
||
//新增和删除意味着整个文件夹都被新增和删除
|
||
if (rrdir.NextOp == NextOpType.Add)
|
||
{
|
||
if (IsUpdateDirFile)
|
||
{
|
||
fileDirOp?.DirCreate(rrdir);
|
||
}
|
||
if (IsUpdateObject)
|
||
{
|
||
ldir.AddChild(rrdir.Clone(null, true));
|
||
}
|
||
}
|
||
else if (rrdir.NextOp == NextOpType.Del)
|
||
{
|
||
if (IsUpdateDirFile)
|
||
{
|
||
fileDirOp?.DirDel(rrdir, false);
|
||
}
|
||
if (IsUpdateObject)
|
||
{
|
||
ldir.Children.RemoveAt(
|
||
ldir.Children.FindIndex(x => x.FormatedPath == rrdir.FormatedPath)
|
||
);
|
||
}
|
||
}
|
||
//当子文件夹和文件不确定时
|
||
else
|
||
{
|
||
var n = ldir
|
||
.Children.Where(x =>
|
||
x.FormatedPath == rrdir.FormatedPath && x.Type == DirOrFile.Dir
|
||
)
|
||
.FirstOrDefault();
|
||
if (n is Dir lldir)
|
||
{
|
||
lldir.Combine(fileDirOp, rrdir, IsUpdateObject, IsUpdateDirFile);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// clone一个新的对象
|
||
/// </summary>
|
||
/// <param name="thisDir"></param>
|
||
/// <param name="optype">重设的操作类型</param>
|
||
/// <param name="IsResetNextOpType">是否重设操作类型</param>
|
||
/// <returns></returns>
|
||
/// <exception cref="Exception"></exception>
|
||
public static Dir Clone(
|
||
this Dir thisDir,
|
||
NextOpType? optype = null,
|
||
bool IsResetNextOpType = false
|
||
)
|
||
{
|
||
var ndir = new Dir
|
||
{
|
||
Path = thisDir.FormatedPath,
|
||
Children = [],
|
||
NextOp = IsResetNextOpType ? optype : thisDir.NextOp
|
||
};
|
||
|
||
var nchildren = thisDir
|
||
.Children.AsEnumerable()
|
||
.Select(x =>
|
||
{
|
||
if (x is File file)
|
||
{
|
||
return new File
|
||
{
|
||
Path = file.FormatedPath,
|
||
MTime = file.MTime,
|
||
NextOp = IsResetNextOpType ? optype : file.NextOp
|
||
} as AFileOrDir;
|
||
}
|
||
else if (x is Dir dir)
|
||
{
|
||
return dir.Clone(optype, IsResetNextOpType);
|
||
}
|
||
else
|
||
{
|
||
throw new Exception("cannot be here!");
|
||
}
|
||
})
|
||
.ToList();
|
||
ndir.Children = nchildren;
|
||
|
||
return ndir;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 改变根路径位置
|
||
/// </summary>
|
||
/// <param name="thisDir"></param>
|
||
/// <param name="oldPath"></param>
|
||
/// <param name="newPath"></param>
|
||
/// <returns></returns>
|
||
public static Dir ResetRootPath(this Dir thisDir, string oldPath, string newPath)
|
||
{
|
||
thisDir.FormatedPath = thisDir.FormatedPath.Replace(oldPath, newPath);
|
||
thisDir.Children.ForEach(e =>
|
||
{
|
||
if (e is File file)
|
||
{
|
||
file.FormatedPath = file.FormatedPath.Replace(oldPath, newPath);
|
||
}
|
||
else if (e is Dir dir)
|
||
{
|
||
dir.ResetRootPath(oldPath, newPath);
|
||
}
|
||
});
|
||
return thisDir;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 文件操作权限检查（废弃）
|
||
/// </summary>
|
||
/// <param name="thisDir"></param>
|
||
public static void AccessCheck(this Dir thisDir)
|
||
{
|
||
//不是核心关注点，下面实现有bug。不校验所有文件夹权限，创建时会抛出错误，此时手动处理吧。
|
||
return;
|
||
//this.Children.ForEach(e =>
|
||
//{
|
||
// if (e is File file)
|
||
// {
|
||
// if (file.NextOp == null) { }
|
||
// else if (file.NextOp == NextOpType.Add)
|
||
// {
|
||
// if (
|
||
// !AccessWrapper.CheckDirAccess(
|
||
// Path.GetDirectoryName(file.FormatedPath)
|
||
// ?? throw new DirectoryNotFoundException(
|
||
// $"{file.FormatedPath} 此父路径不存在"
|
||
// ),
|
||
// [DirAcess.CreateFiles]
|
||
// )
|
||
// )
|
||
// {
|
||
// throw new UnauthorizedAccessException($"{file.FormatedPath} 无权限创建文件");
|
||
// }
|
||
// }
|
||
// else if (file.NextOp == NextOpType.Modify)
|
||
// {
|
||
// if (
|
||
// !(
|
||
// AccessWrapper.CheckFileAccess(file.FormatedPath, [FileAccess.Delete])
|
||
// && AccessWrapper.CheckDirAccess(
|
||
// Path.GetDirectoryName(file.FormatedPath)
|
||
// ?? throw new DirectoryNotFoundException(
|
||
// $"{file.FormatedPath} 此父路径不存在"
|
||
// ),
|
||
// [DirAcess.CreateFiles]
|
||
// )
|
||
// )
|
||
// )
|
||
// {
|
||
// throw new UnauthorizedAccessException(
|
||
// $"{file.FormatedPath} 无权限删除源文件或者创建新文件"
|
||
// );
|
||
// }
|
||
// }
|
||
// else if (file.NextOp == NextOpType.Del)
|
||
// {
|
||
// if (!AccessWrapper.CheckFileAccess(file.FormatedPath, [FileAccess.Delete]))
|
||
// {
|
||
// throw new UnauthorizedAccessException($"{file.FormatedPath} 无权限删除源文件");
|
||
// }
|
||
// }
|
||
// }
|
||
// else if (e is Dir dir)
|
||
// {
|
||
// if (dir.NextOp == null) { }
|
||
// else if (dir.NextOp == NextOpType.Add)
|
||
// {
|
||
// if (
|
||
// !AccessWrapper.CheckDirAccess(
|
||
// Path.GetDirectoryName(dir.FormatedPath)
|
||
// ?? throw new DirectoryNotFoundException(
|
||
// $"{dir.FormatedPath} 此父路径不存在"
|
||
// ),
|
||
// [DirAcess.CreateDirectories, DirAcess.CreateFiles]
|
||
// )
|
||
// )
|
||
// {
|
||
// throw new UnauthorizedAccessException($"{dir.FormatedPath} 无权限创建文件夹或者文件");
|
||
// }
|
||
// }
|
||
// else if (dir.NextOp == NextOpType.Del)
|
||
// {
|
||
// if (!AccessWrapper.CheckDirAccess(dir.FormatedPath, [DirAcess.Delete]))
|
||
// {
|
||
// throw new UnauthorizedAccessException($"{dir.FormatedPath} 无权限删除文件夹");
|
||
// }
|
||
// else
|
||
// {
|
||
// //校验是否拥有子文件或者文件夹的删除权限，
|
||
// dir.AccessCheck();
|
||
// }
|
||
// }
|
||
// }
|
||
//});
|
||
}
|
||
}
|