5 comments about Murach's ASP.NET 2.0 Upgrader's Guide: C# Edition.

1. Murach ASP.Net Upgraders Review
   
   I just got Visual Studio 2005 and installed it. Equiped with Murach's ASP.Net 2.0 upgrader's guide I am ready to upgrade two existing websites and continue using a 1.1 application without upgrading. The Murach book has an entire chapter devoted to this process. The book is concise and to the point about your options in running these applications. You can run ASP.Net 2.0 only, ASP.Net 2.0 and 1.x on the same server or run ASP.Net 2.0 and ASP.Net 1.x under ASP.Net 2.0. I did find the depth here to not be sufficient to correct one of the problems I had; though the information allowed me to have a general idea of where the problem was and resolve it after a focused search on the internet. Overall I would rate this chapter an eight out of ten.
   
   Now with the sites upgraded they were still stuck using ASP.Net 1.1 controls and concepts. I now needed a firm understanding of what the new features were in ASP.Net 2.0 and C#. Chapter 1 made quick work of bringing me up to speed on the new code-behind model and several new features:
   
   - Partial classes
   - Master Pages
   - Login Controls
   - Themes
   - Web Parts
   
   It also introduced me to the changes in the IDE. It emphasized that the IDE would no longer make unwanted changes to hand coded HTML and that the grid layout was gone (hooray!). The first chapter also briefly introduced generics, iterators, nullable types and static classes. I was properly primed to forge ahead and learn more.
   
   The book covered the basics of creating a site. Solid coverage was given to the new method of accesing databases, using cross-page posting, creating master pages, and testing on the development server. The Murach "paired pages" format (how-to and general information on the left and code examples on the right) makes it exceptionially easy to learn once and later refer to the material.
   
   Despite being labeled as an upgrader's guide the book would not all short for someone new to ASP.Net and C#. The topics were covered with enough detail and plain talk to ensure that novice programmers would be able to follow the material.
   
   Murach has done it again and produced another book that will have a place on my small desktop bookshelf; now I just have to figure out which book will get pushed to the bookshelf across the room.



2. Written especially for professional programmers, Murach's ASP.NET 2.0 Upgrader's Guide C# Edition is a no- nonsense, in-depth resource that packs everything a programmer needs to know when making the jump to ASP.NET 2.0. Chapters cover how to use new ASP.NET features such as master pages, tips and tricks for getting the most out of new data access features including GridView, DetailsView, and FormView controls that can develop professional applications with little or no C# code, labor-saving improvements, how to configure and deploy new 2.0 applications especially when converting from ASP.NET 1.x, and much more. Murach's ASP.NET 2.0 Upgrader's Guide C# Edition succeeds admirably in its mission to be the best possible resource on its chosen topic; explanations, examples, sample code, recommendations, suggestions, and painstaking attention to detail make for an indispensable resource.



3. I've recently completed reading Murach's ASP.NET 2.0 Upgraders Guide. It's a fairly recent book that deals with the new features of ASP.NET 2.0 and targets an audience that has quite some experience with ASP.NET 1.0. As an experienced .NET developer I was looking for a book that would bring me up to speed with the latest and the greatest of ASP.NET 2.0. I tend to get bored easily, so I need a book that gets to the point immediately. This is where it failed for me.
   It does cover all the important aspects such as Master Pages, DataGridView, DetailsView and Role and Membership Providers. And does do that well since I learned a lot of new stuff (even though I keep a tight lease on the MSDN site). It even explains how some solution was implemented in ASP.NET 1.0 and why the new solution is so much better. But what bothered me was that a majority of the book is explaining basic concepts that should already be imprinted in your mind. Moreover, the book is organized in way that on every few pages a new concept is explained in two different ways. The right page usually contains a large bullet list with an explanation and some examples, whereas the left page basically contains the same information but written out. For me, it was annoying to start reading the summary (because the text starts by referring to it) and then discover that the left page is not adding anything substantial. One of the two is sufficient for understanding the technology, so I wonder what the author had in mind.
   Anyway, I would give the book three out of five stars. The content is really good, but should have been more compact.



