|
||||||||||||||||||||
|
||||||||||||||||||||
|
||||||||||||||||||||
C# 3.0 Design Patterns
und über 1 Million weitere Bücher verfügbar für Amazon Kindle .
Erfahren Sie mehr
| |||||||||||||||
 Gutschein erhalten
Tauschen Sie jetzt C# 3.0 Design Patterns gegen einen Amazon-Gutschein in Höhe von EUR 8,65 ein - einlösbar für Tausende von Artikeln bei Amazon.de. Entdecken Sie mehr eintauschbare Bücher im Bücher Trade-In Shop. Bitte beachten Sie die Teilnahmebedingungen.
 Jetzt für Amazon Student anmelden und um 20% erhöhten Eintauschwert sichern. |
Wird oft zusammen gekauft
Produktinformation
Möchten Sie die Produktinformationen aktualisieren oder Feedback zu den Produktabbildungen geben?
Ist der Verkauf dieses Produkts für Sie nicht akzeptabel? |
Mehr über den Autor
Entdecken Sie Bücher, lesen Sie über Autoren und mehr
› Besuchen Sie die Seite von J. M. Bishop auf Amazon
› Besuchen Sie die Seite von J. M. Bishop auf Amazon
Produktbeschreibungen
Kurzbeschreibung
If you want to speed up the development of your .NET applications, you're ready for C# design patterns -- elegant, accepted and proven ways to tackle common programming problems. This practical guide offers you a clear introduction to the classic object-oriented design patterns, and explains how to use the latest features of C# 3.0 to code them. C# Design Patterns draws on new C# 3.0 language and .NET 3.5 framework features to implement the 23 foundational patterns known to working developers. You get plenty of case studies that reveal how each pattern is used in practice, and an insightful comparison of patterns and where they would be best used or combined. This well-organized and illustrated book includes: * An explanation of design patterns and why they're used, with tables and guidelines to help you choose one pattern over another * Illustrated coverage of each classic Creational, Structural, and Behavioral design pattern, including its representation in UML and the roles of its various players * C# 3.0 features introduced by example and summarized in sidebars for easy reference * Examples of each pattern at work in a real .NET 3.5 program available for download from O'Reilly and the author's companion web site * Quizzes and exercises to test your understanding of the material. With C# 3.0 Design Patterns, you learn to make code correct, extensible and efficient to save time up front and eliminate problems later. If your business relies on efficient application development and quality code, you need C# Design Patterns.
Synopsis
If you want to speed up the development process on your .NET applications, you're ready to take advantage of C# design patterns - elegant and repeatable solutions to common programming problems that enjoy wide acceptance in the industry. This book is a clear introduction and reference to this difficult subject, with an insightful comparison of patterns and where they would be best used or combined. "C# 3.0 Design Patterns" offers you a fresh approach. While some sources present C# design patterns converted from C++ and Java code, this book gives you patterns using C# 3.0 language features and a bold use of C# libraries, along with plenty of case studies to illustrate how each of the 23 patterns is used in practice. You get less of the why and more of the how, when and what in this concise and practical guide, with program examples that make sense."C# 3.0Design Patterns" includes: an introduction that explains what design patterns are, why they're used, and how to choose one pattern over another; extensive coverage of the classic creational, structural, and behavioral design patterns; new design patterns in popular areas such as parallel programming, security and web design; interesting real-world examples that work well in the design pattern framework; case studies on patterns in mobile computing and applications in software architecture; examples embedded in real programs running on the companion web site; and, tables and guidelines for the choice of patterns. With the improved features of C# 3.0, design patterns are an efficient and clever way to overcome hurdles in software development with proven, tested templates - if you know how to use them. This well-organized and illustrated book gives you an excellent head start on these effective tools.
Welche anderen Artikel kaufen Kunden, nachdem sie diesen Artikel angesehen haben?
In diesem Buch
(Mehr dazu)
Ausgewählte Seiten ansehen
Buchdeckel | Copyright | Inhaltsverzeichnis | Auszug | Stichwortverzeichnis | Rückseite
Buchdeckel | Copyright | Inhaltsverzeichnis | Auszug | Stichwortverzeichnis | Rückseite
Vorgeschlagene Tags zu ähnlichen Produkten(Was ist das?)Setzen Sie den ersten relevanten Tag hinzu (ein Schlüsselwort, das mit diesem Produkt in engem Zusammenhang steht).
|
Kundenrezensionen
Die hilfreichsten Kundenrezensionen
4 von 4 Kunden fanden die folgende Rezension hilfreich
Format:Taschenbuch
In der Gammaschen Design-Pattern-Bibel werden ausschließlich C++ Beispiele behandelt. Auf die Besonderheiten, die sich mit C# ergeben wird jedoch, schon wegen des Alters des Buches, nicht eingegangen. Mit dem Buch von Judith Bishop verhält sich das anders. Es erklärt die Beispiele nur mit C# wobei man sich das 3.0 eigentlich hätte schenken können.
Als Besonderheit dieses Buches gegenüber dem der GoF sehe ich zudem noch die wirklich sehr anschaulich dargestellten Beispiele. So helfen kleine Comics, der lockere Schreibstil und die Verwendung von Alltagssitutationen vorallem Einsteigern, die Problematik besser zu verstehen. Weiterhin befindet sich am Ende jedes Kapitels noch ein Quiz zu den besprochenen Mustern, welches das gelesene vertiefen soll.
Einen Stern abzug gibt es, da das Buch ein paar Fehler enthält und auch hier die wahren Stärken von .Net, in Bezug auf Designpatterns, nicht vollends ausgeschöpft wird. Es ist aber ein gutes Buch um einen Einstieg in die Materie zu bekommen.
Als Besonderheit dieses Buches gegenüber dem der GoF sehe ich zudem noch die wirklich sehr anschaulich dargestellten Beispiele. So helfen kleine Comics, der lockere Schreibstil und die Verwendung von Alltagssitutationen vorallem Einsteigern, die Problematik besser zu verstehen. Weiterhin befindet sich am Ende jedes Kapitels noch ein Quiz zu den besprochenen Mustern, welches das gelesene vertiefen soll.
Einen Stern abzug gibt es, da das Buch ein paar Fehler enthält und auch hier die wahren Stärken von .Net, in Bezug auf Designpatterns, nicht vollends ausgeschöpft wird. Es ist aber ein gutes Buch um einen Einstieg in die Materie zu bekommen.
10 von 12 Kunden fanden die folgende Rezension hilfreich
Format:Taschenbuch
Das Buch enthält keine neuen Informationen, die nicht schon im Buch der GoF (Gamma, Helm, Johnson, Vlissides)enthalten wären. Diese Pattern sind seit 13 Jahren Allgemeingut.
Im vorliegenden Buch sind die Prinzipien hinter diesen Pattern auch recht mager erklärt. Ein Softwareentwickler, welcher die Diagramm im Original GoF-Buch nicht versteht, sollte eh keine Pattern anwenden.
Beispielcode in C#3.0 (99% hat nix mit 3.0 zu tun) sind zwar ganz nett, aber nicht wirklich notwendig.
Ich halte das Buch für Neulinge, sowohl bei Pattern, wie bei C#, für OK. Jemand der C# kennt bzw. schon ein Buch für diese Pattern hat, kann getrost darauf verzichten.
Im vorliegenden Buch sind die Prinzipien hinter diesen Pattern auch recht mager erklärt. Ein Softwareentwickler, welcher die Diagramm im Original GoF-Buch nicht versteht, sollte eh keine Pattern anwenden.
Beispielcode in C#3.0 (99% hat nix mit 3.0 zu tun) sind zwar ganz nett, aber nicht wirklich notwendig.
Ich halte das Buch für Neulinge, sowohl bei Pattern, wie bei C#, für OK. Jemand der C# kennt bzw. schon ein Buch für diese Pattern hat, kann getrost darauf verzichten.
Die hilfreichsten Kundenrezensionen auf Amazon.com (beta)
Amazon.com:
32 Rezensionen
23 von 24 Kunden fanden die folgende Rezension hilfreich
Good overview of Design Patterns using C# 3.0 but seems rushed
31. März 2008
Format:Taschenbuch
On one hand I like the book, I feel the layout and presentation of each pattern is well done, concise, yet you can grasp the main point of each pattern. Each pattern is explained, implemented, further examples are given, uses are explained and then each pattern is wrapped up with a series of exercises.
On the other hand, the book has many typos, the exercises are a very mixed bag and sometimes the explanation are incorrect or incomplete and it is hard to understand why the author really did what they did or the full implications. This really is a mar on an otherwise solidly presented book. The errors did make me dig into the details and I did learn more from my digging. So, if you are willing to work around these warts than you will learn something but for a beginner the level of frustration may not be worth it. For example the Observer pattern blog example, which uses events with a dictionary was not explained in enough detail. If you looked, you would have found something along the lines of the MSDN article "How to: Use a Dictionary to Store Event Instances (C# Programming Guide)" but you had to look for it.
This also applies to the C# 3.0 features that are presented in the book, again citing the example above. The Mediator pattern has a sidebar on delegates and events and it explains in a very high level what you need to know to implement events stored in a dictionary but unless you use sources outside the book you will be missing out on a lot.
The exercises are varied, some are excellent and they really force you think about what the pattern is about and sink your teeth into the details. Others just seem like they are there to fill space, others do not seem thought out well enough. For example in the Decorator pattern one of the exercises asks you to decorate System.Console but you can not do it using the methods presented. You can use a wrapper but that is not really decorating, so you are left wondering what the real intent was or even worse did you miss some key point.
So overall, even though the book does have warts, it definitely useful, you will learn about the GOF design patterns and come away with some useful knowledge on C# 3.0 and beyond that. I would suggest using the book with a critical mind, try to pick apart the examples and experiment with them, test the authors claims and find the mistakes. My impression is that this book needed another revision and some sections feel like they were in the process of being revised but the book was shipped before the process was done.
If I could I would give the book 3.5 stars, it is still very useful but the warts are painful and coming from O'Reilly that is disappointing. Some have mentioned the "Head First Design Patterns", also by O'Reilly. I have to say that if you want to learn design patterns from a Java perspective I would probably recommend that book instead.
BTW, A previous reviewer had claimed the Observer pattern example did not work but I did not have any problems getting that example to work.
On the other hand, the book has many typos, the exercises are a very mixed bag and sometimes the explanation are incorrect or incomplete and it is hard to understand why the author really did what they did or the full implications. This really is a mar on an otherwise solidly presented book. The errors did make me dig into the details and I did learn more from my digging. So, if you are willing to work around these warts than you will learn something but for a beginner the level of frustration may not be worth it. For example the Observer pattern blog example, which uses events with a dictionary was not explained in enough detail. If you looked, you would have found something along the lines of the MSDN article "How to: Use a Dictionary to Store Event Instances (C# Programming Guide)" but you had to look for it.
This also applies to the C# 3.0 features that are presented in the book, again citing the example above. The Mediator pattern has a sidebar on delegates and events and it explains in a very high level what you need to know to implement events stored in a dictionary but unless you use sources outside the book you will be missing out on a lot.
The exercises are varied, some are excellent and they really force you think about what the pattern is about and sink your teeth into the details. Others just seem like they are there to fill space, others do not seem thought out well enough. For example in the Decorator pattern one of the exercises asks you to decorate System.Console but you can not do it using the methods presented. You can use a wrapper but that is not really decorating, so you are left wondering what the real intent was or even worse did you miss some key point.
So overall, even though the book does have warts, it definitely useful, you will learn about the GOF design patterns and come away with some useful knowledge on C# 3.0 and beyond that. I would suggest using the book with a critical mind, try to pick apart the examples and experiment with them, test the authors claims and find the mistakes. My impression is that this book needed another revision and some sections feel like they were in the process of being revised but the book was shipped before the process was done.
If I could I would give the book 3.5 stars, it is still very useful but the warts are painful and coming from O'Reilly that is disappointing. Some have mentioned the "Head First Design Patterns", also by O'Reilly. I have to say that if you want to learn design patterns from a Java perspective I would probably recommend that book instead.
BTW, A previous reviewer had claimed the Observer pattern example did not work but I did not have any problems getting that example to work.
23 von 25 Kunden fanden die folgende Rezension hilfreich
Are Patterns Good for You?
1. Februar 2008
Format:Taschenbuch
The publishers at O'Reilly have been putting out consistently high-quality technical books for a long time. Judith Bishop's "C# 3.0 Design patterns" is no exception.
In a nutshell: If you think the 23 classic "Gang of Four ("GOF") design patterns have value to you as a programmer, and you want to move your programming expertise into the future, then this book is for you.
Bishop has the credentials to pull this off: she is a computer scientist specializing in the application of programming languages to distributed systems and web - based technologies, and has books published in six languages. She is also a chair or member of numerous international conference committees and editorial boards.
What C# 3.0 Design Patterns does is to analyze all 23 GOF programming patterns with expert commentary and "real life" (e.g. Web 2.0 style) programming examples, and put them directly into the C# 3.0 idiom - using Generics, LINQ, and most all of the newest C# language features in a practical guide to solving common programming problems with an emphasis on what each programming pattern can do for you as a programmer in real life.
Bishop provides pictorial and UML illustrations of patterns, quizzes that relate the illustrations to the UML, "theory" code that can be adapted to real-world programming issues, tables providing guidance on when to use a specific pattern as a solution, lists of pattern advantages and disadvantages, and challenges / exercises to help you take your expertise further.
Are classic programming patterns useful to you? The answer lies in where you are at in your programming adventure. If you are just starting out, this book is probably too advanced for you.
If you already understand the C# programming language and have some introduction to Patterns under your belt, this book will be very exciting to you as it opens up the field to completely new possibilities. You'll see some "pretty slick" code examples in this book and even if you only ever end up using one or two of them, you will have certainly gotten your money's worth. Recommended for intermediate - to - advanced C# developers.
In a nutshell: If you think the 23 classic "Gang of Four ("GOF") design patterns have value to you as a programmer, and you want to move your programming expertise into the future, then this book is for you.
Bishop has the credentials to pull this off: she is a computer scientist specializing in the application of programming languages to distributed systems and web - based technologies, and has books published in six languages. She is also a chair or member of numerous international conference committees and editorial boards.
What C# 3.0 Design Patterns does is to analyze all 23 GOF programming patterns with expert commentary and "real life" (e.g. Web 2.0 style) programming examples, and put them directly into the C# 3.0 idiom - using Generics, LINQ, and most all of the newest C# language features in a practical guide to solving common programming problems with an emphasis on what each programming pattern can do for you as a programmer in real life.
Bishop provides pictorial and UML illustrations of patterns, quizzes that relate the illustrations to the UML, "theory" code that can be adapted to real-world programming issues, tables providing guidance on when to use a specific pattern as a solution, lists of pattern advantages and disadvantages, and challenges / exercises to help you take your expertise further.
Are classic programming patterns useful to you? The answer lies in where you are at in your programming adventure. If you are just starting out, this book is probably too advanced for you.
If you already understand the C# programming language and have some introduction to Patterns under your belt, this book will be very exciting to you as it opens up the field to completely new possibilities. You'll see some "pretty slick" code examples in this book and even if you only ever end up using one or two of them, you will have certainly gotten your money's worth. Recommended for intermediate - to - advanced C# developers.
16 von 19 Kunden fanden die folgende Rezension hilfreich
Nice Treatment of GOF Patterns
8. Februar 2008
Format:Taschenbuch
This is a good rehash of the Gang of Four patterns, reworked in C# 3.0. The book's fairly concise and most patterns are clearly laid out with a simplistic example to demonstrate the basics of the patterns followed by a more detailed example in a semi-real world implementation.
The articles are nicely done, there are a good set of exercises about each pattern, and there are some good comparisons between similar patterns. As an example, there's a bit comparing the Builder and Abstract Factory which details that a Builder is concerned with how things are built while an Abstract Factory is concerned with what is built.
A couple things bothered me in the book, namely the lack of a clear overall summary of patterns, and an annoying batch of sidebars on fairly basic concepts. While each pattern has a summary of when you would use it, you're forced to dig through the entire book looking at each pattern trying to figure out if it will solve a problem for you. A consolidated list of the uses of each pattern at the start or end of the book would have been a great help. Regarding the sidebars: do I need a patterns book to lay out fundamental concepts like accessibility modifiers or indexers? These detract from the book's main purpose, which isn't to teach C# 3.0, but show how patterns are done in C# 3.0. Sidebars specific to a pattern's C# 3.0 intricacies are OK, but the fundamentals should have been left out.
Those annoyances aside, I found the book to be a good read and a useful addition to my bookshelf.
The articles are nicely done, there are a good set of exercises about each pattern, and there are some good comparisons between similar patterns. As an example, there's a bit comparing the Builder and Abstract Factory which details that a Builder is concerned with how things are built while an Abstract Factory is concerned with what is built.
A couple things bothered me in the book, namely the lack of a clear overall summary of patterns, and an annoying batch of sidebars on fairly basic concepts. While each pattern has a summary of when you would use it, you're forced to dig through the entire book looking at each pattern trying to figure out if it will solve a problem for you. A consolidated list of the uses of each pattern at the start or end of the book would have been a great help. Regarding the sidebars: do I need a patterns book to lay out fundamental concepts like accessibility modifiers or indexers? These detract from the book's main purpose, which isn't to teach C# 3.0, but show how patterns are done in C# 3.0. Sidebars specific to a pattern's C# 3.0 intricacies are OK, but the fundamentals should have been left out.
Those annoyances aside, I found the book to be a good read and a useful addition to my bookshelf.
Waren diese Rezensionen hilfreich?
Wir wollen von Ihnen hören.
Kunden diskutieren
|
Das Forum zu diesem Produkt
Fragen stellen, Meinungen austauschen, Einblicke gewinnen Aktive Diskussionen in ähnlichen Foren
Kundendiskussionen durchsuchen
|
Ähnliche Foren
|
||||||||||||||||||||||||||||||||||
Lieblingslisten
|
|
Ähnliche Artikel finden
Anhand des Sachgebietes nach ähnlichen Produkten suchen:
Ihr Kommentar
Möchten Sie die Produktinformationen aktualisieren oder Feedback zu den Produktabbildungen geben?
|
