A very good buy, this book goes into just enough detail to stay interesting. The only reason that I won't give it 5 stars is because I don't really like C#/.Net.

I wish I had purchased one of the other C# books. I am an experienced programmer and bought this book to learn C#. My main disappointment was that the first third of the book, which covers the language, is mostly made up of repeated large printouts of code. The author will explain a small change to the code, and then re-display the entire program - even if it takes up several pages. Instead of thorough explanations of the concepts you are left with reams of repeated code.
I also found the general language of the book to have a patronizing tone, have become frustrated with it and am shopping for a new one.

I just finished this book and feel like the experience was a first class introduction. Liberty's style is to explain how things work and what they're intended for and how to think about them, and also provide some very clean examples, which is perfect for me. The extreme opposite style is to provide mostly step-by-step examples with little explanation, which I think gets you started quickly but leaves you not understanding what you're doing and unable to move beyond the examples. But giving some examples is a must. He handles this balance perfectly, I think.
The examples start to follow a pattern I liked - there'd be a class or several classes that exemplify whatever point he's focussed on, and then a "tester" class containing Main() that exercises them and displays results.
Liberty works through all the language basics and also spends the right small amounts of time discussing niche interests like the intermediate language, Web applications, using Visual Studio to manipulate forms, compiling from the command line. I feel well rounded after this intro. He works with Console applications while teaching the basic features of the language per se, then he first gets into Windows applications at the very middle of the book. Amusingly, for his first Windows application example the student adds the single statement "ApplicationExit();" to a button click event generated by VS, but for his second application the user's code is 9 printed pages in the book. I do think I followed this big leap, tho.
I wondered about getting his book Learning C# instead, and after browsing it I think it would have been somewhat easier for me, but I think I managed fine with this book and got further. For me, ideal might have been another 50 pages introducing things the way Learning C# did, added around the beginning of this book, but between the two choices I think this was probably the better.
I'm a scientist who also programs a bit. My programming experience is heavy on some very different languages like Forth and Assembly, and a couple tiny projects in Quick C for DOS, but no experience writing Windows applications or using OOP, no C++ or Java. This past week I wrote a Windows program with a simple interface and an object that does a useful technical task and "deployed" it to two engineers down the hall, who liked it. Reading this book and leafing around in a couple of others, and one conversation at a noisy toddler's birthday party about runtime object instantiation, were my only guides.

Very easy to read, covers all the relevant topics. Advanced readers can skip the first half of the book.

When Microsoft announced the C# language and the .NET framework in 2000, the reception among programmers was uncertain. Now that the language has had a solid six years to develop itself, it has a solid user base and strong examples of applications. Whatever your opinion of the .NET framework is, there is no denying that C# is popular among Windows programmers, and continuous to grow in usage.

C# is an object-oriented language, and has a decided likeness to other high-level languages like C++ and Java – although C# is noticeably simplified. There are only eighty keywords in the language, and twelve built-in datatypes. The language also shares attributes like interfaces and structs.

However, the C# language also sets itself apart from the more classic languages in a variety of ways. C# has built-in XML capabilities, which aid in the creation of documentation. It also supports a feature called ‘delegates’, which act as type-safe references. C# also provides for component-oriented programming, which stores information using metadata. This metadata can be read and used by another environment, independent of any other information available. Effectively, it is able to create a self-contained unit out of each class.

The material in the book is very well presented, and very well written. After the general introduction at the beginning of the book, there is almost not a single page that doesn’t have code on it. While this might sound a little intimidating, it is a welcome relief from books that give no code examples whatsoever. All of the code is well presented, is easy to read, and commented. Also, and perhaps most importantly, the code is discussed and explained by the authors within each chapter. The authors have done a fantastic job of providing their readers with examples to learn from.

In fact, there is so much code and so much discussion, that the book can be hard to work through. Page after page is filled with solid blocks of text and code, with little relief. This can be done and be kept interesting if the writing includes little anecdotes, jokes, and so forth – but otherwise, it becomes hard on the eyes and mundane. I would have liked to see some more images and diagrams used in the book, and perhaps a little more ‘fun’ text. The entire book doesn’t have to read like a textbook, afterall!

