I have picked out a selection of chapters and topics as they caught my attention.
Part 1 - The IDE
Apart from the obvious topics you would expect to see covered here, such as the IDE layout, the various windows, keyboard shortcuts, the Toolbox and so on, it also includes useful little hints, such as suitable alternative fonts to the standard Courier New.
Thanks to the clear explanation in this Part of the book, I also finally managed to understand how the new
window docking features in VS 2005 actually worked. In the past I've been in that (majority?) group who left
the IDE windows set up at the default because we got fed up of "losing" windows that we thought we'd dragged to better locations.
One thing it didn't mention in the explanation of Layout Settings is that it seems that you have to close a Solution and re-open it for changes to Layout Mode and ShowGrid settings to kick in (at least on the PC I tried it out on). However, on the plus side, in the next section they introduced me to the especially useful magenta line which takes lining up one stage further - allowing you to line up the text areas when dealing with controls that have a text aspect to them. This was a tool that I had been totally unaware of.
Part 2 - Project and Solution Design
This covers areas such as common properties and configuration properties for Solutions and Projects. It works through various ways and scenarios for these kinds of configuration.
There is a very useful chapter on Source Control and another that describes XML Resource files in some detail.
Part 3 - Documentation and Research
This part includes details of finer points such as Help Favorites and Customizing Help just the way you want it. The kind things you always mean to sort out but somehow never get round to!
I was slightly disappointed with Chapter 12, XML Comments. Not because it lacks detail on all the various tags that you can use - there is a whole range of these explained, each with realistic samples. But I felt that it more or less fizzled out on the topic once they had got to the end of the list of tags, almost as if they had spent all their energy on the lists of tags and had become bored with the subject and wanted to move on. I certainly would have liked more detailed explanation or a walkthrough of how to use the XML Comments in a meaningful way in a real world project. Unfortunately, the downloadable code samples didn't include a sample for this chapter which compounded my disappointment.
Also in this part of the book, there is a brief overview of the Document Outline Window in VS 2005. Although it doesn't really do anything that you can't achieve by just selecting the control on the form's design surface, in a very busy GUI, possibly with some controls being partially or fully hidden, then it can be very useful. The authors also recommended using this window to see if controls were nested and, if so, which ones; I thought to myself that that wasn't likely to happen much and then the very next day, along comes this thread: http://www.vbcity.com/forums/topic.asp?tid=135597
which contains that exact problem and the same suggested solution. So full marks to them for that one.
Part 4 -Security and Modeling
The chapter on Code Generation briefly looks at a number of features and begins with some usefully worked through examples of how to use the Class Designer. If you haven't dabbled with this tool much then you might find this introduction illuminating. You will probably need to access the MSDN help too if you are going to use Class Diagrams to any great extent; happily the MSDN entries for this topic are quite comprehensive and clearer than many.
The Object Test Bench also gets some coverage and, once you have worked out how to access this feature (View > Other Windows > Object Test Bench) the worked examples are useful.
In the fairly short Chapter 15, Security Concepts get a brief explanation and it helps the reader to understand the core difference between code-based security and role-based security approaches.
Part 5 - Coding
Part V begins with an explanation of Intellisense. It then moves on to bring you up to speed on the Code Snippets feature in VS 2005 . As well as introducing the built in snippets that ship with VS 2005, there is coverage of how to create your own the hard way and the slightly easier way. It also includes a couple of useful hints about problems to watch out for.
Regions, Outlining and Bookmarks, all of which are available in earlier editions of Visual Studio, of course are covered here too but it does include some newly available features, such as XML Commenting for Regions
The next chapter provides the link to the download of Refactor! (currently available free under a deal between Developer Express and Microsoft) and then walks through some of the refactoring scenarios which can be aided with this tool.
Chapter 22 briefly describes some of the new VB 2005 features, Generics, Nullable and Partial Types and Operator Overloading. The coverage is brief, but the chapter does contain some useful hints and warnings for the unwary.
The new style "My" namespace is covered in Chapter 24. The main components are described and several code snippet examples of usage are included.
Part 6 - Automation
The first chapter in Part 6 is a good example of the kind of topic coverage that makes such a specialist book so useful. With detailed instruction on how you can create your own item templates and project templates, plus a full explanation of how to create and install more complex templates, complete with wizards, you can learn everything you need to know about this speciality topic .
Chapter 26 introduces Macros and goes on to look a little deeper into the DTE object; information you will need if you want to advance from the standard "record, save, use" approach for simple macros.
Connection Strings are the subject of the next chapter. This is one of the chapters I'd have happily seen dropped in favour of more coverage of other subjects, a view I also had on the Strongly Typed Datasets, DataBinding and the Starter Kits chapters.
However I thought that the chapters on Add-Ins and Third-party Extensions on the other hand were highly relevant, fairly detailed, useful and exactly the kind of thing I was looking for in the book.
Part 7 - Other Time Savers
Always an intriguing title - we all like good, reliable time savers when we can find them. To a large extent though several of the ten chapters in this part were more "Other Topics" than "Other Time Savers". That's not to say that many of them are not useful, but I didn't think they really all belonged under the same umbrella.
Workspace Control in Chapter 35 was interesting but I would have liked the explanations to drill down further than they did. "Find and Replace" in the next chapter did however get a comprehensive workout. The Server Explorer and Visual DataBase Tools chapters are a handy first walkthrough. There are a collection of various Tips, Hacks and Tweaks in Chapter 40; something I would have enjoyed seeing more of.
Two chapters covered aspects of web application development and the final two chapters - although probably not qualifying as Time Savers - were very interesting in their introduction to Device Application programming; not something you often see in mainstream books.
Part 8 - Build and Deployment
Those of us who have tried using the various upgrade wizards in the past usually approach this subject with some level of fear. It's clear that the authors have some experience in this field too and so the first chapter includes advice that includes a section headed "Things That Just Don't Work". Again, this is the kind of coverage that adds tremendous value to this kind of book.
Part 8 also includes introductory walkthroughs and explanation of the various Build options, the Compile page, MSBuild, building an Installer with the help of the Setup and Deployment project and finally ClickOnce deployment.
Part 9 - Debugging and Testing
Given that debugging is often one of the most time-consuming aspects of our development day, this is an important part of the book. Several chapters work their way through the subject and I was impressed to see that the coverage included material beyond the usual window by window walkthrough of the basic tools and windows that is seen in many books. Chapter 50, for example, steps into the world of Debugging Proxies and Visualizers and Chapter 52 has help on debugging Macros; very relevant for a book that is centred on Visual Studio. Part 9 ends with a chapter on Unit Testing.
Part 10 - Extensions for Visual Studio 2005
The book wraps up with this section which includes coverage at various levels of InfoPath 2003 Toolkit, Visual Studio Tools for Office and the Visual Studio Team System.