C# has grown substantially since its introduction, ten years ago. Since then, there have been four versions of the language. Beginning as a relatively small language (by current language standards), C# has grown into quite a large one. While this certainly provides programmers with features and flexibility, it also complicates learning the language and using it effectively.
This book covers the most recent version of the C# language, 4.0--the basic language, as well as some of the more recent additions to it. It is aimed at experienced programmers, and is definitely not the kind of book from which someone should try to learn to program. Given the size of the language, almost the entire book is devoted to the syntax and semantics of language constructs. One exception is the chapter “In Search of C# Canonical Forms” that gives some advice about good programming style in C#.
Nash provides a fair amount of code, most of which consists of short snippets that facilitate understanding of the feature being discussed. A fair amount of the code concerns a complex number class, which makes it even easier for a reader to examine the sample code and think about the features being discussed, rather than trying to figure out what the code does. Other features require different kinds of code, but thankfully there are few very long samples and none that really require the reader to focus on the problem rather than the expression of a solution in C#.
The book does have some serious problems. Since C# is a large language, it would be helpful to have a concise and technical description of each given feature. The informal descriptions provided are usually helpful and more readable, but sometimes it is hard to figure out what the descriptions actually mean. In several places, I went looking for more information on something and found no single description that assisted me in figuring out what it did exactly. The fact that the index is incomplete (and has errors in a few places) complicates this even more. As a concrete example, there seems to exist an interface, IConvertible, which is referenced in a number of places (not all indexed), but not actually defined anywhere. Instead, we are given advice about how to use it (and how not to) and the suggestion that we look it up in the documentation. The book implies that it is a fairly central interface, so it deserves a better description. There is always Web search to help with such things, but then why buy the book?
In one chapter, interfaces are described using the term “contracts.” This is a problem, as the notion of a contract in programming languages often refers to the “design by contract” style that provides executable descriptions of the expectations for a function, not just to interfaces (which are syntactic descriptions of the types involved). This is even more regrettable, as C# now provides an implementation of contracts--albeit not as a core part of the language--which, worse yet, the book completely overlooks.
A minor (but annoying) problem is that console output is formatted oddly: a gray line precedes and follows any such output, but sometimes there are gray lines also interspersed with the output, for reasons I was unable to determine. While such things are not the most important factors in judging a book, they certainly contribute to the overall impression.
Finally, there are things that just seem odd, such as the section on anonymous recursion. Are Y combinator-based techniques useful? Perhaps, but few programmers actually use them and the example given is contrived. Furthermore, some of the terms and names used--for example, “the BCL team”--probably mean little to most readers.
This book might be good for some readers, although it is hard to determine an audience that it will suit well. It is not written for those who are learning to program, expert programmers are likely to find the descriptions too vague and imprecise, and it offers little even as supplementary material.
