5 comments about MCAD/MCSD Self-Paced Training Kit: Developing Web Applications with Microsoft Visual Basic .NET and Microsoft Visual C# .NET (MCSD Self-Paced Training Kit).

1. I purchased the first edition of this book--which is twice as big as the one currently in the bookstore (2nd edition). I was very disappointed with the first. As I browsed the 2nd edition in the bookstore, my faith in the MSPress series was not restored.

   Bottom line: buy the Amit Kalani book from Que instead. That is tremendously better. I think it is the best book for studying the material on the test. Also, don't forget to get the Trancender exams and flash cards. They too are also very helpful.




2. I usually enjoy MS Press titles, but this one was miserable. Other reviewers have mentioned the plethora of shoddy, uncompilable code, so I won't bother to mention any examples. It is worth noting, I suppose, that the VB.NET examples are in somewhat better shape than the C# examples because the authors apparently wrote their examples in VB.NET, but translated to C# without ever compiling, much less testing, their translation. How such a terrible mess could have slipped out the MS-Press door is quite beyond me.

   If you are technically astute and comfortable with C#, you can probably debug your way through the sample code and derive some benefit from the book. But then we get to area where this book falls down completely: the authors seem to be completely clueless with regard to sound software design. As a service to readers, let me offer some insights into where the book misses the mark so that your code will not similarly go astray:

   1. The authors describe abstract classes and interfaces, but do not describe why you would use one or the other. Of course, the key differentiator that the authors miss is that an abstract class can include default implementations of methods. Here's a rule of thumb: if derived classes can piggyback on an implementation of a common base method or methods, put the common code in an abstract class. Otherwise, use an interface.

   2. The authors explain that you cannot derive a web form from another web form (i.e., there is no visual inheritance). This is true enough, but many shops, including my customers when I was an MS consultant, plus the one where I now work, use a Page-derived base class from which all page classes inherit. This allows you to provide common functionality across all the pages in your site.

   3. On page 157, the authors would have us iterate through a RadioButtonList, check each one to see if it is checked, then perform some operation if it is. This is just dumb. A radio button list can have only one checked member, and it can be accessed by calling RadioButtonList.SelectedItem (or SelectedIndex or SelectedValue, depending on your situation).

   4. On page 200, the page class sets stores "true" in ViewState["Changed"] in the TextBox_TextChanged event handler, then checks the value of ViewState["Changed"] in the butExit_Click event handler. Again, the code works, but it's really dumb. Both event handlers will get fired in the same postback, so you ought to give the class that implements the Page a boolean member variable with a default false value. When the TextChanged event fires, set the member variable to true. Then use the member variable in the butExit_Click method. Using ViewState in this situation is kind of like sending a package to your next-door neighbor via Fedex, rather than walking over and ringing his door bell.

   5. On p. 254, the authors recommend instantiating a single database connection in global.asax and making it available for each user connection by setting a session variable in the Session_Start event handler. Supposedly, this design "conserves resources and makes it easier to maintain connection and adapter settings...." In fact, what this will do is make your web site scale miserably because every single user will have to wait in line while the others take turns sharing that single connection. **I cannot emphasize enough how bad this design is.**

   Windows servers have built in connection-pooling capabilities that do a great job of conserving resources while providing good scalability. Just instantiate a new connection for every database operation, and allow the Windows infrastructure to do its magic behind the scenes. And if you're smart, you'll do this in a class (or classes) in a distinctive logical tier that most designers call the data access layer. However, the three-tier (later n-tier) design revolution that swept through the Windows software world starting about 6 years ago seems to have completely escaped the notice of our authors.

   6. On p. 261, the authors use a typed dataset with a type name of dsContacts. They also have a member variable with the name of dsContacts. Does anyone else see the potential for confusion here?

   7. On p. 385, the authors recommend using user name as the primary key for a user table. The problems this database design will cause are severe.

   * When the second "John Smith" or "Mary Jones" tries to access your system, you'll get a database error. The only workaround is to get John or Mary to use a different name. Yeah, right.

   * Using a long string as a foreign key on other tables that reference the user table leads to inefficient space utilization and terrible performance when you do joins.

   Anybody who knows anything about database design knows that you set up some kind of guaranteed unique key, such as an auto-increment integer, and make name an attribute of the user.

   8. The authors fail to note that if session state uses the sqlserver mode, session state will survive a reset when web.config is changed, so users will not be adversely affected.

   9. On p. 408, the authors ignore the security implications of causing an authentication cookie to be written to a user's hard drive. This is a recipe for disaster for users who are accessing a web app from a public location (library, kiosk, Kinko's, etc.) because subsequent users will have access to their credentials by virtue of the authentication cookie already on the hard drive. Do your users a favor and set the createPersistentCookie parameter to false when you call RedirectFromLoginPage().

   I could write a much lengthier list of "really dumb coding ideas" to accompany this list of really dumb design ideas, but space does not permit. So let me conclude by stating what should by now be obvious: if you have extensive experience with object-oriented web programming in a multi-tier design paradigm, but simply lack exposure to ASP.NET syntax, you can probably find something useful in this book. Otherwise, stay away!




