Test-Driven Development in Microsoft .Net

by James W. Newkirk and Alexei Vorontsov

With the clarity and precision intrinsic to the Test-Driven Development (TDD) process itself, experts James Newkirk and Alexei Vorontsov demonstrate how to implement TDD principles and practices to... This description may be from another edition of this product.

• Format: Paperback
• Language: English
• ISBN: 0735619484
• ISBN13: 9780735619487
• Release Date: April 2004
• Publisher: Microsoft Press
• Length: 273 Pages
• Weight: 1.40 lbs.
• Dimensions: 0.7" x 7.4" x 9.0"

Customer Reviews

First exposure to test driven development

I attended a workshop on test driven development presented by James Newkirk. I was so intrigued with the concept that I had to go out and get his book to find out more. As a result our project now uses NUnit, TestDriven.net for test driven development and find that this has really boosted confidence in the developers and their code. The concept of test-driven development is a very useful agile method of writing code to the requirements based on tests (Red/Green/Refactor). This has certainly changed my perspective towards development and want to thank James Newkirk for purveying this concept.

You need this book in your Agile Library!!!

Test-Driven Development in Microsoft.NET rises head and shoulders above the other books on the subject. While I know that is a very strong statement to make, the authors have made the focus of the book a very practical one. Don't get me wrong, there are several other great books on this subject, but they all seem to fall down when it comes to real-world situations. The book is split into two parts; Part I is an overview of Test-Driven Development, and Part II covers using TDD to develop an example application. Chapter 1 frames the entire discussion with an overview of Test-Driven Development concepts, including some straightforward guidelines for design. I thought it was laid out in very logical fashion. Chapter 2 throws you right into the process it's a classic stack example, found in many other TDD books. What I liked most about it though, was that the chapter began with discussing HOW you start figuring out WHAT tests to write as you develop an application. Chapter 3 covers another critical concept of TDD Refactoring. (What's Refactoring? You askread chapter 3 ;) ). Again, the authors walk you through a short yet concise primer using the Sieve of Eratosthenes implemented in C#. They introduce the algorithm and then discuss it in light of code refactoring techniques as implemented originally in Martin Fowler's Refactoring: Improving the Design of Existing Code. Chapter 4 is the introduction of the example application that will be the focus of the remainder of the book. It lays out the scenario, project features and constraints of the fictitious project. Chapter 5 covers an area that I've found generates a ton of interest when developers start thinking about TDD, namely data access. I really appreciated the practical approach that the authors took when writing the implementation chapters for the example application. I found the tests surrounding entities and relationships and the resulting explanations to be very good. Chapter 6 covers how you create tests when implementing Web Services. In the process, the service interface pattern is discussed along with refactoring Web Services. The authors attempt to lead you through a "thought framework" for creating tests through each of the implementation chapters. Chapters 7, 8, and 9 make a shift from programmer testing to customer testing and cover differing aspects of customer or acceptance testing. This group of chapters starts with an overview of acceptance testing and techniques. The middle chapter deals with driving development up through the implemented layers from a user or customer perspective. Chapter 9 rounds out the discussion by focusing on handling faults and how acceptance testing allows you to tighten things up. Chapter 10 leads us back to the programmer testing side by dealing with transactions. Following this, Chapter 11 introduces the reader to Service-level refactoring, leading you through the thought process behind different techniques. The story winds down in

Changes Your View

Many people think that Test-Driven Development (TDD) is all about testing software. In fact, test-driven development's main goal is not testing software, but aiding the programmer and customer during the development process with unambiguous requirements. The requirements are in the form of tests that the software must pass along the development process. This procedure helps to insure that problems are found early and corrected while they are still small. This book first discusses TDD from a conceptual point of view then gives a TDD example using a realistic application.

Great introduction to TDD on .NET

Obviously, the best way to learn TDD is by doing it, but a short tutorial like this helps immensely. I bought this book to fill in TDD and NUnit gaps after learning the ropes at work from an experienced TDD Java developer. The book covers the basic principals of TDD and provides a thorough NUnit tutorial. Other reviewers nitpicked the web unit testing section and the depth of coverage, but all neglected to mention that the book is mercifully short. What sort of depth do you want on a very complex and subjective topic like TDD in ~250 pages? In my opinion:1) A good xUnit tutorial2) Coverage of the principals of TDD3) Basic examples of TDD principals and xUnit applied in the target language/platformThis book provides all three. After reading through just a few chapters, I embarked on a TDD-based project at work that now has several hundred tests. The info in the book directly contributed to a solid design for my tests, which has proven to be quite scalable across dozens of classes and an extreme amount of refactoring due to new requirements and bug fixing. I can't ask for more than that from such a short book.In my opinion, it's not the author's responsibility to dictate the best tools to use for every single TDD situation--NUnit coverage is good enough to get any experienced programmer started, and it's really up to you to experience and discover the right tools for the job. TDD is a fairly new concept for .NETers (so new that MS won't have any tools of their own for TDD until Visual Studio 2005 is released), and tools are popping up almost monthly on SourceForge for testing ASP.NET, WinForms, and for integrating NUnit into Visual Studio.Cheers to James and Alexei for putting forth such a great, short introduction to TDD for everyone on .NET.

Practical How-To

Great hands on tutorial for unit (NUnit) and user testing (fit.c2). The authors provide practical advice on how to refactor software, as well as, code ala Test-Driven Development.FYI, the demonstrations are written in C# with some very "real" senarios.