4 comments about Microsoft Visual C# 2005 Unleashed.

1. Hoffman's book is not so much about teaching the basics of C#. But more about the support infrastructure that Microsoft has built about it. What it terms the .NET Framework. To be sure, some early chapters discuss what is inherently in C#, like the syntax of conditional statements or of string manipulation. The former is essentially what you could have read in a Fortran text of the late 60s. The if-else is so fundamental that all major subsequent languages have copied its syntax. The string functions match those in Java. Ditto for the sections on collection classes.
   
   But the bulk of the book goes deeply into .NET. Higher value-added functionality for C# coders. Easy read and write of XML files. Part of Microsoft's big push into standardising on XML for a lot of data interchanging. Nowadays, reading and writing of XML should be considered a default ability of a current language. C#'s features here just match those of Java, for example.
   
   More importantly, the .NET Framework also includes abilities that are intrinsically specific to Microsoft. Like being able to use COM objects within a C# program. There is certainly no equivalent default ability in the standard Java distributions.
   
   Another worthy case involves tying C# to Microsoft's SQL Server, with such things as stronger means of doing database transactions. Or hooking C# to a web server with ASP.NET. For this, the newest feature seems to be Web Parts, which let the programmer easily mix shared data and data specific to that user viewing the web page.
   
   All of these play to Microsoft's strengths in comprehensive integration of its products.



2. I use this book at work to write C# 2.0 Windows Applications with SQL Server 2005. I felt that it was a good book and overall I have little ill to say about it. The examples are well written and do a good job of reinforcing what you read in the chapter. You read a little then do an example, then read some more, then add to the example and so on. You don't need any Programming experience to use this book just a decent understanding of programming logic. The only criticism I could offer is that the author should have left out the hefty ASP.NET content that he probably barrowed from his co-worker Stephen Walther "Author of ASP.NET Unleashed" and reinforced his windows applications with universal examples of complex code. It's a good book for learning C# 2.0 Windows Applications as a whole from the ground up and for this reason it's worth the money. It's not an overnight crash course (if that is what you are looking for).



3. The author was very brief on many subjects and points the reader too many times to read about subjects elsewhere instead of supplying the information needed.
   
   Regular Expressions are neglected (a very short chapter exists, but really insufficient, in my opinion): "For more information on regular expressions ... These books will give you the information you need ..." Oh, well I guess I bought this book for nothing then ...
   
   Member Visibility Levels are demonstrated by a table and aren't demonstrated nearly enough.
   
   I'm really dissapointed about purchasing this book ...
   If one of you guys who reads this review is about to buy it, save the money and simply ask me for my copy ...
   
   Kobi.



4. Well.. It is worth to read it once, but it is not my favorite book.
   Some chapters confuse even more then MSDN docs...

3 comments about Practical .NET2 and C#2 Second Edition: Harness the Platform, the Language, the Framework.

1. This books covers a lot of territory, but does it efficiently and in an easy an easy to read and follow style. This is NOT another one of those C# books that regurgitates the Microsoft documentation. This is the C# book I would have written except that Patrick got around to it and I didn't. Useful for beginners and experienced C# programers.
   
   Contents:
   Introduction to .NET
   Assembly, module, IL Lnaguage
   Build, Deploy and CInfigure your .NET applications
   The CLR (Common Language Runtime)
   Processes, threads and synchronization
   Security
   Reflection, late binding, attributes
   Interoperability between .NET and native code/COM/COM+
   Fundamental conepts of the language
   The .NET type system from a C#2 point of view
   Classes and Objects
   Inheritance, polymorphism, and abstraction
   Unsafe Code, exceptions, anonymous methods, iterators
   Collections
   Base Classes
   Input/Output Streams
   Windows Form Application
   ADO.NET 2
   Transactions
   XML
   .NET Remoting
   ASP.NET 2
   Intorductions to web services development with .NET



2. Even if you've sort of moved more into C# 3.0 and ASP.NET 3.5, GET THIS BOOK. That's all I have to say. Again, another code Bible to add to your best collection of books to have on hand at all times.



