Customer Reviews

Professional .NET 2.0 Generics (Programmer to Programmer)

5 star:		(11)
4 star:		(5)
3 star:		(0)
2 star:		(1)
1 star:		(1)

 

 

I just got a copy of this book earlier today and am comfortable reviewing it already. That's because I've read through it already. After I got started, I didn't want to put it down and although I spent most of today reading it, it was very informative and a lot of fun to read.

The first chapter is your standard first chapter and lays the groundwork for the rest of the book. It moves forward into the subject of Generics and new .NET 2.0 Framework featurews , briefly discusses the difference between templates and generics and them moves full steam into generics. To of the last chapters discuss J# and C++ in particular, as opposed more specific generics topics but they are definitely appropriate and don't come at the expense of anything else.

The main thing that this book does is explain why you want to use generics and shows how to use them. The author knows the subject matter well and does a very good job of explaining each objective. by the time you move into the middle of the book, you'll thoroughly understand how to create and manage generic types and you'll learn quite a bit about the performance implications and benefits. Chapters 4-8 walk you through just about every aspect of using generics (as opposed to the previous 1.x way of doing things).

Chapter 8 moves onto the BCL implementations and ties together everything before it. By the time you complete chapter 8, you'll be comfortable in your ability to handle just about anything you'd ever want to accomplish with generics.

Chapter 9 discusses Serialization, Reflection and Remoting. This chapter was ostensibly my favorite but is also the one I have the biggest complaint with. Don't get me wrong, it's excellent. However I really wish the discussion on remoting was a little longer. NOt because it's not in depth enough, nothing after all was left out or short changed. However the Remoting section has a really cool example and explanation, but it's so cool that I could have read 5 more chapters on generics and remoting without getting bored. I'm not really criticizing it though, my only point is that I liked it so much I wish there was more of it because I couldn't get enough.

After chapter 9, Generics guidelines are covered and then generics "under the hood" are discussed. The things that make chatper 11 really good are quite technical in nature and I couldn't possibly go into it in a book review but suffice to say that it's very well done.

C++ and J# are discussed next which are well done but nothing to get excited about compared to the rest of the material. Then th ebook wraps up with "Power collections" which is a perfect finally.

I've never read anything from Mr Golding before but I got his other 2.0 Framework book today too and I really look forward to reading it. Generics are an important subject and definitely warrant having an entire book dedicated to them, and Mr Golding does a great job expalining the ins and outs of them.

Concise and easy to understand, I totally understand why the book has the ratings it does - it's definitely a 5 star book.

Generics are one of the biggest advances introduced in .NET 2.0, and this book provides excellent coverage of the topic. As a diehard fan of C++ templates, I especially appreciated the careful discussion of the differences between templates and generics. There is plenty of introductory material here to help the reader unfamiliar with the basic concepts; but more advanced readers can also dig in to the chapters on the "inner workings" of generics, and on how C++ templates can interact with them. The book also provides a concise reference on the template classes supplied with the framework. Highly recommended.

The most important changes in the new .NET 2.0 is the inclusion of Generics. Note the word 'Professional' in the title. This book is for Professional VB.NET and C# programmers and architects who may be new to generics but have strong Microsoft coding skills.

The book begins on page 1 with a section labeled 'Why Generics.' After three introductory paragraphs he starts off with a couple of sample programs. The two programs do the same thing, but one is written in VB and the other in C#. After a few pages he modifies these two programs to show the benefit to the coding that using Generics provides. As I said earlier, this is by no means a beginners book, it's one professional programmer writing for another.

I don't knwo for sure, but his book probably has more space showing programs than text. This doesn't make for the easiest book to read, but when you get through it, you see exactly what Generics provide. You see the strengths, you see the limitations. You see exactly how to use them in your code.

Finally in the last chapter, which is 77 pages long, deals with the Power Collections generic libraries and how to use them. One thing he does not give is a web address for the collections. Here are some that may be of help:

Power Collections -- www.wintellect.com/powercollections/
C5 -- www.itu.dk/research/c5/
NCollection -- ncollection.tigris.org/
NGenLib -- ngenlib.sourceforge.net/

Generics is [sic] one of the most compelling ideas in any object oriented language. The puzzle is that it was not present in the first versions of .NET and Java. It is only now (2004-5) that both languages comes with this. A little strange, considering that C++ has had templates for several years, and these are roughly equivalent to the implementations of Generics in .NET and Java.