The topics in the book are well chosen and arranged. The first half of the book or so is on programming concepts, syntax, data structures, etc. The second half of the book is split between application examples of C# and working with windows applications (literally – exe files, dll files, etc). I would have liked to see more example applications (perhaps even one on programming for mobile platforms like PocketPCs?), but the authors do a good job with the examples they provide. I also would have also liked to see more information on interfacing with other applications, like Outlook© or Office© - although the authors do leave the reader with enough knowledge to do the research and learn more about how to do something like this independent of the book.

There is clearly a lot of information to communicate, and this is where the authors seem to be a little confused. Personally, I cannot tell if the authors really wrote it so that novice programmers could understand it or not. The beginning of the book states that the book is suitable for anyone, both experienced and in-experienced programmers. However, I found that the material was somewhere in the middle. The authors move at a pace that is fast enough to lose new programmers, and yet approach many topics at a beginner depth that experienced programmers will find redundant. The effect is beneficial to neither party, and I suggest that the authors more decidedly define their audience in future editions to avoid the issue. The end result is that experienced programmers will have no trouble with this book at all, whereas the novice programmer may be a little confused and lost.

Overall, this is a solid text for learning the C# language. I would not personally suggest it as a ‘first-language’ book, but anyone with some programming experience in another object-oriented language should have no problems whatsoever. The C# language has a lot to offer to anyone coding for a Windows© environment, and is increasingly becoming a necessity for programmers in that field. O’Reilly’s C# text is a great lesson in the language, and I recommend it to anyone looking to learn more about .NET coding.

I am an experienced VB programmer and have been using VB/Visual Studio for the last five years. I have dabbled with C# but recently decided I needed to get up to speed and bought this book based on some of the reviews I read here. I started with Chapter 1 and over the course of about two months went through each chapter through the end of the book in 30 minute or one hour sessions in my spare time.

When I finished the book I decided to create an interactive website from scratch and was able to do it in only a little more time than it would have taken me in VB. Most of the extra time was spent referring to the book in order to fully understand some concepts and syntactical differences.

The time was well spent! I feel comfortable with programming C# routine solutions and now use this volume as a reference. I realize that I may need to spend a little more research time should I need to develop solutions to more complex problems.

I like Jesse's style. He presents the material in a very straightforward, intuitive manner and provides excellent examples.

I highly recommend this book if you're an experienced programmer and are looking to get up to speed and productive with C# in a hurry.

If you are anything but a guru in C# you need this book. I've used this book more than any other book in the last 3 years of learning and writing C# code.

Seems to be an okay introduction to C#, but doesn't measure up to the gold standard of computer language books; C&R (The C Programming Language). On the plus side I believe the Author is correct in initially using console applications so the reader can concentrate on the language.

However the author seems to be writing for a rather junior audience, for example the preface actually contains "It is wicked cool." This style of writing gets tired pretty quickly.

Furthermore the initial descriptions of the ICloneable interface is confusing and nearly worthless. For example a note for C++ programmers on page 78 states that "C# doesn't have a copy constructor..." but the following section on the ICloneable Interface states that deep copy should be implemented by "...calling the copy constructor..." Huh?

Experienced programming professionals should look elsewhere, perhaps the "C# Programming Language" by Heilsberg, Wilamuth & Golde.

I've read many C# books, and this one is clearly the best. Look no further. His examples and explanations are carefully crafted so that learning C# is simple and clear.

As both a volume with which to learn C#, as well as one to use for reference, this book is excellent.

It starts by teaching some of the most important fundamentals of the language: the actual structure and methodology of object oriented programming -- before going into things like windows forms and the like.

Overall though, a fantastic book.

I wouldn't necessarily recommend an O'Reilly book to a beginner, just learning, but for anyone with some experience, these are the preferred learning & reference tools.

With respect to this particular book, I got it specifically because I want to work with Microsoft's new XNA tools for creating MS Live games -- which requires the C# language, and the MS 2005 Developers IDE, all of which are free from MS now. The language and setup of the book are typical quality products from O'Reilly.

The examples are not easy to follow and it does not give sufficient explanation. It is basically useless to me.

This book does not attempt to teach anything except the basic. Not worth the money.

My background is in C++ with some experience with Java and no experience with .NET. I didn't fully realize how similar C++ is to C# until I finished this book, and I think my money would have been better spent buying a book on .NET.

This book is 600 pages, but only the first half covers C#. The rest goes into using Visual Studio 2005 and various .NET classes, which applies equally well to any of the languages Microsoft supports. I didn't really learn anything new about C# that I hadn't already read in the various online tutorials. That's not a knock against the book - the information is all there - but if you know C++ and you're buying the book to learn C#, don't bother.

