5 comments about C# for Dummies (With CD-ROM).

1. C# For Dummies claims to take novice programmers into the world of C#. That's probably a stretch--if you haven't programmed before, I suspect you would have a tough time keeping up. But as an experienced VB programmer moving to C#, I have found it quite helpful. Easy, breezy read, with a focus on the language itself (rather than .Net framework classes or Visual Studio). Most programs are console apps, although the book walks the reader through creation of a Windows app. Only negatives: Code on CD doesn't always match up with cook listings (as at p. 261). Also, like most Dummies books, it's a bit light on learning exercises for the reader. I'm using the book as a general introduction to the language, before I dig into more detailed texts.



2. This book is a MUST for absolute beginners. It contains more code examples than any of the other ten C# books combined (I own the O'Reilly and Wrox books also). Furthermore, the Visual Studio IDE bonus chapter (on the CD in pdf format) is worth the price of the book itself. The principle strengths of this book are the disciplined coding techniques modeled by the author, the excellent inline documentation techniques modeled by the author and how this book is strictly focused on C# basics (not ASP.NET, Web Services, ADO.NET, etc.). Get this book if you want to learn C# well in a very short time.



3. Although the "Dummies" title implies a "Beginner" book, this book falls into the "Beginner to Intermediate Developer" range. This is a good book for Visual Basic developers who want to make the conversion to C# or for the beginner. Like all Dummies series, there are ample examples and the author does a great job of explaining the C# language. Windows forms are covered in Chapter 17 and 18 but there is no discussion about Web development or using C# with Active Server Pages (ASP).

   Starting in Chapter 6 (Collecting Data - The Class and the Array) there are several really annoying errors, for example, on page 105 the author uses "for (int i = 0; i < 11; i++)" to iterate thru a 10 element array. In the section below this (Array bounds checking), the author uses exactly the same code and says this will fail. The first code should be "for (int i = 0; i < 10; i++)". These errors are scattered through out the book. Still this is a good book and I would highly recommend it.




4. I bought "C# for Dummies" for myself and "C# and Game Programming" for my son.



5. I revisited this book after about a year, and took the time to really read the first 100 pages. In particular, the author's introduction to OOP via C# classes as data structures first, and as more complex objects containing data and methods second, helped me really understand this concept --- maybe for the first time.

   His example programs are very clever and deceptively simple at first glance. I think the most valuable aspect to his perspective is he obviously has a talent for teaching the "old school" imperative coders, that need hand holding with the new object paradigm. (Like me)

   I really liked Randy's other book on C++, although the "C++ for Dummies" moniker is a riot.

   There aren't any dummies doing C++, of that you can rest assured!

5 comments about C# COM+ Programming (With CD-ROM).

1. Excellent book for a person that needs to understand how C# and COM+ work together. Well written.



2. COM+ is equivalent with Java's EJB. I was utterly disappointed to find the book littered with misspellings. There is no depth to its topic coverage. The book's table of contents is misleading. Save your heard earned money and wait for something near the quality displayed by Oreilly's Enterprise JavaBeans.



3. This book is poorly organized and lacks focus. The topics' coverage is shallow. Even with the lightweight content, it should be titled or described as "How to Transition COM+ programming with VB to C#".



