Kate Gregory has probably forgotten more coding tricks than I have ever learned. That means that she likes her Visual Studio with meat and potatoes. With the new extensibility model in Visual Studio 2010,  Visual Studio can now be the primary source or protein in your IDE diet. In this episode Kate tells us how to add a little hot sauce using Visual Studio extensions.

Kate is in her fourth decade of being paid to program. Her firm, Gregory Consulting Limited, is based in rural Ontario and helps clients adopt new technologies and adjust to the changing business environment. Current work makes heavy use of .NET and Visual C++ along with SharePoint and both web and client development, especially for Windows 7. Managing, mentoring, technical writing, and technical speaking occupy much of her time, but she still writes code every week.

Kate is the author of over a dozen books and speaks at DevTeach, TechEd (USA, Europe, Africa), and TechDays, among others. Kate is a C++ MVP, a founding sponsor of the Toronto .NET Users Group, the founder of the East of Toronto .NET Users group, a member of the INETA speakers bureau, and a member of adjunct faculty at Trent University in Peterborough. Since January 2002 she has been Microsoft Regional Director for Toronto and since January 2004 she has been awarded the Microsoft Most Valuable Professional designation for Visual C++. In June 2005 she won the Regional Director of the year award.

Show Links

• Kate’s Blog
• Kate’s Pluralsight course, Customizing and Extending Visual Studio 2010
• Visual Studio Extensibility (VSX)
• Visual Studio SDK
• Visual Studio Gallery
• The Code Gallery

So here is a hidden performance increasing jewel you might find useful.  We can set the default open mode to be in full XAML view.

First thing you need to do is in Visual Studio go to your Tools ==> Options ==> Text Editor ==> XAML ==> Miscellaneous.  There you will see an option for “Always open documents in full XAML view”.  Check that box.

Now every time you open a XAML file it will open in full XAML view and give you one less thing to gripe about.

Since when is a successful operation a problem?  Now, of course, I am assuming this is intentional and is transmitting information back to Microsoft to tell them that it was successful.  But, I can see how easy it would be for someone to mistaken this for a legitimate error.  Then again, maybe it is.

You know how Visual Studio creates default files in a test project when you create a new one? Those days of immediate file deletion are over, baby!

So, how do I disable resharper to make sure I don’t get any pesky resharper files into my directory structure? By using Visual Studio’s Add-In manager.

1. In Visual Studio go to Tools > Add-in Manager.
2. Uncheck the ReSharper 4 Add-in and then unselect the Startup box so that when you start up VS the next time, the Add-in won’t load.

Not so fast, Gerome! Turns out that when ReSharper installed, it installed in such a way as to make this impossible. The fix is easy.

In your ReSharper Program Files directory, JetBrains\ReSharper\v4.0\Bin, find the Product.VisualStudio.90.AddIn file. Visual Studio needs to be able to modify this file and the installer laid in down read only. Make the file write-able and go back to VS and go through the process again. This time you will be able to turn off startup.

Even after doing this, the ReSharper menu remains in my IDE, which bugs me. All of the functionality is disabled and the context features in the code files are gone, but still…

• Simplified the user experience through cleaner “Add to Source Control” dialogs, drag and drop support to the Source Control Explorer and a much easier to use “Workspace” dialog for working folder mappings.
• Version control now automatically supports non-solution controlled files.
• Various changes to the Source Control Explorer such as a new checkin date/time display column, local path hyperlink support and en editable source location field.

I am not a big fan of installing a beta SP on may dev laptop, but I gotta tell ya, I did it for that feature alone.

Go here:

And get this screen.

Why? Because if you have made some changes to a file while it wasn’t checked out, you will not have the option to merge to your local machine. This option will simply overwrite your local code file.

Why does this feature exist? Because oodles of people asked for it because they were used to it in Source Safe, and the team relented.

Repeat: This is a bad idea!

If, however, you are a person who simply must have this turned on in order to feel snug, there is a way to do it without making your entire team experience the hell that will be yours.

In Visual Studio, go to Tools > Options > Source Control > Environment and do this:

I warned you.

We know that the modeling tools in Team System 2008 are, well… there’s room for improvement. How valuable is a Logical Data Center Design Model when we can’t derive it from a reverse engineering action? There has also been much frustration with the lack of standard UML support in Visual Studio. Guess what?

Rosario proposes that we promote modeling to a first class citizen of the complete Application Lifecycle Management model. Here’s my major takeaway: The way modeling is being supported enables visual exploration of your code base in a way that is seamless with the development process. This can honestly change the fundamental code development experience.

Also, I can plan on sun setting all my organizations Sparx licenses. Cool.

