Visual Basic(r).NET: The Complete Reference

Master this massive programming language upgrade that raises Visual Basic functionality to the level of the .NET platform. Coverage includes all core topics--plus security, debugging, and helpful information on migrating existing Visual Basic projects to Visual Basic.NET.

User review
Quite Appalling, Actually
When you buy a book with `Complete Reference` in the title, you expect one of two things:

1. A thorough reference book that you can use for, uh, reference.

2. A book that will completely explain whatever is in the last half of the title - Visual Basic .NET in this case.

This book fails dreadfully on both accounts.

Let me start by saying that I absolutely love Visual Basic .NET. It is a terrific development environment, and once you start to get a feel for working with objects, you wonder how you ever finished a project before.

This book was actually the first .NET book I bought, over two years ago. I found it utterly incomprehensible and had to go on to other books for help in learning to use Visual Basic .NET. Recently, I've been reading through it again - thinking the book might be useful as a reference now that I have a much better understanding of Visual Basic .NET.

Wrong again. You are much better off with the online reference material that comes with Visual Studio. After realizing that I had wasted $30 and a lot of my precious time on this gigantic paperweight, I was stunned that this sucker got 4.5 stars!

It turns out that one of the first reviews was written by none other than the book's author, Jeffrey Shapiro. (Needless to say, he gave himself five stars.) After reading some of the other five star reviews, I darkly suspect that they must be close, personal friends of the author.

The fundamental problem with this book is that it is so abstract. A reference should, by definition, be detailed. This book spends hundreds and hundreds of pages talking about abstract concepts in object-oriented development in a very vague way. It uses lots of abstract object-oriented terms without really defining them. It doesn't really tell you `how to` do anything. You just come away with a vague impression that however you go about developing something in Visual Basic, it should be `object-oriented`.

The book was also poorly organized. (I don't believe that this is the fault of the author, though. It's the fault of the book's editors.) It is very hard to find anything in the book, which severely limits its effectiveness as a `reference`. The index is terrible. Concepts which are mentioned in many places throughout the book will only have one or two entries in the index. This, too, severely limits the book's usefulness for its stated purpose.

If you want to learn Visual Basic .NET (and you want to learn it from books) here are my recommendations:

1. MURACH'S BEGINNING VISUAL BASIC .NET, by Anne Prince - This book is 700 pages of meticulous and thorough reference. This book tells you `how to` do almost any basic programming task in VB.NET, from creating user interfaces to accessing databases. The format is very easy to read and understand. Each section is very short, takes one topic at a time and covers it very thoroughly. The entire book is meticulously cross-referenced, making it very easy to find whatever you need. This should be the first book you buy.

2. REFACTORING, by Martin Fowler - This book isn't specifically a Visual Basic .NET book. In fact, it isn't really language specific at all even though all of the references are in Java. However, you do not want to pass up this book. It is a classic in object-oriented development. It is very, very easy to read. (In fact, the very readable Java examples illustrate just how similar VB.NET is to Java.) REFACTORING is absolutely stuffed with simple, easy to follow advice on how to write better code (and how to fix the really lousy code you just wrote). I have had this book for nearly two years, and even now hardly a week goes by but I am picking up this book and leafing through it to glean more and more useful advice. One of the nicest things about REFACTORING is that the author, Martin Fowler, never talks down to you, the reader. He speaks to you as a colleague. The book also displays the author's very finely developed sense of humor. This makes the book easier and more enjoyable to read, but it never gets in the way of the material. I can't recommend REFACTORING enough.

3. MURACH'S BEGINNING VB.NET tells you how to do all of the basic stuff that you're always asking about when you are first learning. REFACTORING tells you how to organize your code in such a way that it is easier understand and maintain. Once you've got these two books as a foundation, you can pick up any of the other excellent `how to` types of programming books for tips on specific topics.

4. You certainly don't need it in order to be an effective developer, but if you want to study the abstract concepts of Object-Oriented Analysis and Design, go straight to the source and buy one of Grady Booch's books. Just be sure to bring your own oxygen: Booch tends to stay up in the stratosphere where the air is cold and thin.

User review
Code Download Corrections
I'm still trying to catch up with the `rest of the gang` so this review is later than the others.

It is a very good book in applying computer science knowledge like data structures to .NET. I have seen better explanations of interfaces in other books: for example, Deborah Kurata's `Doing Objects in Visual Basic 6`, Jesse Liberty's `Programming C#`, and the classic on C#, Grant Palmer's `C# Programmer's Reference`.

Regarding the downloaded code, I found it to be much better than most. I corrected 5 problems: 1. A `Shuttles` dll had to be created so `ShuttlesInjectorUI` would work (make sure the reference for this is set correctly, also). 2. `Math` didn't have a module, which I created from the book (though the two formulas for area mystify me: correct formula, area = pi * radius **2). 3. The reference to `vb7cr` in `Nodals` had to be corrected in the project properties. 4. The `BaseTree` module was in the appropriate directory, but had to be added to the `Nodals` project. 5. The `protected` access modifier for `StopInjector` in `Shuttles` had to be changed to `public`.

User review
Examine the code in the book,,.
the first code example doesen't even work!
He must have tested it in the beta version because his examples are sloppy, and poorly organized. I would have liked to have seen more code. In some spots his explinations are overly simple. In some spots it seems like he doesn't know what he is even talking about so he just fills in with techno-jargon. Mostly the code is just plain disappointing, what does work, needs to be re-worked so that it is not so buggy, for example, he uses implicit class declarations to demonstrate inheritance, then talks about the importance of strong type declarations. It goes on and on like that. His code on the web is not any better.

Don't waste your money, I think that I will get a Wrox book next.

User review
Project Lead/Software Developer
You have to read this book, before you spend thousands on a VB.NET course.

I read Mr Shapiro's first VB.NET book in late 2001 and made up my mind that I needed to make the move from VB to VB.NET asap. I am a VB/ASP programmer still struggling with OO design concepts and patterns, and I find his insight into the software development and design process quite remarkable indeed.

He writes with a wit and with metaphors I have not seen elsewhere, and made tackling the complex subjects much easier more me. You'll be chuckling at some of the stuff he says. I find it hard to learn from computer books and prefer classrooms, but reading even the first 30 percent of this book, has saved me a bundle in time and money.

I am more concerned about code than classes and figured that the new OO in .NET would put me off. But I was especially pleased to see Mr Shapiro tackle stuff like merge sort and quicksort and then place them in context with various .NET `features` like delegates, and interfaces. Incidently, if understanding interfaces and delegates has you scratching your head, this is the only book I found, browsing at the bookstore, that devotes a whole chapter to each subject respectively. At first I thought his notes on why Sun hates delegates would not be much use to me but they go a long way to understanding why .NET has delegates and interfaces and Java only has interfaces.

There is also a very comprehensive linked-list example in this book that shows you exactly how to implement interfaces, like IEnumerator, and IList, stuff which very few seem to understand and which are very alien to a VB programmer.

No book is perfect. There are a few typos in the text which are clearly last minute changes the publisher forgot to correct. The source code examples compile without issue. I will be looking for his next book for sure.

User review
Great Book!
Simply put, this book is amazing. In order to take fully advantage of the .NET Muscle, you need a full understanding of the .NET Framework. This book will take you there. The chapter that covers the differences between Value Types and Reference Types is hands down the best I've read. Mr. Shapiro has a gift for writing, so be sure to take advantage of it.

- MKP