4. I honestly don't like writing bad reviews but I feel compelled to save people money when I can. Unless you are looking for a manager's overview of COM+ programming don't buy this book. Coverage of COM+ itself is very light. The author appears to assume that the reader has picked that up someplace else... probably by writing COM+ components in VB 6. There are no in-depth discussions of the technology or even best practices. The jist of this book is that now you use attributes to COM+ enable your code written in C#. The coverage of what attributes are available to you and within those attributes what options are supported and what they mean is likewise incomplete and lacking in depth. However, where I really lost respect for this book was when I looked in the registry to see what was going on from a COM perspective for the classes that I had built based on the code fragments in the text. What a mess. Stale registry entries for previous builds of my components were everywhere. It took me an hour to get the mess cleaned up and several more to piece together what was going on and realize that there are a lot of COM specific attributes never mentioned in this book that you need to known about in order to build a COM+ component _correctly_ using C#. And as I have discovered that is the crux of the situation. To do COM+ using C# you need to be _very_ familiar with COM-CLR interop. Basically you need _much_ more information than this book provides.

   In summary I believe that reading this book will serve only to make one `dangerous' not proficient in COM+ development using C#.




5. If you're looking to get a solid background and understanding on the subject matter, this book does a very good job of covering the bases (not just the basics). What's better is that it comes in a size (# of pages) that one can actually hope to digest. Well done.

5 comments about Data-Centric .NET Programming with C#.

1. I was a technical reviewer on this title and find it to be one of the books I keep going back to. It has a good spectrum of coverage and is really for those applying C# and .Net to a real world situation. It is not going to teach you syntax for C# but will show you how to use the .Net framework for Data intensive apps using technologies such as XML, Active Directory, How to migrate existing apps over to .Net to mention a few topics.



2. As the title implies a large portion of the book deals with data access. However, the book also covers a wide range of other topics of interest to budding C# developers (e.g. messaging/directory/web services). The code in the book is as usefull to VB.net developers as it is to C# developers (assuming you can translate C# into VB.Net). Highly recommended.



3. Data-Centric .NET Programming with C#.

   This book is about using .NET technologies to work with data, since data can reside in different forms at different places, this book focuses on :

   1. Databases.
   2. XML / XSL.
   3. Directory Services.
   4. Messaging Services.
   5. Files.
   6. Legacy Systems.

   Spends 4 chapters on "Databases", 2 on "XML/XSL", 1 on "Directory Services", 1 on "Messaging Services" and 1 on "Files/Registry". Rest of the book contains a chapter on "Web Services" and 3 very useful case studies.

   Now just in case if you are an ASP.NET developer and are wondering if there is something in it for me, the answer is "yes and no". I said "yes" because you'll learn how to work with different forms of data and I said "no" because you won't learn anything specifically related to ASP.NET in it. All the code examples that are given only marginally touch ASP.NET ( and that also mainly "Web Services" ), they mostly make use of GUI clients and programs to do all the processing. This is one important thing you should keep in mind, if you haven't developed any GUI client applications ( like me ), there is going to be lot of new stuff for you. Now this is not something bad, as after reading this I not only learned how to work with data but also "how to build GUI clients using C#". Having said that if you know a bit of ASP.NET, you can change the applications from GUI front-ends to ASP.NET pages with little effort.

   The topics that this book covers are pretty huge and would take separate books to be discussed thoroughly. But I think that the Wrox team has done an excellent job by covering them in a single book.

   The chapters on ADO.NET cover topics like `what is ADO?', `how does ADO compare to ADO.NET?', `OleDb and SqlClient Namespaces', `DataSet, DataReader and DataAdapter classes', `Connected and Disconnected Data', `ADO.NET and XML', `Using Visual Studio to build Windows Forms', `Displaying, Editing, Inserting and Deleting Data', `Connection Pooling', `Integration with COM+', `Object Pooling', `Distributed Transaction Processing' and `Serviced Components in .NET'.

   The chapters on XML/XSL cover topics like `Using MSXML', `System.XML Namespace', `Reading and Writing XML files', `Creating Windows Forms to Display and Edit XML Data', `Validating XML', `XML and ADO.NET', `Schemas', `XPath and XSLT' and `Navigating and Transforming XML'.

   The chapter on Directory Services includes topics like `What is Directory Service?', `What can Directory Services be used for?', `System.DirectoryServices Namespace', `Accessing Directory Services', `Windows Client Application', `Accessing the Active Directory', `Using ADSI', `Searching', `Publishing Services', `Deleting the Service', `Registering the Service' and `Searching the Service'.

   The chapter on Messaging Services includes topics like `What are Messaging Services?', `Where to use Messaging Services?', `Message Queuing Features', `Message Queuing Architecture', `Message Queuing Administrative Tools', `Programming Message Queuing', `System.Messaging Namespace', `Creating Message Queues Programmatically', `Finding a Queue', `Sending Messages to Queues', `Receiving Messages from Queues', `Transactional Queues', `Queued Components' and `COM+ Services'.

   The chapter on Files, Serialization and Registry Operations contains topics like `System.IO Namespace', `Reading and Writing data to files', `Synchronous and Asynchronous Data Access', `Cryptography', `Isolated Storage', `Object Serialization', `XML Serialization' and `Registry'.

   All in all this is a very good book and I give this book 4/5 points and recommend it to any developer seriously interested in .NET C# programming.




