Customer Reviews

Programming Microsoft Visual C# 2005: The Language

5 star:		(13)
4 star:		(7)
3 star:		(7)
2 star:		(4)
1 star:		(3)

 

 

This book is CRAWLING with errors in it. The Microsoft Knowledge Base doesn't even cover many of them, either. The errors aren't just typos either. I'll give some examples of why you shouldn't waste your money on this book:

* Page 54: "Volatile Fields"

"Locks are explained in Chapter 9, Threading".

Chapter 9 in the book is "Exception Handling", and nowhere in the book is Threading mentioned or given as a topic.

* The author discusses writing an equals() method for classes and states : "Objects that are equal should have the same hash code. Therefore, equality can be based on comparing hash codes."

This is so wrong it's not funny. Two completely different objects can have the same hashcode and still not be equal. What is he thinking?

* The author writes a paragraph in the book (page 93):

"Hash codes are recyclable. When a reference is garbage collected, the hash code is returned to the available pool. The hash code is then assignable to a future instance. For this reason, you should remove dead objects from any collections."

I do not know what he means by "recyclable" or "available pool", nor what a "dead" object is. I checked the chapter on collections and GetHashCode() is not mentioned anywhere.

* Page 95, code sample is incomplete. The author left it incomplete, yet uses the example (and discusses the details he left out to prove a point -- which happens to be wrong, too). He speaks about MemberwiseClone() and how it does a bit-wise copy of all the fields (including references). This means that a cloned object will be a shallow copy and still point to the same underlying objects for all of the references. Well, he then essentially says that assigning a new string to one of the references in the original object will also change the cloned object's string. This is absurd and I really think he needs to either go back to C# 101 or pay more attention to writing books because people are spending their hard earned money on this stuff.

I seriously doubt the author is incompetent. I just think it's a matter of carelessness. Either way, I wouldn't buy this book if you are looking for accuracy and good guidance. I recommend Jesse Liberty's book (O'Reilly) over this one, however, Jesse's is a bit dated.

Like many other reviewers, I purchased this book alongside the MS Press 70-536 Training Kit. This book really can only be useful for an experienced C# developer who is looking to fill in any knowledge gaps concerning the language itself. Such a person would be able to spot the numerous errors and move past them without harm done. However, I could not, in good conscience, recommend this to anyone actually seeking to learn the language.

As an example, on page 21, the unary operators are described with examples for each. However, the postfix increment "++" and postfix decrement "--" operators have their examples swapped. Once again, someone already in the know wouldn't be too bothered by this and would figure it out immediately, but for others, it could result in quite a bit of confusion.

The title of this book "The Language" is very appropriate: it offers a very in-depth description of the C# 2.0 language and also covers related topics such as MSIL, Visual Studio 2005 (overview only) and its debugger.

The book is very extensive and every topic (read: language element) is described in extreme detail. Unfortunately this is done using very abstract terms and the entire book looks like a list of syntax definitions. This makes it very tiring to read and the massive number of senseless lines ("Instance members are inexorably linked to an instance and are accessible from the point of instantiation.") and grammar errors compund this.

If you are looking for a very comprehensive language syntax description, I highly recommend this book. If you are looking for a reference guide to help you program...look further.

This is the book I'll use when I need to know how something in C# works, in detail. 95% of what we do as developers doesn't require in-depth knowledge of the language we're using. But the 5% that does can be the most time consuming and painful. When I'm stuck, and I don't understand WHY C# is doing something a particular way that doesn't make sense to me, this is the book I'll be reaching for! Have I read the whole thing from beginning to end? No. This is the type of book you reach for when you're in trouble, and you have to know the inner workings of C#. It's the book that saves your bacon at 2am when you have a project due. My recommendation: read the debugging chapter first. Not 1 developer in 20 knows the debugger as well as they should. That section alone was worth the price of the book.

Several reviewers apparently felt that the book didn't provide them with a sufficiently simple path to learning C#. Unfortunately, they were not the core audience for this book. From the introduction, it states that this book "is for developers who want a comprehensive explanation of Visual C# 2005, or want to explore a specific aspect of the language." In other words, this book is for experienced developers with a need for detail. If you don't know C#, look elsewhere. If you're sharpening your existing C# skills, or migrating from C# 1.0 to 2.0, this is your book.

So, why 4 stars and not 5? Reference books rarely make 5 stars for me. In fact, I would rate my own reference book (Programming ADO.NET) at 4 stars. This is an excellent reference, and one you'll keep on hand. For me, 5 Stars are reserved for those technical books that you absolutely cannot put down. Those that fill you with energy, excitement and passion. Reference books rarely do that. This one is no exception. It won't convince you to drop everything else and spend your life becoming a C# junkie. Instead, it'll save your job when your stuck on that intractable problem and just can't seem to figure out why.

This book contains excellent explanation of various concepts and has also many code snippets and code samples. But many a times these code snippets have typos so that you are left on your own to figure out what correct code should be. Simillarly code samples accompanying book have also missing code files( a case in point is code sample for Airline Seat in Chapter 4, does not contain code file for Person.cs.)

I always rooted for MS Press books because it contians lot of details which other books many a times do not provide.

Bharat Gadhia

This book is great. I have been reading the chapters on Reflection and Debugging, and I'm amazed at the information that this book has over the other books that I've read.
I was looking for an author who could describe generics and anonymous methods, and provide meaningful examples, and Donis Marshal gave me exactly what I was looking for in this book.
I bought this book and several other C# 2.0 books, and what I found is that this book is the one that I contantly come back to. I hope to see more titles from this author.

This book covers quite a bit of material, including all of the new features in C# 2005. I found it very helpful, except that the language is unnecessarily convoluted in many places. "An interface is a contract and defines the requisite behavior of generalization of types.". "Metadata, which is often described as data about data, formalizes the composition of an assembly." Huh? This stuff is hard enough without language like that. "Eschew obfuscation" as the bumper sticker says.

Big mistake! Part I to Part III which is 60% of the book is basically presenting the C# language specification which contains way too many errors that test your patient. I looked for alternative resources and found the C# Language Specification 1.2 and 2.0 by MS Corp; it's FREE and gives you a clear understanding of the C# language with examples that are error free.

The authour has a great knowledge of the language and goes into a lot of depth on the syntax. In purchasing the book I realised it was going to be very code based.
Where I feel this book lacks is relating the concepts to real world applications. For instance, Generics is explained as useful if you don't know the type at compile time, but no explanation of why this would be. If an expert C# developer is using the book, I would expect this wouldn't be an obstacle, but for me I struggle to see where I would apply Generics.
The explanation of metadata and attributes seems a bit thin, once again I was left confused why and how I would use these features.
I found exception handling good, but having made a habit of putting exceptions in my code, I didn't struggle with this concept.
Probably a great book, but is quite advanced in the concepts and assumes the reader has a very large amount of Commercial development experience.
Would also help if the code was commented more. Sometimes difficult to understand what a bit of code is doing, comments make it more readable. Once again, there seems to be an assumption we are all expert coders.
All in all a good book, packed full of info, but difficult to digest. Giving it 3 stars as the authour doesn't make an attempt to explain at my level.

Being a VERY experienced software architect, developer and trainer, I go through tons of books - both as a reference and to recommend to students. This book is on both of those lists. Some of the other reviews already talk to the strengths of this book so I won't rehash them. I will give one specific example however - chapter 8. This chapter gives, among other things, a great explanation of delegates and how / when to use them. This one needs to be on your shelf as I think you'll find yourself using it time and again.