TechPrufer
Get started
Microsoft
Microsoft logoMicrosoft · Feature trail

Code Dependency Visualization and Layer Validation

31 posts · Oct 2010 – Nov 2016

What this trail covers

Visual Studio's architecture modeling tooling has evolved to include enhanced code maps for architectural and dependency analysis. This includes simplified menus, improved performance, progressive display of solution structure, additional link styles, assembly styling, filtering of implicit .NET type dependencies, and robust filtering for code elements and dependency links. The debugger has also been enhanced for child process debugging, with customizable settings for debug engine selection and. This post introduces live dependency validation using Roslyn analyzers, improving authoring and developer experience by providing precise issue identification and faster feedback loops.

All Microsoft trails
  1. Live Dependency Validation in Visual Studio 2017This post announces the upcoming Visual Studio 2017 RC release, detailing improvements to Live Dependency Validation. Key updates include a progress dialog for project upgrades, consistent NuGet package versions across projects, full support for VB.NET, automatic project updates when adding a new Dependency Validation project, and improvements to the Roslyn analyzer (less verbose reporting, delegate invocation reporting). It also advises enabling 'full solution analysis' for comprehensive architectural issue detection. Known issues for RC are listed, with fixes planned for RTM, including saving diagrams, lightweight solution load, and diagram deletion. Error codes (DV0001, DV1001, DV1002, DV1003) for dependency validation errors are explained, along with differences between legacy layer validation (binary-based) and live dependency validation (source code-based). Tips for authoring dependency validation diagrams using drag-and-drop from explorers or code maps are also provided.
  2. Live architecture dependency validation in Visual Studio “15” Preview 5Introduces a new 'Dependency Validation' experience in Visual Studio "15" Preview 5, re-implementing validation logic as Roslyn analyzers that work against source code. This provides live validation, precise issue identification with editor squiggles, and improved error list filtering. It also updates the authoring experience by renaming 'Layer Diagram' to 'Dependency Diagram' and improving property discoverability. The post details the migration experience for existing layer diagrams and outlines limitations in Preview 5.
  3. CodeLens Indicator for Code HealthThis post announces the release of the Visual Studio 2015 version of the CodeLens Indicator for Code Health. This extension updates the previous Visual Studio 2013 version and displays the current Maintainability Index for code elements. It recalculates metrics dynamically as a file is edited and shows the trend of the value. The extension uses Roslyn and required changes to work with VS 2015. It also notes that metrics may not always match between VS Code Metrics window, SonarQube, and this indicator, with a backlog item to reconcile them.
  4. Code Map: From Visual Studio 2013 Ultimate to Visual Studio 2015 EnterpriseThis post details incremental improvements to Visual Studio's Code Map feature between versions 2013 RTM and 2015 RTM. Key enhancements include a simplified Architecture menu for more useful code maps grouped by solution folders, new ways to quickly create code maps (blank or from selection), faster map creation and editing with "Skip rebuilding your solution" option, ability to create diagrams from Class View, Object Browser, and File Explorer via drag-and-drop, code elements appearing with context (assembly and solution folder), filtering of code element nodes and groups (by category, solution folders, assemblies, namespaces, project folders, types, and test projects), filtering of relationships (inheritance, calls), 'Drill-in into dependency links' respecting filters, and simplified context menus with more intuitive icons and independent group layout.
  5. Code Maps improvements in Visual Studio Enterprise 2015 RTM: Code maps now have simpler menus, more intuitive icons, and independent group layoutThis post details improvements to Visual Studio Enterprise 2015 RTM's Code Maps, focusing on icon consistency with Solution Explorer, reorganization of shortcut menus for better discoverability of key commands (like 'create a new code map from selection' and 'show the contribution of links'), and the introduction of independent group layout options for more flexible visualization of group contents. The changes aim to make code maps more intuitive and easier to use for understanding solution architecture and the impact of changes.
  7. Code maps now differentiate test projects, and bring code context into map elementsThis post details two key improvements to Visual Studio's Code Maps feature in the VS 2015 RC: 1. Test project differentiation: Test assets (MSTest, or other frameworks with adapters) are now styled differently in code maps, and a 'Test Assets' filter is available in the 'Filters' pane to show/hide them. 2. Code context improvements: Code maps now automatically include the namespace and assembly containers for selected code elements, eliminating the need for manual 'Show All Containers' steps to understand the broader impact of a change. This provides a more immediate and comprehensive view of code relationships.
  8. Layer Validation in Visual Studio architecture modeling tools may result in excessive size of user’s temporary folderThis post details a specific issue with Layer Validation in Visual Studio 2012 and 2013 where temporary assembly files were not being removed, leading to excessive growth of the user's temporary folder. It provides a concrete workaround by adding a post-build script to the `.modelproj` file to delete the `LmrProviderTempAssemblyFolder`. It also clarifies that this issue does not affect Visual Studio 2015.
  9. “Reference could not be resolved” error when validating your architecture using Visual Studio architecture modeling toolsThis post addresses a specific issue where architecture validation in Visual Studio 2012 and 2013 fails due to primary reference resolution errors when the reference is built against a higher .NET Framework version than the targeted framework. A workaround is provided by editing the modeling project file to set `<ResolveAssemblyReferenceIgnoreTargetFrameworkAttributeVersionMismatch>true</ResolveAssemblyReferenceIgnoreTargetFrameworkAttributeVersionMismatch>`.
  10. Code Map improvements in Visual Studio 2015 CTP6This post details specific improvements to Visual Studio's Code Maps in CTP6, building upon previous releases. Key contributions include a cleaner 'Architecture' menu with unified terminology, renaming 'New Diagram' to 'New UML or Layer Diagram', making code generation settings accessible from UML Explorer, and adding tool windows to the 'Windows' submenu. Performance improvements allow for faster generation and responsiveness, with the ability to cancel background processing. The progressive visibility of solution structure, grouping projects by solution folders, and the ability to generate maps without building are highlighted. Additional dependency link styles are explained, including the meaning of colored and gray dotted links. Assembly styling based on project type (libraries, VSIX, Web, Phone, Portable Library) is introduced, and implicit .NET type dependencies are now hidden by default. New filtering mechanisms for code elements and dependency links are presented, allowing users to focus on specific namespaces, assemblies, or classes.
  11. New ways to quickly create a Code MapIntroduced new ways to create Code Maps in Visual Studio 2015, specifically 'New Graph from Selection' which allows creating a new, uncluttered map focused on selected items from an existing map. Also added the ability to create a new blank Code Map directly from the Architecture menu without forcing the creation of a Modeling Project.
  12. Filter link types on Code MapIntroduced a "filter link types" feature on code maps, allowing users to analyze dependencies and declutter maps by selectively showing or hiding categories of links such as calls, field reads/writes, inheritance, implements, references, and return types. This enables more focused analysis of code design and architecture.
  13. Upcoming Changes in Visual Studio Architecture and Design ToolsThis post announces upcoming changes to Visual Studio's architecture and design tools, focusing on extracting architecture and design information directly from code and validating code against architectural rules. Key changes include improved performance and integration of Code Map with existing explorers (solution explorer, object browser, class view), new filtering experiences, more compact map representations, single-click map generation, ability to refresh maps, improved top-down maps, and better integration of architectural validation with code map and code analysis. Due to the Roslyn code model, the Architecture Explorer and the ability to create UML Class Diagrams from Code are being removed. The ability to visualize code on sequence diagrams is also being cut, with a note that debugger maps and IntelliTrace offer similar scenarios. Feedback is requested.
  14. CodeLens Processing pipeline performance improvementsThis post details performance optimizations for the CodeLens Team Indicators processing pipeline in Team Foundation Server 2013 Update 3. Specifically, it addresses optimizations for changeset processing, particularly for branching and merging operations, and implements batched writing of temporary CodeLens data to reduce database and file service operations. Indicative performance improvements show over 70% reduction in run time for the Keepup and Aggregator jobs.
  15. CodeLens for Git improvements in Visual Studio 2013 Ultimate Update 3 RCThis post details improvements to CodeLens for Git indicators in Visual Studio 2013 Ultimate Update 3 RC. Key enhancements include: automatic refreshing of indicators for Git source control operations (commit, pull, sync, branch change), improved user experience for large files with many changes by showing dimmed placeholders during computation, addition of "when last changed" information to the authors indicator, and the introduction of work item indicators for TfGit when commits are associated with work items. The post also explains how commit messages can associate work items using the "Related Work Items: #1, #3" format and details scenarios where work item information might not be fully retrieved due to connection or permission issues.
  16. Code Lens for Git in Visual Studio 2013 Ultimate Update 3Introduced the preview of CodeLens Team indicators for Git in Visual Studio 2013 Update 3 CTP1. Initially, this provides 'Authors' and 'Change' indicators computed client-side for any Git repository (local, TfGit, GitHub, etc.). This differs from the server-side computation for Team Foundation Server Version Control (TfVC). Future work item indicators are planned. The post details the user experience, including the details popup for commits, contextual actions, and the commit details view in Team Explorer. It also notes that indicator refresh is manual in this CTP.
  17. CodeLens Team Indicators - Processing PipelineDetails the processing pipeline for CodeLens Team Indicators, including Keepup, Aggregator, Cleanup, and Catchup jobs. Explains job run frequencies, characteristics, administration via TFSConfig, and behavior during TFS upgrades. Provides tips for managing large files and temporary data retention.
  18. Introducing Code Map in Visual Studio 2012 Update 1 CTPIntroduces Code Map functionality in Visual Studio 2012 CTP for September. Code Map leverages the dgml format and allows users to visualize code, methods, and variables directly from the context menu. It is interactive, allowing navigation via F12 (Go To Definition), and updates dynamically as items are added, showing relationships and dependencies. The feature is context-specific based on cursor position.
  19. What is new in the Code Index SDK for Visual Studio 2012 RC?This post details updates to the Code Index SDK for Visual Studio 2012 RC. Key changes include modifications to bulk indexing, specifically adding a code index loader for PDB files to include source file and line number information for methods and method calls when using bulk indexing. The post also announces updated samples, including one that displays the source and line of offending tests and a new sample for discovering and outputting the public API of indexed assemblies, which is useful for tracking breaking changes.
  20. The Code Index – Part 3 – Code samples for using indexed informationThis post provides code samples for using the code index, specifically demonstrating how to retrieve statistical information about indexed code (assemblies, namespaces, types, methods, etc.) and how to discover ignored tests with MSTest attributes, including linking them to work items.
  21. The Code Index SDKIntroduced the Code Index SDK as a component of the Visual Studio Visualization and Modeling SDK. This SDK provides MSBuild tasks for bulk indexing managed assemblies into a local SQL Server LocalDB database. The indexed data serves as a cache for querying code element information, improving performance and scalability for architecture diagrams. The post outlines scenarios for using the SDK, such as pre-indexing assemblies during nightly builds and developing in-house tools to leverage indexed data for dependency analysis and impact assessment. It also details how to obtain the SDK, including installation steps for different Visual Studio versions.
  22. Very nice video about what's new in Visual Studio 11 Dependency GraphsThis post highlights a video demonstrating new dependency graph features in Visual Studio 11 Beta. Key features shown include leveraging the code index for both top-down and bottom-up dependency graphs, new touch-up possibilities for commenting and sharing designs, quick find, fast incremental layout, embedded toolbars, and help pages. It also mentions features removed from Visual Studio 2010.
  23. Visualize Code with Visual Studio 11 BetaThis post details the ability to visualize code and understand its relationships in Visual Studio 11 Beta, focusing on creating, reading, and editing dependency graphs. It covers getting the big picture, focusing on details through graph search and Solution Explorer integration, and communicating changes by editing graphs. It also introduces the concept of dependency graphs, nodes, links, and how to navigate and interact with them. Specific features highlighted include generating graphs for entire solutions or specific parts, saving graphs, browsing through zoom and pan, examining items and relationships, expanding/collapsing groups, and using keyboard shortcuts. It also explains how to find items on graphs using CTRL+F and F3, and how to find items in the solution using Solution Explorer and context menus like 'Is Called By'. The post also covers editing graphs by adding nodes, links, comments, groups, and by renaming or deleting elements.
  24. Developing Windows Phone 7 apps with the help of dependency graphs in Visual Studio 2010 UltimateThis post introduces the use of dependency graphs in Visual Studio 2010 Ultimate to visualize and understand code organization during the development of Windows Phone 7 apps. It highlights how architects can leverage these graphs to gain insights into their codebase.
  25. Want to better understand relationships between Team Foundation Server work items?Introduced the Work Item Visualizer, a DGML graph tool for visualizing links between Team Foundation Server work items. This tool helps analyze work item hierarchy, perform basic risk/impact analysis, discuss linked work item scope, plan projects, and view the entire tree of linked work items without creating separate queries or reports.
  26. Short videos about how to visualize your code or system with Visual Studio 2010 UltimateThis post introduces short videos demonstrating how to use Visual Studio 2010 Ultimate for architectural exploration. It covers exploring large codebases in Architecture Explorer, visualizing code relationships on dependency diagrams, and building static and dynamic system views using component and sequence diagrams, with the ability to link model elements to work items.
  27. VS ALM Library Updates on MSDN for December 2010This post announces the release of Microsoft Visual Studio 2010 Feature Pack 2, which includes extended testing capabilities and code visualization/modeling capabilities. It also details new documentation for these features, including support for Firefox browser playback tests, editing coded UI tests, and creating coded UI tests for Silverlight 4 applications. Additionally, it highlights updates to the MSDN ALM Library for Eclipse, Portfolio Management integration with Project Server, build customization documentation, and Lab Management documentation comparing host capabilities.
  28. Visual Studio 2010 Feature Pack 2 expands test capabilities and includes code visualization + modeling tools from previous feature packThis feature pack expands testing capabilities to include action recordings and coded UI tests for Silverlight 4 applications, as well as support for Mozilla Firefox 3.5 and 3.6 in coded UI tests for web applications. It also introduces the ability to generate skeleton code from UML class diagrams, create UML class diagrams from existing code, generate dependency graphs for C, C++, and ASP.NET projects, import XMI 2.1 files from other modeling tools, link work items to model elements, create layer diagrams from C/C++ code, and validate code against layer diagrams.
  29. Visual Studio 2010 Ultimate helps you gain more control over code dependenciesThis post details how Visual Studio 2010 Ultimate enables control over code architecture through dependency visualization at physical (assembly, namespace, class) and logical (layer diagrams) levels. It introduces top-down and bottom-up approaches using dependency graphs and Architecture Explorer, and highlights the use of layer validation for conflict detection and incremental resolution. It also mentions the Visualization & Modeling Feature Pack for custom layer validation rules in C/C++.