4. I'd like to say that the code examples are the best part about the book. Also, it seems that the introduction started out very well, providing a great overview of ADO.NET. Yes, and XML, web forms, windows forms, web services/SOAP, and other useful sounding technologies are covered.

   The book's documentation of the code, however, was very disappointing. It seems as though someone wrote the code, and someone else did their best to document the code. And did a poor job at that. There were too many generalized one liners for very important snippets of code. And the documenter seems to ramble from generalized explaination to explaination. It also, seems as though the vs.net environment was heavily de-emphasized to the point of doing busy work. For example, at one point the book discusses typing a data bound XML schema into a schema document without describing the XML hierarchy that uses complex and choice elements.(You wonder, "is this required every time I want to render a database in vs.net using XML?"). Just to find out by hunting around in the vs.net GUI that you can drag and drop the database table directly from server explorer to the schema and have the XML identically rendered--taking less than a minute to do so(realizing at the same time that vs.net creates the XML schema that way so it can work with the data effectively).

   If you want to learn ADO.NET in a concrete and complete fashion, you're better off starting with Microsoft Q article Q313590 that will point you to even more informative ADO.NET Q articles... (WROX, please learn something from the clarity and brevity and completeness of these Q articles) Otherwise you may be tempted to scower this book to search through its pages hunting for clues that it simply does not contain--wasting precious time for catching up on new technologies.

   My hat's off, though, to whoever really wrote the code examples. There's definitely plenty to learn from there from both a C# and ADO.NET perspective. However, you're better off simply downloading the code from the Wrox site for free and stepping through it in a vs.net project. They really did a reasonable job packaging the code for ready utilization.

   I did give the book two stars. That's because I paid 60 dollars for it. Please add a star for each additional 12 dollars taken off the book. At 24 dollars, this book would be five stars. It does contain valuable code samples and good introductory information. Unfortunately, I'm having to put the book aside because learning is faster, more efficient, and easier to memorize with Microsoft's Q articles and vs.net's help documentation. Sorry WROX, I love to love your stuff, but your programmers need to add writing to their already wonderful skillset. You could try catching this, though, in author review...before the book is published.




5. The book seems to be written by a bunch of programmer who wrote some explanation around some of their already existing code.

   Problem is that the book is so poorly indexed, that even though it covers examples in many subjects, unless you are willing to thumb through the entire book each time you need to look something up ... you won't find it.

   Examples include: parameterized queries, combo boxes and even tool tips. Items such as these are covered, but not indexed, making the book almost useless as a reference guide. The book seems to cover a few high level subjects, without discussing much of the necessary foundation ground work of C#/Microsoft programming.

3 comments about C# Weekend Crash Course (With CD-ROM).

1. A one star rating is an overstatement of the value of this book. I believe the 15 hours is the time the author spent learning the language.

   It is not of value to beginning or experienced programmers. It does not serve well as either a review or an introduction. The examples are poorly chosen, (banking account), poorly explained. The other examples are lacking in clarity.

   Even when something that one knows well from other languages, such as the difference between ++i and i++ is mentioned - it is a mention without an example in a loop or a clear explanation.

   Look elsewhere to get started in C++. 15 hours would be too long to spend with this book. This was my first look at a "Crash Course"...... it looks like a train wreck.




