mis导入器的加强版——vdproj文件资源浏览器

　　上次做的那个导入器不够强大，限制还不小，用起来不方便。于是就再做一个这样的工具。代码基本上不同了，思想还是差不多，但功能肯定比之前的强大。经过了这次编写工具，对vdporj文件的了解又深一层了。

在vs的文件系统编辑器使用过程中，发现有两个不方便：第一是删除文件夹不方便，如果一个文件夹不是空的话，是删不成功的；第二是添加文件夹时，只能添加该文件夹的文件，如果指定的文件夹含有子文件夹，那些子文件夹就要手动一个个去添加，不会一同添加进去。

　　针对第二个问题，我就写出了之前的那个导入器，针对第一个问题，我就写了这个浏览器。这回就先看一下界面

功能大致有一下几个

同步文件夹：把“应用程序文件夹”里的某个文件夹与磁盘上的某个文件夹同步，使得与磁盘上的文件夹有相同的文件和子文件夹。

添加文件夹：把磁盘上某个文件夹的添加进来，包括了文件夹的文件和它的所有子文件夹的文件。

删除文件夹：把该文件夹的内容（包括文件和文件夹）删除。

添加文件：把一个或多个文件添加到文件夹中。

删除文件：把一个或多个文件删除。

不过像vs里面的复制，剪切，粘贴，拖拽这些功能就没有实现了。

介绍了工具的功能到介绍工具的实现了

下面则是所用到的类和它的体系结构图

这里的类大致上与之前的差不多，GUIDCreater是生成GUID值的；SpecialCharacter是记录处理一些特殊字符的；RegexCollection是存放着一些公共的正则表达式。GUIDCreater和SpecialCharacter的源码跟上次的一样。SetupFileInfo，SetupHierarchy，SetupDirectoryInfo这三个类又要唠叨一下。

带Setup开头的几个类，就是vdproj文件里面几个数据项的类，这次就新增了一个SetupHierachy类。这些类存放着各种对象的信息，以及一些自身的方法。

由平时对文件系统的理解和对vdproj文件的分析，得出这三个类的关系是这样的：

SetupDirectoryInfo对象包含有若干个SetupDirectoryInfo对象和若干个SetupFileInfo对象；
一个SetupFileInfo对象只对应这一个SetupHierarchy对象；

因此SetupDirectoryInfo中应该要有一个存放SetupDirectoryInfo对象的集合和一个SetupFileInfo对象的集合；SetupFileInfo中有一个字段存放与之对应的SetupHierarchy对象。

这三个类的字段与属性定义如下

SetupHierarchy类的

 1         public string MsmKey { get; set; }
 2 
 3         private string _ownerKey;
 4         public string  OwnerKey 
 5         {
 6             get 
 7             {
 8                 if (string.IsNullOrEmpty(_ownerKey))
 9                     _ownerKey = "_UNDEFINED";
10                 return _ownerKey;
11             }
12             set
13             {
14                 _ownerKey = value;
15             }
16         }
17 
18         private string _msnSig;
19         public string MsmSig
20         {
21             get
22             {
23                 if (string.IsNullOrEmpty(_msnSig))
24                     _msnSig = "_UNDEFINED";
25                 return _msnSig;
26             }
27             set
28             {
29                 _msnSig = value;
30             } 
31         }

SetupFileInfo类的

1         public string GUID_1
2         { get { return "1FB2D0AE-D3B9-43D4-B9DD-F88EC61E35DE"; } }
3         public string SourcePath { get; set; }
4         public string TargetName { get; set; }
5         public string Folder { get; set; }
6         public string GUID_2 { get; set; }
7         public SetupHierarchy Hierachy { get; set; }

SetupDirectoryInfo类的

1  public static string GUID_1
2         { get { return "9EF0B969-E518-4E46-987F-47570745A589"; } }
3         public string GUID_2 { get; set; }
4         public string Property { get; set; }
5         public string Name { get; set; }
6         public List<SetupDirectoryInfo> Folders { get; set; }
7         public List<SetupFileInfo> Files { get; set; }