Instead I'd recommend:
1. Read an online tutorial or two on the difference between C++ and C#.
2. Download Visual C# 2005 Express Edition (free) and create some examples on your own. The IDE is very good at funneling you into using the right syntax.
3. Buy a book on .NET.

I received the book very fast. The book is in excellent condition as described. I am happy with this purchase.

This book is my introduction to the C# language. I come from a
Java/ColdFusion (mainly web applications) background and wanted to
venture out onto the .Net Platform. What better language to learn
than the most hyped-up language from Microsoft?

I found the book to be for the intermediate developer (at least),
with some programming experience in C++ or Java, although a novice
would also benefit from reading. This book takes the reader from a
the traditional "Hello World" to complex programs covering
everything from Internet related programs to streams and I/O.

The basics of assemblies, their management and deployment span the
first part of this book. The .Net Remoting part covers the subject
well in detail, the third part covers the Web Services, while the
fourth covers the Com and .Net interoperability.

Jesse Liberty commands this area of programming and has compiled
this book in a very well though out manner. The reader will benefit
(as I did), with the "special notes" and snippets pointing out
differences & similarities of C# with Java/C/C++.

In conclusion, I will strongly recommend this book to readers from
novice (with acumen) to intermediate developer.

I've been doing C# programming for the last couple of years and I still managed to learn something by reading this book. Highly recommended.

I was totally new to C# but I did have extended experience in VB. This book was great and taught some really important fundamentals, not only of C# but OOP. Jesse Liberty does a great job of explaining basic and advanced topics. A+++++++++

I can't begin to say enough good stuff about this book! Honestly, it is one of the most clearly written books that I have ever read, and the content is good as well. This is a must have for anyone learning C# for the first time or anyone wanting to build his/her knowledge and pickup some of the subtleties of the language.

I read the 3rd edition of this book cover to cover and thought it did a good job of introducing C# to this longtime C++ and Java programmer. It also served as a reasonable reference for my first C# gigs.

I bought the 4th edition so I could get up to speed on the new features in 2.0 and am sorely disappointed. In particular, where is the chapter on generics? It seems that an edition targeted at C# 2.0 should spend at least that much ink on a feature that can have such a profound impact on program design. Instead, generics are buried in the chapter on collections and the author gives the impression that the only thing they are good for is adding type safety to those classes. There is no discussion of the impact of generics on design, generic type semantics, ...none of the myriad concerns for the programmer who wants to take advantage of the feature.

If you own the 3rd edition, stick with it. Everything the the book adds for C# 2.0 can be easily found online and in the VS help system.

Being a java programer for a while let's me understand this book. for all those reviews out there that say this book is great for beginners, I say NO WAY!! This book is definitely not a beginner book. it jumps into topics like inheritance and polymorphism extremely early for beginners to understand. I have to say that it definitely has some straight-to-the-point examples, but I guarantee the new guys you will have no idea what is going on. I still can't find any better books than Deitel books, you pay almost double the price of this book but it is definitely worth while if you are willing to learn programming. Also this book is a little vague on certain topics and does not talk at all about what is considered good/bad for good programming practices. I have not finished reading it but that's what I found early after reading upto chapter 10.

I have read this book twice except for the last two chapters, and I skip chapter 13.

It is relatively easy to understand the concepts and the organization is relatively good. However, it would be better if the author could have summed up the main keys in each chapter in a conclusion or summary. I have to take notes here and there in the book to remember the key points. There were also a couple of errors in the book.

I think it is a good book for a beginner with some basic background in C/C++.

This book claims "noted author Jesse Liberty gives experienced professionals the information they need to become productive quickly."

IT MOST DEFINITELY DOES NOT DO THAT.

This book might be great for relative rookies, but it is WAY too verbose for getting an "experienced professional" (which basically has to mean an experienced Windows C/C++ programmer) quickly up to speed on C#. The book covers a number of topics, all superficially, with no depth, and little insight.

Any experienced professional needing to get up to speed with .NET and C# is far better off with a quicker introduction to the specific concepts of C#, then using other books with more in-depth coverage of the various major areas of .NET.

