private void UpdateRecursive(SolutionItem solutionItem)
 {
     try
     {
         if (!IsSolutionItemModified(solutionItem))
         {
             return;
         }
         if (solutionItem.IncrementSettings.UseGlobalSettings)
         {
             solutionItem.ApplyGlobalSettings();
         }
         if (ActiveConfigurationMatch(solutionItem))
         {
             if (solutionItem.IncrementSettings.AutoUpdateAssemblyVersion)
             {
                 Update(solutionItem, Constants.ATTRIBUTE_ASSEMBLY_VERSION);
             }
             if (solutionItem.IncrementSettings.AutoUpdateFileVersion)
             {
                 Update(solutionItem, Constants.ATTRIBUTE_ASSEMBLY_FILE_VERSION);
             }
         }
     }
     catch (Exception ex)
     {
         Logger.Write(ex.ToString(), LogLevel.Error);
     }
     foreach (var child in solutionItem.SubItems)
     {
         UpdateRecursive(child);
     }
 }
예제 #2
0
        private async System.Threading.Tasks.Task UpdateRecursiveAsync(SolutionItem solutionItem)
        {
            await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();

            try
            {
                if (!IsSolutionItemModified(solutionItem))
                {
                    return;
                }
                if (solutionItem.IncrementSettings.UseGlobalSettings)
                {
                    solutionItem.ApplyGlobalSettings();
                }
                if (ActiveConfigurationMatch(solutionItem))
                {
                    if (solutionItem.IncrementSettings.AutoUpdateAssemblyVersion)
                    {
                        await UpdateAsync(solutionItem, Constants.ATTRIBUTE_ASSEMBLY_VERSION);
                    }
                    if (solutionItem.IncrementSettings.AutoUpdateFileVersion)
                    {
                        await UpdateAsync(solutionItem, Constants.ATTRIBUTE_ASSEMBLY_FILE_VERSION);
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.Write(ex.ToString(), LogLevel.Error);
            }
            foreach (var child in solutionItem.SubItems)
            {
                await UpdateRecursiveAsync(child);
            }
        }
 private void UpdateRecursive(SolutionItem solutionItem)
 {
     try
     {
         if (!this.IsSolutionItemModified(solutionItem))
         {
             return;
         }
         if (solutionItem.IncrementSettings.UseGlobalSettings)
         {
             solutionItem.ApplyGlobalSettings();
         }
         if (this.ActiveConfigurationMatch(solutionItem))
         {
             if (solutionItem.IncrementSettings.AutoUpdateAssemblyVersion)
             {
                 this.Update(solutionItem, "AssemblyVersion");
             }
             if (solutionItem.IncrementSettings.AutoUpdateFileVersion)
             {
                 this.Update(solutionItem, "AssemblyFileVersion");
             }
         }
     }
     catch (Exception ex)
     {
         Logger.Write(ex.ToString(), LogLevel.Error);
     }
     foreach (SolutionItem current in solutionItem.SubItems)
     {
         this.UpdateRecursive(current);
     }
 }
예제 #4
0
        } // ExecuteIncrement

        /// <summary>
        /// Updates all build versions for the entire solution
        /// </summary>
        private void UpdateRecursive(SolutionItem solutionItem)
        {
            try
            {
                // Do not take any action if current solution item is
                // not modified - just do not waste time for unchanged projects
                if (!IsSolutionItemModified(solutionItem))
                {
                    return;
                }
                if (solutionItem.IncrementSettings.UseGlobalSettings)
                {
                    solutionItem.ApplyGlobalSettings();
                }
                if (ActiveConfigurationMatch(solutionItem))
                {
                    if (solutionItem.IncrementSettings.AutoUpdateAssemblyVersion)
                    {
                        Update(solutionItem, "AssemblyVersion");
                    }
                    if (solutionItem.IncrementSettings.AutoUpdateFileVersion)
                    {
                        Update(solutionItem, "AssemblyFileVersion");
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.Write(ex.ToString(), LogLevel.Error);
            }
            foreach (SolutionItem child in solutionItem.SubItems)
            {
                UpdateRecursive(child);
            }
        }
예제 #5
0
        private async System.Threading.Tasks.Task UpdateProjectAsync(SolutionItem solutionItem)
        {
            await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();

            if (GlobalIncrementSettings.ApplySettings == GlobalIncrementSettings.ApplyGlobalSettings.Always ||
                solutionItem.IncrementSettings.UseGlobalSettings)
            {
                solutionItem.ApplyGlobalSettings();
            }

            if (_updatedItems.ContainsKey(solutionItem.UniqueName))
            {
                return;
            }

            if (ActiveConfigurationMatch(solutionItem))
            {
                if (solutionItem.IncrementSettings.AutoUpdateAssemblyVersion)
                {
                    await UpdateAsync(solutionItem, Constants.ATTRIBUTE_ASSEMBLY_VERSION);
                }

                if (solutionItem.IncrementSettings.AutoUpdateFileVersion)
                {
                    await UpdateAsync(solutionItem, Constants.ATTRIBUTE_ASSEMBLY_FILE_VERSION);
                }
            }

            try
            {
                if (solutionItem.BuildDependency != null)
                {
                    var references = (object[])solutionItem.BuildDependency.RequiredProjects;

                    foreach (var dep in
                             references.Select(o => { ThreadHelper.ThrowIfNotOnUIThread(); return(SolutionItem.ConstructSolutionItem(_package, (Project)o, false)); })
                             .Where(dep => dep != null))
                    {
                        try
                        {
                            await UpdateProjectAsync(dep);
                        }
                        catch (Exception ex)
                        {
                            Logger.Write(
                                $"Exception occured while updating project dependency \"{dep.UniqueName}\" for \"{solutionItem.UniqueName}\".\n{ex.Message}",
                                LogLevel.Error);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.Write($"Failed updating dependencies for \"{solutionItem.UniqueName}\".\n{ex.Message}",
                             LogLevel.Error);
            }

            _updatedItems.Add(solutionItem.UniqueName, solutionItem);
        }
 private void UpdateProject(SolutionItem solutionItem)
 {
     if (GlobalIncrementSettings.ApplySettings == GlobalIncrementSettings.ApplyGlobalSettings.Always || solutionItem.IncrementSettings.UseGlobalSettings)
     {
         solutionItem.ApplyGlobalSettings();
     }
     if (!this._updatedItems.ContainsKey(solutionItem.UniqueName))
     {
         if (this.ActiveConfigurationMatch(solutionItem))
         {
             if (solutionItem.IncrementSettings.AutoUpdateAssemblyVersion)
             {
                 this.Update(solutionItem, "AssemblyVersion");
             }
             if (solutionItem.IncrementSettings.AutoUpdateFileVersion)
             {
                 this.Update(solutionItem, "AssemblyFileVersion");
             }
         }
         try
         {
             if (solutionItem.BuildDependency != null)
             {
                 object[] array  = (object[])solutionItem.BuildDependency.RequiredProjects;
                 object[] array2 = array;
                 for (int i = 0; i < array2.Length; i++)
                 {
                     object       obj           = array2[i];
                     SolutionItem solutionItem2 = SolutionItem.ConstructSolutionItem(this._connect, (Project)obj, false);
                     if (solutionItem2 != null)
                     {
                         try
                         {
                             this.UpdateProject(solutionItem2);
                         }
                         catch (Exception ex)
                         {
                             Logger.Write(string.Concat(new string[]
                             {
                                 "Exception occured while updating project dependency \"",
                                 solutionItem2.UniqueName,
                                 "\" for \"",
                                 solutionItem.UniqueName,
                                 "\".\n",
                                 ex.Message
                             }), LogLevel.Error);
                         }
                     }
                 }
             }
         }
         catch (Exception ex)
         {
             Logger.Write("Failed updating dependencies for \"" + solutionItem.UniqueName + "\".\n" + ex.Message, LogLevel.Error);
         }
         this._updatedItems.Add(solutionItem.UniqueName, solutionItem);
     }
 }
        private void UpdateProject(SolutionItem solutionItem)
        {
            if (GlobalIncrementSettings.ApplySettings == GlobalIncrementSettings.ApplyGlobalSettings.Always ||
                solutionItem.IncrementSettings.UseGlobalSettings)
            {
                solutionItem.ApplyGlobalSettings();
            }

            if (_updatedItems.ContainsKey(solutionItem.UniqueName))
            {
                return;
            }

            if (ActiveConfigurationMatch(solutionItem))
            {
                if (solutionItem.IncrementSettings.AutoUpdateAssemblyVersion)
                {
                    Update(solutionItem, Constants.ATTRIBUTE_ASSEMBLY_VERSION);
                }

                if (solutionItem.IncrementSettings.AutoUpdateFileVersion)
                {
                    Update(solutionItem, Constants.ATTRIBUTE_ASSEMBLY_FILE_VERSION);
                }
            }

            try
            {
                if (solutionItem.BuildDependency != null)
                {
                    var references = (object[])solutionItem.BuildDependency.RequiredProjects;

                    foreach (var dep in
                             references.Select(o => SolutionItem.ConstructSolutionItem(_package, (Project)o, false))
                             .Where(dep => dep != null))
                    {
                        try
                        {
                            UpdateProject(dep);
                        }
                        catch (Exception ex)
                        {
                            Logger.Write(
                                $"Exception occured while updating project dependency \"{dep.UniqueName}\" for \"{solutionItem.UniqueName}\".\n{ex.Message}",
                                LogLevel.Error);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.Write($"Failed updating dependencies for \"{solutionItem.UniqueName}\".\n{ex.Message}",
                             LogLevel.Error);
            }

            _updatedItems.Add(solutionItem.UniqueName, solutionItem);
        }
예제 #8
0
        /// <summary>
        /// Updates build version for the given project and it's dependencies.
        /// </summary>
        /// <param name="solutionItem">The solution item.</param>
        private void UpdateProject(SolutionItem solutionItem)
        {
            //if we should apply them, we will...I don't care if it is a solution or a project
            if (solutionItem.IncrementSettings.UseGlobalSettings)
            {
                solutionItem.ApplyGlobalSettings();
            }

            if (_updatedItems.ContainsKey(solutionItem.UniqueName))
            {
                return;
            }

            if (ActiveConfigurationMatch(solutionItem))
            {
                if (solutionItem.IncrementSettings.AutoUpdateAssemblyVersion)
                {
                    Update(solutionItem, "AssemblyVersion");
                }

                if (solutionItem.IncrementSettings.AutoUpdateFileVersion)
                {
                    Update(solutionItem, "AssemblyFileVersion");
                }
            }

            try
            {
                if (solutionItem.BuildDependency != null)
                {
                    object[] references = (object[])solutionItem.BuildDependency.RequiredProjects;

                    foreach (object o in references)
                    {
                        SolutionItem dep = SolutionItem.ConstructSolutionItem(_connect, (Project)o, false);

                        if (dep != null)
                        {
                            try
                            {
                                UpdateProject(dep);
                            }
                            catch (Exception ex)
                            {
                                Logger.Write("Exception occured while updating project dependency \"" + dep.UniqueName + "\" for \"" + solutionItem.UniqueName + "\".\n" + ex.Message, LogLevel.Error);
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.Write("Failed updating dependencies for \"" + solutionItem.UniqueName + "\".\n" + ex.Message, LogLevel.Error);
            }

            _updatedItems.Add(solutionItem.UniqueName, solutionItem);
        }
 private void UpdateRecursive(SolutionItem solutionItem)
 {
     try
     {
         if (!this.IsSolutionItemModified(solutionItem))
         {
             return;
         }
         if (solutionItem.IncrementSettings.UseGlobalSettings)
         {
             solutionItem.ApplyGlobalSettings();
         }
         if (this.ActiveConfigurationMatch(solutionItem))
         {
             if (solutionItem.IncrementSettings.AutoUpdateAssemblyVersion)
             {
                 this.Update(solutionItem, "AssemblyVersion");
             }
             if (solutionItem.IncrementSettings.AutoUpdateFileVersion)
             {
                 this.Update(solutionItem, "AssemblyFileVersion");
             }
         }
     }
     catch (Exception ex)
     {
         Logger.Write(ex.ToString(), LogLevel.Error);
     }
     foreach (SolutionItem current in solutionItem.SubItems)
     {
         this.UpdateRecursive(current);
     }
 }
 private void UpdateProject(SolutionItem solutionItem)
 {
     if (GlobalIncrementSettings.ApplySettings == GlobalIncrementSettings.ApplyGlobalSettings.Always || solutionItem.IncrementSettings.UseGlobalSettings)
     {
         solutionItem.ApplyGlobalSettings();
     }
     if (!this._updatedItems.ContainsKey(solutionItem.UniqueName))
     {
         if (this.ActiveConfigurationMatch(solutionItem))
         {
             if (solutionItem.IncrementSettings.AutoUpdateAssemblyVersion)
             {
                 this.Update(solutionItem, "AssemblyVersion");
             }
             if (solutionItem.IncrementSettings.AutoUpdateFileVersion)
             {
                 this.Update(solutionItem, "AssemblyFileVersion");
             }
         }
         try
         {
             if (solutionItem.BuildDependency != null)
             {
                 object[] array = (object[])solutionItem.BuildDependency.RequiredProjects;
                 object[] array2 = array;
                 for (int i = 0; i < array2.Length; i++)
                 {
                     object obj = array2[i];
                     SolutionItem solutionItem2 = SolutionItem.ConstructSolutionItem(this._connect, (Project)obj, false);
                     if (solutionItem2 != null)
                     {
                         try
                         {
                             this.UpdateProject(solutionItem2);
                         }
                         catch (Exception ex)
                         {
                             Logger.Write(string.Concat(new string[]
                             {
                                 "Exception occured while updating project dependency \"",
                                 solutionItem2.UniqueName,
                                 "\" for \"",
                                 solutionItem.UniqueName,
                                 "\".\n",
                                 ex.Message
                             }), LogLevel.Error);
                         }
                     }
                 }
             }
         }
         catch (Exception ex)
         {
             Logger.Write("Failed updating dependencies for \"" + solutionItem.UniqueName + "\".\n" + ex.Message, LogLevel.Error);
         }
         this._updatedItems.Add(solutionItem.UniqueName, solutionItem);
     }
 }