4. I purchased this book a few weeks ago and I'm done with it. Here is what I like about it and what I think could be improved:
   
   Bottom Line: If you want a how-to book focusing on just the new features, this book does decent job and there are far worse books out there. This book fills a needed void for quality how-to treatment of ASP.NET. However, if you are looking for a short, concise, and elegant treatment of new ASP.NET features, you may want to look elsewhere. Problem is, you may not find anything better.
   
   Likes:
   ------
   - Best thing I like is that it is virtually without typos. This is huge. Murach has done a great job of editing their product. I have purchased my fair share of garbage texts rushed to market and filled with inexcusable typos, dumb mistakes, and jokes. The authors, editors, publishers have done a great job in this regard. Murach was truthful in stating that book is not released until it ready.
   - The code examples actually work.
   - The book really does stay to what is new.
   
   I'm listing the following Dislikes, but they shouldn't cause you to not buy this book - the book is decent. Here is what could be better in my opinion.
   
   Dislikes:
   ---------
   - This is personal preference but I really don't like the alternating page format. This has the effect of greatly increasing the bulkiness of book with marginal improvement (my opinion)
   - I have found that there are two general styles of books - those that focus more on the "why" of something and those that settle for the "how-to" of something. Both are important, but I like to learn the "why" more than the "how". This book does a decent job of explaining the "how" and I can recommend it for doing that. This is harder to do and often requires a editor looking at the product in this light. I just think it could have taken a step back at points to give a better overview of features and explain them better at a higher level instead of immediately going through the sometimes boring details of this property and that property, etc. For example, the chapter on login controls should have, in my opinion, explained the various controls as a group up front and should have explained the nature of the admin config tool vs the CreateUserWizard control. Each control was instead explained individually in a rote how-to fashion. Even though this book is positioned as a how-to book, I'd like the publisher to add more background on why things were done the way they were and how the whole framework hangs together before getting into the details.



5. I am a big fan of Murach books and their paired page format. This however is the best. Without this book I would not have appreciated Object Data Sources. I learned database design patterns using the ObjectDataSource control that I have used in several projects.
   
   The sample code is worth the price of the book alone, but the clear concise explanations are also invaluable. This is the book that sits on your desk as you program.

5 comments about The .NET Languages: A Quick Translation Guide.

1. This book ignores major features of the .Net Architecture, and barely acknowledges ASP. It is as if the author has heard about the framework secondhand.



