Visual Basic Shell Programming

Rating:
Summary: Good Introduction to Shell Programming in VB
Review: A must read for those who like to push VB beyond the limits, previously viewed as 'impossible to do in VB'. Very well organized and lots of examples.

Excellent reference material and a worthly investment.

Rating:
Summary: Just what the doctor ordered
Review: As a Visual Basic developer, I always envied C++ developers who were able to do Namespace extensions, as well as other integrations with the Windows Shell. Well the wait is over, and now there is a book which explains it all. Never before there has been such a source of information for the Visual Basic developers. We were in the dark. I remember trying to implement the C++ code, and port it to Visual Basic, only to find one obstacle after another. This book clearly explains the steps and API's needed to perform this task. Using and enhancing Windows Shell can be a great supplement to the GUI programming.

Rating:
Summary: Good Introduction to Shell Programming in VB
Review: First off, if all what you want to do is to add an icon to the systray, go find _any_ Win32 API book or even search on the web. This book does not cover simple tricks like this. But if you want to write your own namespace extensions or property sheet handlers, read on.

Many people think VB and windows shell programming don't mix very well. Honestly, I was one of them. But after reading this great introduction, I figured I was wrong. Well, mostly wrong.

There are two issues that make shell programming hard in VB:

(1) As in most "advanced VB programming tasks", the first realization must be you _can't_ do it in pure VB. You need to import Win32 APIs and then fake you are writing your program in C. But that's a very old and well-solved problem, and in fact this book assumes you know how to do it: it shows the import statements without explaining how to get them. But that's fine, for I think most advanced VB programmers have already picked up this old trick.

(2) The windows shell is built heavily on COM, so must be the shell extensions. But this book is not about writing COM servers in VB... Apparently the author did not expect the readers to know COM before, so he offered a short chapter on COM basics that I find too short to be sufficient for the purpose of this book. For example, later on he started using jargons like "in-process COM servers" and "apartment threaded" (these are COM jargons) without explaining what they are. I tried to look up these terms in the index to quote the page number. They are absent---yet another proof of insufficient coverage of COM. I admit that shell extensions are in-process COM servers and so in most cases the readers are not expected to do anything else anyway, but this kind of treatment much weakens a reader's understanding of what he/she is doing.

And there are other problems that plague this almost excellent book:

(1) There is no separate treatment of what should the programmer do when a new shell extension comes out. As an example, icon overlay is not covered in this book. I think this is really the major reason I have to take half a star off: this book is more like "how I wrote those shell extensions" rather than "how you can write your own ones". For example, it does show many examples of how to turn a given IDL into more VB friendly, but not how can the programmer obtain the IDL of an interface that's not covered in the book. (OLE View won't answer all such prayers. Go check the platform SDK or, _cough_, wait for the second edition of the book to have a new chapter on that extension. :P)

(2) There is no coverage of debugging shell extensions. It's not as easy as one may expect, especially as VB will automatically re-register your COM servers when you execute your code while Explorer loads some registry entries only once...

Overall, this is a more than decent introduction to shell programming using VB. If you want to do some typical shell programming like having your own property sheet or namespace extensions, then this book is really good for the job and is worth every single penny. I would rather say it's 4.5 star, but I have to round down for the minor problems I mentioned.

Rating:
Summary: Lot's of info, many mistakes
Review: I have a love hate relationship with this book. There are a lot of useful techniques spelled out in the book, unfortunately there are serious bugs in the demo code. I have been able to fix a few of them, but am still working on others. Maybe this was on purpose to get the reader to truly understand the code rather than blindly copy it.

Rating:
Summary: Overall good, but some sample codes crash in Win2K ...
Review: I particularly like the Shell Extension part which is very
useful to understand somthing more advanced in Windows Shell.

However, what disappoints me is that I found the sample codes from
Chap 11 (Both sample projects DemoSpace and RegSpace) crash in
machines running Win2K. This means that if you want to use the
techniques taught from the book to implement a Shell Extension
by VB, you can only support platforms below Win2K. That will not
be much useful at all.

As far as I know, the author has not yet figured a solution
(through private communications with Orielly's book support).

Rating:
Summary: Shell programming is not for C++ guys anymore
Review: This book is very good.

I was looking for a way to build those fancy IE toolbands and was really disappointed with the Microsoft site, since all the reference about this subject there is on C++. Since those bands are COM objects, I was wondering whether someone had implemented it on VB already. Tried all the search engines and got nothing. Well this book is the only place (by now) where you'll find this information!

Programming the windows shell is a HUGE topic and certainly would require one of those "brick-sized" books to cover it properly. But J.P. Hamilton made a great effort on abridging the most "juicy" stuff, and then it's up to the programmer to develop on top of that information.

Some examples don't work on Windows 2000, but that's something I can understand since I guess most of the techniques shown on this book were developed before the Win2k release. Anyway, as the author states on the preface, this book is not intended for beginners or people who need to be guided on baby steps, but for programmers with some intermediate VB skills at least. This book is all about COM programming, so if you nothing about COM, this book may still be useful (there's a decent COM introduction on chapter 2), but I'd suggest you to play with COM first.

All in all, this is a "cover to cover" interesting book and that kind of book we should keep nearby for reference. Shell programming is a brave new world for VB programmers. I think there are lots of subjects which could be explored on a volume II.

Great job Mr. Hamilton.

Rating:
Summary: COMpletely excellent or worth SHELLing out the bucks for....
Review: Well hats off to you Mr. Hamilton! I had no idea any of these feats of programming wizardry were available, you've put together a very interesting and entertaining look at COM and using Visual Basic to write shell extensions.

When you first look at Shell Extensions, I have to admit you wonder how you will ever make use of these in your own programming.

That is until you see the best part of this book, the constant examples Hamilton peppers in each chapter. Each one of them seems to lead to interesting additions to any quality software project.

Thanks Mr Hamilton, you've provided me with some excellent reading, and a chance to impress my peers, something I always love!

Rating:
Summary: Not neccessary but fun to read
Review: Working with Visual Basic you stay away from doing certain things. Namespace Extensions was one of those things for me. Then I found this book. I have learned more about how Windows and Viusal Basic works from reading this book than any other thing I have ever done. Way to go J. P. Hamilton! Hats off to you. This is a must read book, even if you never have the need to work with the shell.