After many years of scientific programming using C++ and MFC, I was looking for a book to help make the transition to application development using C#. The authors' treatment of fundamental concepts like dialogs, printing and background worker threads, complete with descriptive examples, continues to make this book extremely useful as a reference in new projects, and when porting legacy code to Windows Forms.

Appendices that deal with the differences between MFC and Windows Forms, as well as a C# implementation of document management will be of particular interest to MFC programmers.

This is a highly recommended addition to any .NET programmer's library.

I am not a collector of C# books, although I have reviewed many tens of them before settling on two. Chris Sells' Windows Forms programming is one of them (Jesse Liberty's Programming C# is the other).

Chris does not hand-hold the reader through tediously simple explainations; as other reviewers have mentioned this is not the book to buy if you want photos of which button to click at every step. Instead he provides good high and medium level explanation of every common problem/situation I've encountered with Windows Forms programming (and many more), and backs that up with sample code. That means this is not an attempt to write a comprehensive encyclical, but is enough to solve most problems, and when not, let's one intelligently Google the necessary question.

So far, I've only had one Winforms question that his book could not answer, which dealt with comparing Winforms 2.0 to a new Windows Presentation Foundation version released after the book's publication. Chris answered my question personally the same day I asked him...that's pretty amazing.

Windows Presentation Foundation has been released and we will all immediately stop doing WinForms development and move to the latest and greatest technology. Right. WPF may take over the world -- but not right now. Plenty of folks will still be doing Windows Forms development for some time. Ergo, this book is a great resource to have on the shelf.