2. Anytime I enter into the world of a new technology, I tend to inundate myself with books. I purchased many books as I prepared myself for the transition into .NET, particularly to adopting the use of C#.

   While other books taught me about the ins and outs of the .NET framework, this one helped me to quickly grasp the language. It provides useful and practical examples for tasks I had long taken for granted in VB 6.0 and prior. In fact, the essense of the book is all about bridging one's understanding from the "old way" of coding to the "new way" and it does so quite well.

   Many times I need to quickly recall syntax. The book is well organized and I can almost always find what I'm looking for in a minute. Other books leave me searching or even wondering where that one nugget of truth that I learned last month (but can only vaguely recall this month) must be.

   This book is perfect for the person who wants to learn the language syntax (VB or C#) from practical patterns and examples.




3. I use this book a LOT. The reason I love it is because it does exactly what it was meant to do: take a starting point that I can relate to, Visual Basic 6, and cross-reference my previous knowledge to VB.NET and C#. I have not found any other book that cross-references all three languages the way this one does. For instance, if I know what command I would use in VB 6, but I'm new to C# then it's a 15 minute search to find something equivalent in MSDN. But if I pull out my trusty Translation Guide there it is in a few seconds! From there if I need more in-depth detail I can go straight to the correct article in MSDN, however in most cases it tells me everything I need to know because I already understand the concepts, I just need to know how to do the same type of task in another language. This book is absolutely invaluable to me as a reformed VB6 programmer!



4. Having coded in C#, and having to pick up a project all in VB.NET, which, btw, was ported from VB6, was not familiar with the synthax and conventions of the visualbasicers. My problem was mostly about the lack of knowledge on language synthax and idiom expression. Knew "how to do this and that", but didn't have the synthax on my fingertips. This book pretty much summarizes all my desires at this point: it has side by side examples in VB6, VB.NET, and C#, with a commentary on features that may be offered in one language or another, why they were offered, and within the same programming language, sometimes mentioned an alternate way of achieving the same result. For my particular situation, already knowing the .NET framework and have had some experience in it, this book proved to be extremely useful to jump into another .NET language. I think I found one incorrect statement: the book states that in .NET, Boolean and Integer are not interchangeable, which I found to be true in C#, but not in VB.NET. Also, the difference between static and shared is still confusing. Great book for those that just need a code example in front of their eyes when coding something new. And btw, nice insight on how C# picked up from VB6 the style on read-only property, while paradoxically, VB.NET did not. Also useful in the context covered by this book, are two other books, "Maximizing .NET Performance" and "Effective C#", which lists some traps that are specific to a programming language used in .NET.



5. I bought this book because I had taken on a new job and had 2 weeks to learn VB.Net the way I know C#.Net. This book was and still is a great asset to have for anyone looking for a quick concise guide to translate between VB.Net and C#.Net It's not a learning guide for .Net (as it states in the intro) and does not get to specifics about winforms and webforms. What it does is very effectively explain syntax differences and other caveats to be aware of between the .Net languages (I skipped over all the VB6 stuff so I can't speak to that). The charts at the beginning of every chapter are an invaluable quick reference.
   If you are new to .Net, get another book to learn it effectively...if you know a .Net language and need translate your knowledge to another, then this book is a great tool to have.

No comments about C# 3.0 THE COMPLETE REFERENCE 3/E (Complete Reference).

4 comments about .NET Windows Forms in a Nutshell.

1. The authors appear to go to great length for completeness in a companion reference for programmers creating DotNet Forms, an important new feature of the DotNet frameworks. We have been always looking for a capable web enabled report writer without integrating a third-party product, such as Crystal Reports for the Web. DotNet Forms promises in creating at least simple, yet dynamic, multi-paged reports without a whole lot of work.

   DotNet provides for creating dynamic Excel-like forms for ASP.NET html. Additional form paging provides for DB presentation similar to Yahoo and eBay searches, which is a familiar and intuitive format. DotNet provides these DataGrid forms with the DotNet Forms API. The API architecture is listed in the last two-thirds of this book, which is an inch and a half thick.

   While the authors claim to include a "very fast-paced" tutorial (p1) in the first third (313 pgs) of the book, the DataGrid portion is a mere 6 pages (p307-312), very steep indeed! I'd highly recommend its combined use with another MS Press book by Dino Esposito (0-7356-1578-0) which devotes about half of his book to DataGrid reports and code examples. Another is Jesse Liberty's O'Reilly book on VB.Net (0-596-00438-9) which has one chapter devoted to ADO.net (34pgs).

   The publisher include a MS Visual Studio.Net Add-in on the accompanying CD which has the text of the book as integrated help files, 1.7MB MSI files for VS.Net 2K2 and 2K3. Appears a tad bit small? I have not tested the usefulness of the claimed dynamic integration of the O'Reilly Help files along with MS Help during coding process within VS. It appears that this is the initial product enhancement from this publisher. I wonder if an annotatable PDF file of the book would be more useful; at least this would be in a separate window. This tome was read at a local library.

   At a local SQL Server Users Group meeting, a new technology that will embellish on the DataGrid and Forms was discussed and demoed. It is the forthcoming SQL Server 2K Reporting Services that will be a low/no cost add-on for SQL 2000 Server and authoring with a Visual Studio.Net 2003 download. It currently is in beta and will be released in 4Q03. It appears to be XML based and production reports can be rendered for browser, printer, PDF, and TIFF output. What a seemingly great idea.

   Overall, this detailed 469-page reference on the DotNet Forms API appears needed for the programmer, although this is probably duplicates what's available on a MSDN subscription CD somewhere. The appendix includes another 69-page API term cross-reference and a 23-page index.




2. This was the 3rd or 4th WinForms book I purchased. The others were good, but they were lacking in detail. This book does a great job in explaing 'under the cover' details. The authors do a good job explaining DataBinding, Controls, GDI+, Form, Menus, Inheritace and much more.

   This is more than a resource book. The first half is devoted to getting you up and running with building WinForms apps. The 2nd half is an incredible reference, one I turn to almost daily.

   If you plan to use or are using .NET WinForm, please, do yourself a big favor, buy this book and leave it on your desk.




3. This was the 3rd or 4th WinForms book I purchased. The others were good, but they were lacking in detail. This book does a great job in explaining 'under the cover' details. The authors do a good job explaining DataBinding, Controls, GDI+, Form, Menus, Inheritance and much more.
   This is more than a resource book. The first half is devoted to getting you up and running with building WinForms apps. The 2nd half is an incredible reference, one I turn to almost daily.

   If you plan to use or are using .NET WinForm, please, do yourself a big favor, buy this book and leave it on your desk




4. Databinding is handled later, and lots of interesting stuff I wasn't knowledgeable about came sooner. Bravo. This is a great book that will always be on my desk! (I'm a professional developer with walls of books by Microsoft on Wrox, primarily.)

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 A Programmer's Introduction to C# (Second Edition).

