Programming C#: Building .NET Applications with C#

• #5 in Best csharp Programming Books

205 Reviews

Sort by: Most Helpful ▲ Date Rating

Direct and Intuitive...these are my two words to describe this book. Jesse has exceeded an already high O'Reilly standard with this offering.

I have a basic web background (HTML, XML, JavaScript, CSS, Graphics) and was looking for the one (hopefully) book to help me catch on to C# and the many advanced object oriented concepts that come along with it.

Jesse knows exactly what the object oriented newbie is going to ask, and lets you know exactly what is happening. He knows what will confuse you (me), and clarifies IMMEDIATELY. Having this kind of foresight makes it possible to read this book cover to cover without jumping back to re-learn something that was explained poorly in the first place. The layout in this book is top-shelf.

As C# is completely dependent on the .NET Base Class Libraries, any text on the matter is incomplete without examples of and references to Windows and Web Forms. This book covers Windows Forms, Web forms, Web Services and ADO.NET. (The ADO.NET section is OUTSTANDING)

(If you are ever in doubt about an O'Reilly book, they have the table of contents listed for every item at their site)

I have yet to find a more efficient and easy to read text. Every time I think O'Reilly can't do any better, they come up with something like this.

Your money is well spent here.

As with most other O'Reilly titles, "Programming C#" functions as both a good read and an in-depth work of top quality information.

Programming C# gives an in-depth first look into the C# language that, according to Microsoft, is going to be a very important part of it's .Net strategy, and thus the future of software development. The first part of the book introduces all important concepts that can be found in the C# language. Syntax and object oriented design principles behind the language are explained. (and really, with it's garbage collection, type safety etc. etc. it is almost a 100% Java copy). Part II focusses on some common programming areas where C# is supposed to become big: web-applications, (relational) database handling, and next-generation Windows applications. Special attention is given to topics like ASP.net and ADO. Maybe this chapter could have included some more real-world examples, but as it is it's still quite a realistic look at these areas for C# usage. The last part introduces you to C# and it's hooks to the rest of .Net. This again is a typical example of why you should spend some money on a book by O'reilly and not run out and buy the first "Jumbo 4000 pages .Net Resource Kit" you encounter in a local bookshop from Microsoft Press. You'll get non-bloated information on C#, without all the marketing blah blah Microsoft is surrounding it's new puppy-language with these days. Basic object-oriented principles should be familiar to the reader, since these are not really explained. (but of course, we don't even want that, since we already know all about that, don't we?)

Currently this is without a doubt the best C# book on the market. If now only Bruce Eckel could start with a Thinking in 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.

I was attracted to this book because of prior good experiences with the OReilly series. What I expected was lean, mean, structured, complete, and accurate. What I got was light, fat, unstructured, incomplete, and sloppy.

An example paragraph:
"Classes and their instances (objects) do not exist in a vacuum but rather in a network of interdependencies and relationships, just as we, as social animals, live in a world of relationships and categories"

If it was just a few bad paragraphs of socio-biology, it would not matter. However the technical content of the book is written in the same sloppy fashion. Summaries are missing, important details are relegated to "oh - by the way's" hidden many pages after the topic.' Concepts are presented in random fashion. A little salt here, some pepper over there.

Instead of careful construction, what you have is "stream of conciousness" technical writing. Leave this to James Joyce. It has no place in a book on programming.

Jesse Liberty's Programming C# aims to expose its audience to Microsoft's newly introduced programming language that targets its managed .NET platform. I gather that the Programming line from publisher O'Reilly emphasizes instruction through example. Consequently, this book contains tons of code snippets, while still managing to cover a large range of topics. Though the book does succeed at introducing C#, I consistently had the feeling that it didn't have a clear idea of what its audience should be. In the introduction, Liberty seems to imply that this book would be suitable for everyone from a green newbie to an industry expert. Unfortunately, one-size-fits-none is the rule rather than the exception when it comes to these kinds of scoping decisions, and this book ain't no exception.

That's not to say that Liberty doesn't make a valiant attempt at presenting the material in a way that is comprehensible to everyone. In general, his explanations are succinct and his writing style is quite natural and enjoyable. This is a big plus, since the book weighs in at a cool 600 pages of explanatory text. A lot of those pages are devoted to code examples, as mentioned above. Liberty chooses to exemplify each and every major topic discussed with a complete program, and I suspect that most readers will appreciate this grounded approach, as I did. My only real complaint here is that the discussion of each topic seemed to be slightly incomplete. Explanations of some of C#'s features seemed to be limited to how it applied to his coding examples, and rarely went any further. Given that most of the examples given were rather basic, this can get to be rather frustrating when you need a little more detail to be able to solve the real problem that you're facing.

This book covers everything from the basics of Object-Oriented programming, to most of C#'s more advanced topics. In an earlier review, I was gripping that C# In a Nutshell (also by O'Reilly) didn't cover any Graphical User Interface (GUI) related topics. Happily, Programming C# has more than enough GUI examples to at least get yourself oriented in .NET's way of doing things, though you would still need a better book or reference if you plan on doing GUIs for a living. The book is divided into three parts: the first covers C# language features; the second shows you how to use C# to program different types of applications, such as Web Forms and Services, Windows apps, and even how to tap into ADO.NET, a subset of the .NET platform dedicated to working with data sources; the third part supposedly covers the Common Language Runtime (CLR), and other .NET features. However, the detail here is especially thin and disappointing, which leads me to my main complaint about this book.

As I mentioned earlier, Liberty attempts to write for everyone. However, by doing this, I feel that he makes nobody happy. A raw beginner will have a tough time keeping up with all of the newly introduced concepts, even if an attempt is made to explain all of them. In contrast, an experience professional will quickly get tired of the explanations for every basic concept, and might feel a little gypped once he or she gets to the advanced sections and finds that there is very little detail. I personally felt that way, and I also got a little irritated by the occasional bad advice that Liberty would dispense freely (such as when shows you how to overload the "==" operator, which is not generally a good idea when dealing with a managed language.) Also, the organization of the book is a little odd. Why is the chapter on Streams the second-to-last one in the book? Isn't I/O one of the very first things you want to show when discussing a new language? Why is the chapter on Interfaces shoved between the chapters on Structs and Arrays? Why is it three chapters after Inheritance and Polymorphism?

All in all, this is a good book that complements C# in a Nutshell well. Though there are tons of examples, you might be a little disappointed if you're looking for something outside the scope of those examples. As an introduction to the language though, it's probably pretty hard to beat at the moment.

This is a great book for learning C#. The first part is an excellent tutorial in the language, just right for experienced C, C++ and Java programmers and for advanced VB6 programmers.

The second part introduces how to use the language to create .net programs. This is a bit superficial, but his goal was only to provide an introduction, and it is a very good introduction. For more detail on really building advanced applications you will need an additional book (like his book on ASP.NET).

The third part of Programming C# goes into advanced topics you won't easily find elsewhere, with excellent coverage of (for example) threading, remoting, reflection, streams and so forth.

Liberty writes well, his examples are terrific, and he makes complex material easily understandable. Further, he supports his book on his web site where he provides not only source code but a discussion center where you can ask questions.

I highly recommend this excellent tutorial.

When I bought this book I was a beginning programmer setting out to learn C# and .NET. Liberty states in the book that beginners "may find some of it [the material in the book] tough going" but I took a chance and jumped out in the deep end and began reading it.

Even though this is an extremely well written book (that I now highly appreciate) Liberty was right. I only made it to the middle of chapter 4 before I realized that the pace was too fast.

Luckily I got hold of (and was rescued by) Michelsen's great book C# Primer Plus (on its nearly 1000 pages it teaches C#, OOP and programming basics from the very ground up). I found that the two books greatly supported each other because C# Primer Plus could fill in all my blanks while reading through Liberty's book. Moreover what C# Primer Plus was lacking in terms of .NET stuff (it doesn't touch ADO.NET, Windows Forms etc.) was presented by Programming C# in a now understandable and enjoyable form.

Programming C# is a work by a highly motivated writer in top form and can be enjoyed by anybody who makes sure that the basics are adequately covered.

What I don't like about the book:

The book contains no class diagrams - why oh why don't authors include a nice diagram of important parts of programming APIs. Heaps of words don't tell the same as one nice diagram would do.

Heaps of syntax (how your code must look) and semantics (what the code will do) - but almost no hints about how to make good object-oriented design using C#. The title of the book should be: "Syntax and Semantics of C#" - not "Programming C#" which signals you would find recommendations of how and when to use the features of C# in a smart way. (As Java and C# are VERY much alike - at least in all the fundamental parts - I would recommend Bruce Eckels "Thinking in Java", or Xiaoping Jias "Object-Oriented Software Development Using Java" to people that want to know HOW to use the features of Java and C# in a good object-oriented way).

I find lots of important details missing in the book, while I'm typing in a few C#-programs of my own while reading the book. My own code shows me important aspects of C# left out of the book.

On the good side - the book is easy to read, and provides lots of short examples with important stuff marked in bold (easy to find).

Ohhhh.... and one more thing, which has nothing to do with the book - but rather the C#-language:

I've said ealier that C# and Java has a lot in common. Java-programmers would find it very easy to learn C# - and C#-programmers would learn Java in no time. The core object-oriented features are very much alike. An important difference though is, that C# is more complex and Java more simple, thus C# would be harder to learn than Java, but as C# has more ways of doing the same thing, a good programmer might be able to write the same thing in fewer lines. As a teacher on the university I prefer simplicity to complexity. I don't think the higher complexity of C# is justified, as I find most of the extra features introduces a lot of extra rules to remember without really enhancing the expressiveness of the language. But thats my opinion - please take a look at both languages and judge for yourself.

Actually I think the languages are so alike, that you should make your decision on whether you want to program to Windows & .Net or to the Java Virtual Machine (which runs on Windows, Mac, Linux & Unix) & Java Enterprise Edition.

I cannot understand why the rating of this book in amazon.com is good. I have bought this book based on the reader's review on amazon.com. But now I think the ratings from amzon.com is quite misleading.

Before I read this book, I downloded .NET SDK and read C# documentation in it.

I cannot find any new depth or information in this book more than the C# tutorial and reference SDK.

This book is just cursory.

One of the reason could be that C# does not have much to say to learned java/c++ programmer.

But anyway, I wish the writer could provide readers with the unique characteristics of C# compared to java and c++.

I am disappointed that the author does not mention that C# does not permit to specify the exception in the method definition.

This is critical shortcomings from programmer's viewpoint.

In conclusion, I have doubt why MS creates another language and why this book has so good reputation from reviewes from amazon.com.

Yesterday I bit the bullet and installed VisualStudio.NET beta 2. Bringing up the IDE, I thought, "I guess its time to finally buy a C# book." Inside C# (Archer) reads very well, but it is more of an over view than an in depth treatment. Professional C# (Wrox authors) seems to cover *a lot* of ground, but because of its breadth, depth is not uniform. C# and the .NET Platform (Troelsen) seems exceptionally good, and has been my leading choice.

Today, though, I came across Programming C# (Liberty). From Liberty's other books, I know that he is a careful, thoughtful author, and that he is able to explain things well. His skill is clearly evident in this book. Programming C# goes into even more detail and depth than Troelsen's book. I also appreciate that Liberty puts C# and .NET in the context of other development tools, for such touchstones make the going easier. It is a welcoming book for many classes of readers. Reading various parts of Programming C#, it is clear Liberty has worked hard and effectively to craft an exceptional text. I'm grateful to have waited and to be able to begin my journey into this new programming model with such a helpful, pleasant guide.

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.

When I purchased this book I had little knowledge of C#. After reading the book and building all of the samples, I discovered that my lack of knowledge was something I had in common with the text. A bold statement, so let me explain.

Teaching effectively requires a deep understanding of the material, so what is important is emphasized at the expense of the trivial. In this book, everything is given equal importance, so the important material is lost in the trivial.

The text is frequently written "out of order", that is, statements are made, and then a later statement includes something you needed to understand the previous one. This is evident in the line by line code samples, where the author frequently describes line 3 of the code, and then says "but before we do that, we need to do line 2". This is confusing and not helpful.

While on the subject of the code samples, the samples frequently include a lot of useless code that just confuses the point. I ended up stripping the samples to the basics myself, and in virtually every case I ended up with a 50% or more reduction in lines of code, and a much clearer sample. Even worse, the samples could be done in much better ways, so in addition to being confusing they teach bad usage of the language.

The main problem with the samples is that many of them are taken directly from the SDK. The SDK samples are not designed to teach programming, they are designed to demonstrate how to solve a specific problem. This makes them inappropriate for teaching a language. The ones on ADO, for example, contain complex table joins, which are SQL constructs and have nothing to do with ADO or C#. The reflection API samples includes one where it writes IL directly, certainly not something that most programmers are going to do. And the text never explains the IL that is written.

I own dozens of O'Reilly books, and most are excellent. Unfortunately this one and UML In A Nutshell are the exceptions.

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.

Book is fluff and filler without much useful information.

If you want a C# language refrence or you want to learn C#, look at "C# Essentials, Second Edition" By Ben Albahari et. Al.

Jesse Liberty clearly writes books to make money, not because he is good at it. This and his ASP.NET book have lots of filler and little valuable content. Both books are going back to O'Rielly with a letter of complaint.

I can strongly suggest Albahari's book, it is incredibly concise, about 1/3 the size of Mr. Liberty's book, and it covers far more of the C# language than Jesse's book.

"C# Programming" is close to being the perfect introduction to C#. The author has a nice style of writing that makes the book easy to read and understand. Although the author assumes that you have some familiarity with programming, he does not assume that you know C++ or Java and does not rely on you knowing either language. This helps avoid the problem some authors encounter of explaining how something is "just like in C++" and then losing anyone not familiar with C++. The author does show how to use VisualStudio.NET but he does not rely on this tool, allowing programmers without access to it to run the many examples in the book. Like most O'Reilly books, this is a well-focused and well-written product. The book is divided into three sections. The first is a detailed introduction to the language. The coverage of the C# language in this section is where the book excels. With very few exceptions (I would have liked to see a little more on nested classes) I found the coverage of the book and the examples provided to be excellent. The second section is a brief discussion of several topics including ADO.NET, ASP.NET, and Web Services. This section is just an introduction to these topics. The last section covers advanced topics such as reflection, threading, and remoting. I highly recommend this book to anyone interested learning the C# language even if that interest is purely academic.

This is a very decent introduction to C# and the .NET environment. The book offers a reasonable introduction to the basics of the C# language: types, conditionals, loops. It also discusses OO basics in the context of classes, inheritance, and polymorphism. The book then goes on to introduce Windows Forms, ASP.NET, and ADO.NET. Finally, there are discussions of assemblies and deployment, interoperability with COM, reflection, threads, streams, Web Services and other goodies.

Considering the breadth of the material the text is quite clear and the sample code is generally accurate and useful. Sometimes one needs to go through a whole program listing to extract the line or two that is being discussed, but that isn't so bad because it does provide a useful context. Setting the code
apart by making it bold might be a nice touch though.

The section on interoperability with COM seems a bit weak, and I could not find the OCX and COM components on Jesse Liberty's Web Site as the book promised (the source code is there, but no pre-compiled components). I thought the section on delegates was also weak: The MSDN libary material is more clear in this regard. All in all, most of the chapters are quite solid, but now again there is a chapter that I think ought to be re-written from scratch. I find it a bit strange that the old material has not really been revised much since the 1st edition.

I would say that the target of this book is a fairly solid, well-grounded developer. The book does tend to omit details that would likely stump a beginner, so if you're looking for a book that makes every step very explicit, this one is probably not the best choice.

I consider this to be a good first C# book for developers who have solid experience in other languages. Supplemented with the material that's available free on MSDN, it provides a strong foundation.

O'Reilly is the undisputed champion of technical books and Programming C# is another example of why. This is the third edition of what has been a great book. The new content in this book covers the new .NET 1.1 framework and the new Visual Studio .NET 2003.

Programming C# is both approachable for newcomers to the C# or programming world and detailed enough for experienced developers learning or using C#. It is broken into three distinct parts:
1. the C# language;
2. programming in C#; and
3. the Common Language Runtime (CLR) and the .NET framework.
Each of these sections could be (and most are) a book in their own right and Jesse Liberty does a good job addressing each one.

In Part 1, the C# language, the author takes the reader through the typical "hello world" application to intricacies of exception handling and delegates (which I love by the way). Liberty touches on everything from traditional object oriented design (classes, inheritance, etc.) to operator overloading and support for other .NET languages. An extremely important point made (albeit in a very short section) in the operator overloading chapter is operator pairs. I don't know how many times I have seen Java and Smalltalk developers overload the equals method without overloading the corresponding hashCode method. The point here is that with operator overloading, corresponding operators must be overloaded as well. Overall, this chapter is most useful for people new to C# or new to programming. Experienced OO developers will not find anything new in the objects and classes chapter, but that is not the reason for this book anyway.

In Part 2, the author takes us into the world of building a "real" C# application. I say "real" because no example is a book will ever cover all the gotchas and problems professional programmers see on a daily basis. Liberty touches on building Win32 applications (a bit light on this for my tastes), how to access databases using ADO.NET, building web apps and building web services. The web apps and web services chapter is the most interesting and informative of this part of the book. The author does a great job of explaining how web services work in C# and .NET. Liberty introduces an HTML screen scraping application and transforms it into a webservice consuming application, while explaining the "evils" of screen scraping. As a veteran of 3270 (mainframe) and 5250 (AS/400) screen scraping, I can definitely agree with the author....

In Part 3, Liberty goes into the internals of the .NET framework. Here the author delves into assemblies (for Java developers think jars), versioning assemblies (and why that is important - think dll hell), attributes (an interesting meta data add on to the language) and reflection, and other advanced features like remoting, streams, threads, and COM. This is probably the part of the book that the experienced C# programmer will find the most interesting. Liberty goes into a good amount of detail on each of these topics.

Overall, Programming C# is a well written informative book. The book is sprinkled liberally with code examples. I found the tips and traps a great feature that readily pointed out important topics when I was just skimming over a chapter. The only things I really didn't like was Part 1 (as I have been doing C# for about a year and OO design and programming for over 10) and the surface treatment of Win32 programming. The internals of the CLR and .NET was very interesting. I would definitely recommend this book to brand new and intermediate level C# developers. More experienced programmers may not find all they are looking for here.

This is a fantastic introduction to this important new language. The coverage of C# is excellent, the examples are clear and easy to use. The author goes further and provides a quick introduction to developing both windows and web applications, and then, in part 3, explains the more advanced aspects of programming C#.

I'm surprised by one review here which says that that the author is wrong when he says

int myArray = new int[5];

creates an array of 5 integers. The reviewer points to this as an error, but it is correct. The reviewer is confused by 0 offset, but Liberty gets it right, and he explains well why this array will be indexed 0-4.

More important, Liberty writes well and he fully supports his books, offering the complete source code along with a FAQ, errata and, most impressive, his own private support forum.

This is by far the best book I've read on C#.

This is my first book on C# and it did not take me long to
realize that I've picked up the wrong book. I'm not sure if there is a better book on the subject, but as an experienced teacher and active programmer I can see a number of poor spots in the text and in the style of teaching. One example: examples. Those are really strange. Using just DateTime properties in discussing OOP is I think a bad choice.
Is this book good for novice readers? I think it's not. For experienced programmers moving from, let's say, VB6 to C# (like myself)? Not at all. Not the best book on C# and on computer programming topics in particular. It's not the first time when the popularity of the book might not be right sign for book buyers. And vice versa.

This book is quickly becoming a classic. First rate writing is combined with depth of coverage and well designed and executed example code.

Liberty not only writes well, and with a natural abiltity to explain difficult topics, he goes beyond by showing examples that illustrate exactly what he is trying to teach.

The coverage of C# is excellent. The second part of the book is a quick intro. to programming in .NET and this is weaker, but of course the idea here is just to provide an introduction.

The third part is an in depth exploration of advanced topics, and this is excellent.

Finally, his book is fully supported on his web site, where you can get the source code and also post questions in his private discussion area.

I must add that some of the negative reviews I've read about this book seem to be talking about another book, or were written by people with an interest in hurting this one. Maybe I'm missing something, but this book is so good, I've passed copies along to co-workers and friends and they've come back and thanked me and bought Liberty's other book, on ASP.Net.

Excellent. Highly recommended and very useful.

Lots of errors in examples, figures, and everywhere. Liberty has tried to follow Microsoft model. 'Shove the product out the door fast'.

Liberty is not such a good author, I would say. Confuses in many places.

Very, very poor and artificial examples. You can't use even a single example from this book in your real life. Please do not buy this book, if you have not already done so.

-Ganesan Rajaraman

Liberty's Programming C# is not only well written, it is a complete and thorough primer on C# programming. He begins with a terrific tutorial on the language, taking you through all the fundamentals, and making sure you are comfortable with class, interface, struct definitions and usage. He does not assume you already understand object oriented programming, but teaches the concepts as you need them.

The second part is a good introduction to using C# to program .NET applications, including web services, web apps, windows applications, and the use of ado.net

Part three is a real treasure. Here Liberty teaches the advanced concepts that are difficult to find elsewhere. He explains attributes and reflection, remoting, streams, asynchronous i/o, threading and so forth.

The examples in Prog. C# are excellent; well thought out and on point. Liberty provides source code and other material on his web site.

I can't recommend this book highly enough.

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.

This book begins with a complete introduction to the C# language, with special tips for C++, VB6 and Java programmers. The writing is excellent, to the point, humerous but not silly, no wasted words but plenty of examples.

Part 2 of the book introduces the major types of applications you might build with C#, with a good introduction to ASP.NET, web forms, web services and also to ADO.NET.

It is in part 3 that this book stands out from all the rest, with a thorough explanation of many aspects of the CLR and the Framework Class Library, including lucid and very well written explanations of Assemblies, versioning, attributes, reflection, marshaling, threading, synchronization mechanisms, streams, async i/o, and com interop. Each of these topics can be a book in itself, but this book, Programming C#, provides enough introduction to make you productive and to lay the foundation for further reading.

I've not seen a better introduction to C#, and Liberty has a gift for making technical material crystal clear.

If you know C++ or Java well, then this book will be annoyingly slow and boring for the first third of the book. The treatment of the C# language is for the novice programmer and does not cover the detail of the language (so no use as a C# lang ref).
If you don't know what inheritance and polymorphism mean then this is the book for you otherwise look elsewhere.

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.

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.

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.

I have mixed feelings about this book. It wasn't until I had finished reading it when I began to understand why. The author is clearly very knowledgable in many areas. So much so that he appears bored with certain key topics and thus skims over them. On the other hand, more complex topics such Remoting, Streams, Marshaling, etc... were discussed thoroughly.

The opening sections on the .NET framework are light. If you are looking for background information on how this new runtime works in comparison to other environments, you'll need to look elsewhere. This 5 page section gives you the basics and that's about it.

The chapters on ADO.NET didn't have enough coverage and had a relatively small amount of code samples in comparison to other C# books. Most applications written in C# will utilize ADO.NET and developers need a lot more information than this to be successful.

Arrays, Collections, and Stacks are covered comprehensively to say the least. You'll get more than enough examples and tutorials to create complex methods. The discussion on the differences between Queues and Stacks was quite helpful.
The threading section was a bit weak. You'll get the standard explaination and examples found in just about any threading article on the web. The good 'ol counter example with two different threads. I would have enjoyed a detailed discussion on thread pooling especially with network requests.

If you are new to the object oriented approach to programming, the author does spend a good amount of time in this area. By the time you are finished with these chapters, you'll be able to create more complex implementations. You'll undoubtedly refer to this section many times as part of your design review for the do's and don'ts.

I got the most out of the chapters on Streams and Remoting. They contain a wide variety of detailed code samples that are extremely helpful. Especially the Streaming example of a Network Streaming Client/Server implementation. Of course, I would be remiss if I didn't mention the entertaining Captain Kirk reference during the explaination of marshaling across app domain boundries.

If you plan on writing applications that are dependent on networking remote objects and streams, then this would be a great book to pick up. It really clarified quite a few questions that I had on the subject and prepared me to create some interesting network based applications. However, if you really just need the nuts and bolts of C# and ADO.NET, there are better books out there.

(...)

I work through every example in a book to make sure I'm not glossing over important details as I read. What I found in this book was a real mess of code from one example to the next. Many times the code examples appear to be building on each other as you progress through each chapter but if you actually work the examples, you find that variable names are different, naming conventions are all over the board, and you end up spending time trying to figure out what changed instead of focusing on what you're supposed to be learning. It also felt like a lot of the concepts were just being tossed into the text instead of being treated thoroughly. I will say that I just had to stop after chapter 5 so it may get better but I'm really disappointed so I'm giving it a low rating.

The author has succeeded at stating everything and teaching nothing. I am ashamed to say that I read this book cover to cover. It was my first book ( out of 7 ) that I read on .NET and I consider it to be the worst. [...]

I honestly believe Jesse Liberty should stop writing books. He does not seem to have the ability to form a coherent thought, much less the ability to convey said thought. He often rambles on about the importance of this or that, then complete neglects to actually discuss the topic. He constantly contradicts himself by espousing certain coding practices and then completely ignoring those same practices.

Speaking of coding practices, don't you dare use his code to learn good programming practice. He has no concept of how to indent, apparently indenting at random, and he often forgets brackets; combine that with the random indents and you have completely unreadable code. And to top it off, he defines his variables at the END of his classes instead of the BEGINNING, unlike everyone else in the entire world.

This book is an excellent tutorial on C#. The author writes with a full understanding of how professional programmers and serious amateurs approach programming. He fills the book with useful insights, not only into how you accomplish things, but why.

The examples are simple, straight-forward and to the point. The analysis following each example is excellent. Well written, cleary presented and very useful.

This book starts out with the fundamentals. If you are an experienced C++ or Java programmer, you'll get through this section quickly and easily. The second section introduces .NET programming and the third section tackles advanced subjects.

Throughout the writing is excellent, clear, well presented, humerous and there is great value in the professional insights provided.

I can't recommend this book highly enough. I've also read Programming ASP.NET by the same author, and will post a review for that terrific book separately.

World class.

This book (I have the first edition) goes from absolutely clear explanations and code examples to the worst technical writing I have ever seen. It looks like Jesse's still confused on some of the newer programming concepts that C# offers. His chapter on Delegates, as an example, is just terrible. Very confusing and the examples are even worse. I've noticed that Jesse's writing in general, I have also read (should say, tried to read) two of his books on C++, gets worse as the difficulty level of the concepts go up. This is why we buy these books in the first place, to help us understand dificult subjects. "If you can't explain it in terms that an eighth grader can understand, you don't know enough about the subject" is a famous quote that comes to mind. Sometimes I get the feeling Jesse (and many other "technical writers") are just faking it with technobabble to sell books. All you tech writers out there should check out how Mark Minasi can "turn" a technical phrase that can actually be understood.

WHAT'S GOOD?
Jesse Liberty is a respected author who was written about the Microsoft platform and development languages for a long time. Because of this, he really knows his material and it shows in this book.

Jesse has a website where he personally supports all of the books that he's written, allowing the reader to get up-to-date information and error corrections.

Also, as an experienced author, Jesse Liberty knows how to keep the pace going in a book and explain the key concepts so you are enlightened but generally not bored.

The book is published by O'Reilly which maintains a site for the book and where you can Code Samples from the text, as well as error corrections, etc.

WHAT'S BAD?
Speaking about those errors. The book is full of them! O'Reilly, as well as all other book publishers are racing to the presses with books about .NET and the Framework in an attempt to be the first. But the book can be very frustrating to read with all of these errors. There are mispellings in the code, code examples are repeated twice, and some of the information is just plain wrong.

To O'Reilly's credit, they have already released a second edition of the book to address this issue and therefore are listening to their readers.

WHAT'S TO CONSIDER?
The scope of the book is ambitious. The preface of the book makes it seem like there should be a three-volume set instead of one book. Jesse Liberty tries to make the book accessible to beginning programmers, as well as advanced programmers, and those coming to C# with no prior experience with the C-style languages.

In addition to covering the language of C# itself, Jesse tries to touch on some of the key classes in the .NET Framework itself. A discussion of the Framework already fills several books and the copious documentation available for free from Microsoft. It needs to be touched on here, but of course, it can't be covered in detail and something always get's left out.

Because Jesse tries to make the book accessible to all, those who are experienced Java or C++ developers will be bored with the first few chapters and breeze through them in an attempt to get to information that is new.

IN CONCLUSION...
All in all, the book is alright, and certainly filled in the gaps left by the MSDN documentation, but if it were up to me, I would probably have waited until even the 3rd edition to get the most bang for my buck.

I read the first half of this, and found an error every other page, ranging from typos and missing brackets to plainly incorrect observations about hashing.
I suspect the book was rushed to the presses without much proofreading.

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.

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...

I am one of those people who buy a lot of programming books. I must have six on C# alone, but this one is by far the best written, and the most to the point. The examples are short, clear and (most important) complete. The explanations are clear, but what is most important is that the author does not just repeat what is in the MSDN and other help files, he walks you through the language, teaching you exactly what you need to know to be productive.

The proof of the excellence of this book is in the second and third part, where he goes well beyond the basics to show you how to use C# in building applications and then how to use the framework with C# to achieve advanced goals.

This book does not stand alone. If you want to build ASP.NET applications in C#, start with this book and then go on to the author's book Programming ASP.NET. If you want to build Windows desk-top applications, start with this book and then go on to the author's Programming .NET Applications. In any case, though, this is a great foundation book, and far exceeds the other primers I've read.

As others have mentioned, the author provides unprecedented support for his book on his web site, but what no one else has mentioned, as far as I can tell, is that he also recommends books by other authors (and even other publishers!) to further your study of .NET.

I've read most of the C# books that are currently on the market, and this is definitely my favourite. It has a nice balance between the language and its practical application using the .NET Framework, and is well explained in elegant and concise language. Unlike certain books I could mention that are 1500+ pages of rehashed reference material, Jesse takes the "less is more" approach, with about 300 pages on the language followed by about the same number on the major class libraries needed to apply the language to real-world problems.

If you're familiar with the Core Java books by Prentice-Hall, you'll notice a similar style here - brief coverage of topics that should be familiar to any experienced programmer (classes, objects, interfaces etc.) with more than enough depth where necessary.

If you're already proficient with a language such as C++, Java or Visual Basic and want to convert your knowledge across to C# quickly, this book will provide everything you need in a digestible form. Recommended.

Not only is this text well written, it is the definitive guide to programming .NET with C#. The coverage of the language is excellent, but the coverage of such advanced material as networking and remoting and attributes and threading is unprecedented. This is O'Reilly at its best.

Every concept is illustrated with an example, and Jesse's writing is clear, concise and easily understood. He assumes you have some programming experience, but he explains every difficult concept in detail.

Combining the clarity that Jesse Liberty brings to a subject with the precision of O'Reilly books makes for an excellent introduction to .NET programming. I'm very impressed, not only by this book but by the support provided by Jesse on his web site.

If you are only going to buy one book on C#, then this is the book to buy. I have already ordered his book on ASP.NET and will write a review on that when I've read through it. If it is as good as this one, Liberty will be the leading authority on .NET programming.

The 2nd edition apparently fixes every problem with the first edition, and all the code works with the release version of .NET. You can download the code from his web site or you can type it in yourself.

In short, this book is excellent.

I've read some of Jesse's other books on C++, and found his writing style very approachable. While C# certainly has less of C++'s notorious complexity, it's a new language with a huge amount of extensions and API's (ASP.NET, ADO.NET, WebForms etc.) The book covers all of them in the same approachable style, and gives the reader a good survey of the dot-Net platform beyond the language.

If Microsoft follows through on their standardization plans, I think C# is going to be a very important language for both Windows and non-Windows coders. O'Reilly's take on it will definitely help developers interested in making it part of their toolbox.

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.

[A review of the 4th edition 2005]

As a java programmer, reading a C# book is like wandering into a parallel universe. Most things are different, but everything is recognisable. Liberty walks us through the syntax of C# and then how to program in it. All the nice things in Java can be found in C#. Strong typing. Automatic garbage collection. Interfaces. Introspection... As the author mentions, C# came out in 2000, while Java did so in 96. Those 4 years let C#'s designers effectively make it a superset of Java.

Some of you who might be tempted to read this book will be Java programmers. Well, as a Java programmer, I'd have to say that if you like Java, then intrinsically, you should also like C#. If you have to shift, for career reasons perhaps, then this book might be reassuring. You can re-express your expertise in C# with relatively little effort. The syntax is not too dis-similar. Likewise, the code snippets, necessarily short though they are, will probably follow the same logical ordering as in Java.

I read some criticisms of the earlier versions of this book. I think they're all wrong. This is a great book if you want to learn C#, not Windows Forms, ASP.NET. The title is Programming C# not Windows Forms in C#. If you want a thorough coverage of C#2.0 this is the book to buy.

Coming from a C++ and Java background the differences and similarities are highlighted but could easily be skipped over if the reader has no previous knowledge of Java or C++(also VB6 and VB.NET).

Also another great thing that this book has been criticised for is the insistance on lots of code samples. Wow people complaining about code samples?!! I mean what do people expect from a book about programming?! UML diagrams? It's code heavy but the code is not bloated and clearly shows the practical use of the language feature. A few lines of code says a thousand words. Also typing in code samples makes it stick, how many times do you think you know something until you sit at the keyboard and say 'Wait how do I do that again?'?

Also Jesse Liberty's writing style is very easy to follow, I found that if I read this book at the keyboard or away from it that I was still taking in the content.

So if you really want to learn C# and not have to take onboard a library load of Microsoft marketing spiel then buy this book. (Also see Jesse Liberty's OnDotNet articles too at http://www.oreillynet.com/pub/au/239 )

This book was one of the suggested texts for my 'Web Development' course last semester, which dealt with ASP.NET using C#.

Our lecturer stated that Jesse Liberty's Programming C# was probably the best out there for those students who already know how to program, and who understand the subleties (or even the basics) of OO Development. I have developed in Java for a few years, have some exposure to C++ and needed to get up to speed (as fast as I could) on the C# language for the course I was taking.

With that objective in mind, Jesse Liberty's book served admirably. I finished it in about a week and a half, though I only skimmed Part 3 as I did not need all that material at the time.

Part 1 is a concise, thoroughly readable expose on the C# language itself, it's syntax, etc. The author's writing is not dense, the examples are nice and simple, about a page long on average, which suits me fine, as I did not want to have to plough through complex long-winded examples; there was plenty of time for that later anyway. The explanations (at times) may be a bit 'short' for new programmers, who may need more pages (and more detailed examples) devoted to polymorphism, the nature of objects, stream processing, etc, etc, but for those who already are quite comfortable with such concepts, then Programming C# should be ideal.

Part 2 of the book gives a general overview of Windows Forms, Web Forms, Web Services and ADO NET. These chapters provide just a flavoring, a taster, on these topics, so set your expectations accordingly. I particularly liked the chapter on ADO NET, and wished there was more of it. The writing was very clear, and the examples well chosen.

Part 2 also gives some screen shots of the Visual Studio .NET IDE, how to get going with it, how to drag and drop controls onto your Forms, how to create projects, that kind of thing. Quite useful in fact, as I had no idea how to begin using the IDE initially. Again, this IDE treatment is very introductory, so it may not benefit all equally, though I certainly found it helpful.

Okay, I'll have to mention one thing I didn't like about the book: the chapter on Delegates, chapter 12 I think. I found that a bit confusing and it took me longer than I'd planned in order to get through it. Maybe this was on account of my background; Java uses interfaces for event handling, events, etc but DOT NET uses this delegate model.

That aside, I would certainly recommend Programming C# to those looking to get a grounding in the C# language.

This is the single best book I've read on C# and may be the best introductory book on programming in an object oriented language I've ever read.

There are some surprising reviews below, I suspect they were written by people with an agenda that had nothing to do with this book, because Programming C# is clear and well written, with excellent examples. Liberty goes way beyond the standard documentation to explain all the fundamentals of hte language, which is why this book continues to be one of the best sellers in the field.

The first part of the book is a primer on the language, and it is clear, and understandable and to the point. The second part is a quick review of how to use C# to create .NET applications, and the third part shows advanced topics in C#.

In addition to having written an excellent book, Liberty supports his book on his web site, where he provides all the source code and a support discussion group, where he personally answers readers' questions.

All in all, this is certainly the best C# book I've ever read and may be one of the best programming books I've ever read.

This book skims over C# in too few pages and tries to cover too much. The coverage of the C# is adequate at best, and it doesn't cover the most important aspect of C#: programming for .NET.

Also, this book is lousy for beginners, but also isn't really useful for advanced programmers either because it skims over everything.

I expected far more from O'Reilly. I think they might be losing their touch. Certainly, their .NET books are poor.

This book isn't simple enough for beginners, neither is it advanced enough for real programmers. I recommend you check out "Mastering Visual C# .NET" from Sybex instead: it is a much better book.

This book provides a lot of "what?" information, but not the "whys". After finishing the book, you are left with a lot of disconnected "facts" about C#, without a real understanding. I don't recommend this book for serious, thinking programmers. The Stan Lippman book is WAY better.

This is a well written general introduction to C# programming that goes well beyond the basics to also teach you about .NET programming, the frameworks, and provides a good overview of web and windows programming.

Jesse starts you out with the fundamentals, and provides comprehensive coverage of the language. Each idea is illustrated with an excellent example. He then provides an overview of windows programming, web programming and ADO and ends the book with excellent coverage of advanced topics. The advanced topics include threading, remoting, attributes and reflection and so forth.

I highly recommend this book to C++ and Java programmers, VB6 programmers and even to highly motivated novices. I've looked at a lot of books on .NET and this is the best language tutorial I've seen.

I was also very impressed with the depth of support Jesse provides on his web site. He has posted up to date source code, an errata with all reported errors in the book (there are very few) and he even runs his own support discussion center.

O'Reilly books are excellent, and this is an excellent O'Reilly book.

i bought this book after reading through its glowing reviews - and i'm sorely dissapointed. i'm not familiar enough with C# to know if its clunky language design or ineptitude on the part of this author, but there at least seem to be what look like glaring errors in the book. for example in the interfaces chapter, the author advocates using runtime casts to cast a reference to an object to a reference to an interface that the object's class implements. but why should that be needed ? both the programmer and the compiler know if a particular class implements a particular interface. (if it doesn't, it should be a compile time error - you shouldn't need a runtime check.) on the other hand you would need (for type safety) a runtime check for a cast in the opposite direction but this point completely eludes the author.
another example: on page 27, the author has a sidenote about "The Stack and the Heap" where he claims objects allocated on the stack are garbage collected after the stack frame ends. hello ??? does the author comprehend what he's talking about ? when a stack frame ends, all that is done is that the items are popped off the stack, and the same space reused when the next block is entered or the next function call made. where does the garbage collector come in ? does he mean objects on the stack which contain references to objects allocated on the heap which are cleaned up when the stack frame ends ? (but that is covered when he says "Objects on the heap are garbage collected sometime after the final reference to them is destroyed.") or is he talking about objects on the stack which have corresponding "boxed" info on the heap ?
one more gripe: almost all the examples in the book are perfect examples of how NOT to do object oriented design. no encapsulation, the same tired old theories of how inheritance is a good form of reuse, etc. the author manages to quote from Design Patterns (by the gang of four) - this book really makes me wonder if he's ever even read the book !

This book's relaxed conversational style and dead-on technical information make it a fitting gateway to this innovative new language and equally ground-breaking framework. Whether you're a self-styled web professional who has learned everything from scratch, or a CompSci grad with fifteen years' field experience, you will find this a welcome tutorial and a useful reference.

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.

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.

I purchased the 2nd Edition of this book, so some of my comments may no longer apply. Essentialy, I like the authors style very much, but when O'Reilly get hold of most books they manage to screw them up with typographical errors and incorrect figures etc. I tend to avoid O'Reilly books for this very reason, as I have never encountered so many errors in any books from other publishers. I don't blame the author for this, because many of the errors would not pass the eye of someone who actually knew their subject well enough. My guess is that once the author has produced his manuscript, the rest is handed over to the typesetters (i.e. low paid cheap overseas non-technical labour, just a guess) who consistently manage to ruin an otherwise good book. If you don't like lots of errors in technical books (and I mean really large bloopers, as well as more subtle ones) then avoid O'Reilly books in general, and go for a quality publisher instead. Especially true if you are a beginner.

Very very easy to read. Full of good examples. It grabs you by the hand and teaches you step by step everything about C# in simple, understandable words. Provides examples on every topic, makes comparation between C#, VB.NET, C/C++ and Java. I was eager to learn C# but I did not want to read from a hard, meticulous book. I found this book and it was awesome reading it, and when you less know it you are finished reading these +600 pages book and already programming C#. If you are still deciding which book to purchase, there are good books out there, but THIS ONE is a definitive good decision to acquire and read.

This is the classic book for learning C#. It is little wonder that it has been outselling all other C# books on Amazon for months and months.

Liberty's writing style is clear, and is use of examples is terrific. Each example is kept simple enough to illustrate the point at hand, and not distract with fancy footwork that confuses the reader.

Liberty starts with a full explanation of the language. The book is targeted at programmers with some experience in some other language (VB6, C++ and Java are the clear targets) but a bright reader can get through this book with little or no previous experience.

After teaching C#, Liberty shows how to use it to create applications. He demonstrates simple Web and Windows Applications, and a Web Service.

Finally, in the third part of the book Liberty goes beyond the basics to show advanced ideas in the .NET Framework and how they are used by C# programmers.

This is the best book money can buy, and Liberty supports the book at his web site where he provides all the source code and a link to a private support discusssion center where you can get additional help from him and others.

This book, combined with his Programming ASP.NET (now coming out in a second edition) helped me become a proficient ASP.NET programmer. I'm looking forward to his new book on writing desktop applications (Programming .NET Applications) and I hope he continues to write for O'Reilly, because the quality of these books (editing, etc.) is very high.

All in all I can recommend this book very highly.

I just bought the second edition and I'm sure that this edition must be better, but I don't know how. Coming from VB programming and wanting to learn C# because it pays better, I found this book to be exactly what I needed. I now feel comfortable doing C# after about 3 weeks. I know that anything I am able to do in VB that I can also do now in C#. Just a great training guide.

I have used many of Jesse Liberty's books in the past to get to grips with many programming subjects - Clouds to Code, Beginning Object-Oriented Analysis and Design with C++, and more recently, Programming ASP.NET.

Jesse is one of the best software authors of our time. He has an uncanny ability to predict the questions that you will ask and respond to them in the text. He does this very well in this book.

Having said that, this book *IS NOT* an idiots guide to C#. It is not a good first C# book unless you are bringing OO skills from another language like C++ or Java with you. The book covers everything you need to know in a well paced tutorial with plenty of examples.

To me, the best thing about this book is the support that Jesse provides through his web-site. He is such a great teacher and always has time to help.

If you have already started in C#, or have C++/Java experience and are looking for something with more detail, this a great book.

I believe that this book is an absolute must! You can't go wrong.

I don't recommend this book as it doesn't cover how you really _use_ C# in a .NET environment. It covers only the raw C# language, and doesn't even do that well.

You have been warned.

The author of this book dedicate an entire chapter to string conversion but left out what I considered to be pretty basic of many programming languages and that is string conversion to numerical type. Fundamentally, who knows what else "basic" that the author left out. Buy another book, but don't buy this one!

This book is not only thorough and well written, it includes example programs that illustrate the points discussed and that provide a basis for working with the language.

Liberty starts off with a complete coverage of the language, teaching you all you need to know to program well in C#. If you have any programming experience at all, this book is a fantastic primer.

The second section of the book explains how to write Windows and web applications and how to work with ADO and how to write web services. This is an amazing tutorial on the fundamentals of .NET

The third section is the gold standard on advanced .NET topics. Jesse teaches you how to work with threading, how to use attributes, how to accomplish remoting and much more.

The book is well written, very well put together and he supports the book on his web site where you can download all of the source code. Most impressive of all, he also has a support discussion center, where you can get your questions answered.

I recommend this book without reservation.

I found this book to be a disappointment especially considering the fact that it was published by O'Reilly -- a highly regarded book publisher.

My first impression of the book was that it was somewhat disjointed in some spots. Also, there were some topics I felt that should have been given more coverage at the expense of others. For example, the chapters on ADO.Net, ASP.Net and WinForms Programming could have been removed. These subjects are enough to cover a book in and of themselves; to give them short shrift, IMHO, is a disservice to the reader. I would rather have had the author do an exhaustive coverage of the C# Programming language.

Note that I did find one glaring omission in the book. In the authors coverage of the if statement, he forgets to mention the else if construct. (If someone can find it, please let me know).

All in all, this book does an adequate job of covering the C# language. Coverage of Remoting and Threads was a nice bonus. But the book falls far short of works of the standard-bearers of Windows programming: Petzold, Richter, Prosise, et al.

Well, I understand that Andrew Troelsen's "C# and the .NET Platform" is supposed to be a finalist for a Jolt Award. Time to do more shopping on Amazon....

I am a Java programmer interested in learning c#. Based on the reviews at Amazon, the reputation of other OReilly books, and a quick glance at the book store i picked up this book. I have not been disappointed.

The book is written very well with examples for just about every concept. This is really useful as I can use the examples, and then play around with them to what c# will do.

Furthermore, all of the concepts are explained clearly and concisely, just as I would expect from a book published by OReilly.

Highly recommended.

On Page 250 of this book, the author indicates: An IP address is somthing like 123.456.789.012.
My god! this guy must be kidding us, does he ever uses an IP before?

This is definitely the best tutorial out there for intermediate level programmers with a C++ or Java background. (I don't think VB Programmers will have an easy time of it.) Liberty is careful and very clear. One really can't complain about the lack of applictations given that it isn't a mega book like Troelsen or Professional C#. Still, he gives excellent introductions to ADO .NET and ASP .NET so you do have a sense of what you can do with C#. Highly recommended!

If you want to learn C# painlessly, read this book. After reading the Beta version of this book, I not only could write C# programs, but understood the .Net framework better. Although it is packed with solid information on the C# language and the .Net framework, Jesse's writing style is so easy-going, it wasn't difficult for my brain to absorb. Jesse explains all aspects of the C# language clearly and precisely, and give lots of good real world examples that can be used for future reference. Once you finish this book, you will have a solid foundation for your .Net future.

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.

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.

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 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.

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 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.

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.

This is simply an excellent book, and probably the best overall C# book on the market today. Jesse has a very comfortable style of presenting the salient points of C# in theory and practice. This has to be read, and thereafter referenced, by any programmer working with C# (including the 2005 Beta versions), or planning to do so. Furthermore, source code and other info is available on Jesse's website.

I really enjoyed this book. I think its a great intro to C# and a generally good reference for it.

The only negatives are that some of the examples simply aren't real-world. That's a minor thing, and I wouldn't let it deter me from buying the next edition of the book.

I also wish there were more whole apps in the book. Writing everything to the console gets boring. Again, this isn't a big deal and doesn't detract from the overall usefulness of the book.

If you are a serious C# developer or want to become one, I think you should give this one a good read and keep it close at hand as a reference.

It just doesn't get any better than this. The writing is first class, the examples are on point. The author teaches the fundamentals first, and then goes on to explore how to use the language to create .NET applications. He then teaches you advanced topics that are not covered in other books.

This book is great for Java and C++ and VB6 programmers because the author provides additional specific notes indicating similarities and differences to these languages. I have a friend who had no prior programming experience, and she found this book to be an excellent introduction to programming. As an experienced C++ programmer, however, I found plenty of substance and I thoroughly enjoyed this book.

In addition to excellent writing and useful examples, the author supports the book on his web site and on his own discussion forum, and he has written follow on books both on web development and on Windows development.

I've read a number of books on C#, and this is by far the best written and the most comprehensive without being overwhelming.

When you finish this book, go get his book on Programming ASP.NET!

In the past 18 months, I've looked at a number of the Introductory C# texts and this is the best one that I've found.

It has a clear discussion of events and delegates, something no other book handled well. It also has some good notes for people switching from Java or C++ to C#.

All in all a good book. To this day it remains my primary C# reference.

This book is really only a cursory guide to C#. It doesn't cover any advanced C# programming at all. But the book doens't cover basic language fundamentals very well.

My rating may be harsh, but if the book doesn't cover the simple stuff well, but also isn't advanced enough for real programmers, what use is this book?

I wouldn't buy this book. It doesn't cover C# in nearly enough depth. Coverage of ASP.NET and ADO.NET is almost non-existent, and even the core C# language isn't fully coved: there's no coverage of date and time handling, and other critical language fundamentals are missing.

The Sybex book "Mastering Visual C# .NET Programming" is much better.

This one tries to cover too much with too little and fails -surprise surprise. It tries to teach you C#, .NET fundamentals,
ASP.NET, ADO.NET, and Win Forms, then fails to properly elucidate any of them. Several of the chapters suffer from very uneven flow and/or lack of cohesion. All of the good programming books I've read use at least a three step approach: explanation of concept, then one or more examples that use the concept, then explanation of the examples. A number of the chapters in this obfuscated creation either deviate completely from that proven formula by skipping a step, or the explanations, examples, and concepts are so remotely disjointed that the process of learning becomes unnecessarily painful. The whole thing is badly designed and badly thought out. Covering so many different.NET topics in one book was a bad idea to begin with anyway, and this book proves it.

I really have to question whether the reviewers who gave this 5 stars ever read past the first few chapters!

BTW, I also have Mr. Liberty's ASP.NET book, and he has done a much better job there than in this one.

What a great book. Well written, straight forward, good examples. I always turn to O'Reilly for the best books, and this one is no exception. If you want to learn C# and you know anything about programming in any lanugage, especially if you already know C++ or Java or VB, then this is the book.

If you want to see an example of why not to buy this book, see the "complete" code listing of example 13-3, which ends (abruptly!) on page 331. "Abruptly" means the end of the code segment is not shown! Sure, you can go to the publisher's web page to get the "real" complete code segment, but why should you? There are many examples of this in Liberty's book. A number of the examples, when followed to the letter, do not work. A number of other examples don't tell the whole story, and so you are left guessing about something or other. One gets the impression that this book was done in a real hurry, with little or no editorial oversight. I don't have a recommendation for a good alternative to this book, but I am definitely looking!

With most books the reader must wait until finishing it before forming a final opinion, and this is especially true with technical material. However, even though I have completed only about 1/4 of the book I can clearly and confidently state that my search for a great C# book was successful.

Liberty presents a level of explanation and detail for the language features and syntax that exactly fits the needs of C++ and/or JAVA programmers -- no elementary fluff or filler, no wasted words, and a comprehensive list of topics.

That alone would probably make this book worth the purchase price, but it's only the beginning. After learning the programming language itself in the first half of the book, the reader is then immediately shown how to use C# within the .NET framework. The basic .NET architecture is also discussed, along with the Framework Class Library. This is exactly the way I learned how to program C++ in Visual Studio 6 (the predecessor the Visual Studio .NET) -- FIRST learn the language and then IMMEDIATELY learn about the IDE, along with MFC classes, etc.

I will say, however, that if you're not already a C++ or JAVA programmer you might want to purchase another text to learn the syntax. But you should still buy this book because of its later chapters on using C# to build .NET applications (and because it would make a fine, compact C# reference text after you've grown more comfortable with the language).

This book tries to cover way too much stuff in 500 pages. I think it would have been better as solely a C# syntax book (comparible to Thinking in Java). Instead it attempts to cover syntax, applied programming in the framework(web and windows forms), ADO.NET and other CLR topics. The first section is C# syntax and is ok ... could be more detailed. The sections on web/windows forms, and ado.net are overview at bests and are useless.

Liberty writes clearly and precisely. As you might expect from an O'Reilly book, Programming C# goes beyond the language to provide complete coverage of building applications and using the Framework Class Library. This book is the single best resource I've found for learning C#.

I was particularly impressed by the level of support offered on Liberty's web site. He has a FAQ, the complete source code, and most important a link to a discussion center where you can ask questions that arise from reading the book. I found him to be very responsive to questions and eager to improve his book

I was also impressed by the coverage of such advanced topics as remoting, threading, attributes and reflecton and so forth. His ocverage was extensive, knowledgable and accurate.

I'm looking forward to reading his new book, Programming ASP.NET as well

I've been working through this book for the last week or so. After spending the last two years learning C++, COM, MFC and all things related to Windows and Microsoft Visual C++, I was leery when I started to hear the rumblings of .NET and C#. It became clear, however, that Microsoft's portion of the industry was indeed undergoing a tectonic shift. I began looking for a good tutorial and overview of the .NET framework and C#. For me, Jesse's TY C++ in 21 Days was such a good introduction to C++ that I was confident his new book would be a good investment. I am not disappointed. This book covers a lot of ground. For anyone who has programmed in another object-oriented language, this book will hit right at home. There is not much in the way of spoon feeding. The discussions and examples are short, but very insightful to the topics at hand. They're perfect for someone making the transition; probably a bit terse for a beginner. I must also commend Jesse's support for his book. His web sites for the errata and reader support for this book are helpful. He was prompt in replying to my posts. I'm finding the C# language to be very elegant and the .NET Framework to be far more convenient and object-oriented than MFC. He has succeeded in converting me to a C# enthusiast! I too will probably never look back!

Every topic is clearly and simply explained in the minimum number of words - no waffle. This is the best book I've seen for getting started in C#. In fact it's the best technical book I have ever read. Some people have requested more depth - that would make it too heavyweight for people starting out in C#.

I have a VB and Java background, and I found this book to be extremely helpful in learning C#. Some of the topics are quite complicated even having an object oriented background didn't help me understand them the first time I read them. But, everything made sense when I took the time to read the section again...

This is NOT a beginner's book to object oriented programming, however. The code samples are great, but I'm glad I had previous OOP experience to help me understand them more quickly.

My only gripe with the book is that for all the sample code, the author adopts the coding convention of declaring the private class variables AFTER and class methods. I was reading the first few examples wondering "Is that a class variable or a type?"

Anyway, highly recommend the book. Well worth it!

Jesse Liberty has done a very good job with this book. His writing style is simple and to the point, his examples are clear and thorougly explained. The book provides enough coverage for both begining and advanced developers. I like how the book is divided into 3 parts (the C# language, programming with C#, and C# and the CLR) so that you don't have to go through all of it but rather focus on the areas that are of interest to you. I usually prefer Wrox books over O'Reilly when it comes to covering MS technologies but I think that in this case the O'Reilly offering is much better than Wrox's "Professional C# programming"

I have bought several C# and .NET books in the last months. All the publishers feel like they HAVE to have a book on the subject, but they forget that a book is about content. You pay $40 (if you are lucky) and you get these sloppy attempts at teaching you the new "paradigm", the new "revolution". That is, at least, what happened to me UNTIL I found this book: I really hope this one becomes the Camel book for C#, because it deserves it. Clear, concise, a pleasure to read. You can use the examples, but also - as with other O'Reilly books - you can read them in the subway. Thanks Jesse, please write more and soon, before our companies fill our shelves with useless thick tomes full of nonsense. Yes, I am talking specifically about those thick red books with the photographs of the authors on the cover that read more like a transcription of an spiritism session with 15 guys involved than a carefully organized and structured technical book.

I bought this and the Wrox book "Professional C#", hoping to fill in the gaps in the O'Reilly book. The bottom line is this book is very clear, concise and accurate, in keeping with most O'Reilly books. (On the other hand, I would avoid the Wrox book as it contains too many errors and is inconsistant).

Highly reccomended for intermediate and beyond C/C++/Java developers.

I am on chapter 14 and I cannot state enough how well this book is written. Jesse writes in a manner that just simply makes sense. I have tried to read 2-3 other C# books and cannot get past the fisrt 2-3 chapters w/out putting them down. I come from VB/COM+. I have a lot to learn regarding true oop and his book is helping me get there. I work with some very seasoned OOP programmers who also cannot state enough how good this book is. Nice job Jesse!

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+++++++++

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 abou