Buy Used
CDN$ 29.37
FREE Shipping on orders over CDN$ 35.
Condition: Used: Good
Have one to sell?
Flip to back Flip to front
Listen Playing... Paused   You're listening to a sample of the Audible audio edition.
Learn more
See this image

Professional Refactoring in Visual Basic Paperback – Apr 7 2008

See all 5 formats and editions Hide other formats and editions
Amazon Price
New from Used from
Kindle Edition
"Please retry"
Paperback, Apr 7 2008
CDN$ 96.38 CDN$ 22.89

FREE Unlimited Cloud Photo Storage When You Try Amazon Student
click to open popover

No Kindle device required. Download one of the Free Kindle apps to start reading Kindle books on your smartphone, tablet, and computer.

  • Apple
  • Android
  • Windows Phone
  • Android

To get the free app, enter your mobile phone number.

Product Details

  • Paperback: 517 pages
  • Publisher: Wrox; 1 edition (April 7 2008)
  • Language: English
  • ISBN-10: 0470179791
  • ISBN-13: 978-0470179796
  • Product Dimensions: 18.8 x 3.1 x 23.4 cm
  • Shipping Weight: 794 g
  • Average Customer Review: Be the first to review this item
  • Amazon Bestsellers Rank: #1,101,906 in Books (See Top 100 in Books)
  •  Would you like to update product info, give feedback on images, or tell us about a lower price?

  • See Complete Table of Contents

Product Description

From the Back Cover

Professional Refactoring in Visual Basic

In this one-of-a-kind book, Microsoft MVP Danijel Arsenovski shows you how to utilize the power of refactoring to improve the design of your existing code and become more efficient and productive. He provides you with a hands-on approach so you'll quickly learn how to manage and modify your code with refactoring tools and features. You'll also discover how to perform unit testing, refactoring to patterns, and refactoring to upgrade legacy Visual Basic code.

As you progress through the chapters, you'll build a prototype application from scratch. You'll then utilize refactoring techniques to transform the code into a properly designed, enterprise-level application. Arsenovski walks you step-by-step through each process while offering expert coding tips. You'll then be able to apply this information to real situations that arise as a result of company expansion, policy changes, or similar business decisions.

What you will learn from this book

  • The steps involved in assembling a refactoring toolkit

  • How to activate explicit and strict compiler options

  • Effective strategies for error handling

  • How to eliminate dead code, reduce scope, and remove unused references

  • Method consolidation and extraction techniques

  • Advanced object-oriented concepts and related refactorings

  • How to organize code for large-scale projects

  • Tips for taking advantage of LINQ and other VB 2008 enhancements

  • Core refactorings and basic code smells

  • How to use the free Refactor! add-in for Visual Basic

  • Visual Basic–specific refactorings and smells

Who this book is for
This book is for intermediate to expert programmers, developers, or .NET software architects who are familiar with basic object-oriented concepts, Visual Basic, and the Visual Studio environment.

Wrox Professional guides are planned and written by working programmers to meet the real-world needs of programmers, developers, and IT professionals. Focused and relevant, they address the issues technology professionals face every day. They provide examples, practical solutions, and expert education in new technologies, all designed to help programmers do a better job.

About the Author

Danijel Arsenovski is a software developer from Santiago, Chile. Currently, he works as Product and Solutions Architect at Excelsys S.A, designing Internet banking solutions for numerous clients in the region. He started experimenting with refactoring while overhauling a huge banking system, and he hasn’t lost interest in refactoring ever since. He pioneered the use of refactoring as a vehicle for a VB 6 code upgrade to VB .NET. Arsenovski is a contributing author for Visual Studio Magazine and Visual Systems Journal, holds a Microsoft Certified Solution Developer (MCSD) certification, and was named Visual Basic MVP in 2005.
You can reach him at, and you can take a look at his blog at

Customer Reviews

There are no customer reviews yet on
5 star
4 star
3 star
2 star
1 star