• UML 2.1 at the logical layer
• DSLs at the physical layer
• Generate models from existing assets. This is being discussed as “Architectural Discovery” which is a hilarious term in itself.
• The April CTP has the following
• UML Class Diagram
• UML Use Cases Diagram
• UML Sequence Diagram
• UML Component Diagram
• UML Activity Diagram
• Architecture Explorer
• There is a unifying model underlying all of this, the diagrams are simply views upon that model.
• Newer versions will have some of the features we got to see today. These will come in another CTP later this year.
• Layer Diagram
• Seriously cool, this allows to separate concerns of our tiers in a system.
• I can bind my namespaces to logical layers of my application
• Also has some seriously cool visualization tools for looking through your code.
• Using these views, we can see our cohesion and inheritance in physical form.
• How about namespace visualization using a graph model? Dang, this is cool.
• How about a dependency visualization? NDepend better look out because this one isn’t half bad.
• AND, all views enable us to click right through to our source code. Neato.
• XMI support (seriously, wow). This means we can export models from other applications like Sparx EA, Altova, and Rational and bring them right into Visual Studio. Oh, and it will pull Visio models as well.
• Round tripping of component models to code
• Peter actually built some sequence diagrams and I gotta say that this UX is going to be MUCH better than Enterprise Architect, which will soon loose it’s Market Share. Even use cases look neater.
• Sequence diagrams can be round tripped with classes and even methods. This means we can examine the complexity of our code at a usable level, and do it visually.

What if you could prescribe separation of tiers and limit leaky abstractions?

Nuggets

“Any system should be possible to represent on a white broad in no more than 13 boxes.”

“Using model is simply a way of managing complexity.”

“There will be a model store capability that means we don’t need to keep our models in the same solutions with our code.” But you can

Because the models are all built on DSLs, there is someone out there who has automated the process of building test cases from activity diagrams. That is hotter than a 2 dollar pistol.

We can attach other files like Word files to your model itself.

What if we could could light up the models in the debugger to see highlighting of current activity in a sequence diagram? Neato.

They are trying to figure out how to include support for generating design patterns like found in EA and Rational. This is fun because you can generate domain specific code with a fundamental implementation in a known design pattern like Forward Controller or something.

I need a bigger monitor. Seriously, boss. I need a bigger monitor.

It is clear (and stated) that other RDBMS vendors will follow suit as MS has provided a fundamentally pluggable model for vendors to integrate their DBs into Visual Studio with a provider model. Can you smell Oracle, boys and girls? I can. Gert is being vague about who they are working with. MySQL will be cool.

There are several levels of extensibility:

• DB Provider
• This is the actual connectivity to your own RDBMS. This provider is responsible for talking to the VS model layer for the DB project and translating between your DB and the model.
• VS Features
• The ability to alter features in Visual Studio, like:
• Refactorings available for a given provider.
• Syntax highlighting
• language formatting rules for reverse engineering operations
• Static analysis rules for your particular SQL language
• Yes, you get static analysis rules for TSQL. This is the death clock for select * from …
• Static analysis in BD2 SQL may be different than that in MS TSQL
• You can write your own static analysis rules in .Net by inheriting from the provided Rule class or *yeah* implementing an interface (are we hearing a theme out of MS?) I suppose if your company were anal enough, you could actually implement your proprietary naming convention rules as static analysis rules. Gert actually did this is an demo by writing a rule that checked column names to ensure they were in Pascal case. Neato. The funny part is when some of the developers in the room started telling him how his demo code could be refactored. Lol.
• Model Extensibility
• VS actually works against a model of the data store and lets the provider do the translation.
• Using the model paradigm for DB development provides full round trip model to implementation support for any given DB.
• Gert actually showed a little command line app that looked at a Northwind DB in Access and a different Northwind DB in SQL Server and compared them. There would be very different SQL syntaxes if we were simply comparing creation scripts. The DBs showed as the same. More accurately, the models checked as the same. Cool.
• So, I could script the process of taking a DB2 database and migrating it to SQL Server, or visa versa, in this model paradigm.

This session signaled several things to me.

1. MS products really are being designed with extensibility and integration in mind. No really, this time.
2. The Data Dude model of working with databases has genuine merit. The days of SSMS (SQL Server Management Studio) and the Query Analyzer fan base are numbered. Treating DBAs as developers really is a better model.
3. Something different is occurring at MS with the changing of the guard.

At first I thought that the configuration options for Visual Studio were wrong. I checked the directory settings for Environment/Import and Export Settings and Project and Solutions. Everything seemed in order.

After some journey through the Windows registry, I found this inconsistent value for the HKEY_CURRENT_USER\Software\Microsoft\Visual Studio\8.0\VisualStudioLocation key. It was set to the value “VisualStudioProject” to be more precise. Changing this value to the correct path in the Document and Settings directory solved he problem.

This is a very specific problem that really affected my mood. It even put these backup folders in places that didn’t had any source file. Someone at Microsoft should get fired for this (no, just kidding). An IDE from JetBrains that targets .NET with Boo and IronRuby as first class citizens. That would be cool, don’t you think?