Sneak peek at the first “Feature Pack” for VS2010 Visualization and Modeling Tools

I’ve been hinting about a number of new capabilities that my team has been working on that are designed to add additional functionality to the bits you will experience in the final VS2010 build due out April 12th. This post will give you the some details of those new capabilities.

( I’ll have a post out later that talks a bit about the “Feature Pack” concept and why this deliverable is actually quite a bit different than PowerTool deliverables you have come to know and love. Again, more on this later.  )

We will release this “Feature Pack” to all active MSDN subscribers shortly after we RTM VS2010 ( exact date TBD ).


What’s in this “Feature Pack”?

There are three major areas that this “Feature Pack” is designed to address:

  1. Increased Visualization Support
    1. Visualize your native ( C++ ) code
    2. Visualize your WAP or Web Sites or ASP.NET MVC code
  2. Increased UML support
    1. Code Generation from UML Class diagram
    2. Rapid population of Modeling Store from Architecture Explorer
    3. XMI 2.1 Import
    4. [UPDATED] Work Item to Model Element Back linking.
  3. Increased support for Layer Diagram Extensibility


Increased Visualization Support

In the RTM release of VS2010, we have great visualization support for managed assemblies. We don’t have any support for native developers, nor did we have first class support for Web projects or Web Sites developed inside Visual Studio.

With this “Feature Pack”, you now have some great functionality for both native and web projects in Visual Studio 2010.


Native Code Visualization

All of the visualization features in the RTM version of VS2010 support managed code ( runtime versions 1.1 on up ). This “Feature Pack” will now allow you to visualize your C++ projects, as well as supporting C++ images ( .dll or exe ), with extra support if you also have the PDBs with those images. The support is in three forms:

  1. Architecture Explorer – allows you to explorer your solution just like you would with managed code via the cascading browser
  2. #include dependencies – pick a header file, and visualize the include dependencies associated with that header file. This is great stuff when you are trying to determine just how bad touching a particular header file will mean to your already taxed build times!
  3. Inter-binary dependencies – drag a native DLL or EXE onto the DGML document surface, and we’ll crack those images and tell you how they are related.
  4. Standard Graph Support – if you select the Generate Dependency->By Assembly menu with a C++ project loaded, you’ll get a very similar look graph that you are used to on the managed side. Here’s a shot of a simple MFC application showing dependencies on the ATL CString type:

Web Application and Web Site Project Visualizations

If you are using Web Site, Web Application Projects, or taking advantage of the latest ASP.NET MVC framework, we’ve got some great stuff coming for you as well! 


We will show you not only how your pages are dependent on each other, but how they are also dependent on controls, and how they are related to the code-behind logic behind them, if applicable. And of course, the ability to drive right into your pages, master templates, and code directly from the graph will be supported.



Increased UML Support

We’ve had a ton of great feedback on the UML support that we have put in VS2010. A very common request however, has been the need for quick population of the UML Model Store from code, as well as the ability to generate code from the UML class diagram.

This “Feature Pack” gives you both capabilities.

Code Generation from UML Class diagram

C# code generation is now possible once we ship this “Feature Pack”. Simply right clicking on a UML class diagram, select “Generate Code”, and depending on what is on that diagram, C# code conforming to a corresponding T4 template is created.

Rapid population of Modeling Store from Architecture Explorer

Many folks have asked how they can visualize their current systems into a UML modeling project in order to do some “To-Be” modeling. We’ve enabled that scenario in this “Feature Pack” via a tight integration with the Architecture Explorer. We’ve enabled a drag-drop gesture from the Arch Explorer to the UML Class diagram, for Namespaces and types.

For example, in order to pull in the PetShop.BLL namespace from the Petshop example, I’ll you need to do is drag it onto a UML Class Diagram:


This will automatically create all the types and packages, including referenced types, into the Modeling store. Here’s the UML Model Explorer after I dropped that namespace on the class diagram:


You can also drag individual types ( such as Classes, Interfaces, etc. ) out onto the UML class diagram as well.


XMI Import

This “Feature Pack” enables XMI 2.1 import. This allows you to grab any XMI 2.1 conformant file and import that into VS2010.

We’re still not complete in regards to total coverage of the UML 2.1 spec. This shouldn’t be a surprise to anyone paying attention, as VS2010 only has support for the UML Class, Sequence, Use Case, Component, and Activity diagrams. Any meta types outside of the types that can be displayed on those diagrams will clearly not be imported. Most notably, State and Deployment elements won’t be pulled in.


[UPDATED 3/26/2010]Work Item to Model Element Back-Links

In the RTM version of VS2010, you can right click on a UML model element ( or Layer Diagram node ), and associate that element with a TFS work item. However, you do not have the ability jump to that model element from the Work item if you are currently looking at the work item in the VS. With this “Feature Pack”, you can now do that via a new Link Item type that will be created every time you make an explicit connection between a model element to a work item.

[ I can’t believe I forgot to mention this feature when I posted this info the first time. Sorry ‘bout that! :( )


Increased support for Layer Diagram Extensibility

Extensibility for the layer diagram includes 3 major parts:

  1. The ability to easily create command and gesture extensions for elements on a layer diagram. This mirrors the extension points for our UML diagrams.
  2. An API that allows you to work with layer model elements i.e. to read from and write to layer diagram models.
  3. An extension point and an API that supports the creation of custom layer validation rules. This allows you to
    1. Hook into the layer validation engine invoked when the user clicks “Validate Architecture” (Note: also works from the command line)
    2. Read from and write to the graph that is used during validation analysis.
    3. Create validation errors that are logged to the error list


This is meant to just give you a taste of what is coming soon after RTM. I’ll be providing more details as we get closer to making it available to all you active MSDN subscribers. And like I mentioned earlier, I will be going into more details around the significant differences between “Feature Pack” and PowerTools in a couple days.

Stay Tuned!