2. Stephen Davis, C# Weekend Crash Course (Hungry Minds Press, 2002)

   A while back on one of the mailing lists to which I am subscribed, a chap popped up asking about books that cover programming console applications (you know, those things that when you run them, pop up in a command line box instead of running within Windows) in depth. My first reaction was "who on earth would want such a thing?" I still don't really know the answer to that, but if he's reading this, I recommend this book highly to him. Davis' whole book is devoted to console apps and DLLs.

   And therein lies its major fault. In a programming world where, let's face it, the GUI has won the day (be it Windows, Xwindows, BeOS, Apple, what have you), a book that doesn't even mention the existence of programming graphical forms is painfully outdated, no matter how recently it was released. (The other C# book I'm reading right now was published the year previously, before Microsoft had even finished the C# visual form designer, and still manages to devote a chapter to Windows forms in C#!) The omission is unforgivable in a book on program design in the twenty-first century, even more so when the books covers Microsoft's .NET technology.

   As for the program design itself, there's a decent amount to be learned here if you're trying to pick up C# after knowing another programming language. (As a longtime C++ programmer, I have no idea how total newbies will react; proceed at your own risk.) A few of the sections try to cram far too much into one thirty-minute session, especially towards the end (the Collections session is almost unreadable without a concordance of some sort; thankfully, I happened to be at the same portion of A Programmer's Guide to C# at the time, and it helped me figure things out without too much pain).

   Probably worthwhile as an adjunct, but I can't see it being a primary reference guide for any serious programmer. ** ½




3. If all you need is to learn C# *syntax* in a hurry this is a good book. That's all the book deals with, and therefore, it only has console (DOS-based) programs.
   
   The syntax it goes over is the basic stuff: data types, while/for loops, if statements, arrays. And creating classes, base classes, methods, and it introduces how C# implements inheritance and polymorphism.
   
   It does not teach anything out of the .NET Framework classes for Windows (forms, ASP.NET, ADO.NET, etc.). It is purely C# base code syntax.
   
   Starting at around Session 13, the book's editor started running out of gas. There was the occasional syntax error, grammar error, poorly worded explanation, or mis-matched examples.
   
   The examples are mediocre. The tone of the book simply presents a working program and picks it apart. It doesn't invite the reader to build the program him/herself, but to simply copy it out of the book or load it from the CD. The "Quiz" section at the end of each lesson usually asks really dumb questions like, "What is the most common of all looping constructs (see 'the for loop')?" There are rarely any exercises to actually write any programs that apply what was to be learned.

5 comments about Visual C# .NET: A Guide for VB6 Developers.

1. This book provides an excellent introduction to C# and .NET for Visual Basic 6 developers. Having programmed in VC++ rather than VB for the past few years, I still rate the book highly for anyone interested in getting a grounding in .NET...

   Chapter 14 provides a fitting conclusion to the book by showing us how to deploy our applications. You may be able to deploy your application with a simple XCOPY, but Visual Studio.NET provides powerful tools to create a Setup program. The authors provide a through disscussion of the Setup tools, and remind us that we must insure that the .NET runtime is installed on the target computer. ---Reviewed by Jack D.




2. An adequate introductory on C# for Visual Basic Programmers who are new to C# and the .NET framework, it is organized around several practical applications. The book frequently comparies features between VB6 and C# which make the transition easier.

   Started with a brief introduction of the .NET framework, C# language features and Visual Studio NET common tools, the book leads you directly into building a Windows applications - the SuperMind and the SweepCSharp games. It's fun to be able to code functional games early on.

   Through the BookReview Manager project, the book effectively introduces the use of some common Windows Forms controls (such as TreeView control, ComboBox , Context Menu, DateTimePicker), existing ActiveX controls (e.g. Web Browser, MAPI controls), the creation of custom controls and data-binding at design time.

   For VB programmers who write mainly 2-tier Client-Server applications which consist of forms that collect user data and also connect to SQL Server databases, the book will guide them into designing 3-tier applications through the KnnwledgeBase project, in which database access via ADO.NET is well covered.

   The book sticks to its hands-on approach to the end by creating a setup program for the SweepCSharp game.

   The book does not cover debugging tools and debugging related windows which I think are very important in .NET development.

   Due to it's introductory nature, the book leaves out some advanced topics such graphics, multi-threading, object serialization, reflection. ---Reviewed by Timothy D.




3. I am very pleased with this book. It answers all the necessary questions I have about C# and the .NET framework.

   From OOP issues, to integrating C# with VB6 and visa-versa, plus a whole lot more.

   It also builds on your learning by having great example games to develop as you build on your knowledge and work through the book.

   I recommend it to any VB6 programmers wanting to migrate to C#.NET.

   I am even more impressed because after contacting Wrox support and even one of the authors directly, they responding to my questions in less than an hour (via email); and was happy to give more information about .NET in general rather than just answering questions about their book - very helpful. Thank you guys.

   Although there is a bug in one of their example games and some text refers to code we have not written yet, the book still does a good job of teaching you C#.




4. Newbies to C# will very much appreciate the first 5 chapters, as they cover both C# essentials plus a very nice review of OOP. Some other reviewer jokingly compared this book to the writing of Immanual Kant. If he was referring to this first section, I heartily agree.
   However, prospective buyers should read the scathing treatment of another reviewer here of the subsequent chapters on GUI/Windows application programming. These middle chapters really fall short, with missing or misleading steps in writing the test application, what to do if one does not have the MSMAPI ocx component loaded on his computer (necessary for completing one of the chapters). Twice I could not finish the chapter.
   The first 5 chapters deserve 6 stars. Now I have to find another book on C# to help me through the rough patches in this one.



5. If you come from a background of com+, interface implementation, n-tier and so on, and want to get into c# then this is the book for you. It assumes a general level of OO knowledge but goes over it again as a refresher. It covers both web and win(cli/svr) forms,ado.net and more. The book gave me the confidence to keep going with it, and I often use it as a quick reference to some of the concepts. e.g. I used to do X in vb6, I can't quite remember how to do it in C#. I have other .net books but this is the one I use the most. (other books: wrox prof. vb.net; sams asp.net unleashed;ms.net(developmentor) essential asp.net with c# examples)

5 comments about Microsoft ASP.NET Programming with Microsoft Visual C# .NET Version 2003 Step By Step (Step By Step (Microsoft)).

1. I started this book with a background in both VB and classic ASP, with the goal of upgrading my knowledge to ASP.NET. I'll state that I think this book is just bad.
   
   It seems that half the book presupposes that you have extensive knowledge of classic ASP, and the other half assumes that you've never used any sort of scripting language before. The examples are horribly simplistic to the point that they have absolutely no relation to modern web applications. But, you won't understand large parts of the book unless you have a background in programming.
   
   The first two parts (six chapters) could actually be somewhat useful to a true beginner. They start slow and build up some very basic skills.
   
   Part 2 is a little different. Chapter 7 on web forms is fairly decent, but could use to be longer. Chapter 8 on server controls is just poorly written. Chapter 9 on accessing date is AWFUL. It presupposes you have a fairly good background in traditional database access with something like ADO, so it's definitely not for beginners. For instance it compares the DataReader object to a read-only forward-only cursor, but if you don't have a background in data access you aren't going to understand how cursors work. This is right next to where he explains that the password key "Specifies the password to use to log into the SQL Server database." Yeah, DUH. Also, a bulk of the chapter is devoted to working with XML data but the chapter sets out to work with databases. For a 68 page chapter it conveys surprisingly little actual new information. No time is given to explaining how databases have traditionally been accessed and used in actual working applications. I just wanted to scream as I read it.
   
   Chapter 10 on creating custom server controls and chapter 11 on creating web services are very brief introductions to some fairly advanced and complicated topics. They provide simplistic examples and then expect you might be able to actually use the knowledge you gained in the chapters. Yeah right.
   
   Chapter 13 is aimed at beginners on deploying ASP.NET applications. Chapter 14 on tracing and debugging is actually not bad. (Not good either.)
   
   Also the book is based on using Visual Studio .NET. I'll state that I have a bias against using IDEs for simple scripting, so I won't comment on appropriateness here. But be forewarned that three-quarters or more of the examples involve VS.NET.



2. I expect that this book will help me learn ASP.NET thru VB.NET. I am very frustrated, it didn't really help me to easily understand the simple thought of ASP.NET thru VB.NET. For beginners like me, I will not suggest this book. Much better to browse the web.



3. As an ASP developer who has not used Visual Studio, I found the first chapters of this book very insightful. The author does a good job explaining ASP.NET and its differences with ASP coding.
   
   But if there's one thing that I can't stand in a programming book, it's a lack of proofreading of the code given in the book and poor programming practices displayed. This book, unfortunately, has a lot of that.
   
   An example (from page 216):
   
   Label6.Text = "Final Balance: $" + CalcBalance(Convert.ToInt32(TextBox1.Text),
   Convert.ToInt32(TextBox2.Text) / 100,
   Convert.ToInt32(TextBox3.Text),
   Convert.ToInt16(DropDownList1.SelectedItem.Value)).ToString();
   
   private string CalculateBalance(int Principal, double Rate, int Years, int Period)
   {
   double result;
   double NumToBeRaised = (1 + Rate + Period);
   result = Principal * System.Math.Pow(NumToBeRaised, (Years * Period));
   return(result.ToString("C"));
   }
   
   This is to be a Compound Interest Calculator.
   
   If you enter this code, as given in the book, it won't run. There are several errors:
   
   Error 1) In the calling procedure, it's CalcBalance. In the function, it's CalculateBalance.
   Error 2) If you fix that oversight and run it, your result is the same as the given Principal. Why? Because the function calls for a double Rate variable, and yet the calling routine converts the Rate to an int variable. If you change "Convert.ToInt32(TextBox2.Text) / 100" to "Convert.ToDouble(TextBox2.Text) / 100", the result is correct - sort of...
   Error 3) The result will be displayed as "$$67,537.12" instead of "$67,537.12". The reason for the double-$ is that the function converts the result to a currency string, but then the calling procedure adds an extra "$".
   
   Fixing these three errors will solve the problems, but obviously no one tried this code before the book was published.
   
   And a couple of picky points just because I'm so irritated with something so glaring as these errors.
   
   Error 4) Since the function returns as a string, why then convert the result to a string in the calling procedure?? It's unnecessary.
   Error 5) The code uses default naming of objects instead of taking 1 minute to give some meaningful names, like txtPrincipal instead of TextBox1.
   
   Two stars for having no thought to the simplest details.



