Agile Principles, Patterns, and Practices in C# and over one million other books are available for Amazon Kindle. Learn more

Vous voulez voir cette page en français ? Cliquez ici.


or
Sign in to turn on 1-Click ordering.
or
Amazon Prime Free Trial required. Sign up when you check out. Learn More
More Buying Choices
Have one to sell? Sell yours here
Start reading Agile Principles, Patterns, and Practices in C# on your Kindle in under a minute.

Don't have a Kindle? Get your Kindle here, or download a FREE Kindle Reading App.

Agile Principles, Patterns, and Practices in C# [Hardcover]

Robert C. Martin , Micah Martin

List Price: CDN$ 78.99
Price: CDN$ 49.76 & FREE Shipping. Details
You Save: CDN$ 29.23 (37%)
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
Only 2 left in stock (more on the way).
Ships from and sold by Amazon.ca. Gift-wrap available.
Want it delivered Tuesday, August 5? Choose One-Day Shipping at checkout.

Formats

Amazon Price New from Used from
Kindle Edition CDN $37.44  
Hardcover CDN $49.76  

Book Description

July 20 2006 0131857258 978-0131857254 1

With the award-winning book Agile Software Development: Principles, Patterns, and Practices, Robert C. Martin helped bring Agile principles to tens of thousands of Java and C++ programmers. Now .NET programmers have a definitive guide to agile methods with this completely updated volume from Robert C. Martin and Micah Martin, Agile Principles, Patterns, and Practices in C#.

This book presents a series of case studies illustrating the fundamentals of Agile development and Agile design, and moves quickly from UML models to real C# code. The introductory chapters lay out the basics of the agile movement, while the later chapters show proven techniques in action. The book includes many source code examples that are also available for download from the authors’ Web site.

Readers will come away from this book understanding

  • Agile principles, and the fourteen practices of Extreme Programming
  • Spiking, splitting, velocity, and planning iterations and releases
  • Test-driven development, test-first design, and acceptance testing
  • Refactoring with unit testing
  • Pair programming
  • Agile design and design smells
  • The five types of UML diagrams and how to use them effectively
  • Object-oriented package design and design patterns
  • How to put all of it together for a real-world project

Whether you are a C# programmer or a Visual Basic or Java programmer learning C#, a software development manager, or a business analyst, Agile Principles, Patterns, and Practices in C# is the first book you should read to understand agile software and how it applies to programming in the .NET Framework.




Frequently Bought Together

Agile Principles, Patterns, and Practices in C# + Clean Code: A Handbook of Agile Software Craftsmanship + The Clean Coder: A Code of Conduct for Professional Programmers
Price For All Three: CDN$ 112.11

Show availability and shipping details


Customers Who Bought This Item Also Bought


Product Details


Product Description

About the Author

Robert C. Martin has been a software professional since 1970 and an international software consultant since 1990. He is founder and president of Object Mentor, Inc., a team of experienced consultants who mentor their clients in the fields of C++, Java, OO, Patterns, UML, Agile Methodologies, and Extreme Programming.

Micah Martin works with Object Mentor as a developer, consultant, and mentor on topics ranging from object-oriented principles and patterns to agile software development practices. Micah is the cocreator and lead developer of the open source FitNesse project. He is also a published author and speaks regularly at conferences.



Excerpt. © Reprinted by permission. All rights reserved.

But Bob, you said you’d be done with the book last year.
—Claudia Frers, UML World, 1999

Bob’s Introduction

It’s been seven years since Claudia’s justifiable complaint, but I think I have made up for it. Publishing three books—one book every other year while running a consulting company and doing a lot of coding, training, mentoring, speaking, and writing articles, columns, and blogs—not to mention raising a family and enjoying a grandfamily can be quite a challenge. But I love it.

Agile development is the ability to develop software quickly, in the face of rapidly changing requirements. In order to achieve this agility, we need to use practices that provide the necessary discipline and feedback. We need to employ design principles that keep our software flexible and maintainable, and we need to know the design patterns that have been shown to balance those principles for specific problems. This book is an attempt to knit all three of these concepts together into a functioning whole.

