public ICommonAssembly Create(string assemblyPath)
        {
            using (CurrentDirectoryService.From(Path.GetDirectoryName(Path.GetFullPath(assemblyPath)))) {
                var assemblyName = Path.GetFileName(assemblyPath);

                var symbolStorePath = Path.ChangeExtension(assemblyName, "pdb");
                var haveSymbolStore = File.Exists(symbolStorePath);

                var foundAssemblyFiles = Directory.GetFiles(Directory.GetCurrentDirectory())
                                         .Select(filePath => new { Path = filePath, Extension = Path.GetExtension(filePath) })
                                         .Where(file =>
                                                string.Equals(file.Extension, ".exe", StringComparison.InvariantCultureIgnoreCase) ||
                                                string.Equals(file.Extension, ".dll", StringComparison.InvariantCultureIgnoreCase))
                                         .GroupBy(file => Path.GetFileNameWithoutExtension(file.Path))
                                         .ToDictionary(group => group.Key, group => group.Single().Path);

                var mainReflectionAssembly         = ReadMainReflectionAssembly(assemblyName, symbolStorePath, haveSymbolStore);
                var referencedReflectionAssemblies = ReadReferencedReflectionAssemblies(mainReflectionAssembly, foundAssemblyFiles);

                referencedReflectionAssemblies
                .Select(assembly => new { assembly.GetName().Name, assembly.CodeBase })
                .Where(assembly => !foundAssemblyFiles.ContainsKey(assembly.Name))
                .ForEach(assembly => foundAssemblyFiles[assembly.Name] = assembly.CodeBase.Substring(CodeBasePrefix.Length));

                var mainMonoCecilAssembly         = ReadMainMonoCecilAssembly(assemblyName, haveSymbolStore);
                var referencedMonoCecilAssemblies = ReadReferencedMonoCecilAssemblies(mainMonoCecilAssembly, foundAssemblyFiles);

                return(new CommonAssembly(mainMonoCecilAssembly, referencedMonoCecilAssemblies, mainReflectionAssembly, referencedReflectionAssemblies, haveSymbolStore));
            }
        }
        public void PatchSelfApplication()
        {
            log.Info("Patching all mono cecil applications...");

            using (CurrentDirectoryService.FromExecutingAssembly()) {
                var monoCecilApplicationResultNames = ShiftMonoCecilApplications(applicationPatcherSelfConfiguration.MonoCecilApplicationFileNames, applicationPatcherSelfConfiguration.MonoCecilResultDirectoryName, false);

                foreach (var monoCecilResultApplicationName in monoCecilApplicationResultNames)
                {
                    log.Info($"Patching '{monoCecilResultApplicationName}' application...");
                    PatchApplication(applicationPatcherCore, monoCecilResultApplicationName, applicationPatcherSelfConfiguration.MonoCecilSignatureFileName);
                    log.Info($"Application '{monoCecilResultApplicationName}' was patched");
                }

                log.Info("All mono cecil applications was patched");

                foreach (var monoCecilOutputDirectory in applicationPatcherSelfConfiguration.MonoCecilOutputDirectories)
                {
                    ShiftMonoCecilApplications(monoCecilApplicationResultNames, monoCecilOutputDirectory, true);
                }
            }
        }