One of the first enhancements to the IDE is the capability Microsoft Visual Studio 2010 offers for navigating a call hierarchy. Over the years, many of us have discovered the important Go to Definition and Find All References menu items, allowing us to quickly navigate through our code. But we still often have to do a lot of searching if we’re trying to trace through the code during development. The Call Hierarchy window expands on these concepts, giving us a way to drill down visually through the call references, showing “calls to” and “calls from” a function.
The code editor has lots of improvements, partly because it now uses WPF (Windows Presentation Framework). The zoom feature is nice. Now you can quickly zoom in and out just like you can in a word processor such as Microsoft Word. And when you click on a variable or identifier, every occurrence of the variable throughout the document gets a faint highlight over it.
One really interesting feature is called Generate from Usage. Previous versions of Microsoft Visual Studio had a handy feature called Generate Method Stub. This was activated through a pop-up menu when you typed a function call for a function that doesn’t exist. Other improvements include enhancements to IntelliSense and improvements to the live semantic errors (the squiggly underlines that appear in your code)
Version 4.0 of C# now supports support for late binding, type equivalence support, and Covariance and Contravariance. The type equivalence support is pretty important because it allows you to embed another assembly’s types right in your own assembly so that you can reference those types without having to reference the other assembly at runtime. Why is that a good thing? Because that way you can link at runtime to different versions of that other assembly, which in the past has been very difficult.
If you have experience in older C/C++ languages, you know what a welcome relief the .NET IO classes were, especially the File, Directory and Path classes. For some reason, traversing files and subdirectories had always been a pain in the rear. I remember fighting with the file-searching routines in C, and their abysmal Win32 API equivalents. Microsoft certainly simplified these activities with the .NET classes (as did the creators of other languages such as Python). And now in .NET they’re even easier. The newest version of the Directory class includes methods that return enumerations. That means you can use LINQ on them.
ASP.NET has many improvements as well. For starters, the caching mechanism has been improved to include cache provider extensions, letting you (or a third party) create, as the documentation says, “more intelligent output-caching strategies for websites.” And if you’ve worked on website development at all, then you know just how important this is for keeping a fast, optimal web server.
WPF is now considered to be Version 4 (apparently to match the version numbers of everything else here), and with it comes a few new controls, including Calendar, DataGrid, DatePicker and WebBrowser. There are improvements to maintaining visual state, as well as support for touch input. The text rendering is also greatly improved. Microsoft was hit with a lot of complaints over text rendering early on in both Silverlight and WPF. Initially the company’s execs tried to convince us that the new text rendering was somehow better, even though to most of us with normal vision the text was ugly and blurry. They apparently listened and now the text is rendered much better, even allowing you to use ClearType.
The debugger has greatly improved. You can have greater control over your breakpoints, including the ability to label them and even import and export them. (I’m not sure when you’d need to import and export them, but I imagine there might be the occasional need for it.) The thread debugging window has been improved; this is good because the previous one kind of stunk.
In terms of architecture, there are a lot of improvements to .NET. For example, there’s an entire set of classes now for supporting multicore, parallel programming and even LINQ. (This might look familiar. That’s because it is. Microsoft released an early version of these classes called .NET Parallel Extensions, and they ran under .NET 3.5. I took these classes for a spin and they’re really great. For example, there’s a Parallel.For method that functions very much like a traditional for loop, except the code inside the loop runs in parallel for each iteration rather than sequentially. Indeed, using some tracing tools, by creating a parallel for loop with many iterations, I was able to see that they were being distributed among the cores of my CPU. Very cool.