Customer Reviews

Professional Visual Studio Extensibility

5 star:		(1)
4 star:		(2)
3 star:		(1)
2 star:		(3)
1 star:		(2)

 

 

I'm not sure what the basic idea for the book was; to provide a summary of some (not anywhere near all) the features of the Visual Studio SDK or to serve as an introduction to using the SDK?

In any case, the book is mostly filler. The few examples are always trivial ones like hooking up a button or printing a message somewhere. I think I learned more about the capabilities of the SDK from reading the (argh!) actual SDK doc intros than from reading this entire book.

If you just want to write macros or add-ins for Visual Studio then there are other better books, online examples, etc. If you want to do something more advanced like create a VSPackage, language service, etc. then this is not the book.

Rather than buy this book, please read MSDN articles. I didn't get anything out of it.

Just go to MSDN and read about this or get books like "DomainSpecificDevelopment". YOu won't get anything out of this one other than a few screen shots.

I agree with Demetrius. The book lacks substance and the style is dry, dry dry. I know this stuff isn't sexy, but this author seems to go out of his way to put the reader to sleep. A pity. All the other books in this series I've read (quite a few) are much, much better.

Keyvan Nayyeri explores each of the areas of VS Extensibility. He breaks the book up into logical sections, first illustrating the API that Visual Studio uses to represent the user interface. If you have never looked at the API for Visual Studio before, it's not user friendly, so it was good that he provided a brief description of the properties and methods for the various objects, followed by a few examples using those objects to perform certain tasks.

I thought some of the most useful content of the book features discussions on showing custom windows forms, and creating custom option windows using user controls (to display in the Tools > Options dialog), and creating custom debugger type proxies and visualizers. That's definitely not all the book focuses on; the subject matter also ranges in the areas of working with solutions, projects, code files, the text editor, command bars, custom windows, deployment, testing, unit testing and more.

The book covers other topics related to extensibility. Keyvan covers the Visual Studio hive and how it can be used when developing VS extensions. It also covers Domain Specific Language tools (which I was appreciative for because I didn't fully understand what DSL was supposed to be) by creating a sample language. Code Snippets and Templates are another feature I look forward to implement in one of my applications, because it will be very useful and helpful to my fellow coworkers. And, one of the more interesting topics for VS Packages,
Keyvan works with a consistent motion throughout the book. When he explained the API, he started out explaining each object related to the chapter, then ended the chapter with some sample code. When getting into the other subjects like extending the debugger or macros, Keyvan discusses each subject and mixes in screenshots and code of what each feature looks like as he goes. Only in a couple of chapters does he primarily show the screenshots of how the utility or feature gets setup.

The other point about the book is how he attempt to explain the intricate details about the code that Visual Studio generates, regarding the Connect.cs and .AddIn files generated by the template. This is important because even though the code is generated for you. Again, it's not always clear what the code files are for and it's good to get an overview of these files from the book, and their purpose.

This book help whet my appetite for developing extensions, and I hope to develop one that is functional. The one caveat to this book is that it left me wanting to know more about extensibility, and I thought a few topics were cut short from what they could have been. I agree no book is perfect and will explain every subject to the readers desire, but I felt that a few more examples, or a larger example in an appendix would have been a benefit to the readers.

As many of the other reviewers stated, this book covers a broad range of topics at a very shallow level. It should best be viewed as a roadmap to the many, many api's provided by the Visual Studio environment. The examples are trivial.

The authors prose rambles, he repeats every paragraph by rewording it in the next paragraph. It reads like an undergraduate attempting to fill in a 10 page paper with 5 pages of material. Which is surprising since this is not a large book and a lot of it is code listings.

IMO, this book is best used as a starting point to Visual Studio plugin development. I recommend researching online before investing in this book.

Covers all aspects of VS extensibility, but in a shallow way. Its not surprising, considering the page count and the number of different ways you can extend and use Visual Studio.

The book concentrates more on addins than other points of extensibility. So if you're looking at creating an addin, or some other not-too-complex work (such as visualizers) this is a good starting point.

If you are looking to do some heavy lifting, such as creating VS packages, you won't get much more than an introduction into the subject. A good intro, but not much more.

This is one of those difficult books to review because it attempts to cover a huge topic. Overall it provides a good overview of Visual Studio extensibility but if you want to really use it you're going to have to dive into the MSDN documentation and browse the source on CodePlex (Iron Python and Iron Python Studio are a must). Some topics, such as DSLs and MSBuild have other books dedicated to them.

Unfortunately, due to the depth of the topic, a lot of the chapters are simple introductions and are only useful for highlighting a feature and what can be done with it. This isn't a bad thing, although I think these chapters could have been shortened and merged, and other topics added for completeness (such as language services).

Overall, the book is well written with few errors, although chapter 11 (Tools Options Page) seems to have missed the editors pen and the code is incorrect (and/or not explained properly). The chapters on extending the debugger (17), code snippets (19) and templates (20) are particularly useful and make the book a worthwhile read.

I just ordered the book from Amazon after a careful search online and in bookstores. This was the only in-depth text that covers the topic of extending Visual Studio in all its manifestations be they macros, add-ins or other extension strategies. Team leads, configuration managers and toolsmiths in Windows development environments will not want to miss this.

Anyway, then I saw a copy on a shelf at the local bookseller, so I read the first chapter and skimmed most of the chapters. I'm writing a review because I am very impressed with the tone, honesty and objectivity of the text as well as a refreshing economy of expression that is difficult to find in most books written about Microsoft technology. Most authors, especially, but not limited to Microsoft press, fall all over themselves trying to explain just how wonderful, easy and powerful everything is, adding to your frustration when you sit down and try and use the product. Not this book. It is realistic and open about the complexity that we experienced developers are accustomed to, and then it steers you around the pitfalls.

Good job Keyvan! You go into careful detail about the history of Visual Studio as a com product, and how that makes extending it a little tricky. Thank you for this refreshing honesty and insight, so I know I'm not the only one. You also detail some of the hoops you had to jump through to get proper documentation. I can't wait for my copy to arrive later this week!

If you want an independent, realistic text, this is the book for you.

Update: I've completed a first pass of the entire book and found it broad but not very deep. There are many place that could use more detail or maybe a second edition. It could also benefit from a few detailed examples. The simple examples were a fine start.