对这三个类的其他成员，就是把vdproj文件提取出来构造对象的方法还有把对象转换成字符串的方法。

整个工具的核心就是一个ExplorerCore类，它处理着整个各种业务，包括对vdproj的分析，增删改文件夹；它还管理所有文件夹，文件对象；

对于管理文件夹和文件，ExplorerCore这个核心类使用了6个集合和2个对象，分别是

DirDictionary（文件夹字典集）：利用文件夹对象SetupDirecotryInfo中GUID2值作为键值的字典集，目的在于能通过GUID值方便获取到文件夹对象
DirFile（文件字典集）：利用文件对象SetupFileInfo中GUID2值作为键值的字典集，目的在于能通过GUID值方便获取到文件对象
FileList（文件列表）：文件对象SetupFileInfo的列表，在生成所有文件的字符串时遍历使用。
OrgHierachyList（无对应文件的Hierachy列表）：存放着未与文件对应的Hierachy对象，刚从vdproj文件分析出来的Hierachy对象都先存放在此集合。
OwnerHierachyList（有对应文件的Hierachy列表）：存放着已于文件对应的Hierachy对象。
GarbageGUID（已经废弃的GUID列表）：存放着已被删除的文件或文件夹的GUID值
OtherFiles（一些解析不成功的文件信息）：以字符串的形式存放着解析不出来的文件信息
RootFolder（根文件夹对象）：整个文件系统树形结构的根，也就是“应用程序文件夹”的对象。

　　经过多次的实践得出，这个文件或文件夹的唯一标识码GUID值在vdproj文件中有很大的作用，文件和文件夹通过它进行关联，程序的快捷方式通过它跟指定的文件、文件夹进行关联。因此在删除一个文件或文件夹之后，一定要被删除的对象的GUID值记录起来。等到保存成vdproj的之后统一把文件存在的废弃GUID码删除替换掉。否则保存之后如果vdproj还存在着废弃的GUID码，vs会打不开那个vdproj文件的。

　　ExplorerCore这个核心类的方法就不逐一介绍了，到本文最后就会把整个类的代码粘贴出来。工具写出来了，毛病还是有的，不过至少满足现在的使用需求，能让我打包方便点儿，对类的分析好像还很混乱，有些地方为啥要这样做我也说不清楚(就比如那个SetupHierarchy的对象啥要分开成与文件关联和未与文件关联两个列表存放)，还有一个弊病就是产生的字符串太多了，对GC不怎么友好。还有本文的思路很不清晰，呵呵，莫怪。

ExplorerCore核心类