Most Helpful Customer Reviews on (beta) 5.0 out of 5 stars 7 reviews
6 of 6 people found the following review helpful
5.0 out of 5 stars Great book for putting your team on agile track May 31 2008
By P. Reyes - Published on
Format: Paperback
I am working with group of developers that came to VB .Net from VB6. Currently we are in process in improving the way things operate using some agile stuff. The overall disposition is pretty good, team has already been formed and things like daily stand-ups, client involvement or short iterations are generally welcomed by all. However, when more technical, code level stuff is discussed, there is more discussion (if not opposition). These folks pack years of experience and will not accept that you can teach them their job just like that. There is no way you can force things like unit testing or refactoring. You have to be able to hold your ground and answer all the questions with some good arguments.
This book gives you in-dept view of refactoring with a lot of practical, code examples. This means that you are well prepared to answer any uncomfortable question. It builds up gradually, so it is easy to follow.
Almost every chapter ends up applying the stuff that was just exposed on a sample application with a lot of code. Surely author spent a decent time on this title. You can download the code and see it progress from chapter to chapter. This gives a great insight since you can read and debug the code at the same time and not just some toy or isolated example.
Here is chapter to chapter break-down of the book.

Chapter 1
Intro chapter, defines refactorings end code smells and explains the kind of baggage VB carries because of its origins. Cool section on misinterpretations, this will prepare you for some tough questions that might come from uninitiated developers or managers.
Explains the importance of writing simple, comprehensible code. For example:
Dim oXMLDom as New DOMDocumet() vs Dim portfolio as new DOMDOcument.
The first statement gives you no idea of what first DOMDocument represents, in second it's the portfolio, and if you know the application context you will know what to expect.

Chapter 2
Teaser chapter but also good single-chapter sample of some typical refactoring work. Captures well typical process of development of VB applications. Starts out with few event-handling methods, ends up with number of domain classes and some inheritance thrown in.

Chapter 3
Chapter on refactoring tools, also gives you some insight of how different tools like refactoring add-ins and unit testing framework fit the big picture of agile development process.

Chapter 4
Intro chapter on application that is used to illustrate refactorings throughout the book. Explains the business case, requirements, lists some use cases. It is important to understand the context of the application to be able to follow-up on refactorings. Also some funny stuff here, like freshman developer that takes pride in copy-paste development.

Chapter 5
In-dept discussion on Static vs. Dynamic and Strong vs. Weak Typing that is rarely dealt with in such depth. This is basically controlled with Option Strict and Option Explicit options. If you program in VB, you must be aware how these work out.

Chapter 6
Chapter on error handling, especially legacy vs. structured error handling. Again, something everyone should know, but rarely explained in such depth. Cool stuff is step by step recipe for converting legacy to structured.

Chapter 7
Deals with some core refactorings like Dead Code Elimination, Scope Reduction etc. It's like cleaning up your code for some serious refactoring stuff.

Chapter 8
First step in structuring your code is getting serious about the problem (or business) domain. Also explains Rename and Safe Rename refactoring, talks about Interface vs. Abstract class, Open-Closed principle etc. some serious OO stuff.

Chapter 9
Some core refactoring stuff. Teaches you how to eliminate duplicated code and why it is the worst thing it can happen to your code. Explains Extract Method and Replace Magic Literal with Symbolic Constant variable. Nice and simple example based on circle geometric shape on how procedural design is transformed to Object Oriented design (Module and Shared method rings a bell?)

Chapter 10
If only method extraction would be as simple in real life... This chapter goes further with method extraction and deals with some common problems like temps.

Chapter 11
Where do objects come from? How you design classes? Some core OO stuff in this chapter, including Extract Class, Move Member (Method or Field) refactorings, smells like Database Driven Design or Data Class, Large Class, OO principles like Single Reasonability Principle etc. Lot of stuff and handful of pages in this chapter.

Chapter 12
Build upon previous chapter. Deals with inheritance, polymorphism, genericity. Explains the difference between class and interface (or implementation vs. interface inheritance), difference between delegation and inheritance and criteria to chose one or another, list some common misuses of inheritance etc. Again, a number of refactorings like Replace Inheritance With Delegation or Extract Interface, Extract Super etc. Some heavyweight OO concepts in this chapter, takes a time to digest.

