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类的

        public string MsmKey { get; set; }

        private string _ownerKey;
        public string  OwnerKey 
        {
            get 
            {
                if (string.IsNullOrEmpty(_ownerKey))
                    _ownerKey = "_UNDEFINED";
                return _ownerKey;
            }
            set
            {
                _ownerKey = value;
            }
        }

        private string _msnSig;
        public string MsmSig
        {
            get
            {
                if (string.IsNullOrEmpty(_msnSig))
                    _msnSig = "_UNDEFINED";
                return _msnSig;
            }
            set
            {
                _msnSig = value;
            } 
        }

SetupFileInfo类的

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

SetupDirectoryInfo类的

 public static string GUID_1
        { get { return "9EF0B969-E518-4E46-987F-47570745A589"; } }
        public string GUID_2 { get; set; }
        public string Property { get; set; }
        public string Name { get; set; }
        public List<SetupDirectoryInfo> Folders { get; set; }
        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不怎么友好。还有本文的思路很不清晰，呵呵，莫怪。

    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();
        }
    }