Was this page helpful?
Your feedback about this content is important. Let us know what you think.
Additional feedback?
1500 characters remaining
Export (0) Print
Expand All

Analyze and model your architecture

Make sure your app meets user requirements by using Visual Studio architecture and modeling tools to design and model your app. Understand existing program code more easily by using Visual Studio to visualize the code's structure, behavior, and relationships.

Create models at different levels of detail throughout the application lifecycle as part of your development process. Track requirements, tasks, test cases, bugs, and other work associated with your models by linking model elements to Team Foundation Server work items and your development plan. See Scenario: Change your design using visualization and modeling.

To see which versions of Visual Studio support each feature, see Version support for architecture and modeling tools

Visualize code:

  • See the code's organization and relationships by creating code maps. Visualize dependencies between assemblies, namespaces, classes, methods, and so on.

  • 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.

Note: In this release of Visual Studio, the term code map is used in place of dependency graph. The term graph when used alone generally refers to a Directed Graph or DGML diagram (or document). Code maps are a specialized type of DGML diagram.

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 code maps using Team Foundation version control:

  • Put code maps, 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.

Model type and typical uses

Code maps

Code maps 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.

See:

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.

See:

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 Create models for your app.

Typical uses:

  • Describe requirements and design. You can quickly apply UML to the development of any application. See Use models in your development process.

  • Generate or configure tests or parts of an application. Some work is required to customize the notation and develop the generation templates or configurable application. See Generate and configure your app from models.

  • For general description and for code generation or configuration in smaller projects.

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.

See:

Show:
© 2015 Microsoft