3. I have first edition of the book for about a year and half. Only start to read it recently when I am trying to get some foundation concepts of LINQ in C# 3, such as delegates, anonymous methods, iterator etc. I have only read small portion of chatper 14 of this book and I am completely blown away. In only about 30 pages, the book explained the intricacy of anonymous methods, iterator and delayed execution, which are very difficult topics to explain. Then I flipped through the other parts of the book, and I realize that this is the book I will come to again and again. Patrick explains difficult concepts clear and thorough with to-the-point code samples, and he expands on the concepts with concrete real-world implications. Also I like his sharing some of the reference URL with rest of us. A must-have. Now this book sits side by side with Juval Lowy's Programming .NET Components on my desk. Even if you are moving to .NET 3.5 and C# 3, get this book and read later part of chapter 14, it will make all those LINQ magic more understandable and accessible.

5 comments about C# Class Design Handbook: Coding Effective Classes.

1. Excellent book if you are looking for a reference on coding C# classes. Explains all aspects of class containers very well but only one chapter is devoted to class design concepts. A little more depth into this subject could have been better.



2. Let me start by saying that I found this book to be fantastic. I would recommend this book to any intermediate programmer that's feeling a little stuck in where to go next.
   The book starts off with the basics, the same way that most C# programming books do. It starts with the difference between value types and reference types, but what I found as I read into the first chapter was that this book went way beyond any other that I have read. It has simple examples to differentiate between the two types but then has you view the IL for the examples and starts to explain why value types and reference types are handled differently. That was just the beginning.
   The Class Design Handbook takes you through short, easy to understand examples that enforce the goal of the book but then as in the first chapter it goes on to explain why things are done a certain way, why a good design my incorporate or avoid something and what is actually happening behind the scenes.
   The other aspect of the book that I've found to be exceptionally useful is chapter 6. Events and Delegates; this book contains the first concise explanation of the .NET event handling model that I've seen. It takes you through the code that .NET creates to represent a delegate class and through IL shows you what is really happening.
   This book sits on my desk at work and when I know I'll be writing C# at home, it travels with me.
   Simple explanations, easy to understand code examples and straight-forward text make this an excellent reference book, although I read it cover to cover (geek). I use this book especially during the design phase of any project and recommend that anyone that feels like they need a little boost in the learning department will enjoy this book.



3. This book is intended for the intermediate C# developers who want better understanding of OOP (Inheritence and Polymorphism). The book wastes very little text and gets to the point. This book is clearly not intended for the beginners. The book covers the following:
   
   1)Defining Types
   2)Type Members
   3)Methods
   4)Properties and Operators
   5)Constructors and the Object LifeCycle
   6)Events and Delgates
   7)Inheritance and Polymorphism
   8)Meta data
   
   The book doesn't contain any sample problems or questions. If it did, then I would have given this book 5 stars. I consider sample problems (and answers) crucial in truly understanding a computer language.



4. The book gets to the point and covers the details of the CLR and how classes are represented. The MSIL representations are very enlightening providing good insight into how the class will perform. The example source code from the website is helpful and offers a good place to experiment.
   
   I bought this in 2004 and the cover is worn and faded the pages are dogeared and from time to time I see other programmers digging through it. If anything would be a reference to the books value it would be the amount of wear it has compared to my other books.



5. This book is a great example of the quality literature one expects from Apress. It delves into topics covered in most books on C#, but with an eye strictly toward class design and functionality. The authors have done a great job and the book reads as if it was written by one voice instead of five. A must read for all beginners.

4 comments about C# 2005 Programmer's Reference (Programmer to Programmer).

1. I can't believe the authors actually published this meaningless stack of paper in the guise of a computer manual! Obviously they didn't take the time to review some of the other excellent Wrox offerings to see what a real "Programmer's Reference" should be. Many of their stellar definitions such as this one for Interface Declarations are quite amusing, "Interface declarations are type declarations that declare new interface types", as are the cryptic syntax descriptions that follow, "interface-modifiers: interface-modifier interface-modifiers interface modifier", followed by a list of modifiers with no context (read examples) whatsoever. This is not just an isolated example, the book is rife with them. I was under the impression that a Programmer's Reference book would contain lots of code examples, but the authors seem to be of a different opinion.
   
   I buy many computer-related books and will say this is the worst ever. I am now packaging this book for return to Amazon and am hoping as I write this that I don't get a speeding ticket on my way to the post office.



2. I read a lot of computer books every year and I have to say this has to be one of the worst ones I have seen. I bought this book online (without first checking it out at a local bookstore) and that was a mistake as a quick perusing would have warned me how thin on content this book really is. For instance the chapter on delegates is 4.5 pages long but with all the extra white space and margins reduced it could easily fit on one printed page (the authors state the delegates are just too complicated a topic to be addressed fully in this book). Examples are trivial or non-existent and much of the text is just useless. I cannot believe this book would be any more useful for the beginner than it would be for the experienced programmer. This book reminds me of the worthless reference guides that compiler companies use to include with their products. As a side note, the smirk on the female author's face just seems to be saying to me "I can't believe you were stupid enough to buy the book". Luckily, since I bought this book online, I will be able to return it for a refund.