4. This is the least useful book I have ever bought. It doesn't have anything useful and didn't answer me any questions I had. No wonder it was so cheap. I spent $9.95 for the book from Amozon, but I feel like I was robbed. I can give it to you for free if you ask for, but I would be guilty if I do, becuase it would waste your valuable time. Look at other's review and I was not the only victim, don't buy this one, it is 100% garbage.



5. It's really frustrating to try to learn from a programming book where the author's code doesn't work! None of the examples I tried would actually compile without my having to "fix" his code. In most cases that worked out ok, but in some cases I never really knew if my "fix" was a legitimate way to solve the problem or if it might cause problems later. Not a good way to learn!

3 comments about CodeNotes for C#.

1. This book was reccomended to me by my Senior colleagues and I felt very thankful to them when I started reading this book. It is really a good book if you want to start C#. Very good reading and the authour presents his ideas very straight forward.

   I like the extra pointers that you can explore it in their website if you are interested more about some particular areas.

   After a long time I really enjoyed reading this technical book. My thanks to the authour and the publisher in bringing out such a good book in a very low price.

   Regards
   Mani Subramanian




2. I bought this book to help update my VB/ASP skills to their .NET counterparts. It is layed out in a very smooth and informative manner that walks you through difficult topics with relative ease. My biggest issue is not with the authors portrayal of the subject matter as the obvious lack of editting in the code samples and the companion website.

   In the first 6 code blocks, 3 of them contain errors that prevent the blocks from compiling. An experienced programmer can debug these issues fairly simply, but a novice programmer would likely become very frustrated.

   My second issue is with the companion website. The book relegates many topics to it's website (http://www.codenotes.com/). While this serves to keep the book concise and on-topic, many of the topics are either mislabeled or missing from the website entirely. This was the source of much frustration.

   My final complaint is with the MS ebook format of this book. It cannot be used in a Remote Desktop or Terminal Services connection. You are also prevented from copy/pasting the code blocks, this means each example must be typed out manually even though the electronic format is right in front of you. That is painful at times.

   All said, on the merits of the authors ability to walk the reader through the subject matter, I'd recommend this book.