This book describes those principles, patterns, and practices and then demonstrates how they are applied by walking through dozens of different case studies. More important, the case studies are not presented as complete works. Rather, they are designs in progress. You will see the designers make mistakes and observe how they identify them as mistakes and eventually correct them. You will see the designers puzzle over conundrums and worry over ambiguities and trade-offs. You will see the act of design.

Micah’s Introduction

In early 2005, I was on a small development team that began work on a .NET application to be written in C#. Using agile development practices was mandatory, which is one of the reasons I was involved. Although I had used C# before, most of my programming experience was in Java and C++. I didn’t think that working in .NET would make much difference; in the end it didn’t.

Two months into the project, we made our first release. It was a partial release containing only a fraction of all the intended features, but it was enough to be usable. And use it they did. After only two months, the organization was reaping the benefits of our development. Management was so thrilled that it asked to hire more people so we could start more projects.

Having participated in the agile community for years, I knew a good many agile developers who could help us. I called them all and asked them to join us. Not one of my agile colleagues ended up joining our team. Why not? Perhaps the most overwhelming reason was the fact that we were developing in .NET.

Almost all agile developers have a background in Java, C++, or Smalltalk. But agile .NET programmers are almost unheard of. Perhaps my friends didn’t take me seriously when I said we were doing agile software development with .NET, or maybe they were avoiding association with .NET. This was a significant problem. It was not the first evidence I’d seen of this problem, either.

Teaching week-long courses on various software topics allows me to meet a wide cross-section of developers from around the world. Many of the students I’ve instructed were .NET programmers, and many were Java or C++ programmers. There’s no gentle way to put this: In my experience, .NET programmers are often weaker than Java and C++ programmers. Obviously, this is not always the case. However, after observing it over and over in my classes, I can come to no other conclusion: .NET programmers tend to be weaker in agile software practices, design patterns, design principles, and so on. Often in my classes, the .NET programmers had never heard of these fundamental concepts. This has to change.

The first edition of this book, Agile Software Development: Principles, Patterns, and Practices, by Robert C. Martin, my father, was published in late 2002 and won the 2003 Jolt Award. It is a great book, celebrated by many developers. Unfortunately, it had little impact on the .NET community. Despite the fact that the content of the book is equally relevant to .NET, few .NET programmers have read it.

It is my hope that this .NET edition acts as a bridge between .NET and the rest of the developer community. I hope that programmers will read it and see that there are better ways to build software. I hope that they will begin using better software practices, creating better designs, and raising the bar for quality in .NET applications. I hope that .NET programmers will not be weaker than other programmers. I hope that .NET programmers achieve a new status in the software community such that Java developers are proud to join a .NET team.

Throughout the process of putting this book together, I struggled many times with the concept of my name being on the cover of a .NET book. I questioned whether I wanted my name associated with .NET and all the negative connotations that seemed to come with it. Yet I can no longer deny it. I am a .NET programmer. No! An agile .NET programmer. And I’m proud of it.

About This Book

A Little History

In the early 1990s I (Bob) wrote Designing Object-Oriented C++ Applications Using the Booch Method. That book was something of a magnum opus for me, and I was very pleased with the result and the sales.

The book you are reading started out as a second edition to Designing, but that’s not how it turned out. Very little remains of the original book in these pages. Little more than three chapters have been carried through, and those have been massively changed. The intent, spirit, and many of the lessons of the book are the same. In the decade since Designing came out, I’ve learned a tremendous amount about software design and development. This book reflects that learning.

What a decade! Designing came out just before the Internet collided with the planet. Since then, the number of acronyms we have to deal with has doubled. We have EJB, RMI, J2EE, XML, XSLT, HTML, ASP, JSP, ZOPE, SOAP, C#, and .NET, as well as Design Patterns, Java, Servelets, and Application Servers. Let me tell you, it’s been difficult to keep the chapters of this book current.

The Booch connection In 1997, I was approached by Grady Booch to help write the third edition of his amazingly successful Object-Oriented Analysis and Design with Applications. I had worked with Grady before on some projects and had been an avid reader and contributor to his various works, including UML. So I accepted with glee and asked my good friend Jim Newkirk to help out with the project.

