Customer Reviews

A Programmer's Introduction to C# (Second Edition)

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

 

 

I may have the dubious distinction of having read every published book on C# from cover to cover (well, almost). That said, this book was one of the first I encountered when I started learning C# (in its first edition, of course), and I still return to it several times weekly in its second edition (usually to clarify an exposition by another author).

For my money, this is as good as writing gets when the subject is THE LANGUAGE, PERIOD. The writing style is lean, focused, and rigorously accurate. While you might not take it to bed with you, you'll turn to it over and over when you're actively stuck on a concept and want to get it right and OWN IT.

A careful reader could gain all the confidence they need by reading this book first, and then Troelsen's *C# and the .NET Platform* (also an Apress book; no, I don't work for them). That's not to say that there aren't other gems out there (including Liberty (O'Reilly; download the latest version of the code!) and Robinson et al. (WROX; generally excellent, but some chapters are SO BAD, and the typos are EVERYWHERE). But if you have a limited budget and can stay focused, Gunnerson and Troelson (in that order) are all you need.

While not the best tutorial out there for intermediate level programmers with a C++ or Java background (Liberty's book is better as a pure tutorial), this book is much better at explaining style and C# idioms than Liberty. I bought both books and am glad I did.

Gunnerson is very clear at what is good C# style and what is not and why you should choose one idiom rather than another. Also, unlike Liberty's book, Gunnerson leads you through the process involved in developing (including adding multithreading) a serious application where Liberty's samples are much smaller and much less interesting.

The downside is the order Gunnerson chose for his topics is strange whereas Liberty 's order is much more straightforward and traditional and I think easier to understand. Note that people coming from a VB background will have an even harder time with Gunnerson than Liberty. (People with this background should probably choose Archer's Inside C# book from Microsoft Press.)

Summing up: Buy both books if you can, if not buy Liberty's book for a pure tutorial and buy Gunnerson to learn C# style plus how to develop a serious multithreaded application.

Gunnerson's on the C# design team and know the language as well as anybody - and his experience shows in this really really nice book. This isn't a "quickie book" which is a rehashed white paper, like the book by Wille from Sams! At this stage it is hard to imagine a better book on C#.

What about C# itself? First off you can get the language free as part of the .NET SDK from Microsoft's MSDN web site, it's a command line interpretor like the one in the JDK. Then use your favorite editor to create C# code.

Next, although C# certainly bears a family resemblence to Java it has some truly unique and exciting features that make it the best language yet. For example, it is the first language in the C/C++ family to handle versioning. (For experts the fragile base class problem is gone.) There's also cool stuff like automatic conversion of value types to objects and back again and little things like == doing what it should for strings.

All in all this is a great book that I highly recommend.

In previous reviews I have read about this book, there have been many criticisms regarding the author's use of long examples (~ 100 lines) when 10 lines of code would have sufficed. The author would then make a minor change, and copy the entire code example again. Although this is very annoying, I have a far greater problem with this book:

The author does not have a strong grasp of Object Oriented programming. It is very clear that he has little understanding of interfaces, which are a vital part of C#. The reason I say this is that in every code example I see, he explicitly "casts" classes references to interface references, when one is not needed (He states that this is required on pg. 80 that you must make a "cast", which is incorrect. Amazingly, he contradicts himself on pg. 128 when he states the "cast" is not needed). There are so many errors in chapter 10 (Interfaces), that I would highly recommend that the chapter be skipped entirely. His section on problems with "name collisions" on pg. 86 is so wrong that it is pitiful. Perhaps at the time the book was published, interfaces in the language spec. were pitiful and the author's examples were correct, but I doubt it. These are just some of the many examples used in this book that are either completely wrong, or highly discouraged. Others include using the term "overload" when the author clearly meant "override" (big difference!).

Although I do like the author's style in trying to explain things, it doesn't help much when his understanding is incorrect. I have found that reading the "C# Language Specification" and "C# Programmer's Reference" (although dry) to be a much better use of my time. Note: I did read the 1st edition. I can only assume the author has fixed many of his mistakes in the 2nd edition, which might make this book a decent intro. to C#.

I bought this book a while ago. Days when MS announced C#, I wanted to get my hands on a book that can give me a head start. I saw this one in the market and bought it. This is a good book for those who want an "introduction", for advance stuff you will have to refer to some other book.
Even though I have professional C#, I still sometimes open Gunnerson's book for a quick look on a certain topic. He has done a very good job by keeping things simple.
Second edition of this book is out now. I haven't yet read it, but I belive that there must be some improvements.

Deepak Kapoor

First thing I should say is that the book is very good as an introduction to C#. Syntax of the language is explained fairly well. This book is for everyone who wants to get a quick start with C# and .NET. Having said that I should mention two things that might have been better:

1. There is not much info about .NET in the book. Of course, C# is just a programming language, but it is about .NET, and author uses .NET implicitly through almost all chapters. So a reader should accompany this book with Jeffrey Richter's .NET articles from MSDN Magazine.

2. There are many samples, they are good. But the problem is that one sample is often repeated 2-3 times with some minor changes, and those changes are not emphasized, so it is not easy to find out what exactly was changed. I also think in case only 1-2 lines are changed, it could be enough just to list those lines separately without copying the whole example.

Anyway, I think that if you need a C# book now, then this book is worth buying.

In the introduction to this book, Eric Gunnerson warns the reader that this is a book aimed at programmers. If you do not have quite a bit of experience programming, this is not the book for you. You would be better served by Wrox.

While I am a bit more fond of the Wrox book, as it is much easier to read and has plenty of real world code samples, I like Eric Gunnerson's approach to covering every aspect of the language.

This book is the most thorough book on C# in the market, and, if it were written a more casual tone, it would blow away any other book on the market. As it is, it is my number 2 book on the subject (Wrox's C# book is number 1 currently). However, if I want low level details, this is the first book I consult, so it has a definite place in my library.

One thing I have seen this book criticized is for its lack of an overview. Come on now, this is a C# book, and it stays true to its calling. Faulting a book because you failed to find out what it's about amounts to an unfair attack. Having said that, if you are looking for information on the .Net Framework, look elsewhere.

One thing of note. If you are low level enough that you can read through the .Net Framework help file and understand everything easily, this book may be a waste of time. For the rest, and for those of us who do not have time to decipher the spec, this book is the most detailed on the market and well worth the price.

If I had to choose between the three books currently on the market, I would choose the Wrox book to learn, this book to understand and the Introducing C# pamphlet to start a nice cozy fire to read by. ;->

This is the best book on C# currently available. Eric does a great job and his inside knowledge shows through often. I don't hesitate to recommend this book if you know C, C++, or Java. However, be aware that .NET is still in beta and that some of the features of the currently available SDK download differ from the explanations in the book. For example there is a serious "difference of opinions" on interfaces on page 86 and struct relational operators on page 116. I'm sure that Eric or someone will soon be publishing an errata list for the book on the web which will help to alleviate problems like this (which are almost inevitable given how new .NET is). Good value for money.

This text has the possibility of being really good. The author obviously has some fresh ideas on how to structure and present Yet Another Language Text that does not follow the tried (and perhaps tired) structure of the classics.

Unfortunately, the text lets me down in several ways. First, there are plenty of glaring misprints in the code examples; this can be pretty devastating when you tend to rely on the examples to gain insight in the language. The index, too has reference errors, which is more than a little annoying.

The biggest problem with this text, however, is in the structure. The subjects seem to come in no particular order at all, and many things are used in examples that aren't explained until much later - now, this is unavoidable, of course, but a short reference to a place where you can read up on it would have been good. The author starts right off with exception handling, the motivation being that it is important, and this way, examples can use exception handling. Great idea - except the examples never do, making the early focus on it somewhat moot. I get the feeling the book was intended to look quite different, and has been edited to death in the interest of lowering the page count.

This could have been a very good book on this subject. As it is, it is better than nothing, but I would recommmend looking elsewhere for a better text.

This is a great introduction, for programmers, to the C# language. To get the most out of it, the reader should have a familiarity with programming and object-oriented concepts. The book is well organized, with the exception of the final chapter that gives specific help for those with C/C++, Java, or VB backgrounds. That information would better be presented in three separate appendices.

It is important to note that this book covers only the C# language and NOT the .NET framework. This means, you will need additional help or reference to learn the system classes so you can actually write useful code.