It is often said "there are those who do, and those who write about it". Mr. Liberty is clearly one of those who just writes about it, and there doesn't seem to be a concept in .NET that is too trivial for him to take an extra couple pages talking about it in lieu of providing useful content. The code examples in the book are superficial and offer no professional level insight. The myriad cutesy and ridiculous asides such as discussions of trivial elements of coding style in a book obviously written by a programming lightweight have absolutely no place in a book for experienced professionals. The way Mr. Liberty continuously proselytizes for .NET, often pointing out shortcomings in C# syntax as features that save we programmers from ourselves is just plain bizarre.

As I said, this book may be OK for neophyte programmers who haven't had years' experience doing serious work in Windows programming, and aren't likely to do so, but it's a total waste of time for experienced professional programmers. As this book artfully avoids mention of any of the nastier issues in developing in .NET, and offers only very vanilla insight into C#, I doubt it is of any value to anyone unless they really badly want to write a "hello world" type .NET program, and don't intend going any further.

There's a reason why this book sells near new for $5. I'm not going to bother taking up valuable shelf space with the copy I bought.

Excellent book for beginner to intermediate C# developer. Beginners will suffer from the lack of meaningful examples. Clear explanations and concise language. Good coverage of basic libraries, however somewhat short, as to be expected, on ASP.NET and Web Services. Definite recommend.

This book was one of the best books I have read thus far. I was absolutely impressed with the delivery of Jesse Liberty.

The book opens with a preface that made me really appreciate the mindset of Liberty. He completely skips through the mumbo-jumbo and simply says: if you want to know what is new, put this book down and go get this other one about blah, blah, blah. Then he gives you all of these different categories of reader and if you fit, then this book is for you. That really made me appreciate that he knew he was dealing with a beginner in C# but still a real programmer. None of that intimidation stuff here.

The book is divided into various sections namely the language, programming and the .NET Framework.

There are a lot of do's and don'ts throughout the book even with a brief explanation of why not. There are even tips, but not just any tips. The tips in this book are for the reader and developers of other languages C ++, Java and the like that already understand the topic at hand, but probably know the terms, philosophy or other things relating to that language differently, so he shows how they relate to those other languages.

CODE SAMPLES
It is very helpful that the code samples are available for download to use along with the book. It saves a lot of typing and allow for editing. There are many instances where Liberty gives instructions to cause the code to fail. Then when it does he explains why it failed. That takes us to the warnings that are throughout the book. He even explains the capabilities that C# has and why it would be better to use these instead of the older style of programming that others may be used to.

EXAMPLES
There is also a good dosage of scenarios are used as well. A complex matter is always easier to understand with a good scenario. The tutorial aspect is really good since nothing is assumed about the reader's level of knowledge with C#. Everything is explained, nothing is left out and the really fancy terms are explained before he begins to regularly use them.

OTHER TECHNOLOGY
While the book is about C# you don't get tunnel vision. This book touches on other .NET technologies C# plays along with similar web services, SQL, ADO.NET., ASP.NET to name a few. By the end of this book you will see how C# is a big part of a much, much bigger .NET Framework.

I recommend this book for anyone that wants to know, but are afraid to ask. Read this book.

This book goes too much detail into intricacies of language syntax while the examples are too basic and confusing. Some times the important syntactical explanations are too vague and confusing while the infrequently used items are explained in too much detail. I have found that Wrox books are doing a much better job with explaining the concepts and their examples are more in depth and easier to understand. However, it does cover most of the .net concepts and some topics like Threads are covered in an extremely helpful manner. I find this book to be boring to read but will keep it as a reference, as overall, it is not a bad book.

I really wonder how this book deserved 5 stars from some readers.
Most topics are explained poorly, or sometimes even not explained at all!!! (I started thinking that autor himself need to learn the language). Second, to explain even a trivial thing, the autor presents loooooong codes, what really wastes time, because you always have figure out, which part part of code is really dedicated to explain the point, what sometimes makes me tired before I understand something. Also, in the most of the code examples suddenly there appear something new, something specific to C#, and autor even does not say a word about that. Because of that, since the autor has tendency to use a long code, and on the other hand has a tendency to explain trough examples, this non-explanation makes the book really impossible to understand, not reading several other books.
Who ever is thinking to buy this book please believe me, it is not the first book to read on C#. May be you will understand easily first few chapters having some programming background, but you will have much trouble understanding more advanced topics, specific to C#.
I am giving this book three stars because it is better then some other books, like for example sams c# complete...

