private void ConvertPropertiesToMethods(IProperty[] properties)
        {
            foreach (IProperty property in properties)
            {
                bool hasGetter = false, hasSetter = false;
                string getterName = "", setterName = "";

                if (property.IsReadable)
                {
                    hasGetter = true;
                    getterName = "get" + property.ShortName;
                }

                if (property.IsWritable)
                {
                    hasSetter = true;
                    setterName = "set" + property.ShortName;
                }

                //overrided проперти могут висеть в воздухе если их уже от рефакторили через базовый класс (?)
                if (!property.IsReadable && !property.IsWritable)
                    continue;

                PropertyToFunctionRefactoring refactoring = 
                    new PropertyToFunctionRefactoring(property, getterName, setterName,
                        hasGetter, hasSetter, NullProgressIndicator.INSTANCE);

                refactoring.Execute();
            }
        }

            // Ensure changes in documents are processed by code analyser
            mPsiManager.CommitAllDocuments();
            // Wait until all caches are built, abort action if user cancelled wait
            if (!mPsiManager.WaitForCaches())
                return;

            // Obtain write lock, so that no changes will occur while we are executing action
            using (WriteLockCookie.Create())
            {
                IProperty[] properties = GetAllProperties (mRootNamespace);//собираем все наши проперти

                //skip "using ModificationCookie = EnsureWritable()"... - может зря я их скипанул?

                // besides the failure above, it will also turn on UNDO functionality in VS
                using (CommandCookie.Create("ConvertPropertiesToMethods"))
                {
                    TransactionResult result = mPsiManager.DoTransaction(
                        delegate
                        {
                            //put real processing code here
                            ConvertPropertiesToMethods(properties );
                        });

                    // respond to transaction failure if any - сюда никогда не попадает, как я не пытался:)  
                    if (!result.Succeded)
                        MessageBox.Show("ConvertPropertiesToMethods failure: " + result.FailureDescription);
                }
            }

using (var pw= new ProgressWindow(true))
{
 bool canceled;

            var result = (ICollection<IOccurence>)
                         pw.ExecuteTask(
                           delegate(IProgressIndicator progress)
                             {
                               // do work, return result
                             },
                           title,
                           out canceled);
            if (!canceled)
              return result;
}

using (var progressWindow = new SyncProgressWindow())
{
  progressWindow.ExecuteTaskNonCancelable(delegate (IProgressIndicator progress) {...});
}

X>using (var progressWindow = new SyncProgressWindow())
X>{
X>  progressWindow.ExecuteTaskNonCancelable(delegate (IProgressIndicator progress) {...});
X>}
X>

    using (CommandLineTaskExecutor executor = new CommandLineTaskExecutor())
    {
        executor.ExecuteTaskNonCancelable(GetAllMembersTask, "GetAllMembersTask");
        executor.ExecuteTaskNonCancelable(ConvertPropertiesToMethodsTask, "ConvertPropertiesToMethodsTask");
    }

    SyncProgressWindow progressWindow = new SyncProgressWindow();
    progressWindow.Text = "My window title";
    progressWindow.ExecuteTaskNonCancelable(GetAllMembersTask, "Not used title");
    progressWindow.Dispose();
    progressWindow = new SyncProgressWindow();
    progressWindow.Text = "My window title";
    progressWindow.ExecuteTaskNonCancelable(ConvertPropertiesToMethodsTask, "Not used title");
    progressWindow.Dispose();

А>1. Как бы я не запускал прогресс — через окно, или через консоль — при любом раскладе по окончании процесса студия открывает (а решарпер перепаршивает) все поправленные файлы. Можно эту фичу убрать каким-нибудь ключиком? На тестовом солюшене это работает терпимо... но с трудом себе представляю тысячу открытых файлов в студии, когда дело дойдет до реальных проектов

