Spotlight customer reviews:
|
Customer Rating: 
Summary: Nothing less than wisdom distilled
Comment: At Microsoft I work on a development team that has been using the guidelines from this book for nearly 4 years. I am not always a fan of coding standards, thinking they are a necessary evil, often simply arbitrary choices made for consistency.
The Framework Design Guidelines are different. These ensure deep consistency across not just source code, but more importantly the public classes themselves. They include critical, not to be ignored rules on security, cross-language access and localization, as well as the usual good practice type guidelines. But even these "good" practices are always backed with well reasoned argument and examples. As an added bonus FxCop provides a static analysis tool that enforces the guidelines.
Finally, the Framework Design Guidelines provide deep insight into how the .NET Frameworks are designed and used. With the guidelines in mind it is far easier to remember or even guess what classes are provided and how they should be used. This just makes the libraries that much more productive.
Full disclosure: I know Brad and Krzysztof personally, but I would simply remain silent if I didn't think highly of the work.
Customer Rating:
Summary: Great book even if you aren't a framework developer
Comment: There is only one part of the book that I wasn't completely satisfied with: the coding style conventions. Why? Because I try to follow these kinds of suggested standards, but these are not the default settings in Visual Studio! Who makes this stuff up by the way? No spaces between arguments??? C'mon. Also, I'll "raise" an event, but I won't throw an exception if someone says "fire" an event. Let it go. :-)
That being said...This is a great read for anyone who writes classes in .NET at all even though the objective is writing public APIs. If everyone designed this way, we'd all be a bunch of happy .NET developers.
Customer Rating: 
Summary: Must-own book for any class library developer.
Comment: The new book from Brad Abrams and Krzysztof Cwalina is a must-have book for anyone writing .NET and Mono code.
The book includes many of the design guidelines that Brad's blog is famous for. The book is not just a collection of rules, but it also includes the rationale for some of the design decisions and what really makes the book interesting are the commentaries from other developers and architects involved in .NET.
This book is packed with gems.
Customer Rating:
Summary: many common sense guidelines
Comment: The .NET framework is still rather new and unfamiliar to many programmers. This book is part of an ongoing series of texts from Microsoft that offers education as to the best use of .NET. The book tackles one of the main problems of computing. Namely, how to write code that will be put into libraries and reused by many others? Arguably, this might even be the central problem in many computing projects.
The guidelines given in the text should strike the reader as very much common sense. Take these, for instance: "Do not require that users perform any extensive initialisation before they can start programming basic scenarios", or "Do provide good defaults for all properties and parameters". If you have programmed in any language, you should readily agree with guidelines like these.
The guidelines also include an excellent discussion about the naming of classes and methods in those classes. This is quite general; applying to any object oriented language like C++ or Java. Indeed, if you program in those languages, consider looking up this chapter of the book for useful hints.
The book also continues a nice practice of the earlier books in the series. It has many sidebars with different people offering informal remarks about the adjoining text. Commentaries that can greatly help your assimilation of the material.
Customer Rating:
Summary: If you want me to buy your .NET component or library, you better read this book!
Comment: This book was written by *the* two Microsoft experts on design guidelines for the .NET Framework: Brad Abrams and Krzysztof Cwalina. It really is a MUST read for anybody designing OO class libraries especially libraries that are based on managed code (aka .NET Framework). What I really like is that there are not only "Do", "Do Not", "Avoid", "Consider" guidelines but most of the guidelines are accompanied by annotations from many different folks (Jeff Richter, Rico Mariani, Chris Brumme, Chris Sells, Brent Rector, etc). These annotations really help with the pragmatic side of deciding between conflicting forces. That is, there are many guidelines where you could go one way versus another. The annotations serve to help you decide which way to go. I give it two thumbs way up and even thought it's about 300 pages, it is a quick read.
|
|
|