3. This book had huge potential from my point of view. For the cost I was expecting something akin to the other WROX titles "Visual Basic 2005, Programmer's Reference" and "Visual Basic 2005 Database Programming". The book starts out fine, covers the basics and then leaves the reader high and dry as far as a reference. The companion VB book has 1000+ pages, this book doesn't even make it to 400 pages (60 pages of which is a lexical grammar).



4. 'C# 2005 Programmer's Reference' is one of the worst programming books I have ever had the misfortune to read. I swear the authors just wanted an opportunity to get a cutesy photo of themselves together and published, proudly displaying their hyphenated last names. Horribly written with much less content that should be within a book with such a broad-reaching title, this book is for the most BASIC of C# programmer. If the title of this book had been "Intro to C# Programming" or "Basic C# Programming" I would have been much kinder with my review and slapping a 3 star rating on it, but this book does NOT have that title so I cannot be kind.
   
   Folks if you want to learn C# programming this is NOT the book for you with so many others on the market today. Bad content, misleading title, and terrible all around, this is one of the worst books that Wrox has ever put out. I think highly of most of the books that Wrox puts out, but this is at the bottom of the barrel.
   
   Awful Awful Awful
   
   * NOT RECOMMENDED

5 comments about OOP with Microsoft Visual Basic .NET and Microsoft Visual C#(TM) .NET Step by Step (Step By Step (Microsoft)).

1. The author has perfect understanding of the subject and able to present each topic in a masterly fashion. But there is a terrible flaw in the book. It is the examples chosen for the step-by-step implementation. Most of the chapters have their unique samples getting implemented, and there is no continuity between chapter to chapter examples. Secondly, the examples are not mainstream. For example, Chapter 7 handles Events and Delegates. She has chosen a train running on a track and the track catching fire as the example. To implement this the reader has to draw the tracks on the form and has to learn the Graphics class. Events and Delegates by themselves are very complicated. Why should one complicate the topic further by introducing another difficult topic such as Graphics. Because of this "Events and Delegates" discussion is lost and burried under the Graphics discussion. If the author used a Banking or College registration example, every one understands the business process and could concentrate just on the topic at hand, namely Events and Delegates. Unless you want to get distracted by such examples in each chapter, don't buy this book



2. This book is great for beginners. But this is certainly not for newbie and would be great plus for programmer who knew VB and fundamental of .Net and willing to learn vb.net oops concepts. Examples are chosen well and explain in detail and elaborate. Once you complete the tutorials, you will also get some proficiency in C# too.
   
   Overall a good book to kick start your OOP using VB.net and C#.



3. Well the book isn't bad at all, the code samples aren't explained enought, some OOP basics are there but I would recommend other readings. For sure this isn't a book for beginners, you must have some background in OOP programming to get it. Mainly the Interface chapters, very confusing.



4. Hmm, a bit thin for a book that lists code for two languages. And often, the author forgets her own advice to "put the reader ahead of being clever". Also, the naming convention she uses will confuse people at times. But then again, if you know what you're doing - and you should be at that level when you start this book - you will find the content outstanding and very useful. Overall, I'd say that this one's great to get into OOP.



5. I'm 53 years old and have been programming for 40 years. I picked up Robin's book about 2 years ago. Prior to that my most recent experience was with VBA and Access Basic. 15 years before that I had done some mainframe work in PL/I, SAS and older Basics. I had never done any OOP and my UI was limited to VBA.
   
   This book is an excellent tutorial. You can go through it, chapter by chapter. Don't use the CD -- type in the examples and then alter them little by little and you will learn how this stuff works. I think that if had started with a larger book I would have spent too much time wandering about, and would not have gained a solid foundation.
   
   I hope Robin decides to write a 2005 version.

5 comments about Game Engine Toolset Development.