1. Eric Gunnerson, A Programmer's Introduction to C#, 2/e (Apress, 2001)

   The title of the book pretty much tells you all you need to know, though it might better have been termed "A Programmer Who Knows How to Read Microsoft Documentation's Introduction" etc. Gunnerson is (of course) more complete in his overview than the Microsoft documentation team usually are, but the book does assume more knowledge than even most intermediate programmers already have. Specifically, while one can assume, say knowledge of the basic way string classes work, the book treats some of the more esoteric new features of .NET with the same glossing, leading to some confusing passages.

   This is definitely a worthwhile reference book, as an adjunct to your more in-depth reading, but isn't a good starting point. ***




2. This text has the possibility of being really good. The author obviously has some fresh ideas on how to structure and present Yet Another Language Text that does not follow the tried (and perhaps tired) structure of the classics.
   
   Unfortunately, the text lets me down in several ways. First, there are plenty of glaring misprints in the code examples; this can be pretty devastating when you tend to rely on the examples to gain insight in the language. The index, too has reference errors, which is more than a little annoying.
   
   The biggest problem with this text, however, is in the structure. The subjects seem to come in no particular order at all, and many things are used in examples that aren't explained until much later - now, this is unavoidable, of course, but a short reference to a place where you can read up on it would have been good. The author starts right off with exception handling, the motivation being that it is important, and this way, examples can use exception handling. Great idea - except the examples never do, making the early focus on it somewhat moot. I get the feeling the book was intended to look quite different, and has been edited to death in the interest of lowering the page count.
   
   This could have been a very good book on this subject. As it is, it is better than nothing, but I would recommmend looking elsewhere for a better text.



3. Easily the best C# book on the market. If you want to learn the C# language (as opposed to an introduction to OOP or .NET), then this is the book to get - it's clear, to the point and easy to follow. I've purchased and returned about half a dozen C# books (just search Amazon for C# and you'll see which ones) before discovering this book. Gunnerson writes in a clear and concise style that's simply refreshing after going through so many other poorly written books.