Over the next two years, Jim and I wrote a number of chapters for the Booch book. Of course, that effort meant that I could not put as much effort into this book as I would have liked, but I felt that the Booch book was worth contributing to. Besides, at the time, this book was simply a second edition of Designing, and my heart wasn’t in it. If I was going to say something, I wanted to say something new and different.

Unfortunately, the Booch book was not to be. It is difficult to find the time to write a book during normal times. During the heady days of the dot-com bubble, it was nearly impossible. Grady got ever busier with Rational and with new ventures such as Catapulse. So the project stalled. Eventually, I asked Grady and Addison-Wesley whether I could have the chapters that Jim and I wrote to include in this book. They graciously agreed. So several of the case study and UML chapters came from that source.

The impact of Extreme Programming In late 1998, XP reared its head and challenged our cherished beliefs about software development. Should we create lots of UML diagrams prior to writing any code? Or should we eschew any kind of diagrams and simply write lots of code? Should we write lots of narrative documents that describe our design? Or should we try to make the code narrative and expressive so that ancillary documents aren’t necessary? Should we program in pairs? Should we write tests before we write production code? What should we do?

This revolution came at an opportune time. During the middle to late 1990s, Object Mentor was helping quite a few companies with OO design and project management issues. We were helping companies get their projects done. As part of that help, we instilled into the teams our own attitudes and practices. Unfortunately, these attitudes and practices were not written down. Rather, they were an oral tradition that was passed from us to our customers.

By 1998, I realized that we needed to write down our process and practices so that we could better articulate them to our customers. So I wrote many articles about process in the C++ Report. 1 These articles missed the mark. They were informative and in some cases entertaining, but instead of codifying the practices and attitudes that we used in our projects, they were an unwitting compromise to values that had been imposed on me for decades. It took Kent Beck to show me that.

The Beck connection In late 1998, at the same time I was fretting over codifying the Object Mentor process, I ran into Kent’s work on Extreme Programming (XP). The work was scattered through Ward Cunningham’s wiki 2 and was mixed with the writings of many others. Still, with some work and diligence, I was able to get the gist of what Kent was talking about. I was intrigued but skeptical. Some of the things that XP talked about were exactly on target for my concept of a development process. Other things, however, such as the lack of an articulated design step, left me puzzled.

Kent and I could not have come from more disparate software circumstances. He was a recognized Smalltalk consultant, and I was a recognized C++ consultant. Those two worlds found it difficult to communicate with each other. There was an almost Kuhnian3 paradigm gulf between them.

Under other circumstances, I would never have asked Kent to write an article for the C++ Report. But the congruence of our thinking about process was able to breech the language gulf. In February 1999, I met Kent in Munich at the OOP conference. He was giving a talk on XP in the room across from where I was giving a talk on principles of OOD. Being unable to hear that talk, I sought Kent out at lunch. We talked about XP, and I asked him to write an article for the C++ Report. It was a great article about an incident in which Kent and a coworker had been able to make a sweeping design change in a live system in a matter of an hour or so.

Over the next several months, I went through the slow process of sorting out my own fears about XP. My greatest fear was in adopting a process in which there is no explicit upfront design step. I found myself balking at that. Didn’t I have an obligation to my clients, and to the industry as a whole, to teach them that design is important enough to spend time on?

Eventually, I realized that I did not really practice such a step myself. Even in all the article and books I had written about design, Booch diagrams, and UML diagrams, I had always used code as a way to verify that the diagrams were meaningful. In all my customer consulting, I would spend an hour or two helping them to draw diagrams and then direct them to explore those diagrams with code. I came to understand that though XP’s words about design were foreign, in a Kuhnian4 sense, the practices behind the words were familiar to me.

My other fears about XP were easier to deal with. I had always been a closet pair programmer. XP gave me a way to come out of the closet and revel in my desire to program with a partner. Refactoring, continuous integration, customer onsite: All were very easy for me to accept. They were very close to the way I already advised my customers to work.

One practice of XP was a revelation for me. Test-driven development (TDD5) sounds innocuous when you first hear it: Write test cases before you write production code. All production code is written to make failing test cases pass. I was not prepared for the profound ramifications that writing code this way would have. This practice has completely transformed the way I write software: transformed it for the better.

