“Doing Objects in Visual Basic 2005 is one of the few books that I’ve seen that lays the proper object-oriented foundation to make new Visual Basic.NET developers as well as VB6 veterans successful in moving to the .NET Framework.”

–Paul Ballard, President, Rochester Consulting Partnership, Inc.

“Deborah Kurata’s Doing Objects in Visual Basic 2005 is salvation for every programmer beached on the forbidding isle of .NET object-oriented programming. ‘Right this way,’ she says, leading you confidently into that vaguely menacing interior. Step follows step. Suddenly the daunting and unfamiliar become doable and commonplace. You’re productive again. My goodness, you’re actually enjoying yourself!”

–Ward Bell, V.P., Product Management, IdeaBlade, Inc.

“When is comes to advice on programming objects in Visual Basic, nobody could be better qualified than Deborah Kurata. She’s been doing Doing Objects since VB4, and she doesn’t let us down as we move our classic VB code to the Microsoft.NET platform. From initial analysis and design, through to the final implementation, you’ll find everything you need here to take on the Visual Basic 2005 development environment. This book is a must have for every VB.NET developer!”

–Kel Good, MCT, MCITP, MCPD, Custom Software Development Inc., (www.customsoftware.ca)

“I’ve long been frustrated that I couldn’t recommend a book on object-oriented fundamentals in .NET. Sure, there were plenty of books on OO syntax. But what good is explanation of syntax if you don’t already understand the concepts? At last, we have the successor to the Doing Objects series for classic VB, from which so many of us learned how to think about objects and object design, completely rewritten for .NET. If you’re a VB 2005 developer who needs to add object orientation to your skill set, this is the book you need.”

–Billy Hollis, author/consultant, Next Version Systems

“Deborah Kurata does her Doing Objects thing again! This is the newest book from Deborah which has been completely rewritten from the ground up for the Visual Basic .Net 2005 developer. Anyone needing a solid foundation in object technology, Visual Basic .Net 2005, and Visual Studio .Net 2005 should read this book. Deborah’s presentation of core topics such as class design, object state management, exception handling, events, data binding, validation, data access techniques, and many others is clear, concise, and direct. The clarity of the content, coupled with the hands-on examples make this book an easy read and a must have.”

–Ron Landers, Senior Technical Consultant, IT Professionals, Inc.

“Deborah Kurata continues her tradition of showing both new and experienced Visual Basic programmers the most effective ways to get their jobs done with object-oriented programming.”

–Ethan Roberts, Software Architect, Sundial Software Corporation

“As a VB6 programmer, it was a huge leap for me to go from VB6 to VB.Net; Deborah’s book helped me do that. If you’re trying to make that jump, reading this will enable you to do so with minimal pain.”

–Robin Shahan, VB Developer

The definitive guide to object-oriented development with Visual Basic 2005

Doing Objects in Visual Basic 2005 is the authoritative guide to object-oriented design, architecture, and development with Visual Basic 2005. Author Deborah Kurata is the original pioneer in building object-oriented applications with Visual Basic. In this book she continues to offer clarity and deliver best practices for using object-oriented techniques in Visual Basic 2005. She has been honored with Microsoft’s prestigious MVP designation for her expertise and contributions to the community.

Kurata begins with a concise introduction to core object-oriented concepts and the Visual Basic 2005 features that support them. Next she introduces a pragmatic and agile approach to designing effective applications along with an application framework. From there she walks you through the process of building the user interface, business logic, and data access layers of an application, highlighting key VB 2005 techniques and best practices. Kurata’s step-by-step “building along” activities provide you with deep hands-on mastery; your finished application can serve as the starting point for virtually any custom project. This book

• Shows how the tools in Visual Studio 2005 combined with a solid object-oriented approach can help minimize the complexities of software development and improve productivity

• Clearly explains the fundamental concepts of object development: classes, inheritance, interfaces, scenarios, and more

• Presents a pragmatic agile software design methodology to help analyze and design applications for the real world

• Covers building the user interface layer using a base form class, programmatic interfaces, and object binding

• Details building the business logic layer using a base business object class and validation rules

• Demonstrates how to build the data access layer using ADO.NET

• Provides best practices and tips for experienced .NET developers, those new to .NET, and for those developers moving from VB6 to .NET

Foreward

Preface

Chapter 1: Introduction to OO in .NET

Chapter 2: Designing Software

Chapter 3: Building Projects

Chapter 4: Building the User Interface Layer

Chapter 5: Building the Business Logic Layer

Chapter 6: Class Tools and Techniques

Chapter 7: Binding the User Interface to the Business Objects

Chapter 8: Building the Data Access Layer

Amazon.com® Reader Reviews (Ranked by Helpfulness)

Average Amazon.com® Rating:  Based on 11 Ratings

Like a finely honed detective thriller - 2008-02-19
Reviewer Rating:
I have totally enjoyed this book. So much so that in my leisure I have opted to work through it a second time. Being a .Net programmer and just beginning to leverage the power object programming: I found the book exhilrating.
I never knew how she was going to pull together: like replacing hard-coded item for database tables.
My only disappointment was that the book ended a little too soon. I would have like to have to have seen somewhat more of a data-entry application.

Stephan Onisick; VB/SQL Consultant

