Coverage of Advanced Topics

This book is obviously for the novice reader. However, I thought the author’s coverage of a few important advanced topics near the end of the book was a nice touch. Even his selection of topics to cover is well considered. Part V of the book discusses three topics that the reader will get a lot of mileage from knowing: delegates and events, lambda expressions, and Language INtegrated Query (LINQ).

I found the author’s choice of topics interesting because they’re the three topics that most readers can use most. Chuck does a good job of covering all three topics and I feel the emphasis on lambda expressions is good for the novice to intermediate reader.

The LINQ coverage is what you would expect for a novice to intermediate level reader. Don’t expect to find any expert-level code in this section. On the other hand, the material is just what the doctor ordered for less experienced readers. Chuck covers all the basics including filtering and ordering the data you extract from a data source. In addition, you find a few of the more advanced topics such as counting items and using math to manipulate the data. It’s not what an expert would need, but this isn’t an expert-level book. Given what the author covers in a single chapter, you might be amazed at what you know about LINQ by the end of the chapter.

Interesting Part of Tens

Every Dummies book contains a part called Part of Tens. These are chapters that contain ten individual elements. I’ve seen many different Part of Tens chapters, but this book contains a unique chapter called, “Ten Common Build Errors (And How to Fix Them).” I wish more books had a chapter like this one. The author provides fixes for ten common build errors. The coverage is great and the chapter will certainly help the novice get a good start using C#. In fact, the only problem is that the author didn’t choose to include additional chapters of this sort. For example, it would have been nice to see Ten Common Runtime Errors (And How to Fix Them) in this book. That said, the addition of even one chapter of this sort is going to be extremely helpful to the reader.

Is this a good book?

This is a great book for the novice, less so for the advanced reader. If you’re already an expert, then you really won’t get much out of this book. The author definitely focuses on the novice crowd, which is just fine because that’s the general audience for this kind of book. In the recent past, some people have gotten the idea that Dummies books somehow cover the entire range of readers, but no single book can do that, no matter how well the author writes.

A few of the true novice topics are covered a bit lightly. For example, the author doesn’t spend much time discussing the Visual Studio IDE, so some readers will experience problems trying to perform the tasks that the author asks them to do. Whether this is actually going to present a problem for you depends on your skill with Windows as a whole. Further, if you have already worked with another language, it probably won’t present any problems at all, but I can imagine that some high school and early college students will likely find performing some tasks daunting.

The author also doesn’t spend any time with debugging. The reader is going to need this skill at some point, so the omission is glaring. While I do like the advanced topic coverage in the book, if the author was short on space and needed to remove something, it probably shouldn’t have been the debugging information. Yes, readers will also like those other topics, but they simply aren’t as essential. Does the lack of debugging topics make the book less useful? Well, yes, but the book is still a very good book because it does get the novice started off on the right foot.

One thing the author does do right is include copious coding examples. Just about every page of the book has an example of some type. Not all of the code listings are working examples—some are snippets used to demonstrate a principle in the shortest way possible. Even so, the author does include a considerable amount of code that you can use to discover C# on your own machine. The only shortcoming is the lack of debugging topics—most readers would benefit from tracing through the examples using the debugger to see how they work.

BIO

John Mueller is a freelance author and technical editor. He has writing in his blood, having produced 81 books and over 300 articles to date. The topics range from networking to artificial intelligence and from database management to heads down programming. His current project is LINQ for Dummies (available now), which you can order at http://www.amazon.com/exec/obidos/ASIN/0470277947/datacservip0f-20/. His technical editing skills have helped over 60 authors refine the content of their manuscripts. You can reach John on the Internet at JMueller@mwt.net and his Web site at: http://www.mwt.net/~jmueller/.