4. This book was recommended to me by a colleague as an introduction to C#, but I have to say I'm a bit disappointed.
   
   I'm a fairly experienced C++ and Java programmer, and for someone at my level, it spends too much time on basic programming concepts (object-oriented programming, threading, etc) rather than teaching me about C# at the level I need. (At the same time, the treatment of these subjects is probably too cursory for someone who did not already understand them.)
   
   There are also numerous typos and formatting errors; this might not ordinarily matter so much, but it often makes the code samples more difficult to read.
   
   For an experienced programmer I might recommend "Inside C#" by Tom Archer & Andrew Whitechapel instead.



5. I am an intermediate C++ programmer who hadn't been programming for a few years.
   
   While i disliked how he went into some pretty advanced inheritance topics first and then into simple array manipulation second... i can see why he did that.
   
   I personally loved how every single paragraph ended with a fully functioning example that i could compile. (or a non-functioning program that explains why it doesn't function)
   
   Either way, Eric did a great job on this book and i'm excited to read his 2.0 book once my friend finishes it.
   
   I especially enjoyed the section on threading and asynchronous processing.

4 comments about Microsoft Visual C#.NET 2003 Kick Start.

1. This is a very solid book. It assumes you know the basics of programming like loops, modules and the likes... If you are familiar with any regular programming language (like C, C++, Java, PERL, python, ruby, even shell scripting) then this books is probably your best bet to learn C# quickly.
   
   There is no whole chapters made to get you to write a "for" loop here, you must have programming concepts to really benefit from this book.
   
   As a programmer, I really enjoyed it and was able to get to work quickly on C# programs. If you are totaly new to programming, get another book to get your feet wet before jumping on this one.



2. For any programmer coming over from another language, I really think this book offers the most bang for the buck (and for your time). I'm a VB6 programmer who wasted a lot of time and money on other books that either offer too much hand-holding (next to no code, everything through forms designer) and wasted time on extensive examples building software I'll never use or focused only on console C# applications with no explanation of topics like ADO.NET, winforms, etc. I need to use C# at work and like many programmers, I'm busy and have little time to waste. Yet, I also needed a comprehensive book because the real world of business programming requires the use of data-access technologies (ADO.NET), security, network technologies, etc. This book succeeds on all counts. The coverage is surprisingly comprehensive and details are well fleshed out. Even using ADO.NET in code is covered while many other books only cover using it through form controls in Visual Studio (anyone who writes database-connected applications knows that you really need a high level of control of shaping the data before you can present it). Nothing is dwelled upon for long so be warned that the book does move fast and info is densely packed into each page.



3. This a a very good book for someone who has programming experience. Fundamental concepts are in the book, but they are not belabored. The book quickly gets on with C# and what it takes to create real applications that do something more than say "Hello World".
   
   If this is your first experience with programming, then this book is not for you. If you have done some programming and are moving to C# for the first time, then this book is a great addition to your library.



4. As an experienced C++ programmer, I wanted to try C# out of curiosity. Obviously, I didn't want to read long-winded explanations of the most basic programming constructs -- I just wanted syntax and effective ways to use it. This book fulfills this purpose well. Within a few days, I was able to start writing real, useful C# applications. And, since I'm a game developer, I was able to find Managed DirectX tutorials and I've already written the fundamentals of a C# game engine!
   
   So, if you know how to code, this book will show you how to do it in C#. Thanks, Steven Holzner!

5 comments about Windows Forms Programming with C#.

1. I don't care if you've been coding for years, if your moving to .Net and are learning the basics of c# and the framework, you won't find a better starting place.
   
   I've had a few attempt at .Net, but this book lays out in a clear and precise way what you need to know to get you started. I would suggest its a cover to cover type of book, building on previous examples that are easy to follow, developing an application that touches all concepts of "Windows Forms (desktop)" development. If you want to write n-Tier, ADO.Net ASP.Net or Web Services apps then there are other books out there, but you need a base to build from and this is the book to provide you with that knowledge.
   
   Thank you Erik for providing the best computing book I've read in 10 years, and I've read a few.



2. Most programming books takes two routes: a.)they shorthand the explanations of the code in keep things moving at lively pace or b.) they give such a lengthy, terse description of every line in the code that you could die of old age just thinking about it.
   
   "Windows Forms Programming with C#" brings just the right balance that is oh-so-rare in programming books. It explains everything that happens, but is also brisk enough to keep you from being bored.
   
   The book builds, almost exclusively, a single image viewer application where you get to apply nearly every one of the dozens of Windows Form components. An explanation or every form component, it's attributes, and it's uses are explored in this book, but without being overly academic.
   
   Another great feature are the conventions used in this book. A lot of programming books add little notes and factoids that really contribute nothing. In this book, there are class explanations and action-results tables that are surprisingly well used.
   
   There really isn't anything bad to say, except for that the code does use some Hungarian notation at times (an area of irritation for some). Windows Forms are going to be an important topic for as long as the eye can see, and if you want to learn everything there is to know about them, this is easily the book of choice to read.