3. The authors were apparently faced with an aggressive deadline for this book because it's exceptionally bad, even relative to other MS Press books. Due to the inaccurate writing and poor editing I wasted many late-night hours trying to get the sample code provided for the labs to run properly. Very little of the prescribed code even runs at all, without modification. Corrections for the most obvious errors are published on the MS Press support site but many of the other problems are quite subtle. I'm a decent programmer -- If I do say so myself -- but I had to spend a lot of time on ASP sites researching solutions to all these errors.

   The code design recommendations are also surprisingly poor, the type of code one would expect from a very junior developer, possibly someone who's not even cut out for this line of work.




4. Definitely this book contains some useful material. The first chapters make a good impression, but as you go further you start to see that something is wrong. The author was facing an aggressive deadline and did not take into consideration anything.
   The book will be thrilling to read for someone who already knows and have a hands on experience with .NET, because the book will make you think by making you try to resolve the unclear material. The author definitely knows his stuff and demonstrates that fact to you, but don't hope for any explanations they are beyond the scope of this book.
   Also you will enjoy the wonderful late night "I WON" feeling, after succeeding actually to RUN the most of C# examples.

   I kinda regret reading this book, because I have to read now an other one to pass the test.




5. This is a useless book. It has so many errors that you will have headache. Very poor explanation. Normally MS Press books are good but Microsoft did a very poor job on this. I should use this book in fireplace to get some benifit out of it. I would like to give this book negative star if I can but I cant.

5 comments about Programming Embedded Systems in C and C ++.

