private static IProject GetProjectFromNDependFile(string pathToNDependProject) { var projectManager = new NDependServicesProvider().ProjectManager; var project = projectManager.LoadProject(pathToNDependProject.ToAbsoluteFilePath()); return(project); }
public void Run() { var projectManager = new NDependServicesProvider().ProjectManager; IProject project; if (!projectManager.ShowDialogChooseAnExistingProject(ConsoleUtils.MainWindowHandle, out project)) { return; } Debug.Assert(project != null); var analysisResult = ProjectAnalysisUtils.RunAnalysisShowProgressOnConsole(project); Console.WriteLine("Begin Compute and Store Trend Metrics Values"); // LogTrendMetrics() is an extension method declared by NDepend.Analysis.ExtensionMethodsProjectAnalysis // Two overloads are available: // void LogTrendMetrics(this IAnalysisResult analysisResult, DateTime logDateTime) // void LogTrendMetrics(this IAnalysisResult analysisResult, ICompareContext compareContext, DateTime logDateTime) analysisResult.LogTrendMetrics(DateTime.Now); // <- Here any past or future date can be used! Console.WriteLine("End Compute and Store Trend Metrics Values"); // // Also, from trendStore, any metric value can be persisted, with any date. // //var trendStore = project.Trend.TrendStoreDirectory.GetTrendStoreFromDirectory(); //trendStore.SaveMetricValues(DateTime.Now, new [] { // new MetricValue(new Metric("Metric1", "Unit1"), 1.0f), // new MetricValue(new Metric("Metric2", "Unit2"), 2.0f), //}); // // The method RemoveMetricValues() can also be used to remove all metric values logged at a certain date. // The date equality is defined by the same dated second, no matter the number of miliseconds. //trendStore.RemoveMetricValues(DateTime.Now); }
public void Run() { var projectManager = new NDependServicesProvider().ProjectManager; var dotNetManager = new NDependServicesProvider().DotNetManager; // Gather most recent .NET Fx + directories containing assemblies var mostRecentVersion = dotNetManager.GetDotNetProfileVersionsInstalled(DotNetProfile.DotNetFramework).First(); var dirs = dotNetManager.GetDotNetProfileDirectories(DotNetProfile.DotNetFramework, mostRecentVersion); Console.WriteLine(".NET Fx v" + mostRecentVersion + " directories that contains assemblies to analyze:"); foreach (var dir in dirs) { Console.WriteLine(" -> " + dir.ToString()); } // Gather all .NET Fx assembly var dotNetFxAssemblies = (from dir in dirs from file in dir.ChildrenFilesPath where dotNetManager.IsAssembly(file) select file).ToList(); Console.WriteLine(dotNetFxAssemblies.Count + " .NET Fx assemblies found"); // Create temporary NDepend project and analyze it var project = projectManager.CreateTemporaryProject(dotNetFxAssemblies, TemporaryProjectMode.Temporary); var analysisResult = ProjectAnalysisUtils.RunAnalysisShowProgressOnConsole(project); // Show results ProjectAnalysisUtils.ShowConsoleAnalysisResult(analysisResult.CodeBase); Console.WriteLine("The .NET Fx analysis result produced can now be consummed live from the NDepend project named \"" + project.Properties.Name + "\""); }
public static Result <IProject> GetOrCreateProjectFromVisualStudioSolution(string slnAbsolutePath, string outputDirectory, string outputFileName) { var ndependProjectPath = FileNameConventions.BuildNDependProjectFilePath(outputDirectory, outputFileName); if (File.Exists(ndependProjectPath)) { return(Result.Success(GetProjectFromNDependFile(ndependProjectPath))); } var ndependServicesProvider = new NDependServicesProvider(); List <IAbsoluteFilePath> assemblies = GetAssembliesFromSolution(slnAbsolutePath, ndependServicesProvider); if (!assemblies.Any()) { return(Result.Failure <IProject>("Could not find any assemblies for the solution. Please make sure that the solution is built before running the CodeAnalyzer")); } var projectManager = ndependServicesProvider.ProjectManager; var project = projectManager.CreateBlankProject( ndependProjectPath.ToAbsoluteFilePath(), outputFileName); project.CodeToAnalyze.SetApplicationAssemblies(assemblies); projectManager.SaveProject(project); return(Result.Success(project)); }
public static void Go() { var projectManager = new NDependServicesProvider().ProjectManager; var project = projectManager.LoadProject(@"C:\Dir\NDependProject.ndproj".ToAbsoluteFilePath()); Console.WriteLine("Load newer analysis result"); IAnalysisResultRef mostRecentAnalysisResultRef; if (!project.TryGetMostRecentAnalysisResultRef(out mostRecentAnalysisResultRef)) { Console.WriteLine("Can't find most recent analysis result for project " + project.Properties.FilePath.ToString()); return; } var mostRecentAnalysisResult = mostRecentAnalysisResultRef.Load(); Console.WriteLine("load old analysis result"); IAnalysisResultRef analysisResultToCompareWithRef; if (project.BaselineInUI.TryGetAnalysisResultRefToCompareWith(out analysisResultToCompareWithRef) != TryGetAnalysisResultRefToCompareWithResult.DoCompareWith) { Console.WriteLine("Can't find baseline UI analysis to compare with"); return; } var analysisResultToCompareWith = analysisResultToCompareWithRef.Load(); Console.WriteLine("Create compare context"); var compareContext = mostRecentAnalysisResult.CodeBase.CreateCompareContextWithOlder(analysisResultToCompareWith.CodeBase); foreach (var m in compareContext.NewerCodeBase.Namespaces.Where(compareContext.WasAdded)) { Console.WriteLine(m.Name); } }
internal static int GetNDependLocCount( DevelopmentInstallation installation, bool debug ) { var servicesProvider = new NDependServicesProvider(); var projectManager = servicesProvider.ProjectManager; var project = projectManager.CreateTemporaryProject( getAssemblyPaths( installation, debug ).Select( i => Path.GetFullPath( i ).ToAbsoluteFilePath() ).ToArray(), TemporaryProjectMode.Temporary ); StatusStatics.SetStatus( "Performing NDepend analysis." ); var analysisResult = project.RunAnalysis(); StatusStatics.SetStatus( "Performed NDepend analysis." ); var codeBase = analysisResult.CodeBase; var generatedCodeAttribute = codeBase.Types.WithFullName( "System.CodeDom.Compiler.GeneratedCodeAttribute" ).SingleOrDefault(); var methods = from n in codeBase.Application.Namespaces where !n.Name.StartsWith( EwlStatics.EwfFolderBaseNamespace ) from t in n.ChildTypes where generatedCodeAttribute == null || !t.HasAttribute( generatedCodeAttribute ) from m in t.MethodsAndContructors where generatedCodeAttribute == null || !m.HasAttribute( generatedCodeAttribute ) // We've considered excluding .designer.cs files here, but decided that they should remain part of the count since they still represent // logic that must be maintained (in the designer). where m.SourceFileDeclAvailable && m.SourceDecls.Any( s => s.SourceFile.FilePath.ParentDirectoryPath.DirectoryName != "Generated Code" ) select m; return methods.Where( i => i.NbLinesOfCode.HasValue ).Sum( i => Convert.ToInt32( i.NbLinesOfCode.Value ) ); }
internal static int GetNDependLocCount(DevelopmentInstallation installation, bool debug) { var servicesProvider = new NDependServicesProvider(); var projectManager = servicesProvider.ProjectManager; var project = projectManager.CreateTemporaryProject(getAssemblyPaths(installation, debug).Select(i => Path.GetFullPath(i).ToAbsoluteFilePath()).ToArray(), TemporaryProjectMode.Temporary); StatusStatics.SetStatus("Performing NDepend analysis."); var analysisResult = project.RunAnalysis(); StatusStatics.SetStatus("Performed NDepend analysis."); var codeBase = analysisResult.CodeBase; var generatedCodeAttribute = codeBase.Types.WithFullName("System.CodeDom.Compiler.GeneratedCodeAttribute").SingleOrDefault(); var methods = from n in codeBase.Application.Namespaces where !n.Name.StartsWith(StandardLibraryMethods.EwfFolderBaseNamespace) from t in n.ChildTypes where generatedCodeAttribute == null || !t.HasAttribute(generatedCodeAttribute) from m in t.MethodsAndContructors where generatedCodeAttribute == null || !m.HasAttribute(generatedCodeAttribute) where m.SourceFileDeclAvailable && m.SourceDecls.Any(s => s.SourceFile.FilePath.ParentDirectoryPath.DirectoryName != "Generated Code") select m; return(methods.Where(i => i.NbLinesOfCode.HasValue).Sum(i => Convert.ToInt32(i.NbLinesOfCode.Value))); }
internal static int GetNDependLocCount(DevelopmentInstallation installation, bool debug) { var servicesProvider = new NDependServicesProvider(); var projectManager = servicesProvider.ProjectManager; var project = projectManager.CreateTemporaryProject( getAssemblyPaths(installation, debug).Select(i => Path.GetFullPath(i).ToAbsoluteFilePath()).ToArray(), TemporaryProjectMode.Temporary); StatusStatics.SetStatus("Performing NDepend analysis."); var analysisResult = project.RunAnalysis(); StatusStatics.SetStatus("Performed NDepend analysis."); var codeBase = analysisResult.CodeBase; var generatedCodeAttribute = codeBase.Types.WithFullName("System.CodeDom.Compiler.GeneratedCodeAttribute").SingleOrDefault(); var methods = from n in codeBase.Application.Namespaces from t in n.ChildTypes where generatedCodeAttribute == null || !t.HasAttribute(generatedCodeAttribute) from m in t.MethodsAndContructors where generatedCodeAttribute == null || !m.HasAttribute(generatedCodeAttribute) // We've considered excluding .designer.cs files here, but decided that they should remain part of the count since they still represent // logic that must be maintained (in the designer). where m.SourceFileDeclAvailable && m.SourceDecls.Any(s => s.SourceFile.FilePath.ParentDirectoryPath.DirectoryName != "Generated Code") select m; return(methods.Where(i => i.NbLinesOfCode.HasValue).Sum(i => Convert.ToInt32(i.NbLinesOfCode.Value))); }
public AnalysisHistoryManager(string nDpendProjectpath) { NDependServicesProvider nDependServicesProvider = new NDependServicesProvider(); var projectManager = nDependServicesProvider.ProjectManager; IAbsoluteFilePath pathToNDependProject = PathHelpers.ToAbsoluteFilePath(nDpendProjectpath); IProject nDependProject = projectManager.LoadProject(pathToNDependProject); ICollection<IAnalysisResultRef> analysisResultRefs = nDependProject.GetAvailableAnalysisResultsRefs(); analysisResultRefsList = analysisResultRefs.OrderBy(analysisResultRef => analysisResultRef.Date).ToList(); }
public AnalysisHistoryManager(string nDpendProjectpath) { NDependServicesProvider nDependServicesProvider = new NDependServicesProvider(); var projectManager = nDependServicesProvider.ProjectManager; IAbsoluteFilePath pathToNDependProject = PathHelpers.ToAbsoluteFilePath(nDpendProjectpath); IProject nDependProject = projectManager.LoadProject(pathToNDependProject); ICollection <IAnalysisResultRef> analysisResultRefs = nDependProject.GetAvailableAnalysisResultsRefs(); analysisResultRefsList = analysisResultRefs.OrderBy(analysisResultRef => analysisResultRef.Date).ToList(); }
public void Run() { var projectManager = new NDependServicesProvider().ProjectManager; var visualStudioManager = new NDependServicesProvider().VisualStudioManager; // // Gather all Most Recent Used VS solutions and projects file path referenced in registry // var vsFilesPath = new List <IAbsoluteFilePath>(); foreach (var vsVersion in new[] { VisualStudioVersion.V7_2003, VisualStudioVersion.V8_2005, VisualStudioVersion.V9_2008, VisualStudioVersion.V10_2010 }) { if (!visualStudioManager.IsVisualStudioVersionIntalled(vsVersion)) { continue; } vsFilesPath.AddRange(visualStudioManager.GetMostRecentlyUsedVisualStudioSolutionOrProject(vsVersion)); } Console.WriteLine(vsFilesPath.Count + " VS sln or proj files found"); // // Gather all Debug projects built from these VS solutions and projects // var projectsPath = new List <IAbsoluteFilePath>(); foreach (var vsFilePath in vsFilesPath) { projectsPath.Add(vsFilePath); } // // Create temporary project // var project = projectManager.CreateTemporaryProject(projectsPath, TemporaryProjectMode.Temporary); // // Run analysis // var analysisResult = ProjectAnalysisUtils.RunAnalysisShowProgressOnConsole(project); // // Show results // ProjectAnalysisUtils.ShowConsoleAnalysisResult(analysisResult.CodeBase); Console.WriteLine("The analysis result produced can now be consummed from the CppDepend project \"" + project.Properties.Name + "\""); }
public void Run() { var projectManager = new NDependServicesProvider().ProjectManager; IProject project; if (!projectManager.ShowDialogChooseAnExistingProject(ConsoleUtils.MainWindowHandle, out project)) { return; } // Get the trend store object var trendStore = project.Trend.TrendStoreDirectory.GetTrendStoreFromDirectory(); var years = trendStore.GetYearsContainingValuesDescending(); if (!years.Any()) { Console.WriteLine("No trend values stored for the project {" + project.Properties.Name + "}."); return; } var lastYear = years.Last(); var yearsStringBuilder = new StringBuilder(); foreach (var year in years) { yearsStringBuilder.Append(year.ToString()); if (lastYear != year) { yearsStringBuilder.Append(", "); } } Console.WriteLine("The project {" + project.Properties.Name + "} has trend values stored for years " + yearsStringBuilder.ToString()); // Load all values in one call var historyData = trendStore.Load(years); var metricHistory = historyData.MetricsHistories.First().Value; // Only list the trend values for the first metric Console.WriteLine("Trend values for the metric {" + metricHistory.Metric.Name + "}"); var unit = metricHistory.Metric.Unit; foreach (var datedValue in metricHistory.DatedValuesDescending) { Console.WriteLine(datedValue.Date.ToString() + " " + datedValue.Value.ToString() + " " + unit); } }
public void Run() { var projectManager = new NDependServicesProvider().ProjectManager; var dotNetManager = new NDependServicesProvider().DotNetManager; // Check installation var versions = new[] { new Version(3, 5), new Version(4, 0) }; foreach (var version in versions) { if (dotNetManager.IsInstalled(DotNetProfile.DotNetFramework, version)) { continue; } Console.WriteLine(".NET fx v" + version.ToString() + " not installed!"); return; } // // Gather core assemblies paths // var olderAssembliesPaths = GetCoreAssembliesPath(versions[0], dotNetManager); var newerAssembliesPaths = GetCoreAssembliesPath(versions[1], dotNetManager); // // Do analysis // var olderCodeBase = DoAnalysisGetCodeBase(versions[0], olderAssembliesPaths, TemporaryProjectMode.TemporaryOlder, projectManager); var newerCodeBase = DoAnalysisGetCodeBase(versions[1], newerAssembliesPaths, TemporaryProjectMode.TemporaryNewer, projectManager); // // Create compare context // var compareContext = newerCodeBase.CreateCompareContextWithOlder(olderCodeBase); ConsoleUtils.ShowNLinesOnConsole(3, ConsoleColor.Black); Console.WriteLine("2 temporary projects have been created."); Console.WriteLine("The .NET Fx older and newer analysis results can now be consummed live from the NDepend UI."); Console.WriteLine("Note that .NET Fx types API Breaking Changes represents types moved from System to mscorlib."); // // Show API Changes! // APIChangesDisplayer.Go(compareContext); }
internal static bool TryChooseProject(out IProject project) { var ndependServicesProvider = new NDependServicesProvider(); var projectManager = ndependServicesProvider.ProjectManager; var visualStudioManager = ndependServicesProvider.VisualStudioManager; CHOOSE_PROJECT: var top = Console.CursorTop; Console.CursorLeft = 0; Console.WriteLine("Please choose..."); Console.WriteLine(" a) an existing NDepend project"); Console.WriteLine(" b) one or several Visual Studio solutions to analyze"); Console.WriteLine(" c) one or several .NET assemblies to analyze"); Console.WriteLine(""); var c = Char.ToLower(Console.ReadKey().KeyChar); Console.WriteLine(); switch (c) { case 'a': if (!projectManager.ShowDialogChooseAnExistingProject(ConsoleUtils.MainWindowHandle, out project)) { goto TRY_AGAIN; } break; case 'b': { ICollection <IAbsoluteFilePath> solutions; if (!visualStudioManager.ShowDialogSelectVisualStudioSolutionsOrProjects(ConsoleUtils.MainWindowHandle, out solutions)) { goto TRY_AGAIN; } var assemblies = new List <IAbsoluteFilePath>(); foreach (var solution in solutions) { assemblies.AddRange(visualStudioManager.GetAssembliesFromVisualStudioSolutionOrProject(solution)); } project = projectManager.CreateTemporaryProject(assemblies, TemporaryProjectMode.Temporary); break; } case 'c': { ICollection <IAbsoluteFilePath> assemblies; if (!projectManager.ShowDialogSelectAssemblies(ConsoleUtils.MainWindowHandle, out assemblies)) { goto TRY_AGAIN; } project = projectManager.CreateTemporaryProject(assemblies, TemporaryProjectMode.Temporary); break; } case (char)Keys.Escape: // ESC to exit! project = null; return(false); default: TRY_AGAIN: var nbLinesToErase = Console.CursorTop - top; Console.CursorTop = top; Console.CursorLeft = 0; ConsoleUtils.ShowNLinesOnConsole(nbLinesToErase, ConsoleColor.Black); Console.WriteLine("(ESC to exit)"); Console.CursorTop = top; Console.CursorLeft = 0; goto CHOOSE_PROJECT; } Debug.Assert(project != null); Console.ForegroundColor = ConsoleColor.DarkGray; Console.Write("Project selected: "); Console.ForegroundColor = ConsoleColor.White; Console.WriteLine(project.Properties.Name); Console.WriteLine(); return(true); }
public void Run() { IProject project; if (!ProjectAnalysisUtils.TryChooseProject(out project)) { return; } Debug.Assert(project != null); IReadOnlyList <IAbsoluteFilePath> applicationAssemblies, thirdPartyAssemblies; IReadOnlyList <IAssemblyResolvingError> applicationAssembliesError, thirdPartyAssembliesError; project.CodeToAnalyze.Resolve(out applicationAssemblies, out thirdPartyAssemblies, out applicationAssembliesError, out thirdPartyAssembliesError); //-------------------------------------------------------------------------------------------- ShowConsoleNewCheck(ExtensionMethods.ToEnumerable("Show eventual assembly resolving errors")); ShowEventualAssemblyResolvingErrors(applicationAssemblies.Count, applicationAssembliesError); //-------------------------------------------------------------------------------------------- // Make sure there are enought application assemblies resolved if (applicationAssemblies.Count < 3) { Console.ForegroundColor = ConsoleColor.White; Console.WriteLine("Only " + applicationAssemblies.Count + " application assembly are resolved, this is not enought to try detect versionning issue."); return; } var dotNetManager = new NDependServicesProvider().DotNetManager; var applicationAssembliesInfos = applicationAssemblies.Select(dotNetManager.GetAssemblyInfo); var thirdPartyAssembliesInfos = thirdPartyAssemblies.Select(dotNetManager.GetAssemblyInfo); //-------------------------------------------------------------------------------------------- ShowConsoleNewCheck(new[] { "Try get the application version", "and check assemblies without the application version" }); CoherencyChecker.Go(applicationAssembliesInfos, assemblyInfo => assemblyInfo.Version, "application version"); //-------------------------------------------------------------------------------------------- ShowConsoleNewCheck(ExtensionMethods.ToEnumerable("Check that assemblies references have the same version than assemblies resolved")); AssembliesReferencesVersionningChecker.Go(applicationAssembliesInfos, thirdPartyAssembliesInfos); //-------------------------------------------------------------------------------------------- ShowConsoleNewCheck(new[] { "Try get the common target runtime version", "and check assemblies with a different target runtime version" }); CoherencyChecker.Go(applicationAssembliesInfos, assemblyInfo => assemblyInfo.TargetRuntime, "target runtime version"); //-------------------------------------------------------------------------------------------- ShowConsoleNewCheck(ExtensionMethods.ToEnumerable("Check that all application assemblies are strong named or not")); CoherencyChecker.Go(applicationAssembliesInfos, assemblyInfo => assemblyInfo.IsStrongNamed, "is strong named"); //-------------------------------------------------------------------------------------------- ShowConsoleNewCheck(new[] { "Check that all application assemblies share ", "a common target platform target (AnyCPU, x86, x64, Itanium)" }); CoherencyChecker.Go(applicationAssembliesInfos, assemblyInfo => assemblyInfo.PlatformTarget, "platform target"); //-------------------------------------------------------------------------------------------- ShowConsoleNewCheck(new[] { "Make sure all application assemblies", "PDB file available or not available" }); CoherencyChecker.Go(applicationAssembliesInfos, assemblyInfo => assemblyInfo.PDBAvailable, "PDB file available"); }
public void Run() { var projectManager = new NDependServicesProvider().ProjectManager; var visualStudioManager = new NDependServicesProvider().VisualStudioManager; // // Gather all Most Recent Used VS solutions and projects file path referenced in registry // var vsFilesPath = new List <IAbsoluteFilePath>(); foreach (var vsVersion in new[] { VisualStudioVersion.V7_2003, VisualStudioVersion.V8_2005, VisualStudioVersion.V9_2008, VisualStudioVersion.V10_2010 }) { if (!visualStudioManager.IsVisualStudioVersionIntalled(vsVersion)) { continue; } vsFilesPath.AddRange(visualStudioManager.GetMostRecentlyUsedVisualStudioSolutionOrProject(vsVersion)); } Console.WriteLine(vsFilesPath.Count + " VS sln or proj files found"); // // Gather all Debug assemblies built from these VS solutions and projects // var assembliesPath = new List <IAbsoluteFilePath>(); foreach (var vsFilePath in vsFilesPath) { assembliesPath.AddRange(visualStudioManager.GetAssembliesFromVisualStudioSolutionOrProject(vsFilePath)); } // // Create temporary project // var project = projectManager.CreateTemporaryProject(assembliesPath, TemporaryProjectMode.Temporary); // // Inform about potential assembly resolving error // IReadOnlyList <IAbsoluteFilePath> applicationAssemblies, thirdPartyAssemblies; IReadOnlyList <IAssemblyResolvingError> applicationAssembliesError, thirdPartyAssembliesError; project.CodeToAnalyze.Resolve(out applicationAssemblies, out thirdPartyAssemblies, out applicationAssembliesError, out thirdPartyAssembliesError); if (applicationAssembliesError.Count > 0) { Console.ForegroundColor = ConsoleColor.Yellow; Console.WriteLine(applicationAssembliesError.Count + " assembly resolving error, assemblies with following names won't be analyzed:"); foreach (var assemblyResolvingError in applicationAssembliesError) { // You can use assemblyResolvingError.ErrorDescription to show error in plain english // most of the time it'll be several different assemblies with the same name found. Console.Write(assemblyResolvingError.AssemblyName + " ; "); } Console.ForegroundColor = ConsoleColor.White; } // // Run analysis // var analysisResult = ProjectAnalysisUtils.RunAnalysisShowProgressOnConsole(project); // // Show results // ProjectAnalysisUtils.ShowConsoleAnalysisResult(analysisResult.CodeBase); Console.WriteLine("The analysis result produced can now be consummed from the NDepend project \"" + project.Properties.Name + "\""); }
internal static ICompareContext GetProjectsToCompareAndAnalyzeThem() { var analysisManager = new NDependServicesProvider().AnalysisManager; var top = Console.CursorTop; Console.CursorLeft = 0; IProject projectOlder, projectNewer; IAnalysisResultRef analysisResultRefOlder, analysisResultRefNewer; while (true) { Console.WriteLine("Please choose older and newer versions of the code base..."); bool dialogOk = analysisManager.ShowDialogBuildComparison(ConsoleUtils.MainWindowHandle, out projectOlder, out analysisResultRefOlder, out projectNewer, out analysisResultRefNewer); var nbLinesToErase = Console.CursorTop - top; Console.CursorTop = top; Console.CursorLeft = 0; ConsoleUtils.ShowNLinesOnConsole(nbLinesToErase, ConsoleColor.Black); Console.CursorTop = top; Console.CursorLeft = 0; if (dialogOk) { break; } } // // Load or analyze // IAnalysisResult analysisResultOlder, analysisResultNewer; if (analysisResultRefOlder == null) { Debug.Assert(projectOlder != null); Console.WriteLine("Analyze older version of projects"); analysisResultOlder = RunAnalysisShowProgressOnConsole(projectOlder); } else { Console.WriteLine("Load older analysis result"); analysisResultOlder = LoadAnalysisShowProgressOnConsole(analysisResultRefOlder); } if (analysisResultRefNewer == null) { Debug.Assert(projectNewer != null); Console.WriteLine("Analyze newer version of projects"); analysisResultNewer = RunAnalysisShowProgressOnConsole(projectNewer); } else { Console.WriteLine("Load newer analysis result"); analysisResultNewer = LoadAnalysisShowProgressOnConsole(analysisResultRefNewer); } // // Re-erase // var nbLinesToErase2 = Console.CursorTop - top; Console.CursorTop = top; Console.CursorLeft = 0; ConsoleUtils.ShowNLinesOnConsole(nbLinesToErase2, ConsoleColor.Black); Console.CursorTop = top; Console.CursorLeft = 0; // // Show compare description // Console.ForegroundColor = ConsoleColor.DarkGray; Console.Write("Comparing: "); Console.ForegroundColor = ConsoleColor.White; ShowAnalysisResultRefDescription(analysisResultOlder.AnalysisResultRef); Console.WriteLine(); Console.ForegroundColor = ConsoleColor.DarkGray; Console.Write(" with: "); Console.ForegroundColor = ConsoleColor.White; ShowAnalysisResultRefDescription(analysisResultNewer.AnalysisResultRef); return(analysisResultNewer.CodeBase.CreateCompareContextWithOlder(analysisResultOlder.CodeBase)); }
public MetricsViewer() { InitializeComponent(); nDependServicesProvider = new NDependServicesProvider(); }
internal static IProject ChooseProject() { var projectManager = new NDependServicesProvider().ProjectManager; var visualStudioManager = new NDependServicesProvider().VisualStudioManager; var top = Console.CursorTop; Console.CursorLeft = 0; while (true) { Console.WriteLine("Please choose..."); Console.WriteLine(" a) an existing CppDepend project"); Console.WriteLine(" b) one or several Visual Studio solutions to analyze"); Console.WriteLine(" c) one or several C/C++ projects to analyze"); Console.WriteLine(""); var c = Char.ToLower(Console.ReadKey().KeyChar); Console.WriteLine(); IProject project = null; switch (c) { case 'a': if (!projectManager.ShowDialogChooseAnExistingProject(ConsoleUtils.MainWindowHandle, out project)) { break; } break; case 'b': { ICollection <IAbsoluteFilePath> solutions; if (!visualStudioManager.ShowDialogSelectVisualStudioSolutionsOrProjects(ConsoleUtils.MainWindowHandle, out solutions)) { break; } var projects = new List <IAbsoluteFilePath>(); foreach (var solution in solutions) { projects.Add(solution); } project = projectManager.CreateTemporaryProject(projects, TemporaryProjectMode.Temporary); break; } default: { ICollection <IAbsoluteFilePath> projects; if (!projectManager.ShowDialogSelectProjects(ConsoleUtils.MainWindowHandle, out projects)) { break; } project = projectManager.CreateTemporaryProject(projects, TemporaryProjectMode.Temporary); break; } } var nbLinesToErase = Console.CursorTop - top; Console.CursorTop = top; Console.CursorLeft = 0; ConsoleUtils.ShowNLinesOnConsole(nbLinesToErase, ConsoleColor.Black); Console.CursorTop = top; Console.CursorLeft = 0; if (project == null) { continue; } Console.ForegroundColor = ConsoleColor.DarkGray; Console.Write("Project selected: "); Console.ForegroundColor = ConsoleColor.White; Console.WriteLine(project.Properties.Name); Console.WriteLine(); return(project); } }
public MetricsViewer() { InitializeComponent(); nDependServicesProvider = new NDependServicesProvider(); TagAllDataGridViews(); }
static void Main() { //------------------------------------------------------------------------------------- // // 0) Creates a NDependServicesProvider object // var ndependServicesProvider = new NDependServicesProvider(); //------------------------------------------------------------------------------------- // // 1) obtain some VS solution or project file path // var visualStudioManager = ndependServicesProvider.VisualStudioManager; ICollection <IAbsoluteFilePath> vsSlnOrProjFilePaths; visualStudioManager.ShowDialogSelectVisualStudioSolutionsOrProjects(Process.GetCurrentProcess().MainWindowHandle, out vsSlnOrProjFilePaths); // Could also use: visualStudioManager.GetMostRecentlyUsedVisualStudioSolutionOrProject() can also be used //------------------------------------------------------------------------------------- // // 2) obtains assemblies file path to analyze // var assembliesFilePath = (from vsSlnOrProjFilePath in vsSlnOrProjFilePaths from assembliesFilePathTmp in visualStudioManager.GetAssembliesFromVisualStudioSolutionOrProject(vsSlnOrProjFilePath) select assembliesFilePathTmp).Distinct().ToArray(); //------------------------------------------------------------------------------------- // // 3) gets or create a IProject object // var projectManager = ndependServicesProvider.ProjectManager; var project = projectManager.CreateTemporaryProject(assembliesFilePath, TemporaryProjectMode.Temporary); // Or, to get a IProject object, could also use // projectManager.CreateBlankProject() to create a persisten project // and then project.CodeToAnalyze.SetApplicationAssemblies() // and then projectManager.SaveProject(project); o save the project file // // Or, to get an existing IProject object, could also use // projectManager.ShowDialogChooseAnExistingProject(out project) // Or programmatically list most recently used NDepend projects on this machine through // projectManager.GetMostRecentlyUsedProjects() //------------------------------------------------------------------------------------- // // 4) gets an IAnalysisResult object from the IProject object // var analysisResult = project.RunAnalysis(); // *** This particular method works only with a Build Machine license *** // Or project.RunAnalysisAndBuildReport() // *** This particular method works only with a Build Machine license *** // Or, to get a IAnalysisResult object, first gets a IAnalysisResultRef object, that represents a reference to a persisted IAnalysisResult object // project.TryGetMostRecentAnalysisResultRef() or project.GetAvailableAnalysisResultsRefs() or project.GetAvailableAnalysisResultsRefsGroupedPerMonth() // and then analysisResultRef.Load() //------------------------------------------------------------------------------------- // // 5) gets a ICodeBase object from the IAnalysisResult object // var codeBase = analysisResult.CodeBase; // Or eventually a ICompareContext object if you wish to analyze diff // codeBase.CreateCompareContextWithOlder(olderCodeBase) //------------------------------------------------------------------------------------- // // 6) use the code model API to query code and do develop any algorithm you need! // // For example here we are looking for complex methods var complexMethods = (from m in codeBase.Application.Methods where m.ILCyclomaticComplexity > 10 orderby m.ILCyclomaticComplexity descending select m).ToArray(); if (complexMethods.Length == 0) { return; } Console.WriteLine("Press a key to show the " + complexMethods.Length + " most complex methods"); Console.ReadKey(); foreach (var m in complexMethods) { Console.WriteLine(m.FullName + " has a IL cyclomatic complexity of " + m.ILCyclomaticComplexity); } //------------------------------------------------------------------------------------- // // 7) eventually lets the user opens source file declaration // if (complexMethods.First().SourceFileDeclAvailable) { var mostComplexMethod = complexMethods.First(); Console.WriteLine("Press a key to open the source code decl of the most complex method?"); Console.ReadKey(); mostComplexMethod.TryOpenSource(); // Eventually use ExtensionMethodsTooling.TryCompareSourceWith(NDepend.CodeModel.ISourceFileLine,NDepend.CodeModel.ISourceFileLine) // to compare 2 different versions of a code element } }
public void Run() { var projectManager = new NDependServicesProvider().ProjectManager; IProject project; if (!projectManager.ShowDialogChooseAnExistingProject(ConsoleUtils.MainWindowHandle, out project)) { return; } // Fetch analysis results reference for the choosen project var analysisResultRefs = project.GetAvailableAnalysisResultsRefs(); // Need at least 2 analysis results if (analysisResultRefs.Count < 2) { Console.BackgroundColor = ConsoleColor.Black; Console.ForegroundColor = ConsoleColor.Yellow; Console.WriteLine("Cannot find at least 2 historic analysis results for the project {" + project.Properties.Name + "}"); return; } bool showAll = false; Console.BackgroundColor = ConsoleColor.Black; Console.ForegroundColor = ConsoleColor.White; // Sort by analysis date ascending analysisResultRefs = analysisResultRefs.OrderBy(analysisResultRef => analysisResultRef.Date).ToReadOnlyClonedList(); // TODO --> use .NET 4 System.Windows.Forms.DataVisualization.dll (if available), to plot chart?? // // For each analysisResultRef found for this project // foreach (var analysisResultRef in analysisResultRefs) { var analysisResult = ProjectAnalysisUtils.LoadAnalysisShowProgressOnConsole(analysisResultRef); Console.WriteLine(); Console.WriteLine("Analysis result produced on " + analysisResultRef.Date); // // -->If you wish to follow the evolution of a particular code element (a type for example) // just retrieve the IType in each code base by type.FullName // var type = codeBase.Types.WithFullName("Namespace.TypeName"). // // You can also build a ICompareContext for each 2 consecutive analysis result loaded. // analysisResultNext.CodeBase.CreateCompareContextWithOlder(analysisResultPrevious.CodeBase) // and use the methods // ICompareContext.OlderVersion(ICodeElement):ICodeElement // ICompareContext.NewerVersion(ICodeElement):ICodeElement // to retrieve the newer versions of the particular code element, from its older version. ProjectAnalysisUtils.ShowConsoleAnalysisResult(analysisResult.CodeBase); // Ask all/next/quit? if (showAll) { continue; } switch (ConsoleUtils.ConsoleAskShowNextAllStop()) { case AllNextQuit.Next: continue; case AllNextQuit.All: showAll = true; continue; default: // Quit return; } } }
public void Run() { // // Get dir // var folderBrowserDialog = new FolderBrowserDialog { ShowNewFolderButton = false }; if (folderBrowserDialog.ShowDialog() != DialogResult.OK) { return; } var dir = folderBrowserDialog.SelectedPath.ToAbsoluteDirectoryPath(); // // Get recursive // bool recursive = false; Console.BackgroundColor = ConsoleColor.Black; Console.ForegroundColor = ConsoleColor.Yellow; Console.WriteLine("Search assemblies recursive under {" + dir.ToString() + "} ?"); Console.WriteLine("Yes? y or No? (another key)"); var consoleKeyInfo = Console.ReadKey(); if (consoleKeyInfo.KeyChar == 'y') { recursive = true; } Console.ForegroundColor = ConsoleColor.White; // // Get assembliesPath // var dotNetManager = new NDependServicesProvider().DotNetManager; var assembliesPath = new List <IAbsoluteFilePath>(); var cursorTop = Console.CursorTop; if (!recursive) { ScanDir(dir, assembliesPath, dotNetManager, cursorTop); } else { ScanDirRecursive(dir, assembliesPath, dotNetManager, Console.CursorTop); } Console.CursorTop = cursorTop; Console.CursorLeft = 0; ConsoleUtils.ShowNLinesOnConsole(10, ConsoleColor.Black); Console.CursorTop = cursorTop; Console.CursorLeft = 0; // // Get project // Console.ForegroundColor = ConsoleColor.Yellow; Console.WriteLine(assembliesPath.Count + " assemblies found"); Console.WriteLine(assembliesPath.Select(path => path.FileNameWithoutExtension).Distinct(StringComparer.InvariantCultureIgnoreCase).Count() + " assemblies with distint names found"); Console.WriteLine("Create the NDepend temporary project."); var projectManager = new NDependServicesProvider().ProjectManager; var project = projectManager.CreateTemporaryProject(assembliesPath, TemporaryProjectMode.Temporary); // // Run analysis // Console.ForegroundColor = ConsoleColor.Yellow; Console.WriteLine("Run Analysis!"); var analysisResult = ProjectAnalysisUtils.RunAnalysisShowProgressOnConsole(project); // // Show results // ProjectAnalysisUtils.ShowConsoleAnalysisResult(analysisResult.CodeBase); }
static void MainSub() { //AppDomain.CurrentDomain.AssemblyResolve += AssemblyResolverHelper.AssemblyResolveHandler; //var projectFilePath = NDEPEND_PROJECT_FILE_PATH.ToAbsoluteFilePath(); //Console.WriteLine("*** Load NDepend Project from {" + projectFilePath.ToString() + @"}***"); // 0) Creates a NDependServicesProvider object var ndependServicesProvider = new NDependServicesProvider(); // 1) obtain some VS solution or project file path var visualStudioManager = ndependServicesProvider.VisualStudioManager; ICollection<IAbsoluteFilePath> vsSlnOrProjFilePaths; IntPtr ownerWindowHandle = Process.GetCurrentProcess().MainWindowHandle; // get a non IntPtr.Zero owner Window Handle. If you are in a System.Console try this visualStudioManager.ShowDialogSelectVisualStudioSolutionsOrProjects(ownerWindowHandle, out vsSlnOrProjFilePaths); // Could also use: visualStudioManager.GetMostRecentlyUsedVisualStudioSolutionOrProject() can also be used // 2) obtains assemblies file path to analyze var assembliesFilePath = (from vsSlnOrProjFilePath in vsSlnOrProjFilePaths from assembliesFilePathTmp in visualStudioManager.GetAssembliesFromVisualStudioSolutionOrProject(vsSlnOrProjFilePath) select assembliesFilePathTmp).Distinct().ToArray(); // 3) gets or create a IProject object var projectManager = ndependServicesProvider.ProjectManager; //var path = NDepend.Path.PathHelpers.ToAbsoluteFilePath(@"C:\projetos\estudoipt\dapperdotnet\dapper-dot-net\"); //IProject project = projectManager.CreateBlankProject(assembliesFilePath.FirstOrDefault(), "metricsproject"); IProject project = projectManager.CreateTemporaryProject(assembliesFilePath, TemporaryProjectMode.Temporary); // Or, to get a IProject object, could also use // projectManager.CreateBlankProject() to create a persisten project // and then project.CodeToAnalyze.SetApplicationAssemblies() // and then projectManager.SaveProject(project); o save the project file // // Or, to get an existing IProject object, could also use // projectManager.ShowDialogChooseAnExistingProject(out project) // Or programmatically list most recently used NDepend projects on this machine through // projectManager.GetMostRecentlyUsedProjects() // 4) gets an IAnalysisResult object from the IProject object IAnalysisResult analysisResult = project.RunAnalysis(); // *** This particular method works only with a Build Machine license *** // Or project.RunAnalysisAndBuildReport() // *** This particular method works only with a Build Machine license *** // Or, to get a IAnalysisResult object, first gets a IAnalysisResultRef object, that represents a reference to a persisted IAnalysisResult object // project.TryGetMostRecentAnalysisResultRef() or project.GetAvailableAnalysisResultsRefs() or project.GetAvailableAnalysisResultsRefsGroupedPerMonth() // and then analysisResultRef.Load() // 5) gets a ICodeBase object from the IAnalysisResult object ICodeBase codeBase = analysisResult.CodeBase; // Or eventually a ICompareContext object if you wish to analyze diff // codeBase.CreateCompareContextWithOlder(olderCodeBase) Calculator.ICalculate calc = new Calculator.NumberOfChildren(); var result = calc.Calculate(codeBase); IMetricPrinter m = new ExcelPrinter(); m.Print("NumberOfChildren",result); calc = new Calculator.CouplingBetweenObjectClasses(); result = calc.Calculate(codeBase); m = new ExcelPrinter(); m.Print("CouplingBetweenObject", result); calc = new Calculator.DepthOfInheritanceTree(); result = calc.Calculate(codeBase); m = new ExcelPrinter(); m.Print("DepthOfInheritanceTree", result); calc = new Calculator.LackOfCohesionInMethods(); result = calc.Calculate(codeBase); m = new ExcelPrinter(); m.Print("LackOfCohesionInMethods", result); calc = new Calculator.ResponseForAClass(); result = calc.Calculate(codeBase); m = new ExcelPrinter(); m.Print("ResponseForAClass", result); calc = new Calculator.WeightedMethodsPerClass(); result = calc.Calculate(codeBase); m = new ExcelPrinter(); m.Print("WeightedMethodsPerClass", result); // 6) use the code model API to query code and do develop any algorithm you need! // For example here we are looking for complex methods /*var complexMethods = (from m in codeBase.Application.Methods where m.ILCyclomaticComplexity > 1 orderby m.ILCyclomaticComplexity descending select m).ToArray(); if (complexMethods.Length == 0) { return; } Console.WriteLine("Press a key to show the " + complexMethods.Length + " most complex methods"); Console.ReadKey(); foreach (var m in complexMethods) { Console.WriteLine(m.FullName + " has a IL cyclomatic complexity of " + m.ILCyclomaticComplexity); } // 7) eventually lets the user opens source file declaration if (complexMethods.First().SourceFileDeclAvailable) { var mostComplexMethod = complexMethods.First(); Console.WriteLine("Press a key to open the source code decl of the most complex method?"); Console.ReadKey(); mostComplexMethod.TryOpenSource(); // Eventually use ExtensionMethodsTooling.TryCompareSourceWith(NDepend.CodeModel.ISourceFileLine,NDepend.CodeModel.ISourceFileLine) // to compare 2 different versions of a code element }*/ }
static void MainSub() { //AppDomain.CurrentDomain.AssemblyResolve += AssemblyResolverHelper.AssemblyResolveHandler; //var projectFilePath = NDEPEND_PROJECT_FILE_PATH.ToAbsoluteFilePath(); //Console.WriteLine("*** Load NDepend Project from {" + projectFilePath.ToString() + @"}***"); // 0) Creates a NDependServicesProvider object var ndependServicesProvider = new NDependServicesProvider(); // 1) obtain some VS solution or project file path var visualStudioManager = ndependServicesProvider.VisualStudioManager; ICollection <IAbsoluteFilePath> vsSlnOrProjFilePaths; IntPtr ownerWindowHandle = Process.GetCurrentProcess().MainWindowHandle; // get a non IntPtr.Zero owner Window Handle. If you are in a System.Console try this visualStudioManager.ShowDialogSelectVisualStudioSolutionsOrProjects(ownerWindowHandle, out vsSlnOrProjFilePaths); // Could also use: visualStudioManager.GetMostRecentlyUsedVisualStudioSolutionOrProject() can also be used // 2) obtains assemblies file path to analyze var assembliesFilePath = (from vsSlnOrProjFilePath in vsSlnOrProjFilePaths from assembliesFilePathTmp in visualStudioManager.GetAssembliesFromVisualStudioSolutionOrProject(vsSlnOrProjFilePath) select assembliesFilePathTmp).Distinct().ToArray(); // 3) gets or create a IProject object var projectManager = ndependServicesProvider.ProjectManager; //var path = NDepend.Path.PathHelpers.ToAbsoluteFilePath(@"C:\projetos\estudoipt\dapperdotnet\dapper-dot-net\"); //IProject project = projectManager.CreateBlankProject(assembliesFilePath.FirstOrDefault(), "metricsproject"); IProject project = projectManager.CreateTemporaryProject(assembliesFilePath, TemporaryProjectMode.Temporary); // Or, to get a IProject object, could also use // projectManager.CreateBlankProject() to create a persisten project // and then project.CodeToAnalyze.SetApplicationAssemblies() // and then projectManager.SaveProject(project); o save the project file // // Or, to get an existing IProject object, could also use // projectManager.ShowDialogChooseAnExistingProject(out project) // Or programmatically list most recently used NDepend projects on this machine through // projectManager.GetMostRecentlyUsedProjects() // 4) gets an IAnalysisResult object from the IProject object IAnalysisResult analysisResult = project.RunAnalysis(); // *** This particular method works only with a Build Machine license *** // Or project.RunAnalysisAndBuildReport() // *** This particular method works only with a Build Machine license *** // Or, to get a IAnalysisResult object, first gets a IAnalysisResultRef object, that represents a reference to a persisted IAnalysisResult object // project.TryGetMostRecentAnalysisResultRef() or project.GetAvailableAnalysisResultsRefs() or project.GetAvailableAnalysisResultsRefsGroupedPerMonth() // and then analysisResultRef.Load() // 5) gets a ICodeBase object from the IAnalysisResult object ICodeBase codeBase = analysisResult.CodeBase; // Or eventually a ICompareContext object if you wish to analyze diff // codeBase.CreateCompareContextWithOlder(olderCodeBase) Calculator.ICalculate calc = new Calculator.NumberOfChildren(); var result = calc.Calculate(codeBase); IMetricPrinter m = new ExcelPrinter(); m.Print("NumberOfChildren", result); calc = new Calculator.CouplingBetweenObjectClasses(); result = calc.Calculate(codeBase); m = new ExcelPrinter(); m.Print("CouplingBetweenObject", result); calc = new Calculator.DepthOfInheritanceTree(); result = calc.Calculate(codeBase); m = new ExcelPrinter(); m.Print("DepthOfInheritanceTree", result); calc = new Calculator.LackOfCohesionInMethods(); result = calc.Calculate(codeBase); m = new ExcelPrinter(); m.Print("LackOfCohesionInMethods", result); calc = new Calculator.ResponseForAClass(); result = calc.Calculate(codeBase); m = new ExcelPrinter(); m.Print("ResponseForAClass", result); calc = new Calculator.WeightedMethodsPerClass(); result = calc.Calculate(codeBase); m = new ExcelPrinter(); m.Print("WeightedMethodsPerClass", result); // 6) use the code model API to query code and do develop any algorithm you need! // For example here we are looking for complex methods /*var complexMethods = (from m in codeBase.Application.Methods * where m.ILCyclomaticComplexity > 1 * orderby m.ILCyclomaticComplexity descending * select m).ToArray(); * if (complexMethods.Length == 0) { return; } * Console.WriteLine("Press a key to show the " + complexMethods.Length + " most complex methods"); * Console.ReadKey(); * foreach (var m in complexMethods) * { * Console.WriteLine(m.FullName + " has a IL cyclomatic complexity of " + m.ILCyclomaticComplexity); * } * * * // 7) eventually lets the user opens source file declaration * if (complexMethods.First().SourceFileDeclAvailable) * { * var mostComplexMethod = complexMethods.First(); * Console.WriteLine("Press a key to open the source code decl of the most complex method?"); * Console.ReadKey(); * mostComplexMethod.TryOpenSource(); * // Eventually use ExtensionMethodsTooling.TryCompareSourceWith(NDepend.CodeModel.ISourceFileLine,NDepend.CodeModel.ISourceFileLine) * // to compare 2 different versions of a code element * }*/ }
private static List <IAbsoluteFilePath> GetAssembliesFromSolution(string slnAbsolutePath, NDependServicesProvider ndependServicesProvider) { var visualStudioManager = ndependServicesProvider.VisualStudioManager; ICollection <IAbsoluteFilePath> solutions = new List <IAbsoluteFilePath>(); solutions.Add(slnAbsolutePath.ToAbsoluteFilePath()); var assemblies = new List <IAbsoluteFilePath>(); foreach (var solution in solutions) { assemblies.AddRange(visualStudioManager.GetAssembliesFromVisualStudioSolutionOrProject(solution)); } return(assemblies); }