This book provides a good introduction to basic C# programming. The 4th edition covers C# / .NET 2.0 which introduces many new features compared to 1.x (e.g. generics), and which is the standard platform for Visual Studio 2005 developers. If you're a Visual Studio .NET 2003 developer, you'll need to upgrade (or download a beta version) in order to run some of the examples. This is a book about the C# language rather than .NET, so reading this book will not turn you into a proficient Windows/Web Forms programmer. However, it provides an essential foundation for further reading on more advanced .NET topics. Jesse Liberty writes in a fairly readable style, and I particularly liked the small sections contrasting the way C# does something with similar techniques in C++, Visual Basic and Java. Some of the code examples feel a bit verbose: several times the same long listing appears in full with minor changes between each version. The organization of the book also felt a little quirky, with important topics like streams and threads relegated to the back of the book, appearing after much more obscure discussions of marshalling and remoting. In general though, a good introduction to C# 2.0.

As you might gather from the title of my review, I'm a little hesitant to call this book an "introduction" without also qualifying it as a "review." It seems to be a little bit of both in that it discusses all of the basics of the C# language first (data types, methods, etc.) but the complexity quickly escalates into some fairly complicated sample code/programs. What had me a little confused was how, in the middle of explaining a very complicated section of code, Liberty stops to also explain some very elementary points about the language that you should know by this point -- unfortunately I don't have the book with me to give a real example, but just to help you understand what I mean, it's sort of like telling someone all the in-depth and complicated details of how a database program works, and then you suddenly stop and say "Oh by the way, when you refer to a method, you need to put the class name in front of it with the dot operator" (this is something that you can't possibly have missed if you've gotten as far as DB programming!) This made it hard for me to finally determine who exactly this book is written for.

In my opinion, it's a good intro (until you get to the more complicated sections later), but you might benefit from reading something else first. I hate to sound like a broken record, but Charles Petzold's Programming in the Key of C# is an excellent foundation from which to progress. Liberty's book is the second I read after Petzold, and I know Petzold's book helped me understand this one more than I probably would have. (Liberty also has Learning C#, which is much more of an intro, but I believe it contains a lot of the same information as the first few parts of this book).

Anyway, so why did I give it 5 stars then? Here are a few reasons:

- A nice introduction to all the basic C# elements
- A section on database programming
- A section on web programming
- A discussion of the new features found in C# 2.0
- A lot of advanced topics toward the end of the book (assemblies, attributes, threads, working with COM, etc.)

In short, it seems to have just about everything you'd want to know about C# (not exhaustively, of course) and I recommend it.

Well this being my first time working with C# I found the book to give a good general background, and then moving on to some of the more specific semantics of the language. Though the book only teaches how to write for Console apps, the syntax you learn is still necessary for when you move on to windows apps. .NET was described nicely and I learned quickly how to work with the platform. The tips it gave to programmers of other languages were very helpful, as I also program in C++, and it helped me to avoid errors that I would probably overlook otherwise

For someone who is well versed in programming microcontrollers in C, but brand new to .NET and to C#, it seems like you've walked into an alternate universe where legions of previously common terms like "framework" and "method" and "sealed" suddenly have special meaning. It really takes a while to wrap your brain around it all, but Liberty has done a good job of minimizing the pain involved.

The layout of the book is good--start with the basics you need and move through examples to get you up and going. At the end there are some more conceptual subjects, but by then you know how to write some applications. I particularly like the way Liberty breaks up information into chunks--short paragraphs and regular asides/tips that help clarify the subject. Liberty does not try to impress you with his vast knowledge, but just tells you what you need to know.

While this is not a given with books on programming, I think I can say got my money's worth with this one.

Overall, book is pretty darn good.

The problem I have with the book is the author's choice of example code. At times, instead of selecting "objects", he chooses abstract concepts such as "Compressible". For instance, in chapter 8, which covers interfaces, why not choose the traditional automobile interface. Something surely all of us can quickly grasp, so that we can focus on the C# concepts, rather than what a "compressible" is? Object "A" is a "Compressible", what???, what the heck is a Compressible..... This made it a bit difficult to follow many of the code examples, and subsequently I found myself glossing over the examples, moving on to the next pages in hopes of something more interesting.

As a side note: My favorite computer book of all time is "Win32 System Services" by Marshall Brain. The examples in the book get right to the point, making it very easy to read. This is my benchmark I gauge all other books by.

