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不怎么友好。还有本文的思路很不清晰，呵呵，莫怪。

  1     class ExplorerCore
  2     {
  3         private string FileFullName { get; set; }
  4         private SetupDirectoryInfo RootFolder { get; set; }
  5 
  6         private string _otherFiles;
  7         private string OtherFiles 
  8         {
  9             get
 10             {
 11                 if (string.IsNullOrEmpty(_otherFiles))
 12                 {
 13                     string vdpproj = File.ReadAllText(FileFullName, Encoding.UTF8);
 14                     _otherFiles = Regex.Match(vdpproj, RegexCollection.RegFilesInner).Value;
 15                     _otherFiles = Regex.Replace(_otherFiles, RegexCollection.RegFileString, "");
 16                     _otherFiles = Regex.Replace(_otherFiles, @"s+
", "");
 17                     if (string.IsNullOrEmpty(_otherFiles))
 18                         _otherFiles = "
";
 19                 }
 20                 return "
"+_otherFiles+"
";
 21             }
 22         }
 23 
 24         private Dictionary<string, SetupDirectoryInfo> _dirDictionary;
 25         private Dictionary<string, SetupDirectoryInfo> DirDictionary
 26         {
 27             get
 28             {
 29                 if (_dirDictionary == null)
 30                     _dirDictionary = new Dictionary<string, SetupDirectoryInfo>();
 31                 return _dirDictionary;
 32             }
 33         }
 34 
 35 
 36         private Dictionary<string, SetupFileInfo> _dirFile;
 37         private Dictionary<string, SetupFileInfo> DirFile
 38         {
 39             get
 40             {
 41                 if (_dirFile == null)
 42                     _dirFile =new Dictionary<string, SetupFileInfo>();
 43                 return _dirFile;
 44             }
 45         }
 46 
 47         private List<SetupFileInfo> _fileList;
 48         private List<SetupFileInfo> FileList
 49         {
 50             get
 51             {
 52                 if (_fileList == null)
 53                     _fileList = new List<SetupFileInfo>();
 54                 return _fileList;
 55             }
 56         }
 57 
 58         private List<SetupHierarchy> _orgHierachyList;
 59         private List<SetupHierarchy> OrgHierachyList
 60         {
 61             get
 62             {
 63                 if (_orgHierachyList == null)
 64                     _orgHierachyList = new List<SetupHierarchy>();
 65                 return _orgHierachyList;
 66             }
 67         }
 68 
 69         private List<SetupHierarchy> _ownerHierachyList;
 70         private List<SetupHierarchy> OwnerHierachyList
 71         {
 72             get
 73             {
 74                 if (_ownerHierachyList == null)
 75                     _ownerHierachyList = new List<SetupHierarchy>();
 76                 return _ownerHierachyList;
 77             }
 78         }
 79 
 80         private List<string> _garbageGUID;
 81         private List<string> GarbageGUID
 82         {
 83             get
 84             {
 85                 if (_garbageGUID == null)
 86                     _garbageGUID = new List<string>();
 87                 return _garbageGUID;
 88             }
 89         }
 90 
 91         private void GCGUID(string guid)
 92         {
 93             if (GarbageGUID.Contains(guid)) return;
 94             GarbageGUID.Add(guid);
 95         }
 96 
 97         /// <summary>
 98         /// 增加文件夹到集合中
 99         /// </summary>
100         /// <param name="info"></param>
101         private void AddDirectory(SetupDirectoryInfo info)
102         {
103             if (!DirDictionary.ContainsKey(info.GUID_2))
104                 DirDictionary.Add(info.GUID_2, info);
105         }
106 
107         /// <summary>
108         /// 增加文件到其所属文件夹中
109         /// </summary>
110         /// <param name="info"></param>
111         private void AddFileToDircotory(SetupFileInfo info)
112         {
113             if (DirDictionary.ContainsKey(info.Folder) &&
114                 !DirDictionary[info.Folder].Files.Contains(info))
115                 DirDictionary[info.Folder].Files.Add(info);
116         }
117 
118         /// <summary>
119         /// 增加文件到文件列表中
120         /// </summary>
121         /// <param name="info"></param>
122         private void AddFile(SetupFileInfo info)
123         {
124             FileList.Add(info);
125             DirFile.Add(info.GUID_2, info);
126         }
127 
128         /// <summary>
129         /// 把文件夹 文件 Hierachy组合在一起
130         /// </summary>
131         private void CombineObjects()
132         {
133             foreach (SetupFileInfo item in FileList)
134                 AddFileToDircotory(item);
135 
136             for (int i = 0; i < _orgHierachyList.Count; i++)
137             {
138                 if (DirFile.ContainsKey(OrgHierachyList[i].MsmKey))
139                 {
140                     DirFile[OrgHierachyList[i].MsmKey].Hierachy = OrgHierachyList[i];
141                     OwnerHierachyList.Add(OrgHierachyList[i]);
142                     OrgHierachyList.RemoveAt(i);
143                     i--;
144                 }
145             }
146         }
147 
148         /// <summary>
149         /// 初始化读入文档内容，分析并构建起树
150         /// </summary>
151         /// <param name="fileName"></param>
152         /// <returns></returns>
153         public SetupDirectoryInfo InitExplorer(string fileName)
154         {
155             FileFullName = fileName;
156             string vdprojContent = File.ReadAllText(fileName, Encoding.UTF8);
157 
158             string strFolder = Regex.Match(vdprojContent, RegexCollection.RegFoldersInner).Value;
159             SetupDirectoryInfo root = new SetupDirectoryInfo()
160             {
161                 GUID_2 = Regex.Match(vdprojContent, RegexCollection.RegAppFolderGuid2).Value,
162                 Name = "应用程序文件夹",
163                 Files = new List<SetupFileInfo>(),
164                 Folders = new List<SetupDirectoryInfo>()
165             };
166             RootFolder = root;
167             AddDirectory(root);
168             SetupDirectoryInfo.CreateSetupDirectoryInfo(strFolder, root,this.DirDictionary);
169 
170             string strFiles = Regex.Match(vdprojContent, RegexCollection.RegFilesInner).Value;
171             MatchCollection fileMatch = Regex.Matches(strFiles, RegexCollection.RegFileString);
172             foreach (Match item in fileMatch)
173                 AddFile(SetupFileInfo.CreateSetupFileInfo(item.Value));
174 
175             string strHierachy = Regex.Match(vdprojContent, RegexCollection.RegHierachyInner).Value;
176             MatchCollection hierachyMatch = Regex.Matches(strHierachy, RegexCollection.RegHierarchy);
177             foreach (Match item in hierachyMatch)
178                 OrgHierachyList.Add(SetupHierarchy.CreateHierarchy(item.Value));
179 
180             CombineObjects();
181             return root;
182         }
183 
184         /// <summary>
185         /// 可视化界面 删除文件
186         /// </summary>
187         /// <param name="file"></param>
188         public void DeleteFile(SetupFileInfo file)
189         {
190             FileList.Remove(file);
191             DirFile.Remove(file.GUID_2);
192             OwnerHierachyList.Remove(file.Hierachy);
193             DirDictionary[file.Folder].Files.Remove(file);
194             GCGUID(file.GUID_2);
195         }
196 
197         /// <summary>
198         /// 可视化界面 增加文件
199         /// </summary>
200         /// <param name="dir"></param>
201         /// <param name="fileInfo"></param>
202         public void AddFile(SetupDirectoryInfo dir, FileInfo fileInfo)
203         {
204             SetupFileInfo file = new SetupFileInfo();
205 
206             file.GUID_2 = GUIDCreater.CreateGUID2();
207             file.SourcePath = fileInfo.FullName.Replace("\", "\\");
208             file.TargetName = fileInfo.Name;
209             file.Folder = dir.GUID_2;
210             file.Hierachy = new SetupHierarchy(file);
211 
212             AddFile(file);
213             AddFileToDircotory(file);
214             OwnerHierachyList.Add(file.Hierachy);
215         }
216 
217         /// <summary>
218         /// 可视化界面 删除文件夹
219         /// </summary>
220         /// <param name="dir"></param>
221         public void DeleteDircetory(SetupDirectoryInfo dir,SetupDirectoryInfo parent)
222         {
223             //foreach (SetupFileInfo file in dir.Files)
224             while (dir.Files.Count>0)
225                 DeleteFile(dir.Files[0]);
226             //foreach (SetupDirectoryInfo subDir in dir.Folders)
227             while (dir.Folders.Count>0)
228                 DeleteDircetory(dir.Folders[0],dir);
229             parent.Folders.Remove(dir);
230             DirDictionary.Remove(dir.GUID_2);
231             GCGUID(dir.GUID_2);
232         }
233 
234         /// <summary>
235         /// 可视化界面 增加文件夹
236         /// </summary>
237         /// <param name="dirInfo"></param>
238         /// <param name="dir"></param>
239         public void AddDirectory(SetupDirectoryInfo dirInfo, DirectoryInfo dir)
240         {
241 
242             SetupDirectoryInfo currDir = new SetupDirectoryInfo();
243             currDir.Name = dir.Name;
244             currDir.GUID_2 = GUIDCreater.CreateGUID2();
245             currDir.Property = GUIDCreater.CreateGUID2();
246             currDir.Files = new List<SetupFileInfo>();
247             currDir.Folders = new List<SetupDirectoryInfo>();
248 
249             DirectoryInfo[] dirs = dir.GetDirectories();
250             List<SetupDirectoryInfo> folderList = new List<SetupDirectoryInfo>(dirs.Length);
251             foreach (DirectoryInfo item in dirs)
252                 AddDirectory(currDir, item);
253             AddDirectory(currDir);
254             dirInfo.Folders.Add(currDir);
255 
256             FileInfo[] files = dir.GetFiles();
257             List<SetupFileInfo> fileList = new List<SetupFileInfo>(files.Length);
258             foreach (FileInfo file in files)
259                 AddFile(currDir, file);
260         }
261 
262         /// <summary>
263         /// 可视化界面 同步文件夹
264         /// </summary>
265         /// <param name="dirInfo"></param>
266         /// <param name="dir"></param>
267         public void SynDirectory(SetupDirectoryInfo dirInfo, DirectoryInfo dir)
268         {
269             DirectoryInfo[] dirArry = dir.GetDirectories();
270             List<SetupDirectoryInfo> newDirList = new List<SetupDirectoryInfo>(dirArry.Length);
271             SetupDirectoryInfo newDir = null;
272             foreach (DirectoryInfo item in dirArry)
273             {
274                 newDir = dirInfo.ExistSubDirectory(item.Name);
275                 if (newDir != null)
276                 {
277                     newDirList.Add(newDir);
278                     dirInfo.Folders.Remove(newDir);
279                 }
280                 else
281                 {
282                     newDir = new SetupDirectoryInfo();
283                     newDir.Name = item.Name;
284                     newDir.GUID_2 = GUIDCreater.CreateGUID2();
285                     newDir.Property = GUIDCreater.CreateGUID2();
286                     newDir.Files = new List<SetupFileInfo>();
287                     newDir.Folders = new List<SetupDirectoryInfo>();
288 
289                     AddDirectory(newDir);
290                     newDirList.Add(newDir);
291                 }
292                 SynDirectory(newDir, item);
293             }
294             while (dirInfo.Folders.Count > 0)
295                 DeleteDircetory(dirInfo.Folders[0], dirInfo);
296             dirInfo.Folders = newDirList;
297 
298             FileInfo[] fileArry = dir.GetFiles();
299             List<SetupFileInfo> newFileList = new List<SetupFileInfo>(fileArry.Length);
300             SetupFileInfo newFile = null;
301             foreach (FileInfo item in fileArry)
302             {
303                 newFile = dirInfo.ExistFile(item.Name);
304                 if (newFile != null)
305                 {
306                     newFile.SourcePath = item.FullName.Replace("\", "\\");
307                     newFileList.Add(newFile);
308                     dirInfo.Files.Remove(newFile);
309                 }
310                 else
311                 {
312                     SetupFileInfo file = new SetupFileInfo();
313 
314                     file.GUID_2 = GUIDCreater.CreateGUID2();
315                     file.SourcePath = item.FullName.Replace("\", "\\");
316                     file.TargetName = item.Name;
317                     file.Folder = dirInfo.GUID_2;
318                     file.Hierachy = new SetupHierarchy(file);
319 
320                     AddFile(file);
321                     //AddFileToDircotory(file);
322                     newFileList.Add(file);
323                     OwnerHierachyList.Add(file.Hierachy);
324                 }
325                     //AddFile(dirInfo, item);
326             }
327             while (dirInfo.Files.Count > 0)
328                 DeleteFile(dirInfo.Files[0]);
329             dirInfo.Files = newFileList;
330 
331         }
332 
333         public void SaveFile()
334         {
335             Initial();
336             StringBuilder sbFile = new StringBuilder();
337             foreach (SetupFileInfo item in FileList)
338                 sbFile.Append(item.CreateFileItemInfo());
339             sbFile.Append(OtherFiles);
340 
341             StringBuilder sbHierachy=new StringBuilder();
342             foreach (SetupHierarchy item in OwnerHierachyList)
343                 sbHierachy.Append(item.ToString());
344             foreach (SetupHierarchy item in OrgHierachyList)
345                 sbHierachy.Append(item.ToString());
346 
347             //string strFolders = RootFolder.CreateFoldersString();
348             StringBuilder sbFolder = new StringBuilder();
349             foreach (SetupDirectoryInfo item in RootFolder.Folders)
350                 sbFolder.Append(item.CreateFoldersString());
351 
352             string vdprojContent = SpecialCharacter.ChangeSpecialCharacter(File.ReadAllText(FileFullName, Encoding.UTF8));
353             File.Copy(FileFullName, FileFullName + ".bak", true);
354 
355             vdprojContent =SpecialCharacter.RecoverSpecialCharacter( OverWriteContent(vdprojContent,
356                SpecialCharacter.ChangeSpecialCharacter( sbHierachy.ToString()),
357                 SpecialCharacter.ChangeSpecialCharacter( sbFile.ToString()),
358                SpecialCharacter.ChangeSpecialCharacter( sbFolder.ToString())
359             ));
360             vdprojContent= SafeCheckGUID(vdprojContent);
361             File.WriteAllText(FileFullName, vdprojContent, Encoding.UTF8);
362             Finish();
363         }
364 
365 
366         private string SafeCheckGUID(string vdprojContent)
367         {
368             if (_garbageGUID == null) return vdprojContent;
369             foreach (string guidItem in GarbageGUID)
370                vdprojContent= vdprojContent.Replace(guidItem, "");
371             return vdprojContent;
372         }
373 
374         private string OverWriteContent(string vdprojContent, string strHierarchy, string strFiles, string strFolders)
375         {
376             vdprojContent = Regex.Replace(vdprojContent, RegexCollection.RegFilesInner, strFiles);
377             vdprojContent = Regex.Replace(vdprojContent, RegexCollection.RegFoldersInner, strFolders);
378             vdprojContent = Regex.Replace(vdprojContent, RegexCollection.RegHierachyInner, strHierarchy);
379 
380             return vdprojContent;
381         }
382 
383         private void Initial()
384         {
385             SpecialCharacter.AddCharacter("$");
386         }
387 
388         private void Finish()
389         {
390             SpecialCharacter.ClearRecord();
391             GC.Collect();
392         }
393     }

ExplorerCore核心类