1. This book is geared towards people who intend to venture into the field of embedded systems and need an overview on the basics. These include the scope of development and most importantly, things that the developer should pay attention to (In the embedded system field, the developer has to pay close attention to the underlying hardware's characteristics such as registers, interrupts and memory address locations, in Java application development on the other hand, the underlying hardware and to some extent the OS is considered an afterthought).
   
   Though the examples are targeted to the Arcom board, the author makes a good effort to extract general principles applicable to any other hardware type. A passing knowledge of C and C++ is required though to understand the code.
   
   Of course, experienced embedded systems programmers would find the text a rehash of what they know however for those new to the field, this serves as a very good foundation.



2. "But keep in mind, it is extremely superficial. In other words, it's a great introduction for people who have no idea whatsoever what embedded development involves." This is a quote from a reviewer that gave it 5 stars. I agree with this reviewer comments but don't buy a book you will outgrow before you finish reading it! For now, I still recommend the David E. Simon book.



3. I am curious for the meaning of "advanced users" and what they would enjoy on a "advanced book" and why they despise this book for its basic content, And perhaps, they are after a title like "do my work". I guess much of the material here is very important to embedded developers, being experienced or not. For ex, start up code, the memory initializations and the excellent introduction to a RTOS. I am an Electrical Engineer, always writting embedded application code ( mostly dealing with API calls when it comes to low level ) and I was looking for clarification of several issues and the book did it well. Have a manual for your processor, your compiler and it will be all that you will need. Tips for embedded applications might be easily found on application notes ( be it ARM based processors or AVRs or Freescales ). This book is about writting the software not about the applications them selves.



4. In agreement with an earlier reviewer who also gave this book 1-star rating, it took me about 10 minutes of going through this relatively thin book to realize that its contents was not substantive (at all). Too much hand-waving, and not nearly enough meat. And there's barely any C or C++ code in the book.



5. I'm new to embedded system programming so I bought this book. I was disappointed because I didn't get much from this book. Buy something else.

5 comments about Code Craft: The Practice of Writing Excellent Code.

1. Code craft is an awesome book for anyone who wants to be a better developer. It touches on a lot of practices, viewpoints, areas of conflict, and focuses on turning you into an individual who can work well in a software development environment while leaving the technology / language-specific details to other books.
   
   The book looks simple and juvenile as you're flipping through it at first, but I think it spends about the right amount of time on things and is right up there with classics such as Code Complete and Rapid Development.
   
   I read it cover to cover in about four days and have loaned it to a coworker to look through.



2. I was at the library and this happened to be next to another book that I wanted, so I picked it up too.
   
   And wow, it's rare that I am this disappointed in a book. The content is very thin. It sounds like it was completely gathered from secondary sources, e.g. reading other books about software engineering. It doesn't sound like the result of actual experience.
   
   Every page is filled with platitudes without any examples of real experience backing it up. I'll grant that he has assembled an extraordinarly wide range of *terms* and terminology. It looks like he has tried to shove 3 sentences about every topic in software into a single book. Unfortunately, this ultimately makes for a book with little use.
   
   Another sticking point is the writing style. It comes off like the author is an annoying guy trying to be funny and trying to be your friend. The first sentence irritated me: "What's in it for me? Programming is your passion. It's sad, but it's true."
   
   Huh? Why is it sad that programming is one's passion??? There are similar head-scratchers elsewhere in the book. He also devotes a section to talking about the various types of "code monkeys". And the last type is "You. In the interest of politeness, we'll say no more about this curious beast. Sadly, some people are beyond help..." What? The reader is beyond help? If I pretend for a minute that he's not insulting me, then I still don't know what he's trying to say. This book is incoherent.
   
   And what's with all the reviews below that read like advertisements? Give me a break. It looks like a lot of the author's friends are spamming Amazon's reviews.
   
   I recommend reading Joel Spolsky's books for real, specific insights on programming and the software development process, earned from experience, written in a much clearer and more entertaining style.
   
   I'm also reading Jon Bentley's "Programming Pearls" now.



3. I have two comments.
   First, do not expect technical details on this book. There isn't. Second, the only paragraph that is really good is on page 461 and it says: "Find the classic books of the field". This is not one of those. He recommends and I agree almost completely:
   * Code Complete
   * Design Patterns: Elements of reusable object-oriented software
   * The mythical man-month
   * The psychology of computer programming
   * The practice of programming
   * Peopleware
   * The pragmatic programmer
   * refactoring
   
   I do not thing that "Code Craft" is one of those.



4. This one is a very good book. It is essentially a book in natural philosophy, not quite "scientific", coming from observation to show you a little bit of everything. An insight to the entire world of programming if you like.
   
   It goes from bottom up, from coding style through techniques and tools to paradigms and architecture. A lot (A LOT) of things explained, briefly, but perfectly understandable. It lacks any analysis or in-depth discussion, but that is on purpose.
   
   Not that many things for an experienced programmer to learn from this book though. To a point where it is boring. It took me longer to read this book through than many others, because I knew much of it in the first place.
   
   The language of the book, the author really is in for wordplay and puns of all sorts, it's all over the place. And although I do believe that proficiency (and desire to excel) in written language is a sure indication of a great programmer, this is not always to the book's best. It sure doesn't read like a textbook, but that's ok. There were a few really good jokes, but most of it is just wordplay for its own sake. For example,
   
   [quote]
   This is the really nasty one - when your program isn't pushing up the daisies, just pining for the fjords.
   [/quote]
   
   Look, I know what "pushing up the daisies" mean, and I can deduce the meaning for "pining for the fjords" from the context, but having it written like that doesn't really help.
   
   Like some other reviewer, I also didn't like the "good programmers" vs. "bad programmers" checklists. See, being a good programmer (aren't we all ?), I wouldn't know how bad programmers think, thus any attempt to declare "bad programmers do that" would be at best a guess.
   
   What's really good about this book, is that it goes under a positive "do as I do" key, not a negative "don't do as I say", seen much more frequently. I'd guess that the guy is really keen on what he's doing, and you can feel it in his book.
   
   I was pleased to see that yet another author's word supports my belief in that programming is simply patience, discipline and common sense. Oh, and PRACTICE.
   
   Anyhow, a great book for a beginning pragmatic programmer.