Other than that minor complaint, the book is a valuable resource that I intend to keep, and add to my repertoire of books.

When I started learning C# (and I'm still learning), I purchased a number of books. Though each book contributes a little something extra, this book is my primary reference. The first half of the book covers the fundamentals of the language. If you have absolutely no prior programming experience, I'd recommend the other book from this series "Learning C#". Still, this book is thorough in its explanations. The second half of the book covers the use of C# for Windows and Web applications (and more). I yet haven't devoted much time to this section, but I expect more of the same great instruction. I HIGHLY recommend this book.

If you are going to buy this book, stick with earlier editions. Earlier editions of the book included interesting in-depth discussions of Reflection. In fact, many links on the web discussing reflection or dynamic invokation reference this book's earlier edition. The new edition of the book, however, skips any in-depth discussion of .NET's underlying technology. If you are already programming in C#, you will get very little from this book. It may cover newer material, yet the newer material isn't difficult to master in the first place, so it provides little value.

The book is divided into three parts - introduction and presentation of C#, C# programming techniques, and description of .NET framework and runtime environment.

First part starts with the history and motivation behind .NET and in particular C# programming language particular. And, as in most programming books the author presents a typical C# "Hello World" application, followed by discussion about such concepts as classes, methods, attributes, namespaces, that helps the reader to learn or refresh object oriented programming and language syntax. The details are provided about compilation and running "Hello World" application, instructions are sufficient enough for the beginner to launch the app and even debug through it.

Fundamentals of the C# language are presented in the next chapter, this includes types, statements, enumerations, operators, processor directives. After that the author gives a detailed description of C# classes - their declaration, initialization, constructors and destructors, overloading, encapsulation, and accessors - essentially the basic object oriented concepts, followed by inheritance and polymorphism - the section that also includes abstract and sealed classes, boxing and unboxing. Next paragraphs are about overloading, structs and interfaces. I think it would be logical to have the Interfaces mentioned earlier in a special chapter focused on general object oriented C#, instead of dedicating a separate chapter to it. Next is Arrays, Indexers and Collection - a long and very detailed chapter that explains the usage and handling of these structures. Strings, Exceptions, Delegates and Events are each very important and used by every C# programmer, and author dedicated each of them a separate chapter, thus closing the first part of the book.

Part 2 actually helps to apply the knowledge of the language to build applications, using Visual Studio as a development tool. We learn about Forms - basic user interface components, creating and coding controls. ADO.NET and data access are also described based on SQL databases. ASP.NET and web services are described in the next chapter, here we learn how to use visual and data access controls to create a web application. Steps to create an web services application are presented in good details.

The last part of the book is about .NET framework and runtime environment. It starts with a chapter about marshalling and remoting, that focuses on application contexts and boundaries, marshalling (transporting) objects across application domain boundaries, marshalling with proxies. An example to build a server and a client. Next chapter is threads and synchronization. The author assumes that the reader is already familiar with multithreading and focuses on how threads work in C#, we particularly learn about creating, running, killing threads and applying locks and monitors to synchronize them. Race conditions and deadlocks are mentioned at the end of the chapter.

The streams chapter is essentially about input output and is dedicated to reading and writing data from/to files and sockets. The last chapter is about integrating .NET with COM and ActiveX. Although the subject deserves a separate book, the author provides a detailed example how an ActiveX control can be imported into Visual Studio .NET project.

Overall the book gives a good detailed introduction to C# as a language and teaches how to use it in practice to build either desktop or web based application accessing database. Author illustrates material by screenshots and code examples, that helps the reader to easily create his or her own program. I think, given compact size of the book, author managed to put together all necessary details about C# as a programming language, .NET framework and their essential programming techniques. The book is a good reference material for someone already familiar with basics object oriented programming, multithreading, input output and looking to learn C# basics or make transition from Java to C#. As a developer who programmed with different languages I found the book to be a useful C# syntax reference source.

Although I am mildy disgusted by the language itself, I must admit the book is quite well written. It is not a detailed language reference book, but a tutorial, hence, it lacks depth. But as a tutorial, it couldn't have been better. Examples clearly illustrate concepts and yet simple.

As far as C# goes, it's not very sharp. My definition of C# would be a bunch of script languages put together. It brings in flexibility, but truly lacks characteristic as a language.

Bah!