/// <summary>
 /// Initializes a new instance of the StyleCopThreadCompletedEventArgs class.
 /// </summary>
 /// <param name="data">The thread data.</param>
 public StyleCopThreadCompletedEventArgs(StyleCopThread.Data data)
 {
     Param.AssertNotNull(data, "data");
     this.data = data;
 }
        /// <summary>
        /// Launches the worker threads and waits for them to complete.
        /// </summary>
        /// <param name="data">The threading data.</param>
        /// <param name="count">The number of threads to create.</param>
        /// <returns>Returns a value indicating whether analysis of all
        /// files has been completed. If this returns false, another round
        /// of analysis must be performed.</returns>
        private bool RunWorkerThreads(StyleCopThread.Data data, int count)
        {
            Param.AssertNotNull(data, "data");
            Param.AssertGreaterThanZero(count, "count");

            // Indicates whether total sanalysis of all files has been completed.
            bool complete = true;

            // Create the worker and thread class arrays.
            BackgroundWorker[] workers = new BackgroundWorker[count];
            StyleCopThread[] threadClasses = new StyleCopThread[count];

            // Allocate and start all the threads.
            for (int i = 0; i < count; ++i)
            {
                // Allocate the worker classes for this thread.
                workers[i] = new BackgroundWorker();
                threadClasses[i] = new StyleCopThread(data);

                // Register for events on the background worker class.
                workers[i].DoWork += new DoWorkEventHandler(threadClasses[i].DoWork);

                // Register for the completion event on the thread data class. We do not use the standard BackgroundWorker
                // completion event because for some reason it does not get fired when running inside of Visual Studio using
                // the MSBuild task, and so everything ends up blocked. This may have to do with the way Visual Studio uses
                // threads when running a build. Therefore, we do not rely on the BackgroundWorker's completion event, and
                // instead use our own event.
                threadClasses[i].ThreadCompleted += new EventHandler<StyleCopThreadCompletedEventArgs>(this.StyleCopThreadCompleted);

                // Indicate that we are launching another thread.
                data.IncrementThreadCount();
            }

            // The lock is required so that we can wait on the Monitor.
            lock (this)
            {
                // Start each of the worker threads.
                for (int i = 0; i < count; ++i)
                {
                    workers[i].RunWorkerAsync();
                }

                // Wait for the threads to complete.
                Monitor.Wait(this);
            }

            // Dispose the workers and determine whether all analysis is complete.
            for (int i = 0; i < count; ++i)
            {
                workers[i].Dispose();

                if (!threadClasses[i].Complete)
                {
                    complete = false;
                }
            }

            return complete;
        }
 private bool RunWorkerThreads(StyleCopThread.Data data, int count)
 {
     bool flag = true;
     BackgroundWorker[] workerArray = new BackgroundWorker[count];
     StyleCopThread[] threadArray = new StyleCopThread[count];
     for (int i = 0; i < count; i++)
     {
         workerArray[i] = new BackgroundWorker();
         threadArray[i] = new StyleCopThread(data);
         workerArray[i].DoWork += new DoWorkEventHandler(threadArray[i].DoWork);
         threadArray[i].ThreadCompleted += new EventHandler<StyleCopThreadCompletedEventArgs>(this.StyleCopThreadCompleted);
         data.IncrementThreadCount();
     }
     lock (this)
     {
         for (int k = 0; k < count; k++)
         {
             workerArray[k].RunWorkerAsync();
         }
         Monitor.Wait(this);
     }
     for (int j = 0; j < count; j++)
     {
         workerArray[j].Dispose();
         if (!threadArray[j].Complete)
         {
             flag = false;
         }
     }
     return flag;
 }
        /// <summary>
        /// Initializes the project to prepare it for analysis.
        /// </summary>
        /// <param name="project">The project to initialize.</param>
        /// <param name="data">The analysis data object.</param>
        /// <param name="cache">The file cache.</param>
        private static void InitializeProjectForAnalysis(CodeProject project, StyleCopThread.Data data, ResultsCache cache)
        {
            Param.AssertNotNull(project, "project");
            Param.AssertNotNull(data, "data");
            Param.Ignore(cache);

            // Get the status object for the project.
            ProjectStatus projectStatus = data.GetProjectStatus(project);
            Debug.Assert(projectStatus != null, "There is no status for the given project.");

            // Load the settings for the project. If the project already contains settings, use those.
            // Otherwise, load them from scratch.
            if (!project.SettingsLoaded)
            {
                project.Settings = data.GetSettings(project);
                project.SettingsLoaded = true;
            }

            // Load the project configuration from the cache and compare it to the
            // current project configuration.
            string configuration = cache == null ? null : cache.LoadProject(project);
            if (configuration == null)
            {
                projectStatus.IgnoreResultsCache = true;
            }
            else
            {
                projectStatus.IgnoreResultsCache = !StyleCopCore.CompareCachedConfiguration(
                    project.Configuration, configuration);
            }

            if (cache != null && project.WriteCache)
            {
                cache.SaveProject(project);
            }
        }
 private static void InitializeProjectForAnalysis(CodeProject project, StyleCopThread.Data data, ResultsCache cache)
 {
     ProjectStatus projectStatus = data.GetProjectStatus(project);
     if (!project.SettingsLoaded)
     {
         project.Settings = data.GetSettings(project);
         project.SettingsLoaded = true;
     }
     string flagList = (cache == null) ? null : cache.LoadProject(project);
     if (flagList == null)
     {
         projectStatus.IgnoreResultsCache = true;
     }
     else
     {
         projectStatus.IgnoreResultsCache = !CompareCachedConfiguration(project.Configuration, flagList);
     }
     if ((cache != null) && project.WriteCache)
     {
         cache.SaveProject(project);
     }
 }