In weniger als einer Minute können Sie mit dem Lesen von Effective C# (Covers C# 4.0): 50 Specific Ways to Improve... auf Ihrem Kindle beginnen. Sie haben noch keinen Kindle? Hier kaufen Oder fangen Sie mit einer unserer gratis Kindle Lese-Apps sofort an zu lesen.

An Ihren Kindle oder ein anderes Gerät senden


Kostenlos testen

Jetzt kostenlos reinlesen

An Ihren Kindle oder ein anderes Gerät senden

Jeder kann Kindle Bücher lesen  selbst ohne ein Kindle-Gerät  mit der KOSTENFREIEN Kindle App für Smartphones, Tablets und Computer.
Effective C# (Covers C# 4.0): 50 Specific Ways to Improve Your C# (2nd Edition) (Effective Software Development Series)

Effective C# (Covers C# 4.0): 50 Specific Ways to Improve Your C# (2nd Edition) (Effective Software Development Series) [Kindle Edition]

Bill Wagner
5.0 von 5 Sternen  Alle Rezensionen anzeigen (3 Kundenrezensionen)

Kindle-Preis: EUR 15,13 Inkl. MwSt. und kostenloser drahtloser Lieferung über Amazon Whispernet

Weitere Ausgaben

Amazon-Preis Neu ab Gebraucht ab
Kindle Edition EUR 15,13  
Taschenbuch EUR 25,95  

Kunden, die diesen Artikel gekauft haben, kauften auch