DocumentSettings.Instance.SaveDocumentsAfterModifications = true;

    /// <summary>
    /// Handles BatchAction action, see Actions.xml
    /// </summary>
    /// <remarks>
    /// The class contains Reshrper's plugin workflow logics: ActionHandler implementation,
    /// ReadLock- and Command- cookies, ProgressIndicator, etc.
    /// 
    /// Concrete refactoring logic placed in separate classes. 
    /// </remarks>
    [ActionHandler("Aspose.Porter.BatchAction")]
    public class BatchAction : IActionHandler
    {
        ///<summary>
        /// Updates action visual presentation. If presentation.Enabled is set to false, Execute
        /// will not be called.
        ///</summary>
        ///<param name="context">DataContext</param>
        ///<param name="presentation">presentation to update</param>
        ///<param name="nextUpdate">delegate to call</param>
        public bool Update(IDataContext context, ActionPresentation presentation, DelegateUpdate nextUpdate)
        {
            // check, that current context has solution opened
            return context.CheckAllNotNull(DataConstants.SOLUTION);
        }

        ///<summary>
        /// Executes action. Called after Update, that set ActionPresentation.Enabled to true.
        ///</summary>
        ///<param name="context">DataContext</param>
        ///<param name="nextExecute">delegate to call</param>
        public void Execute(IDataContext context, DelegateExecute nextExecute)
        {
            //Get solution and psi manager from context in which action is executed
            if (!CheckInit(context))
                return;

            // Ensure changes in documents are processed by code analyser
            mPsiManager.CommitAllDocuments();
            // Wait until all caches are built, abort action if user cancelled wait
            if (!mPsiManager.WaitForCaches())
                return;

            //Ensure VS doesn't open _all_ changed documents.
            //Note: when this option is on, user can't undo the Command even if we using CommandCookie.
            DocumentSettings.Instance.SaveDocumentsAfterModifications = true;

            // Obtain write lock, so that no changes will occur while we are executing action
            using (ReadLockCookie.Create())
            {
                //option with comand line progress window, not used now
//                using (CommandLineTaskExecutor executor = new CommandLineTaskExecutor())
//                {
//                    executor.ExecuteTaskNonCancelable(CollectMembersTask, "CollectMembersTask");
//                    executor.ExecuteTaskNonCancelable(ConvertPropertiesToMethodsTask, "ConvertPropertiesToMethodsTask");
//                    // etc.  
//                }

                //option with GUI progress window
                //contrary to comand line option we can't launch several tasks in one window
                using (SyncProgressWindow progressWindow = new SyncProgressWindow())
                    progressWindow.ExecuteTaskNonCancelable(CollectMembersTask, "Not used title");

                using (SyncProgressWindow progressWindow = new SyncProgressWindow())
                    progressWindow.ExecuteTaskNonCancelable(RenameMethodsTask, "Not used title");
                
                using (SyncProgressWindow progressWindow = new SyncProgressWindow())
                    progressWindow.ExecuteTaskNonCancelable(RenameConstantsTask, "Not used title");

                using (SyncProgressWindow progressWindow = new SyncProgressWindow())
                    progressWindow.ExecuteTaskNonCancelable(ConvertPropertiesToMethodsTask, "Not used title");

                using (SyncProgressWindow progressWindow = new SyncProgressWindow())
                    progressWindow.ExecuteTaskNonCancelable(ConvertEnumsTask, "Not used title");
            }

            //@todo remove debug - are we need this here?
            // Ensure changes in documents are processed by code analyser
            mPsiManager.CommitAllDocuments();

            //Return back VS's defaults.
            DocumentSettings.Instance.SaveDocumentsAfterModifications = false;

            //Write log to file
            using (StreamWriter writer = new StreamWriter(mLogFile))
                writer.Write(mLogMessage);

            //Display log file inside VS
            EditorManager editorManager = EditorManager.GetInstance(mSolution);
            editorManager.OpenProjectFile(mLogFile, true);
        }

        //TaskWithProgress.Invoke delegate
        //simple progress without percent calculations used
        private object CollectMembersTask(IProgressIndicator progress)
        {
            progress.TaskName = "0/5 Collecting all the members that should be changed:";
            progress.Start();

            mCollector = new MemberCollector(mSolution, mPsiManager, mRootNamespace);
            mCollector.CollectMembers();

            progress.Stop();
            return true;
        }

        //some tasks skipped...

        //TaskWithProgress.Invoke() delegate
        private object ConvertPropertiesToMethodsTask(IProgressIndicator progress)
        {
            progress.TaskName = "3/5 Converting Properties To Methods:";
            progress.Start(mProperties.Count);
            
            // besides the failure above, it will also turn on UNDO functionality in VS
            using (CommandCookie.Create("ConvertPropertiesToMethods"))
            {
                PropertiesConverter propertiesConverter = new PropertiesConverter();
                TransactionResult result =
                    mPsiManager.DoTransaction(propertiesConverter.Convert, mCollector.Properties, progress);

                // respond to transaction failure if any
                if (!result.Succeded)
                    MessageBox.Show("ConvertPropertiesToMethods failure: " + result.FailureDescription);
            }

            progress.Stop();
            return true;
        }

        /// <summary>
        /// Check Solution and PSI manager is available and language is C#.
        /// Initializes solution and psi manager fields.
        /// </summary>
        private bool CheckInit(IDataContext context)
        {
            mSolution = context.GetData(DataConstants.SOLUTION);
            mPsiManager = PsiManager.GetInstance(mSolution);
            PsiLanguageType languageType = context.GetData(DataConstants.PSI_LANGUAGE_TYPE);

            return mSolution != null &&
                   mPsiManager != null &&
                   languageType != null &&
                   languageType.Name == "CSHARP";
        }

        private ISolution mSolution;
        private PsiManager mPsiManager;
        private readonly string mRootNamespace = "";

        private MemberCollector mCollector;
       
        //some fields skipped
}

    /// <summary>
    /// Collecting all the members that should be changed.
    /// </summary>
    public class MemberCollector
    {
        public MemberCollector(ISolution solution, PsiManager psiManager, string rootNamespace)
        {
            mSolution = solution;
            mPsiManager = psiManager;
            mRootNamespace = rootNamespace;
        }

        public void CollectMembers()
        {
            //Get root namespace
            DeclarationsCacheScope solutionScope = DeclarationsCacheScope.SolutionScope(mSolution, false);
            IDeclarationsCache solutionCache = mPsiManager.GetDeclarationsCache(solutionScope, true);
            INamespace ns = solutionCache.GetNamespace(mRootNamespace);

            //Iterate all members, collect elements to be performed
            IterateNamespace(solutionCache, ns);
        }

        private void IterateNamespace(IDeclarationsCache declarationsCache, INamespace ns)
        {
            foreach (IDeclaredElement element in ns.GetNestedElements(declarationsCache))
            {
                if (element is INamespace)
                {
                    INamespace nameSpace = (INamespace)element;
                    //recursive call
                    IterateNamespace(declarationsCache, nameSpace);
                }
                else if (element is ITypeElement)
                {
                    IterateElement(element);
                }
            }
        }

        private void IterateElement(IDeclaredElement element)
        {
            if (element is ITypeElement)
            {
                ITypeElement type = (ITypeElement)element;
                foreach (ITypeMember member in type.GetMembers())
                {
                    if (member is IField)
                    {
                        string newName = NameUtils.ChangeFieldName((IField)member);
                        if (member.ShortName != newName)
                            mFields.Add((IField)member, newName);
                    }
                    if (member is IMethod)
                    {
                        string newName = NameUtils.ChangeMethodName(member.ShortName);
                        if (member.ShortName != newName)
                            mMethods.Add((IMethod)member, newName);
                    }
                    if (member is IProperty)
                    {
                        mProperties.Add((IProperty)member);
                    }
                    //nested types
                    if (member is ITypeElement)
                    {
                        IterateElement(member);
                    }
                }
            }
        }

        public Collection<IProperty> Properties
        {
            get { return mProperties; }
        }

        public Dictionary<IMethod, string> Methods
        {
            get { return mMethods; }
        }

        public Dictionary<IField, string> Fields
        {
            get { return mFields; }
        }

        private ISolution mSolution;
        private PsiManager mPsiManager;
        private readonly string mRootNamespace;

        /// <summary>
        /// Collections of members whose name should be changed:
        /// Dictionary<ITypeMember member, string newName>.
        /// </summary>
        private Dictionary<IField, string> mFields = new Dictionary<IField, string>();
        private Dictionary<IMethod, string> mMethods = new Dictionary<IMethod, string>();
        private Collection<IProperty> mProperties = new Collection<IProperty>();
    }

       /// <summary>
        /// Converts all properties in given table to methods.
        /// </summary>
        /// <remarks>
        /// JetBrains.ReSharper.Psi.TransactionHandler.Invoke() delegate. Should be used inside 
        /// transaction and wrapped by Read and Command cookies - <see cref="BatchPortingAction.ConvertPropertiesToMethodsTask"/>.
        /// </remarks>
        public void Convert(object[] args)
        {
            //(IProperty[] properties, IProgressIndicator progress)
            Debug.Assert(args[0] is IProperty[]);
            IProperty[] properties = (IProperty[])args[0];
            Debug.Assert(args[1] is IProgressIndicator);
            IProgressIndicator progress = (IProgressIndicator)args[0];

            foreach (IProperty property in properties)
            {
                //PropertyToFunctionRefactoring converts overridden properties without
                //questions so some of them can be already converted from base type
                if (!property.IsReadable && !property.IsWritable)
                {
                    progress.Advance(1);
                    continue;
                }

                progress.CurrentItemText = property.GetContainingType().CLRName + "." + property.ShortName;
                //do the thing
                ConvertPropertyToMethod(property);

                progress.Advance(1);
            }
        }

        private void ConvertPropertyToMethod(IProperty property)
        {
            //@todo 1 sk check for namesake indexer signatures
            //@todo 1 sk correct boolean prefixes
            //@todo 1 sk check for name conflicts when new getter/setter gets the same name as existing method

            bool hasGetter = false, hasSetter = false;
            string getterName = "", setterName = "";

            if (property.IsReadable)
            {
                hasGetter = true;
                getterName = "get" + property.ShortName;
            }

            if (property.IsWritable)
            {
                hasSetter = true;
                setterName = "set" + property.ShortName;
            }

            //@todo remove debug
            string debugStr = string.Format("property {0}.{1} changed to getter/setter: {2}/{3}{4}",
                                            property.GetContainingType().CLRName, property.ShortName, getterName, setterName, CR);

            PropertyToFunctionRefactoring refactoring =
                new PropertyToFunctionRefactoring(property, getterName, setterName,
                                                  hasGetter, hasSetter, NullProgressIndicator.INSTANCE);

            refactoring.Execute();
        }

    }

//option with GUI progress window
//contrary to comand line option we can't launch several tasks in one window
using (SyncProgressWindow progressWindow = new SyncProgressWindow())
    progressWindow.ExecuteTaskNonCancelable(Execute, "Not used title");
        
private object Execute(IProgressIndicator progress)
{
    try
    {
        progress.Start(5);
        
        using (SubProgressIndicator i = new SubProgressIndicator(progress, 1.0))
            CollectMembersTask(i);
        
        using (SubProgressIndicator i = new SubProgressIndicator(progress, 1.0))
            RenameMethodsTask(i);
        
        using (SubProgressIndicator i = new SubProgressIndicator(progress, 1.0))
            RenameConstantsTask(i);
        
        using (SubProgressIndicator i = new SubProgressIndicator(progress, 1.0))
            ConvertPropertiesToMethodsTask(i);
        
        using (SubProgressIndicator i = new SubProgressIndicator(progress, 1.0))
            ConvertEnumsTask(i);
        
        return null;
    }
    finally
    {
        progress.Stop();
    }
}