5. There's some strongly negative reviews for 'Code Craft: The Practice of Writing Excellent Code' but I am not one of those people that feel this is a waste of time reading. Becoming a better developer and designer doesn't come from just one book, one idea, one THING, rather it comes from other things in life by doing/experiencing lots of things and this book is worth the time to read. With 550+ pages of content you will learn about documentation, tools, testing, architecture, source control, etc. You will learn more about what makes a good application and how to go about writing it. You will enhance your development skills and hopefully be better off when you are done with this book.
   
   I like the content of this book and it's tailored towards anyone in the software business that wants to learn to write and design better. While a lot of the concepts in here you will find in many other books, this is a welcome addition to the bookshelf.
   
   My only glaring negative is the boring design in this book. Nothing about the layout makes one get excited about reading it and that's never a good thing. Serious time should have been spent making the inside of the book look better to make the experience better. This isn't a reference book and it doesn't need to look like one.
   
   **** RECOMMENDED

No comments about Professional K2 [blackpearl].

5 comments about C# Essentials (2nd Edition).

1. This is the first book I read when I began working with C#. It gave me the quick introduction to the language I needed to hit the ground running with C#. To this day I still remember turning to it when I needed to learn about indexers!
   
   I have since moved off into the asp.net world (which this book doesn't cover) but I still find it fun to read. This book should be the standard for developers new to C#.



2. Cruising through book stores, I usually encounter the 800 page behemoths that 'teach you programming in 24 hours' or something similar. I suppose those are good for getting you programming with lots of examples.
   
   However, I like to think I'm a pretty good programmer, having grown up with Pascal, C, and C++. I may be aging myself with that first one, but anyway.
   
   I had thought C# was a toy language, ranking right up there with VB. That was until I encountered a powerful .NET financial development package out there on the 'net from SmartQuant. That started me thinking there must be something to this language. I started reading The C# Essentials on one my connections to SaharaBooks online.
   
   Having a programming background, I was able to quickly grasp the basics of the language as they compared to what I already knew. The concepts of delegate functions and events took a while to wrap my head around, after being used to C++'s pointers and function passing. Once understanding the power of events, and how they manage multiple registrations as well as static and object based instantiations, I was sold.
   
   However, I think C# loses it's power due to de-emphasizing the deconstructor and reverting to automated garbage collection. I can see the benefits, but I enjoyed the manual tuning I do with C++.
   
   Well, having digressed to the language itself, now back to the book. The book covers the language itself, in what I think is a very fine balance. The examples are short, sweet and succinct in showing many of the fine points of the language specific it is covering.
   
   I must admit though, that there are language features discussed in the book that do have examples, but still leave me wondering what they mean and how they fill in the big picture. I think they will fall into place as my experience grows, and I find scenarios where they start to make sense.
   
   The book does not cover the .NET run-time library. That is best left to the 800 page reference behemoths, or simply the online reference library provided by the Integrated Development Environment.
   
   I give the book two thumbs up. After a year of programming C#, it is still my primary quick reference on basic language idioms.



3. Although I have MCSD and MCDBA credentials, I found this book to be so brief that it is all but useless. Throughout the book, arcane topics (e.g. event accessors, attribute classes, position to member operator, the IClonable inerface, the IFormatable interface, etc.) are introduced with absolutely no hint of what they might be used for. I suppose if you know what all this stuff is already, but need to refresh your memory, the book might be OK. But for anyone who is trying to learn C#, look elsewhere.



4. I have been writing in C# for over 4 years now. This was my first C# book, and the one I have used the most. Though I have several other, substantially longer C# books, this is the one I go to first. It's odd. When I can't find something I need to know in this book, I often can't find it in the larger books either. Despite the others having significantly more pages, they don't seem to provide me that much more information. One review I read mentioned the book is concise, and that is its greatest asset to me.
   
   However, if you do not know how to program, then this book is not for you. If you are not comfortable writing code in either C, C++, or Java, this is not the book for you. If you know C, but lack OO knowledge, this probably isn't the book for you. Other than that, I highly recommend this book.



5. If you didn't see the list of topics this book covers, then I suggest reading it before continuing on with the purchase. This book is not for beginners. It's a jump into the deep end of C#, with only a brief look at the basic differences/advantages of C# over Java and C++.
   
   Class-based programming is nothing new. However, class-based component orientation programming is a more robust, extensible concept. My favorite aspect of C# is the near-elimination of pointers, and the headache they bring along in C++.
   
   The book is full of syntax help, which is invaluable for anyone attempting to branch out from C++ into new programs in C#, or possibly even for the advanced.
   
   It's deep, and this book will serve those already familiar with object oriented programming much better.

5 comments about Beginning Visual C# (Programmer to Programmer).

1. I've bought many C-Sharp books and I must say., this book is awesome! Where as in other beginning books a lot of details are missing -this book is fine tunned and includes many details about the C# language that are just simply not covered in other books! This book is enjoyable and keeps you thinking.
   
   After completing this book, you will have good experience with C# and ready to move on to more advanced books. You get a taste of different C# topics -towards the end of the book. After completing this book, it will be your choice to go the way of Windows Form programming or ASP.NET, and associated topics in those fields. This book gets 5 stars for an introductory book. (...)This book assumes you know your way around an IDE, which is pretty easy to figure out. Enough said.
   
   



2. I don't comprehend the criticism of this book where the complaint implies the instruction within is too meager. There are twenty-four chapters, eight hundred forty-four pages and it's not fluff. It is an excellently structured "Beginner Level" book which lays a foundation over a broad expanse of C# territory. Each chapter explains principles, leads you through hands-on examples, recaps where the principles are implemented in the examples and then tests your comprehension with exercises at the end.
   
   C# is not a casual topic and this book is not a casual read. You gain great insight when you work the code examples and answer the exercises provided. Between my workday and playtime, it took me three months to complete this book, cover to cover. I am confidant with the basics, such as ADO.NET, ASP.NET or XML handling, to investigate more advanced, specialized C# books now.
   
   Finally, a change of publishers did cause the answers to the chapter review exercises to disappear from the web for a good while. But they're in the Peer-2-Peer forum at the WROX website now, listed under this book title as the topic.



3. As a programmer new to the C# language this book provided structured and informative examples that allowed me to learn and produce code fast.



4. this books provides the basic of c# programming knowledge.
   i'm a student that just start IT course and I think that this book suit for me.. as it is easy to be understand..
   
   the part that i dont like at this book is the first 12 chapters. I skipped it as that one is console-based.. i first read the chapter 14-24.. after i've read the chapter 14-24 then i just start to read the chapter 1-12... (for me the chapter 1-12 is not for beginner.. the chapter that will be the foundation is chapter 13!!)
   
   i like the part of how did they give the example and guide .. overall this book is the best visual c# book... compared with teach urself c# in 21days.. (i bought wrox book first before i bought the teach urself c#)



5. I come from a C++ and Java background and have NEVER worked in C# before. This book is the best investment I've made in a while. It helps you lay an excellent groundwork and builds up to an industry-level standard of programming complexity. A unique, & may I say bonus, advantage is the excellent introduction to the Visual Studio environment which, otherwise, can seem to be very daunting.

No comments about Pro ASP.NET 2.0 in VB 2005, Special Edition (Pro).

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 Visual C# 2005 Recipes: A Problem-Solution Approach (A Problem - Solution Approach).

1. I am very disappointed with this book: I own a copy of the author's C# Programmer's Cookbook ( MS Press ) and I decided to give this new version a try as I am starting to work with C# 2.0. What a mistake: I certainly expected overlap but I was not ready for a photocopy of the book I already own. I guess I can keep one copy at work and the other at home. Do not buy this book if you own C# Programmer's Cookbook. The title of this book is highly misleading, even dishonest. You would be better off buying the earlier version--it even has more stuff.



2. I agree with a previous reviewer in that some duplication exists between this book and Allen Jones' previous C# Cookbook. But this work includes important updates to the recipes relevant to C# 2.0. For example, some of the security and cryptography techniques have changed, and the approach for calling a webmethod asynchronously is different. I therefore definitely recommend this publication to anyone doing professional development in Visual Studio 2005 using C#.



3. Much like the 'Cookbooks' series by O'Reilly, the Apress 'recipes' books are a mix of different techniques and common solutions to common problems that you will find. 'Visual C# 2005 Recipes: A Problem-Solution Approach' by Allen Jones and Matthew McDonald does exactly what it says it will, looking at a wide range of topics and providing over 200 tidbits that will help C# programmers of all levels! This book weighs in at over 550 pages and these tricks are spread out over 14 chapters, covering topics such as data manipulation, application development, XML, database access, graphics, etc. etc. etc.
   
   I like this book but like most Apress titles I feel the overall design internally is very lacking. No color, boring layout, and nothing eye catching that really makes this title stand out from others on the market. There is nothing fundamentally wrong with this title but when you are faced up against O'Reilly on the bookshelf you need to do something marketing-wise that makes you stand out from the leader. If you are only interested in content pick up this book but expect a dry layout, font, and design that really feels dated.
   
   All in all, a thumbs up for C# developers.
   
   **** RECOMMENDED



4. .NET adoption has increased tremendously in the past few years, and the Framework itself has gone thru changes as well. It is not uncommon to come across an end-to-end solution, from front to back, all developed in the .NET framework. I must say, Microsoft has surprised many of us with the complexity and power of the .NET framework and more specifically the C# programming language. For those of us whom are familiar with other programming languages such as C++ know how difficult and challenging it is to develop enterprise-worthy application without the help of experts in the field. Well, C++ (and Java) have many of those, but .NET is still at its infancies and experts all few and far in-between. Allen Jones and Matthew MacDonald, the authors of Visual C# 2005 Recipes, have certainly crossed the threshold to the "expert zone" and have set a standard to beat and for many to live up to.
   
   The text is a collection of small and easy to read sections or recipes tackling a specific problem faced by a developer. The authors start by stating the problem followed immediately by the solution. The section then goes into detail on why the solution will actually solve the given problem. As part of the solution, the authors include a small program that demonstrates the solution to the given problem. The text tackles many important topics of the language such as
   - Application development: these are basic problem faced by new programmer to the language. C# allows very advanced ways to manipulate the assembly and assembly generation; it is very important for a new developer to the language to know about these capabilities.
   - Threading and threading management: it is clearly impossible to build an enterprise wide application without the use of threads. As we all know, threading does have its own challenges and even though C# has made it very simple to program using threads, one still needs to understand how tackle problems such synchronization and process management.
   - Data manipulation and XML processing: Two very detailed chapters are dedicated to these topics. Manipulating data and later meta-data is an essential part of any programmer, and it is part of any programming language.
   - I/O and the file system: Read and writing files may seem simple, but can quickly get very tricky if you talking about COM ports or manipulating binary files. File manipulation is depicted in detail in this text. XML files and manipulation is also tied to this chapter as the authors discuss the details of how XML is integrated in to the .NET framework.
   - Database access: A task that all of us have a need for in our day-to-day job as a developer. Just like JDBC is very important to the Java world, .NET has its own set of classes and libraries for DB access.
   - Networking and network programming: probably one of the most widely speculated and difficult topic in any programming language. Network programming is not an easy task and required much guidance; this topic is well discussed in this book.
   - Unmanaged code interoperability: the topic how one can integrate with legacy system thru unmanaged code. Whether you are talking about Java/C++ or other older programming languages, at some point you need to access or use what is known as unmanaged code. The authors explain how this can be accomplished.
   
   In two words: Great book! If you are new to the C# programming language or consider yourself a C# savvy developer, you will benefit from this book.
   



5. I find myself reaching for this book all the time for answers to common problems. I have never read this from cover to cover but simply use it as reference and it has come through for me 99% of the time.
   
   I highly recommend this book.

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.