resolve revert engineering name

chuongmep · chuongmep · commit b6b067514772 · 2022-07-14T23:39:13.000+07:00
diff --git a/AddInManager/Model/AssemLoader.cs b/AddInManager/Model/AssemLoader.cs
@@ -93,7 +93,7 @@ public Assembly LoadAddinsToTempFolder(string originalFilePath, bool parsingOnly
 
     private Assembly CopyAndLoadAddin(string srcFilePath, bool onlyCopyRelated)
     {
-        var text = string.Empty;
+        var filePath = string.Empty;
         if (!FileUtils.FileExistsInFolder(srcFilePath, tempFolder))
         {
             var directoryName = Path.GetDirectoryName(srcFilePath);
@@ -102,8 +102,8 @@ private Assembly CopyAndLoadAddin(string srcFilePath, bool onlyCopyRelated)
                 refedFolders.Add(directoryName);
             }
             var list = new List<FileInfo>();
-            text = FileUtils.CopyFileToFolder(srcFilePath, tempFolder, onlyCopyRelated, list);
-            if (string.IsNullOrEmpty(text))
+            filePath = FileUtils.CopyFileToFolder(srcFilePath, tempFolder, onlyCopyRelated, list);
+            if (string.IsNullOrEmpty(filePath))
             {
                 return null;
             }
@@ -112,7 +112,7 @@ private Assembly CopyAndLoadAddin(string srcFilePath, bool onlyCopyRelated)
                 copiedFiles.Add(fileInfo.FullName, fileInfo.LastWriteTime);
             }
         }
-        return LoadAddin(text);
+        return LoadAddin(filePath);
     }
 
     private Assembly LoadAddin(string filePath)
