Code Editor & Designer

Just how good is a software developer’s IDE without a good code editor? Any decent editor has support for syntax highlighting, context sensitive help, and basic formatting (for properly indenting source code). And the higher levels of editors have support for bookmarks, and templates. However, the level of customization of most those editors have been disappointing to say the least.

Enter the Visual Studio .NET environment. Each type of file you edit within the IDE can have its own formatting rules and syntax highlighting just like the other IDE’s. But the editor goes far beyond that. Take for example a Visual Basic .NET source code file (and this is true for most other source files). You have IntelliSense completion of classes and method, a context sensitive menu that allows access to the object browser, class viewer, and parameter information. As the top of the editor window it lists all the objects on the page, and next to it, the properties, methods, and events for that object. Just by selecting an object and method, the editor will take you the code for that section, or create a new template within you code. Very handy if you can’t remember the syntax of a particular event handler for the object you are using. The editor also has the ability to split the code window in two, so you can see separate parts of the same source file at the same time. My favorite feature (ok, I’m pretty easy to satisfy) is the collapsible code blocks. Each class, structure, method, or whatever, can be collapsed into a single line within the editor, so that it is hidden from view. Someone else may have had the idea first, but it one of the things that make you say to yourself, “why wasn’t this here before, and why doesn’t everyone have this function”.

The IDE also switches easily between code and designer mode, to allow you to work in both views with little effort. While the “design” mode is a new thing for most Microsoft C/C++ users, the VB, Delphi, and C++Builder community have been using if for a long time. It was nice to see Microsoft finally realize that it was a good thing to have. One of the historical aspects of some Microsoft technology has been the “embrace and extend” method of implementation. The RAD (Rapid Application Development) concept of having a design surface for visual development is no different (sure, it was in Visual Basic, but it was no where near as usable as say, the Delphi IDE). I can understand Visual Basic being “Visual”, but what was so “Visual” about Visual C++ or Visual J++. Microsoft latched onto the terms, and did not deliver. However, the Visual Studio .NET IDE can actually use the word “Visual” without people scratching their head wondering where the visual aspects are. After all, one of, if not the key developer for Borland’s Delphi is now working for Microsoft. Each language built into the environment can be used to design an application in a visual manner by dragging components from the toolbox, and dropping them on the design surface. The designer keeps track of both visual and non-visual components, and can keep them separate so as not to interfere with you applications visual layout. Want to add an event handler for a button you just added? Double click on the button in design mode, and it takes you to a template in your code for the event, ready for you to enter the necessary code. Again, not a revolutionary new concept to some developers, but a nice addition to those that never had it before.

One of the last things I would like to cover in the visual designer is the addition of the database connectivity options in the Enterprise Architect version of Visual Studio .NET. If your application interacts with any database systems, you usually had to design your tables and stored procedures in one environment, and the actual connectivity in another. Now you can do both from the same IDE. Using the server explorer, you can connect to the data source or server that you need access too, and visually design you tables and stored procedures. This saves a lot of time, and as mentioned in the debugging section, allows you to include these database objects in the entire debugging session. This makes for a nice addition to overall development.

Class Views and Object Viewing

The concept of a class viewer and object browser are nothing new to developers, but the close integration between the source code you are writing in the editor, and the ability to see a complete class hierarchy of your entire solution is a must. However, I have not seen to many development environments that have both, and if they do, they don’t do it very well. The class viewers usually can’t keep in-sync with your project, and the object browsers are hard to navigate. Both systems in the Visual Studio .NET IDE are well integrated, and easily understandable. And as with the rest of the IDE, they compliment each other nicely. From within the class view, I can get a context sensitive menu that not only has options for finding where in my application a particular object is referenced, but also allows my to jump into the object browser directly to that object. I can then do the same from the object browser.

The Server Explorer

The Server Explorer built into the IDE is a feature that, frankly, I was not expecting in a development environment. Now that I have seen the use of this feature, I don’t think I could work without it. From within the Server Explorer window, I can create data sources, connection to other servers, and, once connected to a server, view the available services that are available to me. Some of these services include event logs, message queues, performance counters, and system services on the remote sever. Say you wanted to include the ability to write events to the Application log on a remote server. By just dragging the Application event log from the server explorer to your design surface, the required code is created, and all you have to do is access the object (if you have the right security permissions). You can do the same with the system services and performance counters. This could truly be the start of remote RAD design.