"Being an effective .NET developer requires one to have a deep understanding of the language of their choice. Wagner's book provides the reader with that knowledge via well-reasoned arguments and insight. Whether you're new to C# or you've been using it for years, you'll learn something new when you read this book." -Jason Bock, Principal Consultant, Magenic "If you're at all like me, you have collected a handful of C# language pearls that have immediately transformed your abilities as a professional developer. What you hold in your hands is quite possibly the best collection of these tips that have ever been assembled. Bill has managed to exceed my wildest expectations with the latest edition in his eponymous Effective C#." -Bill Craun, Principal Consultant, Ambassador Solutions "Effective C#, Second Edition, is a must-read for anyone building high performance and/or highly scalable applications. Bill has that rare and awesome ability to take an amazingly complex problem and break it down into human, digestible, and understandable chunks." -Josh Holmes, Architect Evangelist, Microsoft "Bill has done it again. This book is a concise collection of invaluable tips for any C# developer. Learn one tip every day, and you'll become a much better C# developer after fifty days!" -Claudio Lassala, Lead Developer, EPS Software/CODE Magazine "A fountain of knowledge and understanding of the C# language. Bill gives insight to what happens under the covers of the .NET runtime based on what you write in your code and teaches pragmatic practices that lead to cleaner, easier to write, and more understandable code. A great mix of tips, tricks, and deep understanding-including things true since C# 1.0 up through new capabilities in C# 4.0-that every C# developer should read." -Brian Noyes, Chief Architect, IDesign Inc. ( "Effective C# is a must-have for every C# developer. Period. Its pragmatic advice on code design is invaluable." -Shawn Wildermuth, Microsoft MVP (C#), Author, Trainer, and Speaker "In this book Bill Wagner provides practical explanations of how to use the most important features in the C# language. His deep knowledge and sophisticated communication skills illuminate the new features in C# so that you can use them to write programs that are more concise and easier to maintain." -Charlie Calvert, Microsoft C# Community Program Manager


C# has matured over the past decade: It’s now a rich language with generics, functional programming concepts, and support for both static and dynamic typing. This palette of techniques provides great tools for many different idioms, but there are also many ways to make mistakes. In Effective C#, Second Edition, respected .NET expert Bill Wagner identifies fifty ways you can leverage the full power of the C# 4.0 language to express your designs concisely and clearly.


Effective C#, Second Edition, follows a clear format that makes it indispensable to hundreds of thousands of developers: clear, practical explanations, expert tips, and plenty of realistic code examples. Drawing on his unsurpassed C# experience, Wagner addresses everything from types to resource management to dynamic typing to multicore support in the C# language and the .NET framework. Along the way, he shows how to avoid common pitfalls in the C# language and the .NET environment. You’ll learn how to


  • Use both types of C# constants for efficiency and maintainability (see Item 2)
  • Employ immutable data types to promote multicore processing (see Item 20)
  • Minimize garbage collection, boxing, and unboxing (see Items 16 and 45)
  • Take full advantage of interfaces and delegates (see Items 22 though 25)
  • Make the most of the parallel framework (see Items 35 through 37)
  • Use duck typing in C# (see Item 38)
  • Spot the advantages of the dynamic and Expression types over reflection (see Items 42 and 43)
  • Assess why query expressions are better than loops (see Item 8)
  • Understand how generic covariance and contravariance affect your designs (see Item 29)
  • See how optional parameters can minimize the number of method overloads (see Item 10)


You’re already a successful C# programmer–this book will help you become an outstanding one.


  • Format: Kindle Edition
  • Dateigröße: 6128 KB
  • Seitenzahl der Print-Ausgabe: 352 Seiten
  • Gleichzeitige Verwendung von Geräten: Bis zu 5 Geräte gleichzeitig, je nach vom Verlag festgelegter Grenze
  • Verlag: Addison-Wesley Professional; Auflage: 2 (5. März 2010)
  • Verkauf durch: Amazon Media EU S.à r.l.
  • Sprache: Englisch
  • Text-to-Speech (Vorlesemodus): Aktiviert
  • X-Ray:
  • Durchschnittliche Kundenbewertung: 5.0 von 5 Sternen  Alle Rezensionen anzeigen (3 Kundenrezensionen)
  • Amazon Bestseller-Rang: #61.349 Bezahlt in Kindle-Shop (Siehe Top 100 Bezahlt in Kindle-Shop)

  •  Ist der Verkauf dieses Produkts für Sie nicht akzeptabel?

Mehr über die Autoren

Entdecken Sie Bücher, lesen Sie über Autoren und mehr

Welche anderen Artikel kaufen Kunden, nachdem sie diesen Artikel angesehen haben?


4 Sterne
3 Sterne
2 Sterne
1 Sterne
5.0 von 5 Sternen
5.0 von 5 Sternen
Die hilfreichsten Kundenrezensionen
5 von 5 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Should have read before starting any project 17. September 2010
The second edition of "Effective C#" is great if you want to start C# without becoming the basics explained over and over again. It prevents from doing bad things one might regret later. From basic keyword subtleties over resource management, API advices+tips ending with dynamics and more: The book follows the same design guidelines as the Effective C++ series of Scott Meyers presenting the content in 50 neat items - each small enough to be read in the subway on the way to the office.
War diese Rezension für Sie hilfreich?
5.0 von 5 Sternen Verständlich, praxisgerecht, eingängig 2. Juli 2014
Von TheReader
Wer möchte nicht, wenn er etwas anspruchsvollere Software-Projekte abwickelt, nach Best Practices vorgehen. Hier bietet dieses Buch eine Reihe von sinnvollen und guten Tipps im Umgang mit C# und seinen sprachlichen Eigenheiten. Besonders gelungen ist, dass nicht nur stur eine "Regel" nach der anderen aufgeführt wird, wie man Code schreibt und formatiert, sondern dass der Author klar aufzeigt und an Beispielen erklärt, welche Probleme man sich früher oder später einfängt, wenn man eben nicht nach Best Practice vorgeht und sein eigenes Süppchen mit Spaghetti-Code kocht. Das Buch hilft dabei, selbst zu reflektieren, was man da so täglich zusammen kodiert und welche Konsequenzen das später mal haben könnte, wenn man den Code überarbeiten muss. Es animiert dazu, drüber nachzudenken, wo man einfache aber wirkungsvolle Optimierungen an seinem (oder fremden) Code vornehmen kann. Ganz klar: Daumen hoch!
War diese Rezension für Sie hilfreich?
5.0 von 5 Sternen Sehr gutes Buch! 16. Januar 2013
Format:Taschenbuch|Verifizierter Kauf
Sehr gut geschrieben und mit guten Beispielen. Kann man auch in Fragmenten lesen.

Nicht für absolute Anfänger aber Leute mit C#-Erfahrung können hier noch einiges lernen.
War diese Rezension für Sie hilfreich?
Die hilfreichsten Kundenrezensionen auf (beta) 4.3 von 5 Sternen  40 Rezensionen
20 von 21 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen A new edition brings new insight to C# on .NET 4.0 28. April 2010
Von S. Anderson - Veröffentlicht auf
Format:Taschenbuch|Verifizierter Kauf
I have both editions of "Effective C#". The older, first edition did not have lambda expressions, LINQ, or generics (though it hinted at generics towards the end). In the second edition, tips (called "Items") that have since fallen out of practice are weeded out and are replaced with fresh concepts from .NET 2.0, through 4.0.

The items are written in a very clear manner. Most of the figures are illustrative of the concepts. Some of the pictures aren't quite as clear as they could be (.NET's Garbage Collector sticks out in my mind - Bill! read some Tufte! :) but for the most part, each item gave a firm understanding. I could read the first and last paragraph of each item to get a clear bird's eye explanation. Later, I would pore over the details with a highlighter and come away enlightened.

This book has a sister - "More Effective C#". This was released PRIOR to "Effective C# - Second Edition". I own that copy too, and it's dog-eared by now. The two books go together like peas and carrots, though "More Effective C#" touches on more advanced .NET 3.0 concepts. "More Effective C#"'s treatment of "yield return", dependency injection, and composition in the third chapter alone are inspiring.

If you really want to go all out, I'd recommend getting "C# in Depth" by John Skeet. There's a new edition coming out in the summer of 2010. Skeet's book will bring the reader up to speed on the advancements of C# in .NET 3.0 (and soon 4.0) without giving them any specific tips. The "Effective C#" series will give the reader specific tips without bringing anybody up to speed.

Also, the author is a cool guy. I emailed him back in 2009 with questions about the first edition and he brought me up to speed by responding on his blog. You are encouraged to give him feedback.

I consider "Effective C#" as one of the first books I reach when I want to brush up on my skill set.
38 von 45 Kunden fanden die folgende Rezension hilfreich
2.0 von 5 Sternen Would you tell me, please, which way I ought to code from here? 5. August 2011
Von James Daniel - Veröffentlicht auf
Format:Taschenbuch|Verifizierter Kauf
I should be clear, I am not criticizing this book as being "bad", but it turns out to have been the least useful C# book I've purchased. This is admittedly in part due to my own preferences and perceptions about what I need from various C# books.

There is a quote from Alice in Wonderland that I find quite applicable here:
Alice: Would you tell me, please, which way I ought to go from here?
The Cat: That depends a good deal on where you want to get to.

This quote kept coming to mind as I read through all 50 tips. They aren't really tips so much as, well, good ideas, assuming what the author is describing is what you want to do. If it isn't what you want to do, any given tip is either not applicable, or actually a bad idea.

I found myself thinking, about each tip, one of three things:
1) Well, yes, of course, that's a good best practice. For most of these, I already knew that. The only one that impressed me was using readonly vs const: it was a good overall explanation of how const can backfire.
2) Um, no, that really isn't true, though a lot of people think it is. In particular his discussion of StringBuilder vs string concatenation was much less enlightening than googling for the topic and reading useful forum/blog posts.
3) Um, I guess that's a good idea, assuming that's what you intend to do in the first place. (Most of the book fit into this category for me.)