Anyhow, Golding focuses on explaining the use of Generics within .NET. The latter encompasses several Microsoft languages that now have this facility - VB, C# and J#. The book makes a practice of giving code examples in pairs; written in VB and C#. To broaden its appeal to practitioners in both.

He shows how Generics can be succinctly thought of as parametric polymorphism. It takes the elementary idea of polymorphism that every object oriented language has, and extends it to parameterising the input types to a class's methods or constructors.

The book gives a pretty thorough rundown on Generics. Including explaining the differences with C++ templates. The biggest being crucially that .NET Generics are instantiated at runtime, while the latter are at compile time. [Golding devotes an entire chapter to the consequences of this.]

You can get an appreciation for the extra type safety and generalisations possible in your code.

Until reading this book, I had been nervous about the introduction of generics into .Net. First, I wasn't sure how well they would be implemented equivalently across multiple languages. Second, I had been an early C++ programmer and lived through how complicated the introduction of templates made that language. This book has convinced me that generics will work equally well in C++, C#, and even Visual Basic.

As a long-time C++ programmer, my favorite chapter was Chapter 3, which presented very cogent arguments as to why generics are not the same as templates. Another favorite is Chapter 10, which presents 23 very specific guidelines for all generics programmers to be mindful of. The book benefits greatly from always showing each example in both VB and then in C#.

I'm sure you could pick up a more general "Programming in .Net" book and read its one chapter on generics. However, since generics are probably the most significant addition to .Net, you will miss out on learning many of the powerful new ways to take advantage of generics that Golding presents in this book.

This book is a very good introduction to .NET generics and covers it very well. Recommended for those starting out with generics and although there are some advanced concepts, it is mostly for those starting out in generics. The advanced topics are not covered in enough detail.

Although it is a bit dated, it is still relevant.

Pros:
If you don't know or are somewhat unfamiliar with the concepts of generics or how to use them in the .NET world, then this book is for you.

Easy to read and understand


Cons:
Too verbose, there is too much talk about generics vs templates and once it's covered; there isn't a need to mention that fact over and over again.

Many of the topics were not covered in depth as they should've been in a Pro book

The chapter on Power Collections is not necessary as most if not all of the information is available and easily read in the documentation

A few factual errors that were kind of annoying since they were too obvious to any seasoned .NET developer but may not have been to a beginner

The chapter about J# is not needed, it is sufficient to say that generics can only be consumed by J# but not created. The rest of the chapter was really copied from other parts of the books as consuming them in J# is almost identical to consuming them in C#

Even though there are more cons listed then pros, I recommend this book overall. But I would rename it Beginning Professional .NET 2.0 Generics instead of Professional .NET 2.0 Generics

I downloaded this book from my library and read it through the Adobe Digital Editions reader. I would have to say I liked the layout of the book. It made for easy reading using an E-Reader.

Any good book on the .NET Framework can give you a good introduction on Generics. This book fills in the details. For example, most C# books will describe how to create generic classes and generic methods. This book goes into more detail by explaining what will happen when you use the same parameter name for your generic class and your generic method. It's those specifics, as well as explaining how generics work "under the hood" that makes this book a keeper.

However, the book feels a bit dated. For example, no chapter on J# is really needed anymore. As an aside, who actually used J# anyway? Perhaps the book needs a second edition. I do not know if Generics have changed in .NET 3.5 and if I am in fact using them wrongly because this book details .NET 2.0 Generics. I don't believe the fundamentals would have changed, but some of the details might have.

Finally, the Power Collections chapter is good but a little long. It was useful to see how collections like Bag<T> and MultiDictionary<TKey, TValue> are used, but the chapter does not need to go into so much detail. That is what the Power Collection documentation is for.

All in all, I would recommend this book, especially if an updated edition is available.

.NET generics are very valuable addition to .NET framework with 2.0 and this book provides detailed information about generics and container issues. As a long time STL user, typed containers brought a lot of value to the framework .I started to be aware of Power Collections library after this book and used in some projects. I would suggest this book to anyone without hesitation.

I have 3 books on my bookshelf at work. "Writing Secure Code", An O'Reilly XSLT Reference and this one. I love it. The style is light and reads very well (unlike most technical books). It's filled with practical examples that do well at both exemplifying the topic at hand and providing a snippet for my own use. The chapters are well laid out and follow the natural order of learning/mastering generics, and they're also strong enough to stand alone for reference when needed. If you work with .NET 2.0 or 3.0, you need this book.

You'll need a good understanding of Programming concepts in general before you start on this book. After that however this is a good way to figure out what Generics are and what they can do for you. Highly recommended for those needing to simplify quite a few repetitive programming tasks...