@@ -135,47 +135,47 @@ private Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs a
     {
         Assembly result;
         new AssemblyName(args.Name);
-        var text = SearchAssemblyFileInTempFolder(args.Name);
-        if (File.Exists(text))
+        var filePath = SearchAssemblyFileInTempFolder(args.Name);
+        if (File.Exists(filePath))
         {
-            result = LoadAddin(text);
+            result = LoadAddin(filePath);
         }
         else
         {
-            text = SearchAssemblyFileInOriginalFolders(args.Name);
-            if (string.IsNullOrEmpty(text))
+            filePath = SearchAssemblyFileInOriginalFolders(args.Name);
+            if (string.IsNullOrEmpty(filePath))
             {
                 var array = args.Name.Split(new char[]
                 {
                     ','
                 });
-                var text2 = array[0];
+                var ass = array[0];
                 if (array.Length > 1)
                 {
                     var text3 = array[2];
-                    if (text2.EndsWith(".resources", StringComparison.CurrentCultureIgnoreCase) && !text3.EndsWith("neutral", StringComparison.CurrentCultureIgnoreCase))
+                    if (ass.EndsWith(".resources", StringComparison.CurrentCultureIgnoreCase) && !text3.EndsWith("neutral", StringComparison.CurrentCultureIgnoreCase))
                     {
-                        text2 = text2.Substring(0, text2.Length - ".resources".Length);
+                        ass = ass.Substring(0, ass.Length - ".resources".Length);
                     }
-                    text = SearchAssemblyFileInTempFolder(text2);
-                    if (File.Exists(text))
+                    filePath = SearchAssemblyFileInTempFolder(ass);
+                    if (File.Exists(filePath))
                     {
-                        return LoadAddin(text);
+                        return LoadAddin(filePath);
                     }
-                    text = SearchAssemblyFileInOriginalFolders(text2);
+                    filePath = SearchAssemblyFileInOriginalFolders(ass);
                 }
             }
-            if (string.IsNullOrEmpty(text))
+            if (string.IsNullOrEmpty(filePath))
             {
                 var loader = new AssemblyLoader(args.Name);
                 loader.WindowStartupLocation = WindowStartupLocation.CenterScreen;
                 if (loader.ShowDialog() != true)
                 {
                     return null;
                 }
-                text = loader.resultPath;
+                filePath = loader.resultPath;
             }
-            result = CopyAndLoadAddin(text, true);
+            result = CopyAndLoadAddin(filePath, true);
         }
 
         return result;
@@ -186,16 +186,16 @@ private string SearchAssemblyFileInTempFolder(string assemName)
         try
         {
             var array = new string[] { ".dll", ".exe" };
-            var text = string.Empty;
+            var filePath = string.Empty;
             if(string.IsNullOrEmpty(assemName)) return String.Empty;
             var str = assemName.Substring(0, assemName.IndexOf(','));
             foreach (var str2 in array)
             {
-                text = tempFolder + "\\" + str + str2;
+                filePath = tempFolder + "\\" + str + str2;
 
-                if (File.Exists(text))
+                if (File.Exists(filePath))
                 {
-                    return text;
+                    return filePath;
                 }
             }
         }
@@ -208,29 +208,29 @@ private string SearchAssemblyFileInTempFolder(string assemName)
 
     private string SearchAssemblyFileInOriginalFolders(string assemName)
     {
-        var array = new string[]
+        var extensions = new string[]
         {
             ".dll",
             ".exe"
         };
-        string text;
-        var text2 = assemName.Substring(0, assemName.IndexOf(','));
-        foreach (var str in array)
+        string filePath;
+        var ass = assemName.Substring(0, assemName.IndexOf(','));
+        foreach (var str in extensions)
         {
-            text = dotnetDir + "\\" + text2 + str;
-            if (File.Exists(text))
+            filePath = dotnetDir + "\\" + ass + str;
+            if (File.Exists(filePath))
             {
-                return text;
+                return filePath;
             }
         }
-        foreach (var str2 in array)
+        foreach (var ex in extensions)
         {
-            foreach (var str3 in refedFolders)
+            foreach (var folder in refedFolders)
             {
-                text = str3 + "\\" + text2 + str2;
-                if (File.Exists(text))
+                filePath = folder + "\\" + ass + ex;
+                if (File.Exists(filePath))
                 {
-                    return text;
+                    return filePath;
                 }
             }
         }
@@ -240,11 +240,11 @@ private string SearchAssemblyFileInOriginalFolders(string assemName)
             var path = directoryInfo.Parent?.FullName + "\\Regression\\_RegressionTools\\";
             if (Directory.Exists(path))
             {
-                foreach (var text3 in Directory.GetFiles(path, "*.*", SearchOption.AllDirectories))
+                foreach (var fileName in Directory.GetFiles(path, "*.*", SearchOption.AllDirectories))
                 {
-                    if (Path.GetFileNameWithoutExtension(text3).Equals(text2, StringComparison.OrdinalIgnoreCase))
+                    if (Path.GetFileNameWithoutExtension(fileName).Equals(ass, StringComparison.OrdinalIgnoreCase))
                     {
-                        return text3;
+                        return fileName;
                     }
                 }
             }
diff --git a/AddInManager/Model/FileUtils.cs b/AddInManager/Model/FileUtils.cs
@@ -111,14 +111,14 @@ public static string CopyFileToFolder(string sourceFilePath, string destFolder,
             var fileNameWithoutExtension = Path.GetFileNameWithoutExtension(sourceFilePath);
             var searchPattern = fileNameWithoutExtension + ".*";
             var files = Directory.GetFiles(directoryName, searchPattern, SearchOption.TopDirectoryOnly);
-            foreach (var text in files)
+            foreach (var srcFileName in files)
             {
-                var fileName = Path.GetFileName(text);
-                var text2 = Path.Combine(destFolder, fileName);
-                var flag = CopyFile(text, text2);
+                var fileName = Path.GetFileName(srcFileName);
+                var desFileName = Path.Combine(destFolder, fileName);
+                var flag = CopyFile(srcFileName, desFileName);
                 if (flag)
                 {
-                    var item = new FileInfo(text2);
+                    var item = new FileInfo(desFileName);
                     allCopiedFiles.Add(item);
                 }
             }
@@ -222,18 +222,18 @@ public static void CopyDirectory(string sourceDir, string desDir, List<FileInfo>
     public static long GetFolderSize(string folderPath)
     {
         var directoryInfo = new DirectoryInfo(folderPath);
-        var num = 0L;
+        var folderSize = 0L;
         foreach (var fileSystemInfo in directoryInfo.GetFileSystemInfos())
         {
             if (fileSystemInfo is FileInfo)
             {
-                num += ((FileInfo)fileSystemInfo).Length;
+                folderSize += ((FileInfo)fileSystemInfo).Length;
             }
             else
             {
-                num += GetFolderSize(fileSystemInfo.FullName);
+                folderSize += GetFolderSize(fileSystemInfo.FullName);
             }
         }
-        return num / 1024L / 1024L;
+        return folderSize / 1024L / 1024L;
     }
 }
diff --git a/AddInManager/ViewModel/AddinManager.cs b/AddInManager/ViewModel/AddinManager.cs
@@ -61,15 +61,15 @@ public AddinType LoadAddin(string filePath, AssemLoader assemLoader)
         {
             return addinType;
         }
-        List<AddinItem> list = null;
-        List<AddinItem> list2 = null;
+        List<AddinItem> commandItems = null;
+        List<AddinItem> appItems = null;
         try
         {
             assemLoader.HookAssemblyResolve();
 
             var assembly = assemLoader.LoadAddinsToTempFolder(filePath, true);
-            list = commands.LoadItems(assembly, StaticUtil.CommandFullName, filePath, AddinType.Command);
-            list2 = applications.LoadItems(assembly, StaticUtil.AppFullName, filePath, AddinType.Application);
+            commandItems = commands.LoadItems(assembly, StaticUtil.CommandFullName, filePath, AddinType.Command);
+            appItems = applications.LoadItems(assembly, StaticUtil.AppFullName, filePath, AddinType.Application);
         }
         catch (Exception e)
         {
@@ -79,15 +79,15 @@ public AddinType LoadAddin(string filePath, AssemLoader assemLoader)
         {
             assemLoader.UnhookAssemblyResolve();
         }
-        if (list != null && list.Count > 0)
+        if (commandItems != null && commandItems.Count > 0)
         {
-            var addin = new Addin(filePath, list);
+            var addin = new Addin(filePath, commandItems);
             commands.AddAddIn(addin);
             addinType |= AddinType.Command;
         }
-        if (list2 != null && list2.Count > 0)
+        if (appItems != null && appItems.Count > 0)
         {
-            var addin2 = new Addin(filePath, list2);
+            var addin2 = new Addin(filePath, appItems);
             applications.AddAddIn(addin2);
             addinType |= AddinType.Application;
         }
@@ -294,16 +294,16 @@ private void SaveToLocalManifest()
 
     private string GetProperFilePath(string folder, string fileNameWithoutExt, string ext)
     {
-        string text;
+        string filePath;
         var num = -1;
         do
         {
             num++;
             var path = num <= 0 ? fileNameWithoutExt + ext : fileNameWithoutExt + num + ext;
-            text = Path.Combine(folder, path);
+            filePath = Path.Combine(folder, path);
         }
-        while (File.Exists(text));
-        return text;
+        while (File.Exists(filePath));
+        return filePath;
     }
 
     private readonly AddinsApplication applications;

Original file line number	Diff line number	Diff line change
`@@ -93,7 +93,7 @@ public Assembly LoadAddinsToTempFolder(string originalFilePath, bool parsingOnly`
`93`	`93`
`94`	`94`	`private Assembly CopyAndLoadAddin(string srcFilePath, bool onlyCopyRelated)`
`95`	`95`	`{`
`96`		`- var text = string.Empty;`
	`96`	`+ var filePath = string.Empty;`
`97`	`97`	`if (!FileUtils.FileExistsInFolder(srcFilePath, tempFolder))`
`98`	`98`	`{`
`99`	`99`	`var directoryName = Path.GetDirectoryName(srcFilePath);`
`@@ -102,8 +102,8 @@ private Assembly CopyAndLoadAddin(string srcFilePath, bool onlyCopyRelated)`
`102`	`102`	`refedFolders.Add(directoryName);`
`103`	`103`	`}`
`104`	`104`	`var list = new List<FileInfo>();`
`105`		`- text = FileUtils.CopyFileToFolder(srcFilePath, tempFolder, onlyCopyRelated, list);`
`106`		`- if (string.IsNullOrEmpty(text))`
	`105`	`+ filePath = FileUtils.CopyFileToFolder(srcFilePath, tempFolder, onlyCopyRelated, list);`
	`106`	`+ if (string.IsNullOrEmpty(filePath))`
`107`	`107`	`{`
`108`	`108`	`return null;`
`109`	`109`	`}`
`@@ -112,7 +112,7 @@ private Assembly CopyAndLoadAddin(string srcFilePath, bool onlyCopyRelated)`
`112`	`112`	`copiedFiles.Add(fileInfo.FullName, fileInfo.LastWriteTime);`
`113`	`113`	`}`
`114`	`114`	`}`
`115`		`- return LoadAddin(text);`
	`115`	`+ return LoadAddin(filePath);`
`116`	`116`	`}`
`117`	`117`
`118`	`118`	`private Assembly LoadAddin(string filePath)`
`@@ -135,47 +135,47 @@ private Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs a`
`135`	`135`	`{`
`136`	`136`	`Assembly result;`
`137`	`137`	`new AssemblyName(args.Name);`
`138`		`- var text = SearchAssemblyFileInTempFolder(args.Name);`
`139`		`- if (File.Exists(text))`
	`138`	`+ var filePath = SearchAssemblyFileInTempFolder(args.Name);`
	`139`	`+ if (File.Exists(filePath))`
`140`	`140`	`{`
`141`		`- result = LoadAddin(text);`
	`141`	`+ result = LoadAddin(filePath);`
`142`	`142`	`}`
`143`	`143`	`else`
`144`	`144`	`{`
`145`		`- text = SearchAssemblyFileInOriginalFolders(args.Name);`
`146`		`- if (string.IsNullOrEmpty(text))`
	`145`	`+ filePath = SearchAssemblyFileInOriginalFolders(args.Name);`
	`146`	`+ if (string.IsNullOrEmpty(filePath))`
`147`	`147`	`{`
`148`	`148`	`var array = args.Name.Split(new char[]`
`149`	`149`	`{`
`150`	`150`	`','`
`151`	`151`	`});`
`152`		`- var text2 = array[0];`
	`152`	`+ var ass = array[0];`
`153`	`153`	`if (array.Length > 1)`
`154`	`154`	`{`
`155`	`155`	`var text3 = array[2];`
`156`		`- if (text2.EndsWith(".resources", StringComparison.CurrentCultureIgnoreCase) && !text3.EndsWith("neutral", StringComparison.CurrentCultureIgnoreCase))`
	`156`	`+ if (ass.EndsWith(".resources", StringComparison.CurrentCultureIgnoreCase) && !text3.EndsWith("neutral", StringComparison.CurrentCultureIgnoreCase))`
`157`	`157`	`{`
`158`		`- text2 = text2.Substring(0, text2.Length - ".resources".Length);`
	`158`	`+ ass = ass.Substring(0, ass.Length - ".resources".Length);`
`159`	`159`	`}`
`160`		`- text = SearchAssemblyFileInTempFolder(text2);`
`161`		`- if (File.Exists(text))`
	`160`	`+ filePath = SearchAssemblyFileInTempFolder(ass);`
	`161`	`+ if (File.Exists(filePath))`
`162`	`162`	`{`
`163`		`- return LoadAddin(text);`
	`163`	`+ return LoadAddin(filePath);`
`164`	`164`	`}`
`165`		`- text = SearchAssemblyFileInOriginalFolders(text2);`
	`165`	`+ filePath = SearchAssemblyFileInOriginalFolders(ass);`
`166`	`166`	`}`
`167`	`167`	`}`
`168`		`- if (string.IsNullOrEmpty(text))`
	`168`	`+ if (string.IsNullOrEmpty(filePath))`
`169`	`169`	`{`
`170`	`170`	`var loader = new AssemblyLoader(args.Name);`
`171`	`171`	`loader.WindowStartupLocation = WindowStartupLocation.CenterScreen;`
`172`	`172`	`if (loader.ShowDialog() != true)`
`173`	`173`	`{`
`174`	`174`	`return null;`
`175`	`175`	`}`
`176`		`- text = loader.resultPath;`
	`176`	`+ filePath = loader.resultPath;`
`177`	`177`	`}`
`178`		`- result = CopyAndLoadAddin(text, true);`
	`178`	`+ result = CopyAndLoadAddin(filePath, true);`
`179`	`179`	`}`
`180`	`180`
`181`	`181`	`return result;`
`@@ -186,16 +186,16 @@ private string SearchAssemblyFileInTempFolder(string assemName)`
`186`	`186`	`try`
`187`	`187`	`{`
`188`	`188`	`var array = new string[] { ".dll", ".exe" };`
`189`		`- var text = string.Empty;`
	`189`	`+ var filePath = string.Empty;`
`190`	`190`	`if(string.IsNullOrEmpty(assemName)) return String.Empty;`
`191`	`191`	`var str = assemName.Substring(0, assemName.IndexOf(','));`
`192`	`192`	`foreach (var str2 in array)`
`193`	`193`	`{`
`194`		`- text = tempFolder + "\\" + str + str2;`
	`194`	`+ filePath = tempFolder + "\\" + str + str2;`
`195`	`195`
`196`		`- if (File.Exists(text))`
	`196`	`+ if (File.Exists(filePath))`
`197`	`197`	`{`
`198`		`- return text;`
	`198`	`+ return filePath;`
`199`	`199`	`}`
`200`	`200`	`}`
`201`	`201`	`}`
`@@ -208,29 +208,29 @@ private string SearchAssemblyFileInTempFolder(string assemName)`
`208`	`208`
`209`	`209`	`private string SearchAssemblyFileInOriginalFolders(string assemName)`
`210`	`210`	`{`
`211`		`- var array = new string[]`
	`211`	`+ var extensions = new string[]`
`212`	`212`	`{`
`213`	`213`	`".dll",`
`214`	`214`	`".exe"`
`215`	`215`	`};`
`216`		`- string text;`
`217`		`- var text2 = assemName.Substring(0, assemName.IndexOf(','));`
`218`		`- foreach (var str in array)`
	`216`	`+ string filePath;`
	`217`	`+ var ass = assemName.Substring(0, assemName.IndexOf(','));`
	`218`	`+ foreach (var str in extensions)`
`219`	`219`	`{`
`220`		`- text = dotnetDir + "\\" + text2 + str;`
`221`		`- if (File.Exists(text))`
	`220`	`+ filePath = dotnetDir + "\\" + ass + str;`
	`221`	`+ if (File.Exists(filePath))`
`222`	`222`	`{`
`223`		`- return text;`
	`223`	`+ return filePath;`
`224`	`224`	`}`
`225`	`225`	`}`
`226`		`- foreach (var str2 in array)`
	`226`	`+ foreach (var ex in extensions)`
`227`	`227`	`{`
`228`		`- foreach (var str3 in refedFolders)`
	`228`	`+ foreach (var folder in refedFolders)`
`229`	`229`	`{`
`230`		`- text = str3 + "\\" + text2 + str2;`
`231`		`- if (File.Exists(text))`
	`230`	`+ filePath = folder + "\\" + ass + ex;`
	`231`	`+ if (File.Exists(filePath))`
`232`	`232`	`{`
`233`		`- return text;`
	`233`	`+ return filePath;`
`234`	`234`	`}`
`235`	`235`	`}`
`236`	`236`	`}`
`@@ -240,11 +240,11 @@ private string SearchAssemblyFileInOriginalFolders(string assemName)`
`240`	`240`	`var path = directoryInfo.Parent?.FullName + "\\Regression\\_RegressionTools\\";`
`241`	`241`	`if (Directory.Exists(path))`
`242`	`242`	`{`
`243`		`- foreach (var text3 in Directory.GetFiles(path, ".", SearchOption.AllDirectories))`
	`243`	`+ foreach (var fileName in Directory.GetFiles(path, ".", SearchOption.AllDirectories))`
`244`	`244`	`{`
`245`		`- if (Path.GetFileNameWithoutExtension(text3).Equals(text2, StringComparison.OrdinalIgnoreCase))`
	`245`	`+ if (Path.GetFileNameWithoutExtension(fileName).Equals(ass, StringComparison.OrdinalIgnoreCase))`
`246`	`246`	`{`
`247`		`- return text3;`
	`247`	`+ return fileName;`
`248`	`248`	`}`
`249`	`249`	`}`
`250`	`250`	`}`
Original file line number	Diff line number	Diff line change
`@@ -111,14 +111,14 @@ public static string CopyFileToFolder(string sourceFilePath, string destFolder,`
`111`	`111`	`var fileNameWithoutExtension = Path.GetFileNameWithoutExtension(sourceFilePath);`
`112`	`112`	`var searchPattern = fileNameWithoutExtension + ".*";`
`113`	`113`	`var files = Directory.GetFiles(directoryName, searchPattern, SearchOption.TopDirectoryOnly);`
`114`		`- foreach (var text in files)`
	`114`	`+ foreach (var srcFileName in files)`
`115`	`115`	`{`
`116`		`- var fileName = Path.GetFileName(text);`
`117`		`- var text2 = Path.Combine(destFolder, fileName);`
`118`		`- var flag = CopyFile(text, text2);`
	`116`	`+ var fileName = Path.GetFileName(srcFileName);`
	`117`	`+ var desFileName = Path.Combine(destFolder, fileName);`
	`118`	`+ var flag = CopyFile(srcFileName, desFileName);`
`119`	`119`	`if (flag)`
`120`	`120`	`{`
`121`		`- var item = new FileInfo(text2);`
	`121`	`+ var item = new FileInfo(desFileName);`
`122`	`122`	`allCopiedFiles.Add(item);`
`123`	`123`	`}`
`124`	`124`	`}`
`@@ -222,18 +222,18 @@ public static void CopyDirectory(string sourceDir, string desDir, List<FileInfo>`
`222`	`222`	`public static long GetFolderSize(string folderPath)`
`223`	`223`	`{`
`224`	`224`	`var directoryInfo = new DirectoryInfo(folderPath);`
`225`		`- var num = 0L;`
	`225`	`+ var folderSize = 0L;`
`226`	`226`	`foreach (var fileSystemInfo in directoryInfo.GetFileSystemInfos())`
`227`	`227`	`{`
`228`	`228`	`if (fileSystemInfo is FileInfo)`
`229`	`229`	`{`
`230`		`- num += ((FileInfo)fileSystemInfo).Length;`
	`230`	`+ folderSize += ((FileInfo)fileSystemInfo).Length;`
`231`	`231`	`}`
`232`	`232`	`else`
`233`	`233`	`{`
`234`		`- num += GetFolderSize(fileSystemInfo.FullName);`
	`234`	`+ folderSize += GetFolderSize(fileSystemInfo.FullName);`
`235`	`235`	`}`
`236`	`236`	`}`
`237`		`- return num / 1024L / 1024L;`
	`237`	`+ return folderSize / 1024L / 1024L;`
`238`	`238`	`}`
`239`	`239`	`}`
Original file line number	Diff line number	Diff line change
`@@ -61,15 +61,15 @@ public AddinType LoadAddin(string filePath, AssemLoader assemLoader)`
`61`	`61`	`{`
`62`	`62`	`return addinType;`
`63`	`63`	`}`
`64`		`- List<AddinItem> list = null;`
`65`		`- List<AddinItem> list2 = null;`
	`64`	`+ List<AddinItem> commandItems = null;`
	`65`	`+ List<AddinItem> appItems = null;`
`66`	`66`	`try`
`67`	`67`	`{`
`68`	`68`	`assemLoader.HookAssemblyResolve();`
`69`	`69`
`70`	`70`	`var assembly = assemLoader.LoadAddinsToTempFolder(filePath, true);`
`71`		`- list = commands.LoadItems(assembly, StaticUtil.CommandFullName, filePath, AddinType.Command);`
`72`		`- list2 = applications.LoadItems(assembly, StaticUtil.AppFullName, filePath, AddinType.Application);`
	`71`	`+ commandItems = commands.LoadItems(assembly, StaticUtil.CommandFullName, filePath, AddinType.Command);`
	`72`	`+ appItems = applications.LoadItems(assembly, StaticUtil.AppFullName, filePath, AddinType.Application);`
`73`	`73`	`}`
`74`	`74`	`catch (Exception e)`
`75`	`75`	`{`
`@@ -79,15 +79,15 @@ public AddinType LoadAddin(string filePath, AssemLoader assemLoader)`
`79`	`79`	`{`
`80`	`80`	`assemLoader.UnhookAssemblyResolve();`
`81`	`81`	`}`
`82`		`- if (list != null && list.Count > 0)`
	`82`	`+ if (commandItems != null && commandItems.Count > 0)`
`83`	`83`	`{`
`84`		`- var addin = new Addin(filePath, list);`
	`84`	`+ var addin = new Addin(filePath, commandItems);`
`85`	`85`	`commands.AddAddIn(addin);`
`86`	`86`	`addinType \|= AddinType.Command;`
`87`	`87`	`}`
`88`		`- if (list2 != null && list2.Count > 0)`
	`88`	`+ if (appItems != null && appItems.Count > 0)`
`89`	`89`	`{`
`90`		`- var addin2 = new Addin(filePath, list2);`
	`90`	`+ var addin2 = new Addin(filePath, appItems);`
`91`	`91`	`applications.AddAddIn(addin2);`
`92`	`92`	`addinType \|= AddinType.Application;`
`93`	`93`	`}`
`@@ -294,16 +294,16 @@ private void SaveToLocalManifest()`
`294`	`294`
`295`	`295`	`private string GetProperFilePath(string folder, string fileNameWithoutExt, string ext)`
`296`	`296`	`{`
`297`		`- string text;`
	`297`	`+ string filePath;`
`298`	`298`	`var num = -1;`
`299`	`299`	`do`
`300`	`300`	`{`
`301`	`301`	`num++;`
`302`	`302`	`var path = num <= 0 ? fileNameWithoutExt + ext : fileNameWithoutExt + num + ext;`
`303`		`- text = Path.Combine(folder, path);`
	`303`	`+ filePath = Path.Combine(folder, path);`
`304`	`304`	`}`
`305`		`- while (File.Exists(text));`
`306`		`- return text;`
	`305`	`+ while (File.Exists(filePath));`
	`306`	`+ return filePath;`
`307`	`307`	`}`
`308`	`308`
`309`	`309`	`private readonly AddinsApplication applications;`