Quantity:

Express Checkout with PayPhrase

What's this? | Create PayPhrase

More Buying Choices

42 used & new from $9.94

Have one to sell? Sell yours here

Share with Friends

Share your own customer images

Search inside this book

Tell the Publisher! I�d like to read this book on Kindle Don�t have a Kindle? Get your Kindle here.

Test-Driven Development in Microsoft .NET (Microsoft Professional) (Paperback)

~ James W. Newkirk (Author), Alexei A. Vorontsov (Author) "In this chapter, we define test-driven development (TDD) and then describe a process for applying it when developing software..." (more)
Key Phrases: automatic transaction management, int rating, push null, Bruce Springsteen, After Push, The Rising (more...)

4.0 out of 5 stars See all reviews (15 customer reviews)

List Price:	$39.99
Price:	$34.37 & this item ships for FREE with Super Saver Shipping. Details
You Save:	$5.62 (14%)
	o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o

Upgrade this book for $7.99 more, and you can read, search, and annotate every page online. See details

In Stock.
Ships from and sold by Amazon.com. Gift-wrap available.

Want it delivered Tuesday, November 10? Choose One-Day Shipping at checkout. Details

27 new from $23.66 15 used from $9.94

Frequently Bought Together

Customers Who Bought This Item Also Bought

The Art of Unit Testing: with Examples in .NET

by Roy Osherove

4.8 out of 5 stars (12) $26.39

Agile Principles, Patterns, and Practices in C#

by Robert C. Martin

4.4 out of 5 stars (23) $36.66

Pragmatic Unit Testing in C# with NUnit (Pragmatic Programmers)

by Andrew Hunt

4.3 out of 5 stars (11)

Refactoring: Improving the Design of Existing Code

by Martin Fowler

4.5 out of 5 stars (139) $53.45

Pro Silverlight 3 in C#

by Matthew MacDonald

3.7 out of 5 stars (3) $31.49

› Explore similar items

Editorial Reviews

Product Description

Learn how to apply the concepts and techniques of Test-Driven Development (TDD) to writing software for Microsoft .NET. Two experts in agile software development teach—using a wealth of pragmatic examples in C# and other .NET development tools—how to use automated tests to drive lean, efficient coding and better design. You’ll focus on .NET-specific issues for TDD, including the best time to employ the inherent features of .NET class libraries and how to use NUnit, a leading unit-testing framework for .NET. And you’ll see real-world examples of TDD-for .NET projects, including a Microsoft ADO.NET relational database, a user interface created with Microsoft ASP.NET and Microsoft Windows® Forms, Web services, and other useful applications.

About the Author

James W. Newkirk has been a software practitioner for more than 18 years. He has been involved with the agile processes community since its inception. He has contributed to many books, written many articles, and is a frequent speaker at XP/Agile Universe and OOPSLA. He has been a frequent contributor to the development of NUnit, a unit testing tool for the .NET environment, and is now the administrator of this open source project.

Alexei A. Vorontsov has been a software developer for more than eight years. He has developed software in a variety of environments, from scientific mathematical applications to enterprise systems. His interests include development, testing, and management of large distributed software solutions and pragmatic application of agile methods to meet the goals of enterprise system development in a cost-efficient manner.

Product Details

Paperback: 304 pages
Publisher: Microsoft Press (April 14, 2004)
Language: English
ISBN-10: 0735619484
ISBN-13: 978-0735619487
Product Dimensions: 9 x 7.4 x 0.9 inches
Shipping Weight: 1.2 pounds (View shipping rates and policies)

Average Customer Review: 4.0 out of 5 stars See all reviews (15 customer reviews)