So by fall of 1999, I was convinced that Object Mentor should adopt XP as its process of choice and that I should let go of my desire to write my own process. Kent had done an excellent job of articulating the practices and process of XP; my own feeble attempts paled in comparison.

.NET A war is going on among major corporations. These corporations are fighting to gain your allegiance. These corporations believe that if they own the language, they’ll own the programmers and the companies that employ those programmers.

The first volley of this war was Java. Java was the first language created by a major corporpation for the purpose of gaining programmer mindshare. This turned out to be wildly successful. Java has indeed penetrated very deeply into the software community and is largely the de facto standard for modern multilayer IT applications.

One responding volley comes from IBM, which via the Eclipse environment is capturing a large segment of the Java market. The other significant barrage comes from those consumate elaborators at Microsoft who have given us .NET in general and C# in particular.

Amazingly, it is very difficult to differentiate between Java and C#. The languages are semantically equivalent and syntactically so similar that many code snippets are indistinguishable. What Microsoft lacks in technical innovation, it more than makes up for in its remarkable ability to play catch-up and win.

The first edition of this book was written using Java and C++ as the coding language. This book is written using C# and the .NET platform. This should not be viewed as an endorsement. We are not taking sides in this war. Indeed, I think that the war itself will burn itself out when a better language surfaces in the next few years and captures the mindshare of the programmers that the warring corporations have spent so much to secure.

The reason for a .NET version of this book is to reach the .NET audience. Although the principles, patterns, and practices in this book are language agnostic, the case studies are not. Just as .NET programmers are more comfortable reading .NET case studies, Java progarmmers are more comfortable reading Java examples.

The Devil Is in the Details

This book contains a lot of .NET code. We hope that you will carefully read that code, since to a large degree, the code is the point of the book. The code is the actualization of what this book has to say.

This book has a repeating pattern: a series of case studies of varying sizes. Some are very small, and some require several chapters to describe. Each case study is preceded by material that is meant to prepare you for it by describing the object-oriented design principles and patterns used in that case study.

The book begins with a discussion on development practices and processes. That discussion is punctuated by a number of small case studies and examples. From there, the book moves on to the topic of design and design principles and then to some design patterns, more design principles that govern packages, and more patterns. All these topics are attended by case studies.

So prepare yourself to read some code and to pore over some UML diagrams. The book you are about to read is very technical, and its lessons, like the devil, are in the details.

Organization

This book is organized into four sections and two appendixes.

Section I, Agile Development, describes the concept of agile development. It starts with the Manifesto of the Agile Alliance, provides an overview of Extreme Programming (XP), and then goes to many small case studies that illuminate some of the individual XP practices, especially those that have an impact on the way we design and write code.

Section II, Agile Design, talks about object-oriented software design: what it is, the problem of and techniques for managing complexity, and the principles of object-oriented class design. The section concludes with several chapters that describe a pragmatic subset of UML.

Section III, The Payroll Case Study, describes the object-oriented design and C++ implementation of a simple batch payroll system. The first few chapters in this section describe the design patterns that the case study encounters. The final chapter is the full case study, the largest and most complete one in the book.

Section IV, Packaging the Payroll System, begins by describing the principles of object-oriented package design and then goes on to illustrate those principles by incrementally packaging the classes from the previous section. The section concludes with chapters that describe the database and UI design of the Payroll application.

Two appendixes follow: Appendix A, A Satire of Two Companies, and Appendix B, Jack Reeves’ article, “What Is Software?”

How to Use This Book

If you are a developer, read the book cover to cover. This book was written primarily for developers and contains the information needed to develop software in an agile manner. Reading the book cover to cover introduces practices, and then principles then patterns, and then provides case studies that tie them all together. Integrating all this knowledge will help you get your projects done.

If you are a manager or business analyst, read Section I, Agile Development. Chapters 1–6 provide an in-depth discussion of agile principles and practices, taking you from requirements to planning to testing, refactoring, and programming. Section I will give you guidance on how to build teams and manage projects. It’ll help you get your projects done.

If you want to learn UML, first read Chapters 13–19. Then read all the chapters in Section III, The Payroll Case Study. This course of reading will give you a good grounding in both the syntax and the use of UML and will also help you translate between UML and C#.