great overall vb book on objects - 2008-07-31
Reviewer Rating:
If I can change the rating, it would be 4 out of 5 only, Amazon won't let me change it. The reason for that is the methodology (GUIDS) used alone. I think I can use that in my work. The chapter on interface layer is also good, but might confuse a beginner vb.net programmer. Overall the book is great, however, the chapter on business layer is not what i have expected. It delved on interfaces and state management of object for most of the chapter, but seems to be getting nowhere with the sample. I will have to read the chapter again to understand it fully, as I got lost in the process. I was actually expecting object collaboration on this chapter, but that was left out, so what's really the purpose of business layer chapter then? I will not recommend this book to novice programmers. For a much better discussion on object-oriented approach with clear explanation on 3-tier from the ground up, I highly recommend Dan Clark's Beginning Object-Oriented Programming using VB2005 book.

Useful and concise - 2008-07-25
Reviewer Rating:
I have been using Ms. Kurata's book at work in making the transition from VB 6.0 to Visual Basic 2005. I find her explanations easy to understand and her examples immediately relevant to the work I am doing. I have a library of reference books on the subject, but lately I have found myself regularly referring to this book to quickly jog my memory on topics such as creating property statements and custom event handlers. This book packs a lot of knowledge into a well-written concise package.

Ms. Kurata's book is similar to Tim Patrick's book, which is another of my recent favorites that I also recommend.
Start-to-Finish Visual Basic 2005: Learn Visual Basic 2005 as You Design and Develop a Complete Application (The Addison-Wesley Microsoft Technology Series)

Good book - 2008-07-24
Reviewer Rating:
After searching long and hard for a book about business objects and databinding, I stumbled across this one. It gives you a good starting point and makes you think in a Object Orientated way. Lots of reuseable code and the presentation was good. I like a book that you can read and do a project at the same time.

However, I thought the book ended abruptly and left things a little undone. Furthermore, I would of liked it to go into more detail on sorting and filter business objects since this is a major issue.

In all, this was a great buy and I'll be referencing it for a while.

An objective review by VBRocks - 2008-07-24
Reviewer Rating:
**** 4 Stars for Deborah Kurata ****

This book accomplishes a few useful things:

First of all, this book teaches you Object-Oriented development concepts, such as what Object-Oriented programming is, the basic elements of Object-Oriented architecture, and the benefits of using an Object-Oriented approach.

It also teaches you how to design software using the GUIDS Methodology: Goal-centered design (includes use cases, scenarios, business object identification, and domain model), User Interface design, Implementation-Centered design, Data design, and Strategies for construction.

Additionally, this book teaches you how to implement N-Tier architecture in an application, and explains its benefits. The N-Tier approach in this book is comprised of a Presentation Layer, Business Layer and a Data Access Layer.

A downside to this book is that it leaves you short of having a fully functional application, supporting record sorting and filtering, which, in my opinion, is a fundamental element of data presentation.


Additional Comments:

Being an ADO.NET proponent, and competent in extending ADO.NET, I found the OOP approach demonstrated in this book to be (frankly) a lot of work. A lot of the code that goes into this approach can be significantly reduced using ADO.NET. Furthermore, ADO.NET requires much less time to become proficient in, and faster to develop.

Here's a simple example that creates a Customer Class:

Public Class Customer


Public Sub New(ByVal customerName As String)

Me.Name = customerName

End Sub


Private m_Name As String
Public Property Name() As String

Get

Return m_Name

End Get

Set(ByVal value As String)

m_Name = value

End Set

End Property


End Class


A customer can be created like this:

Dim c As New Customer("Chili's Grill & Bar")


Now, how do you get a list of Customers? You have to use List(Of Type):

'Create a list
Dim customerList As New List(Of Customer)

'Add Customers
customerList.Add(New Customer("Chili's Grill & Bar"))
customerList.Add(New Customer("Dickey's BBQ Pit"))
customerList.Add(New Customer("La Hacienda Ranch"))


My Next question is, How do you handle sorting in a List(Of Type)? You may be tempted to, Well, Sort() of course!

customerList.Sort()

However, if you did not implement the IComparable interface in the Customer class, then you cannot use the Sort method... Any other ideas?


Now, what about filtering? How do you filter a List(Of Type)?

...


Put it this way, if you want to be able to bind the list to a control, like a DataGridView, and then have the list sorted when a DataGridViewColumn header is clicked, then you need to do some programming to implement the IBindingList interface. And then what if you want to do advanced sorting and filtering? You need to implement the IBindingListView... That's quite a bit of programming!


But life is MUCH easier with ADO.NET!

'ADO.NET (Create a Customer table and add a Name column)
Dim table As New DataTable("Customer")
table.Columns.Add("Name")

'Add 3 customers to the table
table.Rows.Add("La Hacienda Ranch")
table.Rows.Add("Chili's Grill & Bar")
table.Rows.Add("Dickey's BBQ Pit")

'What about Sorting?
Dim view As DataView = table.DefaultView
view.Sort = "Name ASC"

'What about filtering?
view.RowFilter = "Name='La Hacienda Ranch'"


Another example is, How do you handle the IDataErrorInfo interface? You have to do a bit of work with OOP, but with ADO.NET... You don't have to do anything, because it's already implemented in a DataTable... Sweet!

What about all of the other concerns about data validation? Create a Strongly-Typed DataSet, add a Customers DataTable to it, Double-Click on it to create the ColumnChanging event, and then validate away!


Overall, it's a pretty good book. And it's definitely worth reading, even if you don't end up using the OOP concepts presented, because there are quite a few things you can learn that will help you as a developer.

In the end, the path to OOP architechture or ADO.NET architecture is up to, but hopefully I've provided you with a few helpful thoughts.


Gary Lima
aka VBRocks
2008 Microsoft Visual Basic MVP
VisualBasicRocks.com

Browse Similar Topics

Top Level Categories:
Programming

Sub-Categories:
Programming > Visual Basic