So I find myself reading tips that are either really obvious, or I believe they're wrong or slightly misinformed, or they really don't apply to anything I need to do at all. The author appears to use C# mostly to write APIs that would be used generally by others, e.g., more on the "web service" side than the "web application" side. If your goal is to write APIs, you may very well find these tips to be much more useful than I do. The tips aren't "wrong", but as I find myself usually writing applications instead of APIs, they don't explain anything that I'd actually use. Other tips discuss architecture decisions that would never come up for the person who is merely responsible for implementing them: this is sometimes useful, but really, architecture decisions are entirely dependent on what you want the application to do (queue the Alice quote again).

I would suggest that his worst tip is the one where he briefly discusses the StringBuilder vs string concatenation debate. The tip is to not create unnecessary objects. This is certainly a valid concern. He doesn't really weigh the advantages/disadvantages, rather he simply asserts that StringBuilder is better because fewer objects are created for the garbage collector to collect. I don't want to belabor the already-well-known-and-easily-googled discussions on the matter, but suffice it to say, the real answer is "it depends". Sometimes StringBuilder is clearly the best choice. Sometimes simple string concatenation is clearly superior (the garbage collector really is very smart about how to handle the extra strings that are orphaned by concatenation, so long as you don't abuse it). And String.Format really isn't all that advantageous, either, unless you need special/complex formatting, because it goes and creates a new StringBuilder (with associated overhead and requiring garbage collection) every time you call it.

"Would you tell me, please, which way I ought to [code] from here?" asked Alice. "That depends a good deal on where you want to get to," replied the Cat.

I would steer those who are looking for expert-level knowledge about how C# "really works" to check out Jon Skeet's "C# in Depth, Second Edition", also available from Amazon. It covers many of the same topics, but I believe it provides a deeper understanding of C# such that you don't need any "specific tips", but rather the correct course of action becomes obvious based on the circumstances at hand.
34 von 42 Kunden fanden die folgende Rezension hilfreich
1.0 von 5 Sternen Poor Kindle Edition 12. Juli 2011
Von Greg Grundy - Veröffentlicht auf
Format:Kindle Edition|Verifizierter Kauf
The Kindle edition uses different font weights so that the text is shown differently from the code.
a) A normal black for the text; and
b) a completely invisible grey for the code.
If you have any desire to actually see the code in this book, don't bother with the Kindle edition.
The conversion was very shoddy.
2 von 2 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Worthwhile C# Reference, IMHO 31. Dezember 2012
Von D. Suilmann - Veröffentlicht auf
Format:Kindle Edition|Verifizierter Kauf
First, of all, I read a lot of code... co-workers, Code Project, Open Source, blogs, books, etc. Books like this are a significant cut above the average source code uploaded to the internet, but you still need a critical eye. While I don't take issue with any of the advice, its importance to your daily coding will vary quite a bit. Bottom line is that I'd recommend this book, but make sure you have plenty of other references.
2 von 2 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen A good book with a lot of details on internals of C# Constructs 30. Oktober 2010
Von Arvind - Veröffentlicht auf
Each tip in the book will help you understand the various different internals of the .Net framework and help you write cleaner , easier and performant code.

This is an easy read , take tip a day and you will be done in no time.
Waren diese Rezensionen hilfreich?   Wir wollen von Ihnen hören.
Kundenrezensionen suchen
Nur in den Rezensionen zu diesem Produkt suchen

Beliebte Markierungen

 (Was ist das?)
Always create an override of ValueType.Equals() whenever you create a value type. &quote;
Markiert von 49 Kindle-Nutzern
Updating the value of a public constant should be viewed as an interface change. You must recompile all code that references that constant. Updating the value of a read-only constant is an implementation change; it is binary compatible with existing client code. &quote;
Markiert von 47 Kindle-Nutzern
Inheritance means is a, and interfaces means behaves like. &quote;
Markiert von 44 Kindle-Nutzern

Kunden diskutieren

Das Forum zu diesem Produkt
Diskussion Antworten Jüngster Beitrag
Noch keine Diskussionen

Fragen stellen, Meinungen austauschen, Einblicke gewinnen
Neue Diskussion starten
Erster Beitrag:
Eingabe des Log-ins

Kundendiskussionen durchsuchen
Alle Amazon-Diskussionen durchsuchen

Kunden, die diesen Artikel markiert haben, haben auch Folgendes markiert

Ähnliche Artikel finden