3. I purchased the book because I decided I wanted to learn C#. I liked it because it doesn't dally around much. It is written in a very straightforward style. The code samples are very direct and don't contain extra fluff just to fill out the book (like too many computer books today). I liked the order in which the concepts were presented, with a few exceptions where they brought up a concept way before it was "officially" introduced.

   This book is not for the novice programmer, it does not hold your hand. It does a fair job of not making too many assumptions about what kind of language you already use, however I don't believe that a programmer who has only ever used Visual Basic will be able to go through this book quickly. For example, the book has some sections on Object Oriented Programming (OOP) but most of their samples show bad OOP practices (probably intentionally to keep the samples simple and direct). This will almost certainly set a VB-only developer off on the wrong foot.

   While I previously applauded the authors for keeping the samples simple, I still fault them for showing bad programming practice when they could have easily shown good practices (for example, catching unnamed or general exceptions rather than specific ones). They clearly don't want to get into the "political" arguments surrounding some issues (such as the use of "goto") and I feel their pain, but they could have been more thoughtful to provide samples that encourage better programming than just the minimal sample that shows the feature. I have not yet seen any of the online samples so these may be better (more about that below).

   I would have given the book 5 stars except that it is missing some very important topics: Threads, methods with variable argument lists, most of the Collection classes, memory usage and limitations, distribution (or installation) issues of C# applications and assemblies, assembly versioning (it covers it somewhat but not how to control it), and the IO model (it assumes you get the concept of streams). Instead of covering these topics it often "punted" and sent me to www.codenotes.com to look up a sample, article, etc. The big problem with this is two-fold: One is that I tend to read the book in restaurants, in the park, in my hammock, etc. pretty much anywhere except for sitting in front a computer. Two, I have yet to find the code notes site active when I have gone in search of one of the notes (the web server on that site has been unresponsive the whole time I spent writing this review). This is not just a problem with this book, but with any book that assumes the code notes site will be highly available.

   The book also has numerous errors, mainly in the sample code (errors that keep many of these from even compiling, let alone functioning as defined). Many of these errors are obvious cut-paste type errors. The publisher of the book allowed code samples to be broken up between non-facing pages (on facing pages that's not so bad, but when you have to flip the page back and forth to try to figure out a sample that is only 5 lines long it seems pretty silly). I found very few errors in the actual text of the book, however, so there were only a few times (maybe five) that I had to re-read the text to figure out why the sample code didn't match up with the description. Note that I am an expert in both C++ and Java so these mistakes may cause more learning problems for others (for example a programmer who is only expert in VB and has no OOP experience).

   Bottom line: If you are expert at C++ and/or Java you will get a lot out of this book. If you are an expert at VB but have studied some Object Oriented language you will also be able to get good use from this book (but it will be slower work). If your only language is VB then you might want to look for a book that doesn't make so many assumptions about your knowledge level. In fact I would suggest picking up a book on Object Oriented Design and Programming first, in C# if you can find one, in Java if not, and that will give you a big boost to prepare you for C# (you can use any Object Oriented Design book, but Java is the closest language in which you are likely to find an existing book).

5 comments about C# Web Development for ASP.NET (Visual QuickStart Guide).

1. It is amazing how short the shelf life for some of these software titles is. There are a couple of new freebies from Microsoft that makes learning C# & ASP.net web development a whole lot simpler.
   
   1. Visual Web Developer 2005 Express Edition:
   This is a free download from Microsoft. So your choices are no longer limited to either buying the full blown commercial version or use notepad as editor and compile on the command line (as the author describes early in his book).
   
   2. IIS is no longer essential:
   ASP.net development server is included in the express edition download. With this server, you will no longer need to install IIS. So you can do development even on XP home edition. While you will not be able to use this as a deployment solution, it nevertheless works for developing and testing web pages on a local machine (or for learning as is the case).
   
   Note: The menu paths and some of the options mentioned in this book are not for the express edition. So if you do decide to go with the express edition, you may want to skip this book. Otherwise some sections of this book might be confusing.



2. I have read this book when I was first starting out and it helped me tremendously. This is a great book with good examples by a very good author.



3. The Good: I like the format of this book; lots of pictures and lots of very short sections to work through.
   
   The Bad: The problem I noticed is that it doesn't present a very technical look at C# like an Apress or Wrox book would do. But that's ok, I guess, since the Visual Quickstarts are made to get a beginner up and running quickly. The other part I found interesting is taht the book covered advanced subjects, such as Delegates, Events, Inheritance and Interfaces, without first taking a deep look at the UI components. For a beginner I think things would make much more sense when learned from UI down.
   
   The book is definitely geared towards beginners, but I would have a hard time recommending it to my beginner friends due to the short amount of coverage given to building ASP.NET UIs.



4. The book is ok for code snippets. But, if you try to develop and run the project for each chapter you will become frustrated. The complete code is not in the text and even the download code is also incomplete. I agree with the other reviewers who said the author went from topic to topic without explaining anything.



5. A very good book with plenty of explanations and examples. I am now working with C# with confidence as opposed to the fearful
   approach I took prior to reading it.

No comments about Fundamentals of N-Tier Architecture.

5 comments about Beginning C# XML: Essential XML Skills for C# Programmers.

1. ALOT examples are missing in this book OR don't work, but this book is defineltly NOT good enough to get you started.

   The merits of the book is a good intro to new technology when working with .net but what is the good if the code don't work
   as in this book

   there is missing code in chapter1 adding a recordset to xmlfile
   chapter3 code in p118 and 119 don't work
   Chapter 8 discusses xslt isn a very poor manner, in addition to all the missing xslt files and the non working application
   in the download section.

   At this point I cannot continue reviewing this book, there are
   too many fundamental flaws in code and I don't know where to begin

   As usual I have resorted to wrox support and again there is no comment to no surprise.

   As a veteran of xml and xslt for the last 4 yrs, if you want
   a book with alot of questions and NO answers this is the book for you.

   until the code is this book is revised by the authors or WROX
   this book is a death sentence to ALL who want to know about xml
   and xslt in the .net world

   The validity of the review is only good if the programmer
   actually tries to run the code and not just say it that
   it works.

   Lets see if wiley can get these missing examples up and running for us




2. I really enjoyed this book and didn't find ANY problems with the code as the reviewer below stated - maybe he was doing something wrong.

   Wrox support wasn't very good but i didn't need it much.

   Some examples are complex, but then some of the topics are pretty complex and it does a good job of explaining them - will help if you have a larger pure XML reference book too!!




3. This is not an easy book to read. The first 3 chapters are very heavy going with little in the way of productive examples. I was looking for a book that gave me the basics of XML with C#. I was not looking for a book that spent the first 3 chapters covering the basics of XML on its own.

   Having said that, I think the authors do a fairly good job of covering the material that they are attempting to do. This is definitely an introduction to XML, though, and there are a lot of unanswered detail questions that you will obviously need to research in other books.

   There are several mistakes in the quoted code, and the fact that the WROX site is no longer available makes this a tough book to work through. Fortunately my C# is good enough to spot most of the syntactical errors, but I pity someone who is new to C# too.

   In a nutshell, this book is okay, but you're going to need a lot more than this to really get to grips with the stuff.

   I'm going to look at a couple of the O'Reilly books...




4. I bought this book as an introductory text to teach myself XML with C#. The book gives me that, but it could have been done far better. I am left with the overall impression that this was either a first time effort for the authors, or that the book was rushed to make a deadline and not enough editorial review and proof-reading took place (I suspect both).

   Simple things like the illogical order in which topics are presented throughout each chapter, misleading diagrams, unclear or just plain bad use of grammar, inadequate use of examples in the early chapters, some VB code snippets (it's supposed to be a C# book) are all simple mistakes that could have been eliminated at editorial stage, and which, had this been done, would have made for a far better reader experience.

   This book does it's job, but I am sure there are better texts out there.




5. This is a code snippet from the book on page 25 (first code sample in the book):
   DataTable objTable = new DataTable();
   DataRow objNewRow;
   objDataSet.WriteXML( "C:\\AddXML\\Contacts2.xml" );
   DataSet objDataSet2 = new DataSet();
   objDataSet2.ReadXML( "C:\\AddXML\\Contacts2.xml" );
   dataGrid1.DataSource = objDataSet2.Tables[0].DefaultView;

   Now, where exactly is the objNewRow used? Why declare it if you're not going to instantiate it or reference something with it?

   And that London guy found no flaws in the code? This is the first code example in the book, and already I can't figure out what they're trying to do. Also, this preceded that last snippet:
   string XmlFilename;
   XmlFilename = "C:\\AddXML\\contacts.xml";

   Okay... assuming that we're using Hungarian notation, which is what the author did in a rather odd way in the earlier example, why not just do this:
   string _strXmlFilename = @"C:\AddXML\contacts.xml";

   I used an underscore to denote that the variable is private. No matter.

   People code some strange stuff, in some strange ways. But Wrox just gets me. It seems like they were producing just total crap in the past couple of years. I bought this book because it was only 10 bucks at Borders, and I guess it's worth the 10 bucks in that it gives me sheer delight to know that these guys made so much more money than I ever will, and I still code better than them.

   -Ryan Cammer
   ryancammer@yahoo.com