Modeling the Application

To make sure your application meets user requirements, you can use Visual Studio Ultimate to understand the code and model your application. Visual Studio Ultimate helps you visualize the code so you can understand its structure, relationships, and behavior more easily. You can create models at different levels of detail and track requirements, tasks, test cases, bugs, or other kinds of work associated with your models by linking model elements to Team Foundation Server work items and your development plan. You can perform these tasks throughout the application lifecycle as part of the development process. See What's New in Modeling Tools for Application Lifecycle Management in Visual Studio 2012 and Scenario Overview: Change Your Design Using Visualization and Modeling.


Visualize the code:

  • See the organization and dependencies between assemblies, namespaces, classes, methods, and so on by creating dependency graphs from code.

  • See the message sequence inside a method by generating sequence diagrams from code.

  • See the class structure and members for a specific project by creating class diagrams from code.

  • Find conflicts between your code and its design by creating layer diagrams to validate code.

Describe and communicate user requirements:

  • Clarify user stories, business rules, and other requirements and help ensure their consistency by drawing UML diagrams such as use case, activity, and class diagrams.

Define the architecture:

  • Model the large-scale structure of your software system and the design patterns by drawing UML component, class, and sequence diagrams.

  • Define and enforce constraints on dependencies between the components of your code by creating layer diagrams.

Validate your system with the requirements and intended design:

  • Define acceptance tests or system tests based on the requirements models. This creates a strong relationship between the tests and your users' requirements and helps you update the system more easily when the requirements change.

  • Validate code dependencies with layer diagrams that describe the intended architecture and prevent changes that might conflict with the design.

Share models, diagrams, and graphs using Team Foundation version control:

  • Put dependency graphs, modeling projects, UML diagrams, and layer diagrams under Team Foundation version control so you can share them.

When you have multiple users who work with these items under Team Foundation version control, use theseĀ guidelines to help you avoid version control issues:

Generate or configure parts of your application from UML or domain-specific languages:

  • Make your design more responsive to requirements changes and easily variable across a product line.

Customize models and diagrams:

  • Adapt models to how your project uses them by defining additional properties for UML elements, validation constraints to make sure that your models conform to your business rules, and additional menu commands and toolbox items.

  • Create your own domain-specific languages.

Types of Models and Their Uses

Model type and typical uses

Dependency graph

Dependency graphs help you see the organization and relationships in your code.

Typical uses:

  • Examine program code so you can better understand its structure and its dependencies, how to update it, and estimate the cost of proposed changes.


Layer diagram

Layer diagrams let you define the structure of an application as a set of layers or blocks with explicit dependencies. You can run validation to discover conflicts between dependencies in the code and dependencies described on a layer diagram.

Typical uses:

  • Stabilize the structure of the application through numerous changes over its life.

  • Discover unintentional dependency conflicts before checking in changes to the code.


UML model

A UML model includes several views, including class, component, use case, activity, and sequence diagrams. You can customize UML to suit your application domain. For example, you can attach tags, additional information, and constraints to the model elements. You can also define tools that operate on the models. See Developing Models for Software Design.

Typical uses:

Code-based sequence diagram

Sequence diagrams that you can generate from .NET code help you visualize how the code implements a method.

Typical uses:

  • Understand and analyze program code.


Domain-specific language (DSL)

A DSL is a notation that you design for a specific purpose. In Visual Studio, it is usually graphical.

Typical uses:

  • Generate or configure parts of the application. Work is required to develop the notation and tools. The result can be a better fit to your domain than a UML customization.

  • For large projects or in product lines where the investment in developing the DSL and its tools is returned by its use in more than one project.


Where can I get more information?



Visual Studio ALM + Team Foundation Server Blog

Technical Articles and Journals

The Architecture Journal - Issue 23: Architecture Modeling and Processes

Other Sites

MSDN Architecture Center

See Also


Application Lifecycle Management with Visual Studio and Team Foundation Server