The writing style's clean, clear, and concise, and the examples all show the right level of detail. Graphics throughout the book are good, and there's even a full-color section in the middle of the book to show off how nice various WinForms displays can look. (Although I should note some of the figures there aren't particularly interesting.) A very handy "New" marker in the margins highlights features and functionality new to the .NET 2.0 framework -- a great benefit for folks experienced in 1.1 development who are looking for quick exposure to what's new in 2.0.



The book's content is terrific and extremely useful. There's a solid introduction which hits all the important fundamentals of WinForms development and also hits the right features you'll need in Visual Studio. There's awfully good coverage on basics such as form lifecycle, MDI basics, data validation, and why/how properties are important in WinForms development.



The authors do a very solid job laying out other important concepts like data binding and validation. There's also a great amount of background on localization through the entire book, and I found the chapter on resources particularly informative. The bits on components and custom controls were also a very good read.



Overall it's a solid book and very useful for folks still working in WinForms development.

Windows Presentation Foundation has been released and we will all immediately stop doing WinForms development and move to the latest and greatest technology. Right. WPF may take over the world -- but not right now. Plenty of folks will still be doing Windows Forms development for some time. Ergo, this book is a great resource to have on the shelf.

The writing style's clean, clear, and concise, and the examples all show the right level of detail. Graphics throughout the book are good, and there's even a full-color section in the middle of the book to show off how nice various WinForms displays can look. (Although I should note some of the figures there aren't particularly interesting.) A very handy "New" marker in the margins highlights features and functionality new to the .NET 2.0 framework -- a great benefit for folks experienced in 1.1 development who are looking for quick exposure to what's new in 2.0.

The book's content is terrific and extremely useful. There's a solid introduction which hits all the important fundamentals of WinForms development and also hits the right features you'll need in Visual Studio. There's awfully good coverage on basics such as form lifecycle, MDI basics, data validation, and why/how properties are important in WinForms development.

The authors do a very solid job laying out other important concepts like data binding and validation. There's also a great amount of background on localization through the entire book, and I found the chapter on resources particularly informative. The bits on components and custom controls were also a very good read.

Overall it's a solid book and very useful for folks still working in WinForms development.

This book is great, exceptional, outstanding.
The authors take on a subject of mind-boggling complexity, and manage to structure their way into a readable, understandable explanation. It's not a reference book: you have to read your way through it from cover to cover, once, to gain an understanding of Froms 2.0. Yet such reading is probably the most efficient way for you to learn the subject. Thereafter, use it as a "how-to" reference for specific items and techniques.

Also, it assumes familiarity with both the c# language and the casual use of VS05. Having first done some elementary c# programming on VS05, read the book and it'll be an eye-opener.

This book is great, exceptional, outstanding.
The authors take on a subject of mind-boggling complexity, and manage to structure their way into a readable, understandable explanation. It's not a reference book: you have to read your way through it from cover to cover, once, to gain an understanding of Froms 2.0. Yet such reading is probably the most efficient way for you to learn the subject. Thereafter, use it as a "how-to" reference for specific items and techniques.

Also, it assumes familiarity with both the c# language and the casual use of VS05. Having first done some elementary c# programming on VS05, read the book and it'll be an eye-opener.

The writing style is easy to follow, the coverage is comprehensive, and there are details and tips throughout the book that distinguish it from other books on the subject.

The authors clearly leverage their knowledge and experience. Sample code is clear and concise. There are many things in Windows Forms that you simply should or should not do; the authors convey these best practices in an expedient fashion.

The book is relatively new, and there is not an errata page on the AW website, however I noticed only a very small number of errors.

The writing style is easy to follow, the coverage is comprehensive, and there are details and tips throughout the book that distinguish it from other books on the subject.

The authors clearly leverage their knowledge and experience. Sample code is clear and concise. There are many things in Windows Forms that you simply should or should not do; the authors convey these best practices in an expedient fashion.

The book is relatively new, and there is not an errata page on the AW website, however I noticed only a very small number of errors.

OK, I'm a little ticked off because I have just wasted some money. If you're a VB developer like I am, this book is not for you. If you're a C# developer, then maybe it is; maybe it isn't. I don't know. All the coding examples are in C#, although the title of the book doesn't say it's exclusively C#. I gave it four stars (since that's the current overall rating) just so I wouldn't be responsible for changing the overall rating. And considering I'm really ticked off at the moment, I'd say that's pretty good of me.

Now for my rant:

I just don't understand why in the year 2007 these authors and publishers can't properly identify whether their books are for VB or C# developers if they're going to make all of their coding examples in one or the other language. While most do, many still don't, like these authors. If you're not going to indicate which language, then include examples in both. If you're only going to show all the coding examples in just one language, THEN INDICATE THIS IN THE TITLE!!!

Is this done to purposely trick people in to buying a book they can't use just to increase sales?

This may be the best Winforms 2.0 book out there. It serves as an excellent reference, given the breadth of information that it covers. It also is a great way to learn Winforms from scratch. Sells does a wonderful job of explaining how things work and has very clear and understandable examples.

This may be the best Winforms 2.0 book out there. It serves as an excellent reference, given the breadth of information that it covers. It also is a great way to learn Winforms from scratch. Sells does a wonderful job of explaining how things work and has very clear and understandable examples.

This is a mixture of reference and in depth overview. It covers all of the features and design ideas behind windows forms 2.0, but it does not walk the user through an entire application or attempt explain every subtle property or event of the DatagridView for example.
I learned about how to use many useful features of the new framework from this book and it gives a solid overview of windows forms.

I purchased the first edition of this book not long after it came out and subsequently bought this, the second edition (covering .NET 2.0). These are the best books I've found for Windows Forms programming.

One of the problems I've had with other books (e.g. the books by Charles Petzold) is that they will often show several ways to do the same thing with no discussion as to the advantages and drawbacks to each. In Windows Forms Programming, the authors get to the point and concisely explain the reasoning behind the code shown. As an example, in the beginning of the first chapter they start with creating your main form and displaying it - just a few lines of code. But they show that there are a few ways one might consider doing this which are wrong and explain why, going on to show the canonical way to start your app's main form. With experience, what they show seems obvious but as someone new to Windows programming I found this instructive. The Windows API is huge for someone coming to it for the first time and there are often many different ways to do a one thing. I felt like this text gave me some of the same 'group wisdom' that I got from many of the great Unix programming texts I've used in the past (APUE by Stevens for example). Just because something can be done a particular way doesn't mean it's the best/'right' way to do something and this text seemed to show just that.

I also found the writing style very readable. This book didn't strike me as being for completely inexperienced/beginner programmers, but it's completely accessible for beginning Windows programmers with clear explanations that were just the right length. Based on other books I've purchased, I've found that most other authors in this area seem to enjoy explaining and will use 20 words where 10 will do. I won't mention any more names of competing authors, but I hate reading programming texts that spend half their time trying to be witty with silly chapter titles and long-winded text. I don't like going back to look something up just to find, e.g., a chapter entitled "Console Thyself". I want to get the information quickly and get back to work. This book seemed logically structured and until now moving to WPF, I referenced the text often.

Highly recommended.

This book is King of Forms! It covers all the topics needed to build a strong, full featured "Windows" like form. One of few programming books I have actually read from cover to cover and it still serves me well as reference. A must have text.

I have been programming for nearly 20 years. Starting from Pascal and FORTRAN to C++ to Java and C#. Needless to say I have to keep reading new books and material to keep up with innovations in software development.

Unfortunately, I have found Windows 2.0 to be perhaps the most useless book I have ever read in the area of software development. Good books are either 'primers' to introduce new users to a language or 'tutorials' to show certain tool, like an IDE, or a language or a book is a 'reference' where practitioners can turn to for advanced topics and hop around as needed instead of going through from start to finish. This book is a lousy fit for any of these catagories.

It comes closest to a reference but an incomplete one. For example, have a look at MaskedTextBox control in chapter 3. It gives a simple definition of what it is and its benefits (you can get the same and more on the web for free) but fails to mention mask tokens that are used for automatic input validation in MaskedTextBox. From nearly a 1000 page monstor one expects explanation of such basic features.

I found that any topic/chapter I have read has failed to enhance my understanding or knowledge at a theoretical or practical level.

Organization? Perhaps in a Faulkner stream-of-consciousness sense. "Applications" is _chapter 14_. The topic emphasis has little to do w/ the needs of most developers. You get two entire chapters on "Design Time Integration", whereas you get a small (two page) subsection on "Keyboard Handling" and likewise "Scrolling". Gee, how about if I want to handle the _arrow keys_!? Maybe you could explain scrolling in more than a paragraph of English text? How about an example? To top it off, it's in a narrative & chummy style. Yuck.

The basics of Windows forms programming are fairly obvious. You drag controls from the toolbox onto the design surface, set the properties as necessary, and wire code to the events. For simple apps this is all you need to know and you typically don't need to bother with the documentation.

Fortunately for us, Microsoft didn't stop with the obvious. This books contains excellent coverage of many advanced topics, including:

* the form lifecycle
* form extras such as tool strips, status bars, tool tips, and on-line help
* drawing directly to the screen using brushes, pens, and fonts
* image processing
* writing to printers
* creating your own components/controls, including how to fully integrate your controls into the Visual Studio design environment
* how to manage resources
* internationalization
* user settings
* data binding
* multi-threaded forms programming
* Click Once
* drag and drop

The book doesn't try to replace MSDN. You wont find a list of properties and events for any of the controls. You will find a clearly written tutorial on the things you need to know to write a great Windows forms application.

What a disappointment. I went in to this book knowing almost nothing about Windows Forms. After reading it, I think I know less now than when I started.

It's hard to describe what's so wrong about this book. I think someone else who reviewed it said that it's neither a beginner's tutorial nor an advanced guide to Forms. That's so true! It's like the authors cobbled together little scraps of knowledge about MANY different aspects of Forms programming and called it a book. There's absolutely no depth here. They typically start off talking about a subject, and then quickly end this discussion with an implied "...the rest of this should be fairly intuitive. Now, on to the next mini-topic..."

What a waste. This book could have been so much more. I think they could have put the paper is was printed on to a better use by just printing out all of the Microsoft Forms namespace members/classes/etc. I learned a lot more about Forms by just looking at the free info on MSDN. Save yourself the $40 and do the same.

I own Chris Sells "Windows Forms Programming in C#". This is an absolutely excellent book. I was expecting that "Windows Forms 2.0 Programming" by Chris & Michael will be mainly an update and extension to version 2.0. Unfortunately, this is not the case at all. The book is a mess with bits an pieces all over. Compared to the formarly mentioned book the examples are bad and often not very helpful. The index is terrible, too. At the time I bought this book (I ordered it before it was out) it was the only one about Windows Forms 2.0. If you find another one don't buy this book. If there is no other one, well, I guess then you don't have another choice...

This book is all over the place, it doesn't provide good step by step instructions and it is not a good reference.

The book contains overview of Windows Forms 2.0, and some how-tos of using VS designer to lay out form controls (UI widgets).

The overview is shallow, the how-tos are perfunctory, and it is adeqaute neither as reference nor tutorial, yet the author manages to inflate it to over 1000 pages.

I'm disappointed at AW and the series editors - AW technical titles used to have consistent and high editorial quality.

Chris Sells and Michael Weinhardt have written an informative book with their latest "Windows Forms 2.0 Programming." After completing this book, or just reading a couple of key chapters, any developer will have enough information to put together a decent windows forms application. My favorite aspect of this book is that they introduce how to work with a particular concept and then show you how Visual Studio 2005 makes it all that much easier to do the same concept. The balance that is struck between instruction for hand written code and tool written code is just wonderful. In particular the chapters on Components, Controls, Design Time Integration, and Data Bindings are essential reading. I put this book on my must read list for .NET development.

This is a great book for anybody who has to work with windows forms, covers the majority of subjects with bundles of code examples its definatley the strongest book in its field.

Its also suitable for beginners so don't think this is just for pros.

Microsoft is well renowned for usually doggedly improving its products. This book by Sells and Weinhardt shows that trend in action, with its description of MS Windows Forms 2.0. It describes major improvements over version 1.

The book is all about UI programming in a Microsoft operating system. The code examples are written in C# and the text shows a close interaction between Forms programming and the .NET framework. What is also interesting is the authors' remark that Forms 2 focuses on writing code for client applications, and not necessarily for web-based applications. After all, the very name .NET was chosen in the expectation that the latter would be what a lot of programmers would want.

It is hard to tell what an arbitrary reader of this book might be looking for. But, as a guide, there is now a consistency possible in the look and feel with that of MS Office. The authors allude to a considerable demand in the marketplace for this. And given Microsoft's dominance with Office, this should be no surprise. Although one should add that you are not restricted to your applications having an Office-like look and feel. There is considerable leeway in customising, with code showing how this is done.

Also, if some of you have written HTML pages, or web applications that use JavaScript or JScript, then Forms gives you a far richer set of widgets. It can make writing static HTML or HTML/JScript seem very restrictive.

The layout of the book and its content should not present any problems if you have done some previous graphics programming (and not necessarily restricted to Microsoft environments). Most of the chapters deal with topics that are now common to any major graphics package. So there is a chapter on drawing basic entities like lines and curves, and filling areas. Another chapter on drawing text. Another on laying out widgets inside a Form (window). Obviously, the syntax is specific to Forms. But not the concepts, and if you already have those, everything else will be straightforward.

Truly an excellent book on Programming Windows with 2.0. This book should be on every Windows programmer's shelf. I am very impressed.

Before this book, I had very little Windows Forms 1.0/1.1 experience. So, I can't speak to how well it works for people who are moving from the 1.0/1.1 world into 2.0. But for those starting with Windows Forms 2.0, this covers data binding to a depth I doubt will be surpassed by any other source. Ever.

The only reason I don't rate it 5 stars is that while it does cover using DataSets and DataTables as the objects to bind to, and it does cover using custom data-bound objects and collections, I felt the focus was more on the DataSet/DataTable aspect. I personally have a fondness for custom business objects, so I had hoped for more coverage on how to do this *easily*.

He does cover how to make a custom data-bound collection and class, but it surely is a lot of work - perhaps if he could have provided some base classes (generics might've helped a lot with this) as a download, with a lot of this stuff outlined in skeleton, it could have made it more plausible to implement a very rich custom databound class or collection. As it stands, the prospect is daunting.

I won't get into the holy war over DataSet vs. custom business object, I just note that my preference is custom objects and this book makes data-binding with them a bit more daunting than I had initially thought it would. But, perhaps this is just a fact of the .NET Framework - DataSet is a massive piece of functionality, and getting all of its binding richness in a custom object may be just that hard without any alternative - I was just thinking this book would help in making it easier.

In all, this is an incredibly solid book, with excellent coverage of the entire scope of data binding, and very readable from start to finish. I read every page, and find myself much more prepared to exploit data-binding now than I was, and it's a great reference that I'll keep around for years.

There are just a handful of writers of which there is a need to get editions of their books as they come out. For me, Chris Sells is definitively one of those writers! And from the looks of it, Michael Weinhardt could be one of them too.

The books are concise, and practical. They explain real problems, for real programmers in a real world. If you can only have one book on Windows Forms, this is it! Period.

I am thrilled to own the second edition too, now.

another excellent book from mr. Sells. has thorough coverage of the rich UI environment that .NET provides for windows application development. this book has complete coverage of the enormous jump in Microsoft's framework from version 1 to 2. from dialogs to settings to deployment and includes a very helpful set of appendices which includes special coverage of drap and drop, delegates, a component reference, some MFC comments, and more.

Had this book on order since before it came out.
I finally got my copy a week ago and it's come in handy every day since.

With such a large volume of information and hogh number of topics covered, the book is a great place to go to get at any of the WinForms fundamentals.

While some topics are only touched on briefly, they all provide a great place to start.

The Data Binding chapters were particularly great. One read over completely demystified databanding for me. The presentation is logical and starts from a "common sense" place and then shows how WinForms features accomplish what you would otherwise do by hand.

Highly recommended book to have for any person or shop that develops WinForms apps.

When great brains gathered to write about the most popular development platform over the (yet) most popular operating system, the result is enjoyable journey in the .Net fields.

All major subjects are covered with unique Sellsy humor that delivered the C# Bedtime Story and such.

This book is recommended even to those who write Asp.Net apps since its dealing with the .Net fundamentals.

If you do serious Windows programming this is a must have book.
Chris and Michael covered nearly every aspect of Windows 2.0 programming, from "Hello World" to ClickOnce, from GDI+ to Databinding in a pleasant to read big book where every argument is described in a detailed way.
I recommend this book even if you own previous release, it has nearly totally rewritten and (that's what i like most) it emphasize what's new on version 2.0.

While this book explains Windows applications fundamentals in great length, it covers the most advanced topics like Delegates, Events, threading, ClickOnce deployment very well.
It's a great all-in-one book for windows application development. It covers database applications, Graphics, Visual Studio integration and internationalization.

agarwalmk at hotmail dot com