Illustrated C# 2005 [ペーパーバック]

I own a lot of .NET books, including about 10 C# texts. What sets Illustrated C# 2005 apart is that it reads as if I were watching a professor draw on the chalkboard in class. That is the best analogy I can think of. It is hard to find a page without some type of flow chart, code snippet or diagram on it. This is a very visual book. It is a fantastic text for anyone new to the C# language. If you like to learn by seeing then Illustrated C# 2005 is probably the book for you.

This book is geared toward C# beginners or those who prefer a more "visual" approach to learning. However, with that said, this book is a handy reference in any C# library because of the thoroughness in which it covers its topics. For example the subject of Classes spans four chapters. It does a better job of explaining objects than my first semester C# college textbook. And there is no filler on these pages. The diagrams are very compact. I love it when publishers print an honest page worth. Nice!

A few advanced topics such as threading are not covered. That is probably a good thing as cramming every bit of C# knowledge into this book would be overloading the user. Not pun intended :)

Several parts of this book really stand out. It has a great explanation of a computer system's "stack" and "heap". A lot of us know what these are or have read something about them. For me, the diagrams really helped to clarify how a program uses the stack and heap while running. And that section has a nice segue into value types and reference types.

Another chapter I like is the one on Generics. Generics are a way to apply a class' actions to any "type". They allow you to add an additional layer of abstraction so that you can more easily reuse the code you have written. The Generics chapters is very well written with several nice visual examples. The chapter on Arrays is yet another great example. Most of us who have learned (or tried to learn) arrays know that it is easier to grasp a multidimensional concept when you can see it! There are lots of illustrations in the Arrays chapter.

The last chapter "Other Topics" contains discussion of the StringBuilder class, parsing strings to data values, nullable types, method Main, code domination and nested types. I have noted each chapters approximate page count in parenthesis.

CHAPTERS

C# and the .NET Framework (13)
Overview of C# Programming (14)
Types, Storage and Variables (13)
Classes: The Basics (15)
Methods (32)
More About Classes (40)
Classes and Inheritance (30)
Expressions and Operators (35)
Statements (30)
Namespaces and Assemblies (25)
Exceptions (15)
Structs (8)
Enumerations (10)
Arrays (25)
Delegates (15)
Events (15)
Interfaces (22)
Conversions (30)
Generics (25)
Enumerations and Iterators (22)
Attributes (18)
Processor Directives (10)
Other Topics (25)

I have been a programmer for over 25 years, and a C++ programmer for the last 12 years. This book is great for someone like me to quickly come to an understanding of the C# language. The content and format allowed me to skim the text and the bulleted items and study the pictures. When there was something new, I was able to slow down and study the material in a bit more detail. I recommend this book to any experienced programmer who wants to learn about the salient features that C# offers.

This is a truly superb book. I saw it in a bookshop and bought it instantly. I'm very glad I did.
It is an anatomy book for C#. Whilst this book will in no way make you one of those C# gurus like some other books, it does tend to concentrate on the C# language, its basic elements and how they interact with the CLR and under the hood with the stack and heap.
It is choc-full of useful logical diagrams that really explain rather tricky things. This is not surprising as the title of the book is 'Illustrated C#'. It's as if a really clever friend or colleague of yours has created laminated cheat sheets for each major C# topic with a heavy emphasis on visuals, short code examples and pithy and concise paragraphs with clear bullet point type rules. For example it shows clearly that there is a difference between a class field and a local variable when they are value types. Class fields value types are always instantiated on the heap whereas local vars (that live inside mehtod members) value types are always instantiated on the stack. It makes very clear how static members work and it names everything by its official name so that you quickly realise that whilst an event is a class member, a delegate is actually a type. These things are quite frustratingly amorphous in most other books.
The book is peppered with simple but ingenious examples along with diagrams to make any particular point. It builds logically, when there is anything added that is not yet explained it is flagged up clearly with references to the correct forward chapter. It makes very light work of explaining Inheritance, a concept that many other authors either ignore (Richter) or make very heavy weather out of.
There's a very useful flowchat explaining how the runtime deals with exceptions, delegates are really well explained as are events, interfaces, generics and iterators. None of these topics are basic and all are given a decent but concise treatment.
There is everything you need here if you read it from front to back to becoming fairly proficient with the bare bones of how a C# object-oriented program works and interacts with the CLR.
To learn to write real world apps you will need to explore other books that go into Winforms, ASP.net, ADO.net or XML etc... this isn't about any of that.
I would lastly like to add that it's a very easy read and astonishingly the examples make sense even away from a computer, but of course you'll get more out of it if you run them (there is a code download at the Apress website)

I can see this format being widely copied, for example for VB.net, Javascript, Java, php, Regular Expressions, and quite possibly for Ruby on Rails

Hearty congratulations to Dan Solis for such a solidly well done and original book, one that to my eye at least, looks like a real labour of love. In short SUPERB!

Pros:
great diagrams
great bullet point rules for what works with what
great tables that explains complex topics like scoping in inheritance and across assemblies etc..
pithy code examples
wide coverage of the essential and rich C# features
it's a great place to solidify your knowledge of C# more nebulous concepts

Cons.
The code is not production grade and you wouldn't expect it to be, it is illustrative of the point being made and more than fit for purpose.
so this is not really a con
You will still need to read the other heavy hitters to be professional