If you want to learn about design patterns, read Section II, Agile Design, to first learn about design principles. Then read Section III, The Payroll Case Study, and Section IV, Packaging the Payroll System. These sections define all the patterns and show how to use them in typical situations.

If you want to learn about object-oriented design principles, read Section II, Agile Design, Section III, The Payroll Case Study, and Section IV, Packaging the Payroll System. The chapters in those sections describe the principles of object-oriented design and show you how to use them.

If you want to learn about agile development methods, read Section I, Agile Development. This section describes agile development from requirements to planning testing, refactoring, and programming.

If you want a chuckle or two, read Appendix A, A Satire of Two Companies.


1. These articles are available in the publications section of www.objectmentor.com. There are four articles. The first three are entitled “Iterative and Incremental Development” (I, II, III). The last is entitled “C.O.D.E Culled Object Development process.”

2. The website http://c2.com/cgi/wiki. contains a vast number of articles on an immense variety of subjects. Its authors number in the hundreds or thousands. It has been said that only Ward Cunningham could instigate a social revolution using only a few lines of Perl.

3. Any credible intellectual work written between 1995 and 2001 must use the term Kuhnian. It refers to the book The Structure of Scientific Revolutions, by Thomas S. Kuhn, University of Chicago Press, 1962.

4. If you mention Kuhn twice in paper, you get extra credit.

5. Kent Beck, Test-Driven Development by Example, Addison-Wesley, 2003.




Inside This Book (Learn More)
First Sentence
Many of us have lived through the nightmare of a project with no practices to guide it. Read the first page
Browse Sample Pages
Front Cover | Copyright | Table of Contents | Excerpt | Index
Search inside this book:

What Other Items Do Customers Buy After Viewing This Item?


Customer Reviews

There are no customer reviews yet on Amazon.ca
5 star
4 star
3 star
2 star
1 star
Most Helpful Customer Reviews on Amazon.com (beta)
Amazon.com: 4.3 out of 5 stars  35 reviews
54 of 63 people found the following review helpful
4.0 out of 5 stars Well done, with one exception April 19 2007
By G. Askew - Published on Amazon.com
Format:Hardcover|Verified Purchase
First, this book is well written and presents information in a constructive manner. It is well thought out, and is not just another C#/OOP/XP book.

Now for the bad news. One unnecessary oversight is the use of casts and "object" in some examples. Any author writing any C# book since 2005 must know that these idioms should no longer be encouraged. It is unacceptable for a book published in February 2007 to possess this flaw.

Generics, used in moderation, result in cleaner code that is also type-safe, and usually performs better due to the absence of boxing/unboxing. The authors should consider posting alternative examples that favor Generic types and collections on their errata web page. If you purchase this book, you would be well-advised to review the examples with a bias against the use of casts and the word "object".

To be entirely frank, I don't see how other reviewers can justify a five star rating.
25 of 28 people found the following review helpful
5.0 out of 5 stars Critical work on design and development Dec 12 2006
By James Holmes - Published on Amazon.com
Format:Hardcover
This book is amazingly great from start to finish. All the basics of good agile development are covered clearly and sensibly in the first section: what agile is, how to go about it, why testing and planning are so critical, and where refactoring fits in all of this. Design and general patters are hit in the second section, again in a clear, concise, and sensible fashion -- and with common sense thrown in.

The final two sections cover a real-world case study implementation of a payroll system. Here the rubber meets the asphalt: walking through use cases, building transactions based on smartly-chosen patterns, discussion of what patterns make sense where and why, implementation, packaging, and evolution.

I found myself shaking my head in wonder as I read this book and stumbled across one nugget of gold after another. Some bits of goodness pop out in the middle of nowhere simply because the authors are so well-versed in their domain that they're letting fly wisdom even when discussing other topics. An example of this is in the XP pairing session episode where some discussion of increment operator side effects is tossed in the middle of another discussion stream. You read that section once and pass over it, only to do a head check, bounce back and re-read it while nodding your head and saying "Yeah, that's absolutely right and I might not have caught that otherwise."

Another bit of greatness is the chapter on UML. The authors are emphatic about keeping UML tightly in check and using it only in specific cases where it makes clear sense. Mountains of UML diagrams are not the answer; the authors show where a few concise diagrams make perfect sense.