class ExplorerCore
{
private string FileFullName { get; set; }
private SetupDirectoryInfo RootFolder { get; set; }

private string _otherFiles;
private string OtherFiles
{
get
{
if (string.IsNullOrEmpty(_otherFiles))
{
string vdpproj = File.ReadAllText(FileFullName, Encoding.UTF8);
_otherFiles = Regex.Match(vdpproj, RegexCollection.RegFilesInner).Value;
_otherFiles = Regex.Replace(_otherFiles, RegexCollection.RegFileString, "");
_otherFiles = Regex.Replace(_otherFiles, @"s+ ", "");
if (string.IsNullOrEmpty(_otherFiles))
_otherFiles = " ";
}
return " "+_otherFiles+" ";
}
}

private Dictionary<string, SetupDirectoryInfo> _dirDictionary;
private Dictionary<string, SetupDirectoryInfo> DirDictionary
{
get
{
if (_dirDictionary == null)
_dirDictionary = new Dictionary<string, SetupDirectoryInfo>();
return _dirDictionary;
}
}

private Dictionary<string, SetupFileInfo> _dirFile;
private Dictionary<string, SetupFileInfo> DirFile
{
get
{
if (_dirFile == null)
_dirFile =new Dictionary<string, SetupFileInfo>();
return _dirFile;
}
}

private List<SetupFileInfo> _fileList;
private List<SetupFileInfo> FileList
{
get
{
if (_fileList == null)
_fileList = new List<SetupFileInfo>();
return _fileList;
}
}

private List<SetupHierarchy> _orgHierachyList;
private List<SetupHierarchy> OrgHierachyList
{
get
{
if (_orgHierachyList == null)
_orgHierachyList = new List<SetupHierarchy>();
return _orgHierachyList;
}
}

private List<SetupHierarchy> _ownerHierachyList;
private List<SetupHierarchy> OwnerHierachyList
{
get
{
if (_ownerHierachyList == null)
_ownerHierachyList = new List<SetupHierarchy>();
return _ownerHierachyList;
}
}

private List<string> _garbageGUID;
private List<string> GarbageGUID
{
get
{
if (_garbageGUID == null)
_garbageGUID = new List<string>();
return _garbageGUID;
}
}

private void GCGUID(string guid)
{
if (GarbageGUID.Contains(guid)) return;
GarbageGUID.Add(guid);
}

/// <summary>
/// 增加文件夹到集合中
/// </summary>
/// <param name="info"></param>
private void AddDirectory(SetupDirectoryInfo info)
{
if (!DirDictionary.ContainsKey(info.GUID_2))
DirDictionary.Add(info.GUID_2, info);
}

/// <summary>
/// 增加文件到其所属文件夹中
/// </summary>
/// <param name="info"></param>
private void AddFileToDircotory(SetupFileInfo info)
{
if (DirDictionary.ContainsKey(info.Folder) &&
!DirDictionary[info.Folder].Files.Contains(info))
DirDictionary[info.Folder].Files.Add(info);
}

/// <summary>
/// 增加文件到文件列表中
/// </summary>
/// <param name="info"></param>
private void AddFile(SetupFileInfo info)
{
FileList.Add(info);
DirFile.Add(info.GUID_2, info);
}

/// <summary>
/// 把文件夹文件 Hierachy组合在一起
/// </summary>
private void CombineObjects()
{
foreach (SetupFileInfo item in FileList)
AddFileToDircotory(item);

for (int i = 0; i < _orgHierachyList.Count; i++)
{
if (DirFile.ContainsKey(OrgHierachyList[i].MsmKey))
{
DirFile[OrgHierachyList[i].MsmKey].Hierachy = OrgHierachyList[i];
OwnerHierachyList.Add(OrgHierachyList[i]);
OrgHierachyList.RemoveAt(i);
i--;
}
}
}

/// <summary>
/// 初始化读入文档内容，分析并构建起树
/// </summary>
/// <param name="fileName"></param>
/// <returns></returns>
public SetupDirectoryInfo InitExplorer(string fileName)
{
FileFullName = fileName;
string vdprojContent = File.ReadAllText(fileName, Encoding.UTF8);

string strFolder = Regex.Match(vdprojContent, RegexCollection.RegFoldersInner).Value;
SetupDirectoryInfo root = new SetupDirectoryInfo()
{
GUID_2 = Regex.Match(vdprojContent, RegexCollection.RegAppFolderGuid2).Value,
Name = "应用程序文件夹",
Files = new List<SetupFileInfo>(),
Folders = new List<SetupDirectoryInfo>()
};
RootFolder = root;
AddDirectory(root);
SetupDirectoryInfo.CreateSetupDirectoryInfo(strFolder, root,this.DirDictionary);

string strFiles = Regex.Match(vdprojContent, RegexCollection.RegFilesInner).Value;
MatchCollection fileMatch = Regex.Matches(strFiles, RegexCollection.RegFileString);
foreach (Match item in fileMatch)
AddFile(SetupFileInfo.CreateSetupFileInfo(item.Value));

string strHierachy = Regex.Match(vdprojContent, RegexCollection.RegHierachyInner).Value;
MatchCollection hierachyMatch = Regex.Matches(strHierachy, RegexCollection.RegHierarchy);
foreach (Match item in hierachyMatch)
OrgHierachyList.Add(SetupHierarchy.CreateHierarchy(item.Value));

CombineObjects();
return root;
}

/// <summary>
/// 可视化界面删除文件
/// </summary>
/// <param name="file"></param>
public void DeleteFile(SetupFileInfo file)
{
FileList.Remove(file);
DirFile.Remove(file.GUID_2);
OwnerHierachyList.Remove(file.Hierachy);
DirDictionary[file.Folder].Files.Remove(file);
GCGUID(file.GUID_2);
}

/// <summary>
/// 可视化界面增加文件
/// </summary>
/// <param name="dir"></param>
/// <param name="fileInfo"></param>
public void AddFile(SetupDirectoryInfo dir, FileInfo fileInfo)
{
SetupFileInfo file = new SetupFileInfo();

file.GUID_2 = GUIDCreater.CreateGUID2();
file.SourcePath = fileInfo.FullName.Replace("\", "\\");
file.TargetName = fileInfo.Name;
file.Folder = dir.GUID_2;
file.Hierachy = new SetupHierarchy(file);

AddFile(file);
AddFileToDircotory(file);
OwnerHierachyList.Add(file.Hierachy);
}

/// <summary>
/// 可视化界面删除文件夹
/// </summary>
/// <param name="dir"></param>
public void DeleteDircetory(SetupDirectoryInfo dir,SetupDirectoryInfo parent)
{
//foreach (SetupFileInfo file in dir.Files)
while (dir.Files.Count>0)
DeleteFile(dir.Files[0]);
//foreach (SetupDirectoryInfo subDir in dir.Folders)
while (dir.Folders.Count>0)
DeleteDircetory(dir.Folders[0],dir);
parent.Folders.Remove(dir);
DirDictionary.Remove(dir.GUID_2);
GCGUID(dir.GUID_2);
}

/// <summary>
/// 可视化界面增加文件夹
/// </summary>
/// <param name="dirInfo"></param>
/// <param name="dir"></param>
public void AddDirectory(SetupDirectoryInfo dirInfo, DirectoryInfo dir)
{

SetupDirectoryInfo currDir = new SetupDirectoryInfo();
currDir.Name = dir.Name;
currDir.GUID_2 = GUIDCreater.CreateGUID2();
currDir.Property = GUIDCreater.CreateGUID2();
currDir.Files = new List<SetupFileInfo>();
currDir.Folders = new List<SetupDirectoryInfo>();

DirectoryInfo[] dirs = dir.GetDirectories();
List<SetupDirectoryInfo> folderList = new List<SetupDirectoryInfo>(dirs.Length);
foreach (DirectoryInfo item in dirs)
AddDirectory(currDir, item);
AddDirectory(currDir);
dirInfo.Folders.Add(currDir);

FileInfo[] files = dir.GetFiles();
List<SetupFileInfo> fileList = new List<SetupFileInfo>(files.Length);
foreach (FileInfo file in files)
AddFile(currDir, file);
}

/// <summary>
/// 可视化界面同步文件夹
/// </summary>
/// <param name="dirInfo"></param>
/// <param name="dir"></param>
public void SynDirectory(SetupDirectoryInfo dirInfo, DirectoryInfo dir)
{
DirectoryInfo[] dirArry = dir.GetDirectories();
List<SetupDirectoryInfo> newDirList = new List<SetupDirectoryInfo>(dirArry.Length);
SetupDirectoryInfo newDir = null;
foreach (DirectoryInfo item in dirArry)
{
newDir = dirInfo.ExistSubDirectory(item.Name);
if (newDir != null)
{
newDirList.Add(newDir);
dirInfo.Folders.Remove(newDir);
}
else
{
newDir = new SetupDirectoryInfo();
newDir.Name = item.Name;
newDir.GUID_2 = GUIDCreater.CreateGUID2();
newDir.Property = GUIDCreater.CreateGUID2();
newDir.Files = new List<SetupFileInfo>();
newDir.Folders = new List<SetupDirectoryInfo>();

AddDirectory(newDir);
newDirList.Add(newDir);
}
SynDirectory(newDir, item);
}
while (dirInfo.Folders.Count > 0)
DeleteDircetory(dirInfo.Folders[0], dirInfo);
dirInfo.Folders = newDirList;

FileInfo[] fileArry = dir.GetFiles();
List<SetupFileInfo> newFileList = new List<SetupFileInfo>(fileArry.Length);
SetupFileInfo newFile = null;
foreach (FileInfo item in fileArry)
{
newFile = dirInfo.ExistFile(item.Name);
if (newFile != null)
{
newFile.SourcePath = item.FullName.Replace("\", "\\");
newFileList.Add(newFile);
dirInfo.Files.Remove(newFile);
}
else
{
SetupFileInfo file = new SetupFileInfo();

file.GUID_2 = GUIDCreater.CreateGUID2();
file.SourcePath = item.FullName.Replace("\", "\\");
file.TargetName = item.Name;
file.Folder = dirInfo.GUID_2;
file.Hierachy = new SetupHierarchy(file);

AddFile(file);
//AddFileToDircotory(file);
newFileList.Add(file);
OwnerHierachyList.Add(file.Hierachy);
}
//AddFile(dirInfo, item);
}
while (dirInfo.Files.Count > 0)
DeleteFile(dirInfo.Files[0]);
dirInfo.Files = newFileList;

}

public void SaveFile()
{
Initial();
StringBuilder sbFile = new StringBuilder();
foreach (SetupFileInfo item in FileList)
sbFile.Append(item.CreateFileItemInfo());
sbFile.Append(OtherFiles);

StringBuilder sbHierachy=new StringBuilder();
foreach (SetupHierarchy item in OwnerHierachyList)
sbHierachy.Append(item.ToString());
foreach (SetupHierarchy item in OrgHierachyList)
sbHierachy.Append(item.ToString());

//string strFolders = RootFolder.CreateFoldersString();
StringBuilder sbFolder = new StringBuilder();
foreach (SetupDirectoryInfo item in RootFolder.Folders)
sbFolder.Append(item.CreateFoldersString());

string vdprojContent = SpecialCharacter.ChangeSpecialCharacter(File.ReadAllText(FileFullName, Encoding.UTF8));
File.Copy(FileFullName, FileFullName + ".bak", true);

vdprojContent =SpecialCharacter.RecoverSpecialCharacter( OverWriteContent(vdprojContent,
SpecialCharacter.ChangeSpecialCharacter( sbHierachy.ToString()),
SpecialCharacter.ChangeSpecialCharacter( sbFile.ToString()),
SpecialCharacter.ChangeSpecialCharacter( sbFolder.ToString())
));
vdprojContent= SafeCheckGUID(vdprojContent);
File.WriteAllText(FileFullName, vdprojContent, Encoding.UTF8);
Finish();
}

private string SafeCheckGUID(string vdprojContent)
{
if (_garbageGUID == null) return vdprojContent;
foreach (string guidItem in GarbageGUID)
vdprojContent= vdprojContent.Replace(guidItem, "");
return vdprojContent;
}

private string OverWriteContent(string vdprojContent, string strHierarchy, string strFiles, string strFolders)
{
vdprojContent = Regex.Replace(vdprojContent, RegexCollection.RegFilesInner, strFiles);
vdprojContent = Regex.Replace(vdprojContent, RegexCollection.RegFoldersInner, strFolders);
vdprojContent = Regex.Replace(vdprojContent, RegexCollection.RegHierachyInner, strHierarchy);

return vdprojContent;
}

private void Initial()
{
SpecialCharacter.AddCharacter("$");
}

private void Finish()
{
SpecialCharacter.ClearRecord();
GC.Collect();
}
}

ExplorerCore核心类

分类: C#