1. I bought this book thinking it would help me write a new tool for, say, building 3d models, or some other general tool. When it arrived I got excited just by the shear size of it, it's huge!
   
   However, I started flipping through it browsing each and every chapter (didn't read them all in detail of course, but quite a few) and it doesn't teach you how to make a NEW tool for your game, it teaches you how to make an EXISTING tool better. While that knowledge is extremely valuable (and the reason I gave it 4 stars instead of 3), it's not what the description of the book stated: "Readers are not required to have any experience developing game engine tools." If you have no experience developing a tool, you're going to have a little trouble getting started. If you know enough math and have good enough coding skills to get a game engine going, you'll be able to write a tool for your game, but you don't need this book to do it.
   
   Now, with that said, this book IS quite good and worth your money so long as you don't expect to read this book and then write a tool, you're going to need more info. Get the book anyway and use it as a guide, it's usefull in that aspect.
   
   This book is so good at making a tool better, most of it's "gems" can and should be applied to ANY application, game tool or not. Also, it covers some good highlevel (or lowlevel, depending on how you view it) .Net functionality such as interfacing with COM and code documentation, as well as few other excellent techniques. These "gems" are quite valuable on their own.
   
   So, in conclusion, if you know nothing about writing a tool, or you don't know C#, hold off on buying this book (make sure to put it in your wish list however). If you have a tool but find it's difficult to work with, or you want to broaden it's appeal, or just simply make it better, get this book, you won't regret it.



2. I just received my copy of Game Engine Toolset Development and I have been unable to put the book down. The author gives a good introduction to .NET 2.0 and relates it to toolset development for games. The chapters are easy to read and follow and he gives good advice on how to build good tools. He could have looked at other toolsets to make the book more complete, but I see this book as a way to introduce students to game programming who have a basic programming background (Java, C++, C, Alice 2.0, etc.).



3. Then, as a hobbyist, I'll just let you know that this book not only teaches, but flat you gives you some great modular code that you can work into many different types of tools.
   
   There's also some great design principles covered that have improved my workflow, even though i'm currently working solo.



4. This is an excellent book, which covers a lot of important aspects of game/engine tool development, but it is more like a recipe book, as each chapter subject is almost stands on its own - just like game programming gems series. My favorite is how to integrate native code into a managed application. The book is well written (one of the best I've read recently), and the only thing i missed is a few chapters on how-to integrate into an existing pipeline - like importer/exporter for a common 3d package at least. A better title for this book would be "(game)tool programming gems"



5. I admit that at first I was thinking this book would focus more on the game engine part of the toolset development in its title. I knew it wasn't REALLY about developing a game engine but even so, make sure you understand what you're getting.
   
   That said, I really liked this book. I'm halfway through it already (it's a very quick read given how discrete each chapter is and the clear and easy to read print and examples).
   
   I've read a number of game development books and you rarely get everything done right. This book gets close. The author describes the particular problem the chapter seeks to solve (e.g. encryption, batch processing, etc.) and goes through the steps of solving it.
   
   The book is similar to those programming gems types of books that aren't organized in some linear fashion but are discrete chapters on specific topics that can be picked and chosen as you see fit.
   
   The author does a very good job of putting the examples together and many of the chapters have been useful to me (I plan on implementing a number of the tools/frameworks he mentions).
   
   If you're working on a game engine, I really suggest trying this book out. This assumes you're not already an expert game programmer who already built a lot of these sorts of tools before.
   
   If you're looking for something that will help you build a full-fledged game engine, look for another book...then come back to this and get it to help you flesh out your toolset.

5 comments about C# Design Patterns: A Tutorial.

1. I'm what I would call an advanced C# developer, but have always felt I could use some education in accepted design patterns. I thought this book would be a great start. Boy was I wrong! I second every complaint I've read in these user reviews.
   
   That said, I'd like to add one more to the list: Often there was nothing in the text to explain how exactly the example code exemplified the pattern being discussed! This was maddening to me--you get some bad code, then an unnecessary line-by-line description of how the bad code works, but you're no closer to understanding the proper application of the design pattern.



2. Basically a horrible book for the same reasons listed by all the other 1 star ratings. I bought it on a whim whilst browsing in a bookstore - wished I'd read a review or few first.
   
   To echo my major issues with it:
   - The book is 363 pages long, the first 96 being a tutorial on C# and OO, so its effectively only 259 pages on design patterns.
   - The tutorial pupports to teach you both C# and OO general principles in 96 pages (and some UML as well)? Seriously now...
   - The whole book is full of typographical errors, particularly in the code with regards to erroneous spaces (or lack of) - there are inconsistencies everywhere, as well as misspelled words etc. etc.
   - Poor and erroneous commenting e.g.: //create a new Arraylist
   - Examples are very contrived and often far from real world scenarios. I realise examples have to be somewhat contrived for print publishing, but this goes way too far...
   - As others have mentioned, the code seems more like Java than C# a lot of the time.
   
   Given the above, I haven't even bothered to load the CD.
   
   Consequently the only bits of the book that are actually valuable are the bits transcribed and summarised from other people books, most obviously the classic "Design Patterns" be Gamma et. al. Given this you're much better off just referring to the original source material. (Ironically both of these books are published by Addison-Wesley)



3. I am reading the original "Design Patterns" book by Gamma, Helm, Johnson, and Vlissides in conjunction with this book. The original "Design Patterns" book clearly set the standard, yet was written before C# was in "production". I suspect that James felt that there would be an audience of developers that would benefit from a refresher in C# and to present C# design philosophy before applying it to design patterns in C#. That's what the first 100 pages are.
   
   The following content of the books pretty much mimics the catalog of design patterns in the original "Design Patterns" book looking at it from a C# prospective. The code examples that I've run are somewhat sloppy, but fine. By sloppy I mean the code appears to have been ported from a Java code-base and not written using Visual Studio. The important thing is that, in my opinion, James does a fine job translating the original material into a form that C# programmer can benefit from.
   
   On a final note, James used a tool called WithClass from MicroGold [...] to draw the UML diagrams in the book (UML 1.x). Included on the CD ROM is a trial version (although there is a more recent version on MicroGold's website now). The CD ROM includes the UML diagram and code. The book is becoming dated, as is the original "Design Patterns" book but is still useful to apply the concepts to C#.



4. While reading this book, I found myself wondering what took me so long to get this book. It's not difficult to read, and each of its 22 design patterns is both applicatable for different goals I needed, and easy to implement in my code.
   I recommand this book to anyone starting to program C# applications, and/or Buisness logic classes.
   
   It blew my mind, and Improved my C-Sharp skills a lot.
   I hope it does the same for you !



5. I bought the book in high hopes and good faith for a well researched and easy to read text. I was mistaken.
   
   I didn't mind the first 7 chapters being a sort of 'programming overview' and introduction to the concepts used in the book - what I did mind was that it was poorly expressed, often missed key points and was sloppy and felt rushed. For example, in Chapter 4 some of the code (in the 4th edition of the text mind you), went something like this:
   
   if (index > length of array) {
   return array[index]
   } else {
   return special value
   }
   
   I am sure I am the only one to see the problem with that.
   Then in chapter 7 (I think), they have this gem:
   
   pos = string.trim().indexOf(" ");
   if (pos > 0) {
   left = string.substring(0, pos).trim();
   ....
   }
   
   Ok, so most of the time this is going to work, but if the string begins with some whitespace? *sigh*
   
   Then when they finally got to the patterns, it still felt rushed, the descriptions were little more than an introduction to the code (as stated already questionable) that implemented the pattern - not much to give you that 'aha' moment they talked about in the introduction, and from what I understand they didn't even explain the Singleton pattern correctly....
   
   It was at this point that I returned the book and bought the original "Design Patterns: Elements of Reusable Object-Oriented Software" - at least I know they know what they are talking about, and so far it has been much better (and cheaper), so now I can relax and actually learn something.
   
   In this book's defence I didn't actually open the CD and try to run the code to see if they had fixed the bugs as written in the text - but if a programming book can't even match discussed code with runnable code, then it's pretty poorly written/maintained in my opinion.
   
   Nuf said.

No comments about Learning C# 2008.

No comments about C# 3.0 Unleashed: With the .NET Framework 3.5 (Unleashed).

5 comments about C#: The Complete Reference (Osborne Complete Reference Series).

1. This is an excellent -- repeat excellent -- book on C#. That's not surprising since its written by legendary author Herbert Schildt. (Just about anyone who has been arround programming for the past 20 years probably has two or more Schildt books!) It provides an incredibly detailed description of the C# language and the .NET Framework libraries. Schildt carefully describes each feature, keyword, and attribute of C#, and shows how to apply them. He even shows how C# compares to and differs from Java and C++. This is clearly a book from an author who knows his stuff.



2. I have been programming since I was 15 (3 years now) but up until this book it had been QBasic and Visual Basic. C# was my first delve into the world of a real programming language.

   Having studies Software Design and Development at high school (7th in the state in the HSC w00t...) I knew quite a lot about the theory behind Object Oriented Programming: Encapsulation, Inheritance and Polymorphism and could describe in psuedocode a complete program but lacked any knowledge of a programming language in which I could implement my ideas and algorithms that were floating around.

   So I wanted a book that didnt harp on about the principles of OOP but was about reserved words, syntax and supporting classes. I found the ideal book in C# the Complete Reference. The overview of OOP priciples was brief and to the point, allowing the book to concentrate on the practical implementation (for readers who have no idea about OOP possibly C# the Beginners Guide would be preferable as a slower paced read). I flew through this book in a week and a half and felt that a blistering pace was kept up by Herb Schildt, at no time did I feel that the book was overdoing examples, with new concepts and syntax appearing all the time.

   The examples in this book are excellent - I hand coded them all and every one compiles first time(unlike some other books I read that involve a bit of debugging). The examples are straight to the point, not only introducing the new idea but consolidating previously learnt work into the example.

   The coverage of all topics was supurb, especially the book's treatment of classes, inheritance, operator overloading and exception handling. If I had any criticism it is that the sections on Attributes and Delegates were a bit brief, and could have done with some more explanation and examples, and the chapter on working with Collections (chapter 22) was a bit disjointed, introducing all the interfaces that are inherited and methods used by the various collections before actually telling you what these collections were - I advise reading this chapter in reverse.

   Not only the language was convered (as I have seen in some other books) but some of the common classes included in the .NET framework are discussed. The System Namespace is explored - going into detail about System.Math and all the data types (like System.Int) and the many methods supported by them.
   There is a valuable section on strings and formatting, going into great depth about the string as an object and the methods it supports. The System.Threading and System.Web namespaces are also discussed in depth (including code to build a webcrawler). However, as Herb Schildt acknowledges there are many other classes not examined here, but gives a good introduction nonetheless.

   The book concludes with three practicle examples of C# - implementing Components, creating a basic Windows form and most interestingly a recursive descent expression parser.

   I recommend this book to anyone who wants to learn C#, and learn it fast. However I also recommend readers of this book have some previous programming experience (my Visual Basic experience was usefull for understanding some concepts) or an understanding of programming theory. This book isnt for someone who has never coded before, but beginners with only a month or so of programming in another language behind them will find this book easy to read.

   This book has inspired me to purchase Java 2 The Complete Reference and C++ the Complete Reference by Herb Schildt, as he is the best author I have read (and since reading this I have read several other programming books, mainly on C# - and none have come close to Herb yet).

   So what are you waiting for! Buy it now!

   Deon Poncini




3. There exists many types of books on most programming languages. Reference Guides, How To's, Beginners Books, Advanced Books, and those that tie into specifics like Science and Engineering, Video Games or perhaps Databases. Herbert Schildt usually writes How To and Reference Guides. He's an acknowledged master in the world of object-oriented programming (OOP) and a frequent author because of his down to earth communication style. An earlier book "C++ From the Ground Up" is a legend in itself. It was one of the few books you could learn C++ from without ever having learned the C language.

   This book suffers a little from the beginners syndrome. While its intention is to start from the beginning, unfortunately, that usually means, something will be left out. Unless you want to read 3000 pages, most books have trouble covering the scope of a well-developed computer language. As other reviewers have said, this does lack some things that should be included about C#. That said, it's written in Schildts trademark literary style. Like most of his works seems to speak directly to you rather than talk above or around the reader.

   I do understand that Schildt has another book on C# coming soon if its not our already and that may pick up the detail this book has missed. One of the nice things about this like most of Schildt's books is that it is not written like a dissertation. Too many programming books start out sounding very good and then after 50-60 pages the author "treats" us to 200 pages of annotated code. I've never been able to learn much about reading code. It's better at least for me to learn what the language can do and write my own code. Small examples are ok to get the syntax right, but reading a large program looses my attention.

   If you were unsure, you'd like Schildt's style check out the first chapter or two from "C++ From the Ground Up" at the local bookstore (they may have this one too). Then come back here and buy at a discount.




4. Herb Schildt is my favorite programming book author. I like this explanations and his method of evolving the subject he is teaching. The C# complete reference, 2002 has several errors that have perplexed me for hours causing me visit the osborne.com web site.
   
   At the site, I found no listing for this book, but Schildts' other great books are listed.
   It appears Osborne has given up on this book! Why don't they list the book and why do they not have an erratum on this book?
   
   Schildt is a great author but Osborne is not a good publisher! If you can, wait for his new C# book.



5. This book covers every aspect of the language with easy to understand and follow examples. The code samples would help the reader to understand every nut and bolt of the language and will get you up to the speed in a relatively short period of time. I am making my living with this book and would recommend it to every c# programmer.