public ProjectItemIterator(EnvDTE.Solution solution)
        {
            if (solution == null)
            {
                throw new ArgumentNullException("solution");
            }

            projects = TryHelper.Run <IEnumerable <EnvDTE.Project> >(() => solution.Projects.Cast <EnvDTE.Project>());
        }
 public IEnumerator <EnvDTE.ProjectItem> GetEnumerator()
 {
     foreach (EnvDTE.Project currentProject in TryHelper.Run <EnvDTE.Project[]>(() => this.projects.ToArray()))
     {
         foreach (var currentProjectItem in Enumerate(TryHelper.Run <EnvDTE.ProjectItems>(() => currentProject.ProjectItems)))
         {
             yield return(currentProjectItem);
         }
     }
 }
        private IEnumerable <EnvDTE.ProjectItem> GetProjectItems(EnvDTE.ProjectItems projectItems)
        {
            List <EnvDTE.ProjectItem> result = new List <EnvDTE.ProjectItem>();

            int itemCount = TryHelper.Run(() => projectItems.Count);

            for (int i = 0; i < itemCount; i++)
            {
                result.Add(TryHelper.Run(() => projectItems.Item(i + 1)));
            }

            return(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);
        }
        private IEnumerable <EnvDTE.ProjectItem> Enumerate(EnvDTE.ProjectItems projectItems)
        {
            foreach (EnvDTE.ProjectItem item in GetProjectItems(projectItems))
            {
                yield return(item);

                if (item.SubProject != null)
                {
                    foreach (EnvDTE.ProjectItem childItem in Enumerate(TryHelper.Run <EnvDTE.ProjectItems>(() => item.SubProject.ProjectItems)))
                    {
                        yield return(childItem);
                    }
                }
                else
                {
                    foreach (EnvDTE.ProjectItem childItem in Enumerate(TryHelper.Run <EnvDTE.ProjectItems>(() => item.ProjectItems)))
                    {
                        yield return(childItem);
                    }
                }
            }
        }
        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());
            }
        }