Compras Nikon Bluetooth |
Be aware that it is not for the programming beginner, in my opinion. This book is perfect for seasoned C/C++/Java programmers or those who are fairly comfortable with C#.
If you're just starting out learning C# and the .NET Framework, I would definitely recommend buying this book and reading it AFTER you have read a more basic book on learning C# programming.
But one thing is for sure --> This book NEEDS to be in your .NET library!
The book is not clear and sometimes confused in describing C#. I myself got confused a couple of times. Here are a couple of examples, in page 195, "IComparer and IComparable ..." section, where does "IComparable" comparable come from? I had to look up from MSDN to find out it from System.IComparable. Another example, is "string" a built-in C# type or just a keyword mapping to the .NET class? Third example is why "using System.Text;" is used in code examples 10-2 and 10-3.
Does ADO.Net only provide disconnected classes but not connected classes? That is an idea the book give me. The book does not mention anything about the connected classes. I assume that some of developers would still use the connected classes. I also purchased "ADO.NET in a nutshell" by B. Himilton and M. MacDonald. They are pretty good in giving me better ideas of what are ADO.NET and and some points of how it would be used in the real world.
The way that he includes information about ADO.net and ASP.net is great as it allows me. To see where I could go with this language, and some of the things I can do.
His use of code is the way it should be. Small snipets that refer to exactly what he is talking about. I have caught some mistakes but as I said I am a PROGRAMMER, so I caught them quickly. Besides they are small and would have been caught by the compiler anyways.
The size is exactly what it needs to be. C# is a rather large language so there are quite a few things to be covered. As well as that Mr. Liberty adds small sections to allow for review of important concepts eg OO.
The final section is rather advanced and I personall skipped it. But I have a feeling that I will come to a point when I will have to go back and review it.
The ratio of obvious errors to good tips is about 1:1 for the first three chapters and I assume this holds true for the rest of the book. I don't know if these errors were introduced in the 3rd edition or if they are carry-overs from previous editions, but the number of errors is just unacceptable.
If the errors and typos are corrected, this book would rate at least 4 stars.
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.
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.
I don't having anything particularly negative to say about the book. The code samples are brief and use sparingly. There aren't many screenshots, and I prefer it that way. The text is well written and concise. And the author sticks to the central themes of each section without delving into the minutiae.
This book is O'Reilly at it's best, well written and edited, built specifically with the engineer in mind, and taking the time to develop and refine a work that helps the reader as opposed to inflating the author.
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.
The organization of the book deserves praise. Part I covers the language fundamentals. I personally read all of part I, as well as chapter 13 on Windows forms and am now ready to program. I can also understand most of the MSDN documentation. I plan to read the remaining chapters on an as-needed basis. Thus, Programming C# will serve as a reference book of sorts.
My only criticism is that the examples in Part I, while they clearly demonstrate language features and object oriented programming, only print messages to the console. Only in chapter 13 was a fully functional application given in an example.
Still, I highly recommend this book to anyone with prior programming experience.
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.
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.
That said, although I had to reread a couple of the pages, I think this is probably the best book for both non-OO and OO programmers to pick up, who want to start learning C# and .NET application development. After reading this book, I believe the .NET SDK documentation would be sufficient to fill in all the gaps. Adequete code samples of both correct and some incorrect programming methods are provided along with detailed explanations and how certain aspects of C# differ from VB6 and Java. The language of the book is technical, but quite understandable. As I said previously, I've dabbled with Java and C/C++ before - but after reading this book I finally have a proper understanding of the fundamentals of object oriented programming.
So for all those programmers who have been thinking about .NET for the last few years but just haven't gotten around to learning it, this book is probably the best place to start. Note that I said "programmers"; I would not recommend this book to people who have not learnt another language yet. C# is complicated, like all object oriented languages. For non-programmers I strongly recommend that you learn a linear type language - for example ASP or PHP, before taking on something like C#.NET.
I give "Programming C#, Third edition" by Jesse Liberty 5 out of 5 as both a learning and a reference book.
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!
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.
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.
About half the book is devoted to C# and there is a good treatment of the language along with tips for C++ and VB programmers making the switch. The second half of the book consists of an overview of the major parts of .NET, including ASP.NET, Winforms, web services, the CLR, remoting, etc...
I'd recommend this book as a good initial overview of C# and the .NET technologies to anyone coming from the Win32 platform SDK and C++ world. Very readable with concise code examples.
What you ought to expect is topics presented as linearly as possible, simple examples with details chosen for relevance, and references or new concepts to be briefly introduced. Unfortunately, the book lacks what you might call good serialization.
In places, you don't know where it's going until you get there. Concepts appear out of nowhere, and sometimes never get explained in useful terms (when two good sentences would do). Examples sometimes have tons of irrelevant detail or complexity, and the author can switch gears or put examples through long incremental transformations without helping you out along the way (e.g. assuming you know what's coming, or that you'll remember whether example X.Y, way back when, was the server or client, and before or after the first set of changes, etc). Chapter 19 on marshalling and remoting was actually painful (I just read it again after reading better write ups).
The content seems to be there. It just needs a really nit picky technical copyeditor, to offload the painful work from readers. I think this book takes about 50% too long to read as it stands, and is not yet up to highest O'Reilly standards. You'll learn the stuff, but you'll struggle a bit unnecessarily to do so.
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.
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.
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.
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.
In addition, this book goes beyond teaching the language and teaches how to use C# to build various kinds of .NET applications. Finally, in the last section, Liberty teaches advanced concepts in C# programming that you won't find in many other books.
I loved this book.
Liberty starts slow, with a complete disucssion of the syntax of the language and the meaning of object oriented programming and how it is implemented in C#.
The second part provides a quick but surprisingly complete introduction to building Web and Windows applications with C# and even introduces ADO.NET
The third part tackles advanced topics such as attributes and reflection, threadion, etc.
His writing is clear, his examples are on point and useful and he provides additional support on his web site. I highly recommend this book, both for people new to .NET and especially for C++ and Java programmers making the transition to .NET.
If you are totally new to programming, check out his Learning C#, but for everyone else, this is THE book to have.
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.
You have been warned.
All I can say is that this is the mother of all books. I like the way its written. But its a bit of hard at the beginning. I would have liked a soft start. But anyway, a goodbook.
This book is divided into four parts (three in the book and then one on his web site).
Part I is a solid, comprehensive, well written tutorial in the language. He covers it all, but he does so in a way that is clear and understandable. Advanced concepts like delegates are explained carefully and illustrated with meaningful examples.
Part II is a brief introduciton to programming with C#. He covers ASP.NET (which he covers in more detail in his ASP book), Windows Forms (is there a book on this coming?) ADO.NET and Web Services. The latter two are introduced here but expanded on in his ASP.NET book.
Part III goes beyond the language to show how C# is used with the .NET Framework, and this part alone is worth the cost of the book.
C++ and Java programmers will find part I easy going, C and VB programmers will work harder. Part II is just an overview, and part III is simply terrific.
The final part is the extensive support Liberty provides on his web site. Not only does he offer a FAQ and errata, but he has a link to a discussion group where he answers questions about the book!
Finally, the writing is excellent, the examples terrific and the overall quality of this book superb. O'Reilly continues to produce excellent books and this is no exception.
I highly recommend this book, unless you have no prior programming experience at all, in which case you might prefer to start with his other book, Learning C#.
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?
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.
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#.
The Sybex book "Mastering Visual C# .NET Programming" is much better.
For instance, on page 162 Mr. Liberty writes: "myIntArray = new int[5]" and then states: "This declaration sets aside memory for an array holding five integers." The array really holds six integers. On page 223 Mr. Liberty states that "In Unicode (as in ASCII), a lowercase letter has a smaller value than an uppercase letter." Actually, in ASCII, "A" is decimal 65, and "a" is decimal 97.
There are other problems like these, so, if something doesn't work quite right, don't take Mr. Liberty's text as gospel. Try some alternatives. It's surprising to see an O'Reilly book with errors like these.
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.
Some reviewers complain that this isn't 'in-depth' enough. Well, C# is a new language for a new platform. Should one expect a writer to understand and examine the nuances, tips/tricks, etc. that typically characterize an 'in-depth' analysis? Not in my opinion. Instead, Jesse Liberty tells you what you need to know to be productive right away, in a clear, lucid style.
Other reviews have pointed out that the author provides extensive support through his web site, I will only say that the level of support is unmatched. In addition, the third section provides an excellent introduction to some of the more advanced and interesting aspects of .NeT programming.
If you are a C++ or Java programmer, this is clearly the book for you. If you have no previous OO experience, however, begin with Liberty's other book, Learning C#.
I was very impressed with this book, and recommend it highly.
I would recommend this book to those new to C#. I came from mainly a Java/C background and I found this book useful to pick up the syntaxes. It is not meant for giving the more extreme dotNET programming tips.
I am not sure if this book is suitable to beginners in programming.
Please let me know if you have any questions or suggestions.
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.
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.
I can't believe O'Reilly put out such a book, especially since C# is a very important topic.
It is a pity I cannot give 6 stars (out of 5).
No other tutorial I've read offers nearly as much coverage of the most important aspects, not only of C# as a language, but of building meaningful applications with C#.
The coverage of ASP.NET, WebForms and ADO.NET is, of course, superficial; Liberty's goal is just to familiarize you with these topics. He has a full book on ASP.NET for example, and with any luck he'll have books on WebForms and ADO.NET too one day.
The coverage of the CLR is first rate. He covers advanced topics here, such as reflection and threading, but his focus is on the most important things you might like to do (opening streams, creating asynchronous applications, dealing with remoting, and so forth).
The book is very well written, and he supports the book on his web site with source code, a FAQ, a full errata and so forth.
I highly recommend this book.
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.
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.
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.
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.
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
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.
While the first part of the book taught me the language, this book went much further, and taught me how to apply the language to creating real applicatoins. I'm very impressed by how mcuh is covered in this book. Perhaps the most important contribution, however, is that the author not only shows you all the techniques, but shows you when and why you use these techniques. All of the skills are taught in terms of creating real applications.
The support provided for this book is unusual: the author offers source code and a support discussion group on his web site. He participates in the news groups and generally remains available to help.
I'm very impressed with this book: if I were going to buy only one C# book, this would be it.
I recommend this strongly to anyone starting out on the platform. Everyone at our office agrees with this review. We cannot keep track of our 3 copies. It would be nice to have a reference copy on CD or the web.
While the first part teaches the language in great detail, and is filled with useful examples, the second and third parts go on to show you how to use C# in building .NET applications. This is where the book really shines.
I'm very impressed with the writing skill but also with the clarity and relevence of the examples.
Really, this is one of the best technical books I've ever read, and I recommend it very highly.
The author writes well, and the material is very well organized. The first part of the book explains the language in clear, concise terms. There is good coverage of advanced material, and excellent examples to illustrate the ideas.
The second part of the book teaches you how to apply the language to developing applications: windows, web and web services. The examples here are more complex, but they nicely illustrate how programs are built.
The third part is more advanced, explaining the .net frameworks in some detail. I found this part of the book particularly useful.
The author also provides the source code on his web site. He also offers an errata and a news group of his own for discussing his books.
I was very impressed with this book. O'Reilly has done it again.
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.
I started with Sharp & Jagger's MS Visual C# .Net from MS Press, but was quickly bored. Too simple. Flaccid writing. No depth.
Then I picked up Liberty's Programming C# and Programming in ASP.NET, along with Thai & Lam's .Net Framework Essentials. I have a new entry to the Tech Book Pantheon (Fowler, Eckel, Flanagan, et. al.): Jesse Liberty.
While I'm not yet convinced that C# and .Net are going to replace Java and J2EE (or even compete strongly), I was more enchanted by the lucidity of Liberty's examples and the seamless flow of exercise to exercise, building up understanding in layers, than I was by Microsoft's technology.
Bravo.
Programming in C# and Programming in ASP.NET have set a standard for new technology exposition.
[One caveat: these may not be beginner's books, as you will defnitely need to be comfortable with OO concepts/syntax, SQL/SQL Server, HTML/XML, and general Windows de-spaghettifying issues. FYI - Jesse Liberty did do a tremendous service for developers by including all examples in C# AND VB.]
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.
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).
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).
"A power so great, it can only be used for Good or Evil!"
-- Firesign Theatre, "The Giant Rat of Summatra"
What the world *really* needs is a good Automatic Bicycle Sharpener.
