DevCity.NET -
Book Review: Building Applications and Components with Visual Basic.NET
Ged Mead

Ged Mead (XTab) is a Microsoft Visual Basic MVP who has been working on computer software and design for more than 25 years. His journey has taken him through many different facets of IT. These include training as a Systems Analyst, working in a mainframe software development environment, creating financial management systems and a short time spent on military laptop systems in the days when it took two strong men to carry a 'mobile' system.

Based in an idyllic lochside location in the West of Scotland, he is currently involved in an ever-widening range of VB.NET, WPF and Silverlight development projects. Now working in a consultancy environment, his passion however still remains helping students and professional developers to take advantage of the ever increasing range of sophisticated tools available to them.

Ged is a regular contributor to forums on vbCity and authors articles for DevCity. He is a moderator on VBCity and the MSDN Tech Forums and spends a lot of time answering technical questions there and in several other VB forum sites. Senior Editor for DevCity.NET, vbCity Developer Community Leader and Admin, and DevCity.NET Newsletter Editor. He has written and continues to tutor a number of free online courses for VB.NET developers.

by Ged Mead
Published on 4/9/2006



Building Applications and Components with Visual Basic.NET

By Ted Pattison and Dr Joe Hummel

is published by Addison-Wesley as part of their Microsoft.NET Development Series.   



   Ged Mead reviewed this book for VBCity readers.


    A colleague of mine, whose opinion I greatly respect, recommended that I buy myself a copy of this book as part of my efforts to get to grips with Object Oriented Programming (OOP).    As usual, his advice was sound.   

   Now it probably won’t have escaped your notice that neither of the phrases “OOP” or “Object-Oriented Programming” appear in the title of this book. So you may be wondering why it was recommended as part of my OOP education.   Well, the reason is that the main middle section of this book deals with the core range of OOP topics in great detail and in a way that makes it, well, easi-ier.

   Let’s face it, there isn’t really an easy way to learn all the ins and outs of such a varied and complex topic as OOP. If, like me, you have come to VB.NET from Classic VB and have not had much previous exposure to true object orientation then the bump on your forehead as you run into the glass wall will be that bit more painful.

   At least if you have the help of a book which covers  topics in a logical order, carefully explained and with code snippets that work (Thank you, Tech Editors!) then you  would soon be on your way upwards through that learning curve.

   In my opinion, this is just such a book.  The authors work through the topics with a clear narrative style, reinforcing important issues and referring back to earlier points where relevant.     On those odd occasions where I found myself reading a code snippet and saying “Wait a minute!  Shouldn’t that be….?” I almost invariably found that in the next paragraph it was explained clearly why the approach used was the best one.   (Of course this was only in those few areas where I actually did have some prior knowledge!  The rest I take on trust, but it hasn’t let me down yet)

   The target audience for this book is clearly described by the authors:

"The typical reader is assumed to be an intermediate to advanced developer who has experience with Visual Basic, C++, or Java. You should already know how to create a simple class definition that contains fields and methods. You should know why it's important to use encapsulation and how to define certain class members as private. Finally, you should understand the difference between a class, an object, and an object reference.

It's helpful (but not essential) that you know the basics of computer science. It would be impossible to conduct an in-depth discussion of developing software for the .NET Framework without talking about issues such as scope, lifetime, the call stack, the heap, and threads. If you lack this kind of background, I ask you to ponder how things work at a lower level."

   Clearly, not for rank beginners then.   However, I did find that even where the technicalities got deep and difficult the explanations were clear enough to enable me to get to grips with them.



Book Content

 As it is traditional to list a summary of the contents in these kind of book reviews, I’ll give you my potted version.   You could of course cut out the middleman and go directly to the publishers web site




 and check out the official versions for yourself.

    By the way if you do follow the link above and visit the book display on Amazon, my advice would be to ignore completely the review of the misguided person who tells you that this book is worthless without a download of the code samples.   I don't think he can have read much (any?) of the book before firing off that complaint   Admittedly, the Barracuda site does seem to have gone the way of the dodo and the dinosaur, but the truth is that the code snippets are almost all quite short and only intended to demonstrate one particular teaching point at a time.  So the fact that you can't download them (instead of simply reading them as part of the narrative, as the authors obviously intended)   is absolutely not a problem .

  • Chapter 1         The .NET Framework.   What it is, how it is structured, what it contains, how you can use it, why you should use it and problems you may encounter when you do use it.
  • Chapter 2     Developing with VB.NET.   The Compiler, Namespaces, References, major changes and improvements from Classic VB in VB.NET
  • Chapter 3    The Common Type System explained in great detail and very clearly.   Arrays demystified.
  • Chapter 4    Classes.  Aha!   Class members, Shared members, Instance members, nested types, Encapsulation.
  • Chapter 5   Inheritance, Polymorphism and Type Substitution, Static and Dynamic Binding, Shadowing, Overridable, NotOverridable, Overloading.
  • Chapter 6   Abstract classes, Interfaces.   (I despaired of ever really grasping the topic of Interfaces, but this book finally flicked the switch for me!)
  • Chapter 7   Delegates, Multicasting.
  • Chapter 8   Defining and Raising Events.   Event Handlers.
  • Chapter 9   Exception Handling – the .NET Structured way.
  • Chapter 10   User Defined Types – Enumerations, Structures.  Object cloning.  Garbage Collection and object lifetime.
  • Chapter 11   Assemblies – Building, Deploying, Versioning.
  •  Chapter 12    COM Interop

  (You can also view small excerpts from the start of each section via the Addison-Wesley link above or look into the book via Amazon).



    So, is this book going to make you an OOP expert in one sitting?   Nope. 
Is it going to magically make it all very easy overnight?   Nope again.
Personally I don’t think such a book could exist.  In my view OOP is a very difficult topic and one that you
really have to work at for some time in order to grasp it totally.
   If you invest the time needed to read this book thoroughly and  carefully, I am certain that you will come
out at the other end with a firm grasp of OOP theory, principles and practices, which you will then be able to  apply in your program design and coding.   You will also  have a far, far better understanding of what others are doing when you read OOP based code samples, projects, solutions and articles.   

    From this firm platform you will have everything you need to become a fully fledged OOP developer yourself.   And of course the content which doesn’t deal directly with OOP matters is just as well written, comprehensive and clear as those topics I have highlighted.
    Even allowing for the absence of  “OOP” in the title, my advice is to take a look at this book when you are
next looking for guidance on the subject.  I found it to be tremendous value.