Amazon.com Sales Rank: #212,335 in Books (See Bestsellers in Books)
Popular in these categories: (What's this?)
#43 in Books > Computers & Internet > Microsoft > Development > .NET
#58 in Books > Computers & Internet > Programming > Software Design, Testing & Engineering > Testing

Would you like to update product info or give feedback on images?

More About the Author

Discover books, learn about writers, read author blogs, and more.

› Visit Amazon's James Newkirk Page

Inside This Book (learn more)

First Sentence:
In this chapter, we define test-driven development (TDD) and then describe a process for applying it when developing software. Read the first page

Key Phrases - Statistically Improbable Phrases (SIPs): (learn more)
automatic transaction management, int rating, push null, programmer tests, test runner, guard clause, customer tests, recording database, return recording, data access layer, ignore attribute, topmost element, string content, code duplication, private static, code compiles, test list, schema file, test assembly, object sender, existing review, string nothing, existing recording, test code, test fixtures

Key Phrases - Capitalized Phrases (CAPs): (learn more)
Bruce Springsteen, After Push, The Rising, Driving Development, Fake Artist Name, Repeater Web, Visual Studio, Martin Fowler, Modified Name, Deleted Artist, Fake Review Content, Test Reviewer

New!
Books on Related Topics | Concordance | Text Stats

Citations (learn more)

This book cites 15 books:

Design Patterns: AND Applying UML and Patterns, an Introduction to Object-Oriented Analysis and Design and Iterative Development: Elements of Reusable Object-oriented Software by Erich Gamma on page 197, and Back Matter
Extreme Programming Installed by Ron Jeffries on page 5, and Back Matter
Refactoring: Improving the Design of Existing Code by Martin Fowler on page 36, and Back Matter
JUnit in Action by Vincent Massol in Back Matter
Domain-Driven Design: Tackling Complexity in the Heart of Software by Eric Evans in Back Matter

See all 15 books this book cites

Books on Related Topics (learn more)

Microsoft� ADO.NET by David Sceppa

Discusses:

MCAD/MCSD Self-Paced Training Kit by Jeff Webb

Discusses:

MCAD/MCSD Training Guide by Amit Kalani

Discusses:

Enterprise Solution Patterns Using Microsoft .Net by Microsoft Corporation

Discusses:

What Do Customers Ultimately Buy After Viewing This Item?

	54% buy the item featured on this page: Test-Driven Development in Microsoft .NET (Microsoft Professional) 4.0 out of 5 stars (15) $34.37
	22% buy The Art of Unit Testing: with Examples in .NET 4.8 out of 5 stars (12) $26.39
	12% buy Test Driven Development: By Example 3.9 out of 5 stars (32) $41.22
	6% buy Agile Principles, Patterns, and Practices in C# 4.4 out of 5 stars (23) $36.66

Explore similar items

Tags Customers Associate with This Product

(What's this?)

Click on a tag to find related items, discussions, and people.

tdd(6)

csharp(3)

nunit(2)

programming(2)

software development(2)

computer(1)

quality(1)

unit testing(1)

See all 10 tags...

Sell a Digital Version of This Book in the Kindle Store

If you are a publisher or author and hold the digital rights to a book, you can sell a digital version of it in our Kindle Store. Learn more

Customer Reviews

15 Reviews

5 star:		(8)
4 star:		(2)
3 star:		(3)
2 star:		(1)
1 star:		(1)

Average Customer Review

4.0 out of 5 stars (15 customer reviews)

Share your thoughts with other customers:

Create your own review

Most Helpful Customer Reviews

51 of 57 people found the following review helpful:

3.0 out of 5 stars Good, but derivate and incomplete, June 12, 2004

By	David Laub (Skokie, IL USA) - See all my reviews (REAL NAME)

Amazon Verified Purchase(What's this?)

If you want to really learn about test driven development, go to the original book by Beck. If you really want to learn about refactoring, go to the original book by Fowler.

This book does try to cover virgin territory with testing apps that use databases and web interfaces - but it really falls apart at the Web GUI interface level (not to be confused with the Web services interface level, which the book covers well). The techniques recommended in the book essentially try to simulate a web GUI interface with nUnit versus actually using an existing web GUI interface. With one Web form, maybe this isn't too much duplication, but with a large Web app, this is just silly - plus it never tests the actual Web client, so the test results are obviously incomplete. The authors neglect how easy it is to truly test a Web GUI interface - with java based tools (JWebUnit & HttpUnit) which build on top of xUnit, and which work fine on any web app (including asp.net) dot net programmers will need a little understanding of java syntax to use these tools, but java and c# and so nearly identical syntactically for the subset needed, that this is not much of an issue. I hope native ports of these tools to the dot net world are coming soon, but you can live without them and still test Web GUIs easily enough with a little java knowledge, and the authors are remiss in neglecting this.

Plus the blurb on Amazon about the book promised a Windows Form based example - and this is NOT in the book at all!

Comment Comment | Permalink | Was this review helpful to you? Yes No (Report this)

16 of 17 people found the following review helpful:

5.0 out of 5 stars You need this book in your Agile Library!!!, July 29, 2005

By	John Alexander (Seattle WA) - See all my reviews (REAL NAME)

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 Chapter 12 with applying the process of TDD to implementing a web client.

All in all, while I'd have like to have seen a both a simpler example and always more "real world" tips and tricks, I can tell you from my own experience that finding that balance is extremely difficult. I believe the authors have made a significant attempt at striking the "real world" / simplicity balance and that the resulting outcome is an excellent resource for learning TDD. When that is combined with the level of effort the authors are putting in to maintaining the code and forums at their GotDotNet workspace, this makes Test-Driven Development in Microsoft .NET an excellent choice for your library.

Comment Comment | Permalink | Was this review helpful to you? Yes No (Report this)

14 of 15 people found the following review helpful:

3.0 out of 5 stars 7/10, July 18, 2004

By	Dr. Neil (Earth) - See all my reviews

I give this book seven out of ten

What I liked about it:
It is easily to read. The topics are well presented and clearly defined.
The book introduces the concepts behind TDD (Test Driven Development)
Some of the less trivial aspects of TDD are discussed, like testing web services or using transactions.
Refactoring is introduced very well in chapter three.
The concepts of FIT are well explained and demonstrated.

In order to get a ten:
The book needs to decide who the target audience is. The material seemed too hard for a first introduction book and too simple for advanced developers.
As the book is about TDD it should have spent more time examining the benefits of developing software using this approach.
I would have liked to have seen more real world (hard to solve) problems tackled.

Comment Comment | Permalink | Was this review helpful to you? Yes No (Report this)

Share your thoughts with other customers: Create your own review

› See all 15 customer reviews...

Most Recent Customer Reviews

5.0 out of 5 stars Good, simple and descriptive information
I am new to TDD. This book does a very good job for me to get first time insight into test driven development. I highly recommend this book for first timers in TDD. Read more

Published 12 months ago by Ashish Mahajan

4.0 out of 5 stars Great pump-primer for ASP.NET developers
For .NET developers new to test-driven-development who want a recipe for the process, an invaluable book. Read more

Published on September 2, 2006 by Richard J. Cabral

5.0 out of 5 stars 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. Read more

Published on September 29, 2005 by Scott Brookhart

5.0 out of 5 stars Great Book for Experienced Developers
This is a great book for experienced developers. It covers a wide range of realistic uses in .NET and has plenty of detailed examples. Read more

Published on June 20, 2005 by Randy Given

5.0 out of 5 stars 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... Read more

Published on January 28, 2005 by John Matlock

4.0 out of 5 stars Great intro to TDD and more
This books fits in fine with our recent search of .net enterprise devlopment material and we have out it to good use. Some of the chapters seem out of place.

Published on July 7, 2004 by joannie89

5.0 out of 5 stars 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. Read more

Published on June 28, 2004 by J. Jacob

2.0 out of 5 stars Too shallow
The book provides only shallow explanation of how TDD is supposed to work. Oversimplification may lead to bad code. Read more

Published on June 11, 2004 by Mikhail Arkhipov

3.0 out of 5 stars Average
I bought this book hoping it would clarify some of the issues I have with TDD, but not so. Granted the book does a decent job explaining what TDD is, but the level of coverage and... Read more

Published on June 6, 2004 by Manny

1.0 out of 5 stars You can't judge a book by its cover
When picking up this book for the first time, I expected to be submersed in the concepts of test driven development with some specific Microsoft . Read more

Published on June 3, 2004 by Michael E Weliczko

› See all 15 customer reviews...

.jsOffDisplayBlock { display: block; } .jsOffDisplayInline { display: inline; } .jsOffVisibility { visibility: visible; } .jsOnDisplayBlock { display: none; } .jsOnDisplayNoneBlock { display: block; } .jsOnDisplayNoneInline { display: inline; } .jsOnDisplayInline { display: none; } .jsOnVisibility { visibility: hidden; } .jqOnDisplayBlock { display: none; } .jqOnDisplayInline { display: none; } .jqOnVisibility { visibility: hidden; } .jqOnDisplayNoneBlock { display: block; } .jqOnDisplayNoneInline { display: inline; }