More goodness can be found throughout the book in the gems relating to any number of design issues such as a small example of a problem the authors put forth to students of their various design/patterns courses: build a coffee maker. The authors go through the most common result they see and show the specific problem areas of that solution -- and then show a solution that is amazing in its simplicity, elegance, and maintainability.

This book is a critical read for folks at any level of experience. I'm going to do my best to make sure it gets on the required reading list for developers at my company.
13 of 14 people found the following review helpful
5.0 out of 5 stars Agile Methods and Practices clearly explained Oct. 31 2006
By William Barrett Simms - Published on Amazon.com
Format:Hardcover|Verified Purchase
This book really covers two topics: Agile management methods and development practices used by agile team.

Section I, the description of the Agile methology is brief. This is obviously the intent of the author and agile is meant to be documenation-light. This section only consists of 100 pages. It's a quick read giving you everything you need to know to implement the Agile methodology in your team.

Section II, is titled "Agile Design". These chapters are high-level design principles with low-level examples and a thorough treatment of UML. This should have been split into two sections. This first, would be most useful for a beginner/intermediate developer to take their skills to the next level. The second part, is required reading/knowledge for any developer who needs to work with a team or who needs to plan a complex application.

Section III is presented as a case study. Under the guise of a desiging a payroll system, the authors present the most popular design patterns. This section depends on the previous sections and is a great example of the thought process of agile developers.

The book is well written and easy to read for intermediate to advanced developers. Beginning developers would stuggle with some sections. However, all levels would beneift from reading this book.
9 of 10 people found the following review helpful
5.0 out of 5 stars great book, title a bit misleading Jan. 10 2012
By Dennis Mnuskin - Published on Amazon.com
Format:Hardcover|Verified Purchase
There are two things I would've changed about this book: 1) remove "in c#" from the title and 2) make it clear that all code examples are pseudo-code in a made up language that kind of looks like C++/Java/C#.

I've read just about every review of this book and all the people who rated this book low (3 and lower) completely missed the entire essence of why this book was written. Their complaints were "not enough C#" and "how dare you not use generics, C# programmers should know better!" This book is not about teaching you how to program in C#; there's a ton of print out there to do that. This book is about teaching you how to approach coding, and what they teach can be applied to just about any language out there (well, OO is probably more suitable).

I've been coding professionally for 13 years and 8 more as a hubby before that. I've written some really, really horrendous code, and I got to where I am today by always reflecting back on all of my work. Over time I learned what to do and what should be avoided and when I first discovered Gang of Four's design patterns book, every single pattern I've already used somewhere in my own code.

Currently being a technical team lead on the project, I'm now brushing up on a lot of material regarding design, agile practices, architecture and so on. My goal is not to teach the team solely from my self-taught know-how. Instead, I'm reading all these books because I want to combine my experience with more authoritative voices on the subject and the views of other, more-experienced engineers.

Most of this book was nothing new to me. I've been already practicing a lot of the techniques and habits that the author recommends. However, having said that, there are still quite a few things that authors helped me see in a different light and I've already taken these lessons back to the team. No matter how much experience you have, if you read this book (keeping open mind and not with goal of learning C#), you will learn at least one valuable thing which will make you a better software engineer. They also helped me because their wording and examples are at a perfect level. Intermediate to experienced programmers (i.e. those with enough experience to know how much bad code really costs, in terms of money, time and blood pressure) can easily relate to what is being said and the examples they use are not standard, fictional, non-realistic "animal, cat, dog". Their examples helped me communicate with other team members to whom I wanted to convey some of the concepts behind agile, OOD approach and SOLID principles.
8 of 9 people found the following review helpful
3.0 out of 5 stars Interesting, but needs work July 23 2010
By Maccurt - Published on Amazon.com
Format:Hardcover
This book is not a five. Full of bad code that does not use the full strength of C#. The concepts and ideas are excellent. The author in person is witty and very charismatic. It could have been a better book if he would have correctly converted it to C#. The examples are okay, but could have been better. Examples with squares and rectangles just don't do it for me. I will say the book did change my coding style. This realy is more theory, something to think about. I fear people will use the book and start implementing patterns for symptons they do not even have!

Look for similar items by category


Feedback