private static void Main(string[] args)
        {
            ClearFilesArgs result = GetParameters(args);

            if (result != null)
            {
                CodeMaidCleaner cleaner = new CodeMaidCleaner();
                cleaner.ClearFiles(result);
            }
        }
        private EnvDTE.Solution GetSolution(ClearFilesArgs clearFilesArgs)
        {
            EnvDTE.Solution soln = TryHelper.Run(() => System.Activator.CreateInstance(Type.GetTypeFromProgID(Settings.Default.VisualStudio))) as EnvDTE.Solution;

            TryHelper.Run(() => { soln.DTE.MainWindow.Visible = false; });

            if (!String.IsNullOrWhiteSpace(clearFilesArgs.ProyectFile))
            {
                TryHelper.Run(() => { soln.AddFromFile(clearFilesArgs.ProyectFile); });
            }
            else
            {
                soln.Open(clearFilesArgs.SoluctionFile);
            }

            return(soln);
        }
        public static ClearFilesArgs GetParameters(String[] args)
        {
            ClearFilesArgs result = new ClearFilesArgs();

            if (args.Length == 0)
            {
                Console.WriteLine(String.Format("{0}{1}{1}", SYNTAX, Environment.NewLine, Environment.NewLine));
                return(null);
            }

            for (int i = 0; i < args.Length; i++)
            {
                string parameter = args[i].ToLower();

                switch (parameter)
                {
                case "/?":
                case "/h":
                    Console.WriteLine(String.Format("{0}{1}{1}", SYNTAX, Environment.NewLine, Environment.NewLine));
                    return(null);

                case "/p":
                    result.ProyectFile = args[++i];
                    break;

                case "/s":
                    result.SoluctionFile = args[++i];
                    break;

                case "/f":
                    result.FilesFile = args[++i];
                    break;

                case "/mo":
                    result.MinimumOutput = true;
                    break;
                }
            }

            return(result);
        }
        public void ClearFiles(ClearFilesArgs clearFilesArgs)
        {
            try
            {
                TryHelper.Run(() => CleanUp());

                //If it throws exeption you may want to retry couple more times
                EnvDTE.Solution soln = GetSolution(clearFilesArgs);

                if (!String.IsNullOrWhiteSpace(clearFilesArgs.ProyectFile))
                {
                    if (!clearFilesArgs.MinimumOutput)
                    {
                        Console.WriteLine(String.Format("Limpiando '{0}'", Path.GetFileName(clearFilesArgs.ProyectFile)));
                    }
                }
                else if (!String.IsNullOrWhiteSpace(clearFilesArgs.SoluctionFile))
                {
                    if (!clearFilesArgs.MinimumOutput)
                    {
                        Console.WriteLine(String.Format("Limpiando '{0}'", Path.GetFileName(clearFilesArgs.SoluctionFile)));
                    }
                }

                if (String.IsNullOrWhiteSpace(clearFilesArgs.FilesFile))
                {
                    TryHelper.Run(() => soln.DTE.Commands.Raise(Settings.Default.GuidCodeMaidCommandCleanupAllCodeString, Settings.Default.CmdIDCodeMaidCleanupAllCode, null, null));
                }
                else
                {
                    ProjectItemIterator iterator = new ProjectItemIterator(soln);
                    String[]            files    = File.ReadAllLines(clearFilesArgs.FilesFile).Select(f => Path.GetFileName(f)).ToArray();

                    foreach (var addedItem in iterator)
                    {
                        string itemName = TryHelper.Run(() => addedItem.Name);

                        string kind = TryHelper.Run(() => addedItem.Kind);

                        if (kind == ProjectKinds.vsProjectKindSolutionFolder || kind == folderKindGUID)
                        {
                            continue;
                        }

                        if (files.Select(f => String.Compare(itemName, f, true) == 0).Count() == 0)
                        {
                            continue;
                        }

                        if (!clearFilesArgs.MinimumOutput)
                        {
                            Console.WriteLine(String.Format("\tLimpiando {0}...", itemName));
                        }

                        TryHelper.Run(() =>
                        {
                            // Console.WriteLine(nameFile);
                            addedItem.Open(Constants.vsViewKindCode);
                            addedItem.Document.Activate();

                            addedItem.Document.DTE.Commands.Raise(Settings.Default.GuidCodeMaidCommandCleanupActiveCodeString, Settings.Default.CmdIDCodeMaidCleanupActiveCode, null, null);

                            addedItem.Save();
                        });

                        if (clearFilesArgs.MinimumOutput)
                        {
                            Console.WriteLine(itemName);
                        }
                    }
                }

                TryHelper.Run(() => soln.Close());

                if (!String.IsNullOrWhiteSpace(clearFilesArgs.ProyectFile))
                {
                    if (!clearFilesArgs.MinimumOutput)
                    {
                        Console.WriteLine(String.Format("Finalizado limpieza '{0}'", Path.GetFileName(clearFilesArgs.ProyectFile)));
                    }
                }
                else if (!String.IsNullOrWhiteSpace(clearFilesArgs.SoluctionFile))
                {
                    if (!clearFilesArgs.MinimumOutput)
                    {
                        Console.WriteLine(String.Format("Finalizado limpieza '{0}'", Path.GetFileName(clearFilesArgs.SoluctionFile)));
                    }
                }
            }
            finally
            {
                TryHelper.Run(() => CleanUp());
            }
        }