3. I love this book and when I upgraded to Visual Studio 2005 I picked it up again to re-do all of the examples. I knew there would be some changes but Microsoft changed Menus considerably more than I expected in VS 2005 and I was left slogging through the mud in Chapter 3. I finally gave up because I don't have the time to spare. I understand a new version of this book has gone into production and may be on the shelves in April 2006. I plan on buying the new book.



4. This book might be useful to a beginner with no experience who needs step-by-step guidance for even the simplest things, but for anyone else it is tedious at best.
   
   The text is needlessly wordy, and the presentation of certain information is regrettable. For example, the properties, methods, and events of each control are listed in a table; but the items are presented in alphabetical order rather than by order of importance or frequency of use. No context is provided about the C# language or the use of Windows in an a production environment.
   
   Even a beginner could learn more easily by experimenting and reading the documentation that comes with Visual Studio and the .NET Framework. And there are much better books on the market.
   
   I'm sending my copy to the recycle bin.



5. This is a decent step-by-step book for programming using Windows forms in C#. The entire book is well written in a tutorial format. Plenty of examples present key how-to-use features of the Windows forms. It's an excellent entry level book for GUI programming with C#. However, as some reviews mentioned, the details on some specific topics, such as progress status bar and the multi-threading, are missing.
   
   Buyers/Readers be aware: this book is a bit out of date. The examples in the contents are different from you will find in Visual Studio 2005 or later.

2 comments about C# Annotated Standard.

1. Disclaimer: I'm one of the annotators in the book, so have a natural bias.
   
   If you care about understanding the code you're writing, you should care about language specifications. When code doesn't behave as you expect it to, the quick way of handling the situation is to experiment until it does what you want - but it's far better to consult a book to find out *why* the original code failed. What better reference could you possibly hope for than the language specification?
   
   Unfortunately, specifications are typically difficult to read. Where tutorials can be vague and woolly, specifications are meant to handle every possible situation, or at least explicitly state which aspects of behaviour are unspecified. Furthermore, they rarely contain the motivation behind various decisions - and it's understanding that motivation which can help you to learn to work hand-in-hand with a language instead of fighting against it.
   
   The C# Annotated Standard is a rare gem - a reliable standard which allows the authors to express reasons, pitfalls, anecdotes, errors, and other little nuggets of wisdom.
   
   I can't wait for the C# 3 edition :)



2. Standards can be a pretty dry read but Jagger, Perry and Sestoft have managed to make this a fascinating read. This book is chock full of tidbits and interesting insights that reveal why C# and the C# 2.0 standard is the way it is.
   
   Every C# programmer should have this on their shelf.

No comments about How to Code .NET: Tips and Tricks for Coding .NET 1.1 and .NET 2.0 Applications Effectively.