Chapter 13
Explains what is important when taking a birds-view of software. This chapter is especially important for software architects. Talks a lot about dependencies in software and why you should minimize dependencies in your code.

Chapter 14
Single chapter for huge subject, still a lot of material covered. Design patterns are the most advanced subject in OO, so refactoring your code in order to make use of patterns is in no way child's play. Mostly deals with creational patterns. First mention of Dependency Injection in some VB book I come across. Now taking into account that Unity application block [...] has been released in April, this is really cutting edge stuff!

Chapter 15
Talks about latest VB improvements that come with VB 2008. Starts with XML enhancements like XML literals and then the rest is about LINQ. Explains a LINQ implementation called LINQ-to-SQL. This is first Microsoft Object-Relational Mapper (ORM). Again, cutting edge.

Chapter 16
If you still deal with VB6 code, than you know that migrating to .Net is no easy ride. This chapter explains some techniques that will help you migrate your code and make it .Net in sprit, not leaving it crippled by simple migration that will only make it execute in .Net. VB6 lacks inheritance, generics etc, so you need refactorings to make it VB .Net.

This book has no real competition as far as I know, no book on refactoring or agile for VB .Net developers. The one that come close is Agile Principles, Patterns, and Practices in C# (Robert C. Martin Series) but it is for C# developers and requires a lot higher starting point.
When other books come up, I am sure Professional Refactoring in VB will continue to hold its ground. Highly recommended!
5 of 5 people found the following review helpful
5.0 out of 5 stars Must read for any serious VB developer. May 2 2008
By D. Mijatovic - Published on
Format: Paperback
First of its kind for VB.Net developers. While it does not contain a complete catalogue of all known refactorings, you get a thorough study case used throughout the book, tooling, how to use refactoring for upgrade of legacy VB6 code, a chapter on VB 2008, some important object oriented principles and even short intro on refactoring to patterns.
This book is deep and takes a while to digest. However, it's not about showing off some irrelevant academic knowledge. Author is not afraid to mention "Dependency Injection" or "Single Responsibility Principle" but all of these are demonstrated to be relevant and get illustrated through very practical and real-life examples.
4 of 4 people found the following review helpful
5.0 out of 5 stars Great Book on Refactoring May 4 2008
By Slavko Glisic - Published on
Format: Paperback
Really great book on refactoring. Although it is based on Visual Basic examples, same advices can be applied to C#, Java or any other OO language.
Martin Fowler finally has a fair partner on my shelf ;).
2 of 2 people found the following review helpful
5.0 out of 5 stars Very well done! June 13 2008
By Jason Down - Published on
Format: Paperback
Arsenovski has done a great job with this book. It is clearly written, easy to follow and very practical. A great one to keep on the shelf and reference as needed. The free tools that he covers in the book are a bonus! They really help to get you applying what you've learned quickly.

I highly recommend this book for any .NET developer, not just those who use Visual Basic.
1 of 1 people found the following review helpful
5.0 out of 5 stars A worthwhile, unique, focused book for VB.NET developers Feb. 2 2010
By B. G. Palin - Published on
Format: Paperback
This is a unique book. It is non-introductory material, and it specifically targets VB.NET developers. This is a refreshing change, as most specialized books for .NET target C#.

Refactoring in Visual Basic introduces the reader to the concept of refactoring, using some simple examples, and then moves forward with various larger examples. The examples are all based on a running sample, which is explained early on in the book. Danijel describes each refactoring technique and the problem that it addresses, both in general and with respect to the running sample. By the end of the book, the reader has a healthy knowledge of various refactoring techniques and is able to start on his own refactorings.

Some nice mentions in this book include unit testing, refactoring to patterns, refactoring code from VB6 to .NET form, and VB9 features.

Throughout the book, the relevant smells are shown in light gray boxes, which helps to distinguish them from regular text. Unfortunately, there seems to be some repetition between the boxed text and the normal text...this was slightly offputting, but not a big issue really.

This book is a worthwhile read for any VB.NET developer. It is very focused on the topic, and it provides discussions specifically regarding code in VB.NET.