|
C# 3.0 Design Patterns | 
 enlarge | Author: Judith Bishop
Publisher: O'Reilly Media, Inc.
Category: Book
List Price: £24.99
Buy New: £13.90
You Save: £11.09 (44%)
Rating:  5 reviews
Sales Rank: 42380
Media: Paperback
Number Of Items: 1
Pages: 314
Shipping Weight (lbs): 1.1
Dimensions (in): 9 x 7.2 x 0.7
ISBN: 059652773X
Dewey Decimal Number: 005.133
EAN: 9780596527730
ASIN: 059652773X
Publication Date: January 11, 2008
Availability: Usually dispatched within 1-2 business days
Shipping: International shipping available
Condition: Brand New. Shipped from UK Mainland. Delivery is usually 3 - 4 working days from order by Royal Mail, International Delivery is by Airmail.
|
| Similar Items:
|
| Customer Reviews:
 Poor effort October 29, 2008
This book has convoluted and baffling explanations of the design patterns when compared to other books on the subject.
The whole point of an example seems to have been lost i.e. a simplified or contrived scenario to clearly demonstrate the concepts.
Additionally, having typos in the code is the most frustrating for someone trying to get to grips with new ideas/technology because if you try and code them yourself it simple doesn't work. There is no excuse for this - it just indicates that the book was poorly edited and rushed out.
Very promising title but does not deliver June 28, 2008
3 out of 3 found this review helpful
I am a developer working with C# 3.0 on a daily basis and so I was very excited by this book, hoping that it would give me greater insight into C# 3.0's excellent new features and some new tools in my programming toolkit, as well as more insight into design patterns and their use in designing modular, maintainable, extensible systems.
I have ploughed my way through the book, but it has taken me a while because it simply doesn't live up to expectations. The examples are not very relevant to everyday programming problems and often seem contrived and there are some annoying typos and some dubious advice (see other reviews).
Instead of this book, I would recommend a good book on design patterns and a good book on C# 3.0.
Disappointing June 23, 2008
I bought this book because Eric Lippert mentioned it on his blog (he is one of the reviewers and wrote the foreword) and I'm a big fan of Eric's work. I guess reviewing a book is not the same as writing it! I started with a deep interest in both topics (C# 3.0 and design patterns) as well as (too) high expectations and I got fairly quickly disappointed by the lack of innovative ideas in the proposed implementations and the somewhat superficial use of C# 3.0.
The code lacks consistency as if it was written by different people with different level of expertise, the layout (of the code) is far from perfect with a few irritating typos. Sometimes the lengthy explanations about the implementation cover trivial matters while unnecessarily confusing bits are just taken for granted.
There is even one suggestion that made me fall from my chair, page 170 in the Chain of Responsibility and Command pattern: storing information in the numerical value of enums! What a convoluted idea for no practical benefit (apart maybe saving 4 bytes of memory) and a potential nightmare for maintenance.
Overall, all the ingredients for a good book, but you might have to wait for the second edition (if it ever gets that far) to make it worth it.
 The design patterns book that every C# programmer needs January 23, 2008
6 out of 7 found this review helpful
C# 3.0 Design Patterns by Judith Bishop takes a new approach to a classic subject. In so doing, Bishop imparts deep insight into what is widely considered a difficult subject and conveys practical knowledge in a concise manner that will greatly benefit any serious developer programming in C# for .NET.
After an introductory chapter entitled "C# Meets Design Patterns," there are nine chapters presenting all of the 23 classic design patterns from Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides's seminal work Design Patterns: Elements of Reusable Object-Oriented Software. The patterns are presented two or three at a time, and each chapter begins with a real-world illustration of the pattern in action. This is followed by a clear UML diagram, a concise description of the pattern players and their roles and a theory example that implements the pattern in quesiton in a complete console application that is made as short as possible, usually 50 to 80 lines of code.
After presenting each pattern, Bishop provides one or more examples, several of which are carried over to and expanded in subsequent chapters, and presents numerous exercises for the reader. Each chapter typically contains sidebars briefly describing one or more C# features and how they can be leveraged in implementing the pattern at hand. There is also excellent guidance on when to use each pattern and an invaluable comparison of the patterns presented in each chapter that provides further insight into their characteristics. In addition, all of the patterns, their interactions and the examples in which they are illustrated are summarized in the final chapter.
In a book of less than 300 pages, the examples, although highly relevant to practical programming problems, are necessarily somewhat simplistic. They do not contain any of the error checking, exception handling or test methods that would be present in industrial-strength code. Nonetheless, they are all complete programs that clearly illustrate the pattern in question and how to code it in C#. Several of the examples are also expanded over several chapters and presented in an appendix as fully functional programs that can be easily extended to provide additional functionality.
Perhaps the greatest strength of Bishop's book and its greatest benefit to C#/.NET developers is its description of advanced C# 3.0 features and how they can be leveraged to create pattern implementations that are elegant and concise. Bishop not only writes with the authority one would expect of a professor of computer science. It is also very evident that she is an educator who has considerable experience in making difficult subjects comprehensible. As Microsoft C# Senior Developer Eric Lippert puts it in his preface to the book, "C# 3.0 Design Patterns brings the frequently abstruse world of design patterns into sharp focus with pragmatic C# 3.0 implementations."
Accomplishing this in less than 300 pages is nothing short of a tour de force. I have been trying for some time to get my head around design patterns and searching for good C# implementations. Now my search is over, and I have a practical guide to understanding and implementing the patterns that I need written by an accomplished theorist, practitioner and educator.
Let down by poor examples January 14, 2008
8 out of 8 found this review helpful
I'm an IT professional currently working with C# and the .NET Framework and whose previous knowledge of Design Patterns was gained mostly from the excellent Head First Design Patterns book.
So it was with eager anticipation that I pre-ordered this book with a view to enhancing my Design Pattern knowledge while simultaneously getting acquainted with the newer (and possible lesser used) features of the C# 3.0 language.
In general, the concept of the book is sound and well structured. Each design pattern is presented by its Role (high level description), Illustration (some everyday example of how the pattern is implemented), Design (UML diagram), Example (theoretical code, practical code), Use (scenarios where the pattern may be considered) and Exercises (enhancements to Examples). New or unusual C# language features used in each pattern example code are presented in summary in sidebars when required - nice feature.
Where I feel the book does let itself down is in the examples, both the Illustrations and the example code.
For example, the illustration of the Adapter pattern (a pretty simple design pattern) involves an in depth discussion of versions of Mac processors and their subsequent replacements' compatibility with Linux and Windows. (In fact, the author is so wound up in this example that they even give a reference for further reading!).
A simpler (possibly more contrived) example could have illustrated the Adapter Pattern much better and made it easier to recall (this is where the Head First book is better); instead the illustration only shows how knowledgeable the author is about Macs etc. And the illustration/code example of the Two-Way Adapter pattern is again hopelessly bogged down in the details of a ludicrous scenario to enhance your understanding.
Examples should be there to illuminate the concepts presented - not to flaunt the author's prowess.
Still, in the main it's a good read with much to commend it, but the poor examples to illustrate concepts and the baffling quiz sections (based on vague and ludicrous illustrations) may frustrate some.
|
|
|
Site powered by Amazon.co.uk | |