Windows Forms Programming in C# (Microsoft .NET Development Series)

• #14 in Best csharp Programming Books

90 Reviews

Sort by: Most Helpful ▲ Date Rating

I bought this based on the rave reviews on Amazon but I must say after a couple of weeks I am very disappointed by this book. I had hoped it would be a convenient and quick reference to such questions as "how do I use FolderBrowserDialog and/or OpenFileDialog to open a file in my C# program?" but although these standard components are indexed in the book the discussion of them in the book is shorter than this review I am writing. What I would want is some kind of sample code, maybe a step-by-step description of how to add the components to my program. I am left wondering what exactly is filling up the 658 pages of this book. I much prefer Sharp and Jagger's Visual C#.Net Step by Step both as a tutorial and as a general reference.

Windows Forms Programming in C# doesn't disappoint.

The book quickly dives into the basics of form development, layout and resources. Even though the topic is somewhat introductory to someone who's done a lot of Windows Form development, the book is written in such a way that there was several times still found myself learning something new. I particularly enjoyed the chapters on drawing, there's always something interesting to be found when working with GDI+.

200 pages later, I found myself in a chapter that discusses a topic that you rarely see in any Windows programming book - Printing. This chapter is worth the price of the book alone to have it on your shelf as a reference guide. You won't find a more detailed coverage of printing anywhere else.

While I could go on and on about each individual chapter, I wanted to point out one that I particularly found helpful - Chapter 14 on Multithreaded User Interfaces. I had originally read part of this in an MSDN article, and was looking forward to the full content - and wasn't disappointed: Asynchronous operations, Safety and Multithreading, Callbacks (synchronous and asynchronous), etc. are all covered.

Anyways, I could go on and on - there are plenty of tasty .NET morsels in here to keep both the novice and experienced developer consumed with this book.

First I want to comment on this book only. My negtive comments do not mean other books are better than this one. I just do not know other books.

Source code problems:
When you read book, you rarely find he reference the example. You have to download the example source code from his personal web site (strange to me). Then you find it is a total mess. A lot of rubbishes are not cleaned and even the runtime exception can be seen. If the money I paid includes such code definitely I want it back.

Printing chapter problem:
Visual C# has a clear rute to control printing. That is one document plus 3 dialogs: PrintDocument, PrintDialog, PrintPreviewDialog and PageSetupDialog. But the book author put them under the topic like PrintController, PreviewPrintController which are something advanced user should know.

Controls chapter problem:
The author only talk the standard controls very very briefly. There are so many topics need more detail but missing, like LinkLabel, ListView, TreeView and scrooling picture/text/listView/TreeView. His LinkLabel cause runtime exception too. For example, how to play on the ListView and DataGrid are the big issues and I have to go to online help to learn them. If best treatment is 100% I give this chapter 50%.

Multithreaded User Interfaces chapter problem:
1. Why not to introduce Application.DoEvents(). No thread or delegation are needed any more.
2. In order to calculate 1000 digits of PI, 1000 ShowProgressHandler delegate thread are created and then garbage collected. This is wrong. The correct treatment is to create one ShowProgressHandler delegate thread and call it 1000 times in CalcPi function. Do not abuse multithread.

I'm a Java programmer who finished reading O'Reilly's "Programming C#" (very good book), and wanted to get started in Windows Forms programming. Chapters 1 and 2 were decent and Appendix B was an excellent introduction to Delegates and Events.

The rest of the book, however, was very weak. All it did was give a brief summary of some of the windows forms components (and the coverage was very weak). If you want to learn about a component you are going to have to look it up it on MSDN.

I was hoping the book would give me something other than what I can get by looking at an API. I was really hoping there would at least be a few chapters on how to design Windows Forms applications - there was nothing. The easy part is learning how to use a component. The difficult part is learning best practices about design an application - something this book didn't touch.

Also, I'm not sure how the rest of the books in the "Microsoft .NET Development Series" are, but I think it's very cheap and dishonest to make a book 'appear' weighty. The book is 680 pages, but the margins, line spacing, and text are all very large. This book easily could have been half its size.

I've been a big fan of Chris Sells since I discovered his website while conducting background research for a telephony project. His website is loaded with well-written and useful information for developers of all levels; this book is no different.

Crammed with practical examples, this book manages to avoid what I consider the cardinal sins of most programming books: not knowing the target audience, and not knowing how thin to spread the material. Neither is an issue with this book: there is introductory, intermediate and advanced material covered throughout, none of which is at the expense of any other level; there is little extraneous information and lots of on-target information on what seems like every topic a .NET rich-client developer will face.

If you are at all interested in rich-client development, be it UI, controls, components, or soup-to-nuts WinForms development, this book is for you. Where Petzold provides an excellent overview of the basic WinForms objects and namespaces, Sells fills in the gaps in Petzold and expands upon that base to cover issues faced every day by real-world developers. Buy this book; I don't think you'll be disappointed.

"...I had hoped it would be a convenient and quick reference to such questions as "how do I use FolderBrowserDialog and/or OpenFileDialog to open a file in my C# program?" but although these standard components are indexed in the book the discussion of them in the book is shorter than this review I am writing. What I would want is some kind of sample code, maybe a step-by-step description of how to add the components to my program..."

There's no way I could have said it better. The book seems to want to cover "everything" but actually manages to say "nothing".

The only part in which I would have to disagree with the previous reviewer is his rating. He gave it three stars. I think it deserves one.

Before buying Chris's book, a friend recommended another book as the best C# WinForms book, so I bought that one. It was my second one on this subject. I didn't find anything useful in it, and I almost concluded that all WinForms books were going to be worthless for me.

However, I still needed some good answers to WinForms questions, and resources such as the newsgroups weren't giving them to me. So I bought this book and a few others as a last effort to find intelligent coverage of this topic. Chris Sell's book totally changed my opinion of WinForms books -- Chris has shown that it is possible to cover this subject the way Troelsen covered an introduction to C# (Troelsen's book was voted best .NET book in the world, btw.)

This is a highly useful book full of intelligent information. It covers the basics, but also provides depth and detail.

I'm a good C# programmer, but I have done very little with WinForms. This was definitely the book I needed. I really think it is the right book for almost any level of WinForms experience. There are good tips in here that will benefit experienced WinForms developers. For example, I've seen smart people debate certain WinForms issues on the newsgroups in lengthy threads, without a clear resolution -- one quick read of a section in Chris's book could have clarified and resolved the issue(s). For every topic like this that I needed to understand, Chris took me from the basics to a full and in-depth understanding.

(I almost feel like going back to all those newsgroup threads and posting answers out of Chris's book. It would make me look like a genius. If you want to be smarter than the average WinForms "expert", read this book.)

Chris Sells has used his knowledge and writing talents to provide a clear picture of the WinForm world, browsing each notion in the right order and explaining one complicated notion at a time when needed.

After digesting the WinForms basis in the chapters 2 and 3, you'll understand how the pieces are working all together, from the Application class to the WndProc method, last frontier with the old Win32 world without forgetting features not often detailed such as the HTML help system or the MDI layout.

The Chapters 4 to 6 are dedicated to GDI+ and give you a complete reference of color, brush, pen, shape, path, images, font and text. You'll see the basic stuff but also how to handle transparency, animation and optimized drawing, advanced string formatting and Transforms.

If you have to send your rendering code to a printer, chapter 7 is for you: you'll learn how to use the common dialogs and how to put your code in the right place during the printing workflow. Maybe a complete document printing example would have been better for code reuse than the different smaller examples.

From here, the chapters dig deeper in complicated notions and this is where its value shines. With the chapters 8, 9 and 10, you'll see how to use the existing controls and how to build your own controls that smoothly integrate the Visual Studio IDE and enhance code reuse. The localisation and resource usage in the managed world are clearly described and you won't loose hours trying to access resources in your code anymore!

The chapter 11 focuses on your program execution through the Application, Registry/RegistryKey and Environment classes. The section related to the application settings and Isolated Storage itself is worth the price of the book!

The mecanisms behind data access, dataset and data binding are detailed in Chapter 12 and 13.

If you want to check that this book is really for you, look for Chris Sells articles on MSDN and MSDN Magazine web sites. The last two chapters about Web based deployment and multi-threaded GUI treat how to solve the same kind of problems. As you'll see, the rest of the book offers the same level of quality, with details and solutions you'll find nowhere else.

I have a tiny regret: I would have expected more "under the cover" journeys based on decompiled views of .NET assemblies for an even better understanding of the relationship between classes of the Framework. I'll have to keep on playing with Anakrino and Reflector, waiting for your next "Inside/Undocumented WinForms" book Chris :^)

As a computer scientist pursuing a Masters Degree, and teaching undergraduate courses, I am very picky about reading and learning material, even when choosing such material for my own education or enjoyment.

Also, while I appreciate new technology, I also fear aspects of it, such as "Form Designers" and "Drag and Drop" rapid prototyping of the GUI, without knowing the hidden code underneath it all. These are all wonderful tools, but my concern has been future generations of computer scientists with only 'dumbed down' knowledge of computer science and programming languages.

This book solves all of this. It not only shows you aspects of the built-in rapid GUI construction capabilities of VS .NET, but it shows you how the code works, and how to code such things by hand.

However, I WOULD NOT recommend this to someone who has had NO experience in C#. I would recommend getting Microsoft Visual C# .NET Step by Step guide first, and then perhaps get this book. This book makes some assumptions about your knowledge of terminology and C# itself.

Nevertheless, this is an incredible addition to any C# developer's library. It is easy to read, enjoyable to learn with, and maintains overall excellent quality throughout.

The book "Windows Forms Programming in C#" will not disappoint you.

This book is targeting both programmers with experience developing in .NET and those who still haven't and who are looking to start doing that.

This book is using C# for explain all topics. You should be familiar and have basic understanding of C# language.

I found the book to be easy to read and I think you can learn a lot about writing Windows forms application from it.
The book is well organized and you will find it useful during your .NET Windows Forms development.

Here, you will find everything that you need to know and learn about developing Windows Forms: basics of using forms, controls, events, multithreaded UI, "no-touch" deployment, data binding, etc ...

Highly recommended.

What stands out for me after reading this book is the quality of the code examples (which you can download from the author's website). There are complete sample programs for every chapter. For example, there's a dialog program that shows you all the different types of common dialogs, examples of SDI / Multi SDI / MDI applications, and a controls program that demonstrates all of the different types of user controls. I think the author's intent with these examples (and the book in general) is to try to cover as much of WinForms features as possible, rather than focus on detailing every which way to use a TreeView control. For such details you need to go somewhere else, or look it up on MSDN.

I thought the second half of the book was better, with its coverage of more advanced topics such as integration of custom components within Visual Studio, multithreaded UIs, and application settings. Where I think the book falls short though is in the presentation, and its usefulness as a tutorial for beginners. First of all, it's important to note that the book does not teach you the basics of C# or .NET. So if you have never heard of WinForms before, you really should start off with an introductory Visual C# book before looking at this one. Problems with the presentation include the fact that the author does not really reference the code examples in the book itself. Typically, only partial code snippets are shown and there is this convention of using "..." in the code sections throughout the book which makes it difficult to follow - I found myself having to flip back and forth between pages to recall exactly what code the author has now considered "superfluous" (in his words).

Basically, the content and coverage are there. But the book doesn't seem to be as polished as its MS Press counterparts. I would recommend waiting for a future edition that will likely use VS 2005 examples.

Worst book ever from Chris Sells. No real explaination, touch and go...this book should named How to use C# with VS.NET instead.

In general, this is a pretty good book. Chris Sells does a decent job of giving the reader an introduction to WinForms programming. The first 110 pages are truly excellent reading.

As the book progresses, however, one gets the impression that Chris is trying to jam a few too many topics into this book. Yes, WinForms is vast, and certain topics get glossed over, and the excellent flow established within the first hundred or two pages doesn't appear consistently throughout the rest of the text. I would have preferred fewer topics in more depth, and more conceptual coverage.

I got the impression that this book might have done better as a two volume set, the first with more of a conceptual hands-on coverage of WinForms with practical examples, and the second volume offering more of a reference of available Windows Forms controls and components, with plenty of references to Microsoft documentation.

So I'm giving it 4 stars. It's a very good book overall, but I can't say that it is far superior than a comparable O'Reilly/Jesse Liberty book (maybe just a bit better? maybe not?)

Rather than focus too obsessively on finding the perfect introductory .NET WinForms book, I recommend buying this or a comparable O'Reilly book without much online research, and spending more effort in your search for an intermediate->advanced .NET programming book(s). I do think that "Programming .NET Components" by Juval Lowy (O'Reilly) is just such a book, and would be worth taking a look at.

WinForms is the main starting point for .NET programming and you can expect the major publishers and authors to cover this topic well enough for you to get up to speed. Most of work required to get up to speed with WinForms involves you playing around on your own with Visual Studio .NET with the help of one of these WinForms books.

The book is not only full of usefull information but so well organized that can be used not only to learn the concepts but as support tool during development. Even containing so many concepts the writting is so well done that is easy to read and understand. Don't forget to download the supporting code from the web as the book doesn't include a CD, the address to download the code is http://www.sellsbrothers.com/writing/wfbook/

I got this book after having already done quite a bit of WinForms programming and found it a compelling read. I'd have read after a platform/language primer but before doing any actual WinForms work, had I had it in my possession at that time.

Its the first programming book in some time that I read as a 'page turner' - it's that well-written (in prose terms).

It's also very well copy-edited, which shows that a lot of effort went into getting the book just right, which can't be said for all books (I guess the gap between release of .NET 1.0&1.1 and this book allowed for that more than in other books).

As for the relevance of the information, I believe it to be very relevant to a wide variety of application types, regardless of that being the main criticism I see in other reviews here. I guess that comes from the fact that you can't please all the people all the time. Still, I'd venture it comes as close as any other book is going to come.

For me it's very near the top of the must-have books if you're going to be writing non-trivial production WinForms apps.

One thing to be aware of is that the .NET 2.0 version is on the way in the coming months, making it Essential unless you're not in a position to use 2.0 stuff.

This book is a good introduction of Windows Forms programming. Author shows his style and history are definitely from the VB world. So if you are a VB programmer, this is probably at your level. Covers Forms well and the standard controls. Was sorely lacking details about more interesting controls such as DateTimePicker and TreeView.

But if you are looking to do custom controls and apply object oriented techniques, you will find it wanting. Relies very much on Visual development and its "magic". Sure wish he would have covered the trapping of dialog keyboard events.

His no-touch-deployment and security chapters makes the book worth buying. Also did a good job with Resources. Would recommend Petzold and this book to complement each other. Bottom line, its worth the buy.

This book covers a lot of topics from how to create a rectangle to custom controls to XML and resources. I primarily bought this book to understand how to manipulate windows user interface on the control level. Unfortunately book doesn't provide enough information about exposed methods of controls and doesn't tell you how to override their behavior. The examples given in the book are very short and do not allow you to see the full workings of the class or method being described.

This book has a lot of 5 star reviews. This was the reason why I bought it, so may be there is something there for you, but I'm talking it back to amazon and hope to get something better for my purpose.

As the author of a pretty popular windows forms application ( http://www.sharpreader.net ), I thought I knew a thing or two about programming windows.forms. So, despite all the excellent reviews here, I delayed buying this book initially and just figured stuff out on my own through the .net docs, msdn and various weblogs.

Now that I finally got my own copy and read it though, I see just how much I was still missing. This book is packed with tons of useful information on windows forms, controls, custom drawing, printing, data-binding, threading and web deployment of winforms apps. Not only that, but it also contains many tips on how to use Visual Studio.NET effectively to easily get to all this functionality.

If you're a windows forms developer, don't make the mistake I made and get this book ASAP, you won't regret it.

This book was written in a style that assumes prior knowledge of the material. In other words, much of what is written will make no sense whatsoever unless you already know the material, which makes much of the book useless. For example, the author states in the section covering Data Binding (Current Data Row): "The Position property is fine when it comes to navigating the rows currently shown, but it's not good for finding the current row in the data table". What does "currently shown" mean? What does "current row" mean in the context of DataSets, which have no concept of a current row? Is he referring to a Data Table object somewhere? In short, this sentence is useless. The rest of the treatment on this subject is the same. Useless. If one were to actually READ this book, they would find that there are many such examples throughout. That is unless, of course, one already knows the material, in which case the book is a waste of money.

One of the first things I noticed about the book was the unique approach to the presentation of material that Chris took. Many books on GUI development take the approach of showing only one way to create applications using the wizards and designers baked into the IDE. Other books eschew the IDE completely and focus on development with nothing but text editors and command line compilers. Chris takes a hybrid approach. He recognizes the fact that many readers want to use the IDE for most if not all of their daily work, so he spends a considerable amount of time discussing the Visual Studio .Net forms designers. He also knows the importance of looking under the hood and spends quite a bit of time examining, explaining and modifying the wizard generated code. After reading this book, you should be able to use the IDE efficiently and really know what it is doing for you, so youll be able to color outside of the lines when you need to.

The book is also a pleasure to read. Chris obviously has a great command of the language, and knows how to speak to the reader. You can expect an interesting and entertaining experience that keeps you turning the pages.

A good portion of the book is dedicated to making standard windows GUI applications using Windows Forms. These programs have windows, dialog boxes, text boxes, buttons, labels, menus, etc. Chris starts with the basics of creating an empty window, and advances at a quick pace to creating complicated user interfaces that accept and validate data, support resizing and layout, while explaining everything in a clear and concise manner. For comprehensive coverage of the standard controls, Chris supplies Appendix D.

Once you get bored with the standard controls, and trust me you will, you will want to venture out and either customize existing controls or even create an entirely new control from scratch. Again, this book wont let you down. There is in-depth coverage of drawing with the GDI+. There is excellent coverage of text and fonts, and even some discussions of why working with text is so hard, and what you can do to get it right. When you have perfected your text layout or created your masterpiece, youll find out how to create output on the printer.

As anyone who has written a commercial application knows, having a flashy GUI is no guarantee of success. Many more details must be covered to turn your program into a commercially viable, quality software application. Again, Chris helps here by covering topics such as Settings, Application Lifetime Management, Resources (and localization). Once youve finished you app, you can turn to the chapter on Web Deployment and learn one way to get your application into the hands of your users.

The bottom line is that Chris knows his stuff. He presents the material well. This book will help make your applications shine.

I purchased this book a few months ago and I haven't placed it in my bookcase yet, I'm continueously referencing it!

The format is great and topic detail is execellent! A specific example is the Long-Running Operations topic in chapter 14 where control interaction across threads is explained in detail and much more clearly than other books I have referenced.

This book is THE definitive guide to Forms and Controls programming. It is comprehensive, lucid and contains great examples. It doubles as a teaching book and later as a fantastic reference book. Few books can boast that. I had read the book before I took an advanced .NET training course by Wintellect (Wintellect and DevelopMentor are the premier companies in MS and .NET training). The instructor Jason Clark, (Chris' competitor in .NET training and a contractor for Microsoft) highly recommended this book during the training course and it was the only one he recommended for Forms and Controls programming while recommending at least three books on every other area of .NET programming. Jeff Prosise, also an instructor from Wintellect recommends the book as well. It's really hard to top accolades from one's competitors. I am a bit astonished by the occasional low star ratings. It makes me wonder if these people actually read or even have a copy of the book at all. This book should be included in the MSDN reference library, it's that good (though I don't think Addison Wesley would agree with that suggestion). It contains info that is not even in the MSDN docs.

The last book I remember written that brought you up to speed with such complete understanding of a Microsoft technology was Scott Wingo's and George Sheppard's book "MFC Internals". I need a second copy of this book so I don't have to carry it back and forth to work each day. It's getting a little frazzled. Wish they offered it in hardback. This is the first book I have read that could come with a money back guarantee, and the publisher would not lose a cent. Don't waste your money, BUY THIS BOOK.

Note: This book is best for C# programming. If you are a VB programmer you will probably find Chris' other book "Windows Form Programming in Visual Basic" even better since it will have the examples in VB. You can bet the content there is as good as this book.

Very rarely do I read a programming book and feel this confused. In the opening chapters, the author, jumps through every major topic without a decent explanation. I found the book's organization and explanations poor and lacking. Ultimately, I just decided to buy a different book instead of trying and to figure out what this guy doing.

I'm developer form years. I'm just starting C# programming and I've bought many books about C# and .NET. One of them are too easy (and not enough detailed for me), rest assumed that people know .NET.

This book is different.
It is really good developers guide as well as novice or advanced developer.

Describes everything in detail, including many pictures. I like code presentation style - it is not many pages code listed in book - it shows only most important part of code.

Information presented in book is very realistic - I'm sure every developer can find there answers in most cases.

I must also say about text style of book - it's written like a good story - so reading it is big pleasure!

If you are interested in Windows Form Programming in C#, using VS .NET - do not thing too long - just buy this book - you will not regret this!

Good work Chris!

For any given topic there is a book or two that are a must have and Chris Sells' book falls in this category. The book covers all the key topics to building a serious production Windows Forms application including Localization, Drawing, Printing, & Multi-threading. Of all the books about this topic it covered more advanced topics than the others, particularly in using GDI+ to create customized user interface elements. I liked the book so much I accidentally bought it twice!

I had an incredibly fun time learning Forms with the help of Chris's book. Knowing all that we learned about VB/Java/C++, I knew Microsoft couldn't possibly wait to infuse some great new ideas in The Framework. Chris shows you what it is like to work with this framework, covering gotchas you should come to expect and highlighting hiddens gems.

At times, the tutorial is complete and gentle (but never condescending), at others Chris's in-depth Forms experience and understanding really shows through: C#, Visual Studio .Net and the .Net Framework brings many of the best practices to the table, and you'll be pleased to find Chris using all available facilities. Although everything is crystal clear, I was new to some concepts and I had to reread, your mileage may vary. Having said that, the editing and reviewing is excellent and it shines.

Whenever I read about a topic one would think to gloss over, I find myself reconsidering after reading what Chris had to say. Printing, Forms fundamentals, asynchronous invocations, components, data access, and application settings are just some of these areas which will really open your eyes. It turns out you'll be thinking about them a lot more often than you think, and making the wrong set of calls may reduce future code maintenance efficiency! The author was careful to show you all the most common patterns found in the wild, and takes care to explain why people prefer them, and he concludes by explaining to you why a certain pattern will give you the best mileage--great advices!

The honesty and depth of this work really goes a great distance in giving you the perspective of an experienced Forms coder. The cautions and advices will help you write some solid code in your first production Windows Form app. If all authors take care to expand on key topics with such care, my job would be easier. This is an excellent book to accompany your journey into Visual Studio .Net 2002/2003. You'll find it indispensible.

Follow up notes: Past reader reviews made a relevant observation: this book fills in the holes left by other .Net books--where others stretch your patience by listing every function call but not really explaining common patterns that use or avoid them, Chris's book will do the rest. You'll know which, how, and why to call. I read much of Programming Visual Basic .Net by Francesco Balena and a book from O'Reilly and Associates before reading this book (they are completely different books) and I have to agree, Chris's book fills in the conceptual gaps really well. What the API listings don't do for you, is connect the dots for you in a People-Shoot-Themselves-In-The-Foot-This-Way-So-Do-This-Other-Safer-Better-Thing-Instead--I think Chris's book accomplishes this goal really well. Maybe it is also prudent for you to think about the need to read more than one treatment on .Net, simply because it will give you the best chance of understanding it perfectly. Best of luck with your Windows Forms education! :-D

As an architect on the .NET Client Team, that produced Windows Forms, I find Chris' book to be an excellent overview of the breadth of Windows Forms. The first section does such a great job of providing an overview of the basic features, and then the rest of the book serves as a great drill down into each feature area. Throughout the book Chris lets his fun personality shine through, making the book very enjoyable to read.

I highly recommend this for anyone that wants to learn about Windows Forms.

The second edition is out that covers Windows forms V2, you may want to buy it instead.

I run a very small software development business and transitions in development paradigms are a serious matter for us. I have been working with MFC for many years and I am just starting to re-implement some of our software stock. I decided to take the C# route rather than fudging the MFC version. I have purchased about $1500 of books for my library in the last year. Each transition, I find that there are lots of books that provide endless detail and very little by way of explanation, and if you are lucky there is one that stands out as providing the bridge. In moving to MFC, it was Mike Blaszczak's MFC VC++4 that provided nearly all the rational explanations. During this current move to C#, I have found that it's Chris Sells book that has fulfilled that role. Many thanks Chris.

This is the one to have if you're transitioning from VB6 GUI development (RIP) and especially if you have some c++ background. While all credit must be given to Petzold and the newest version of his 'Programming Microsoft Windows' (with C#), Petzold does not address IDE-developed forms and controls. In fact he doesn't work with the IDE designer at all.

Sells gives you the skinny on working with forms, part tutorial, part cookbook. It's not really a primer (for example, the section on passing command line arguments from the second invocation of a single-instance program to the first is fairly heavy-duty), but you can treat it as such with judicious text-skipping. But don't mistake it for 'Learning xyzzy in 24 minutes'. And it's definitely not one of those list-like books that explains every control and component in the IDE. That's what documentation is for.

I found this book useful literally as soon as I opened it. While I've been programming for years, I'm fairly new to Windows, so most of this stuff is news to me. The book addresses a lot of the question marks left by the MS documentation. It comes at the material from a different perspective and takes a "lower-level" look at things, offering a explanation of "why," which augments the "how" that one can find in so many other places. I'd heartily recommend this book to anyone seeking a fundamental understanding of Windows Forms.

Whether you're approaching .NET for the first time or digging yourself out of trouble in mid-project, this is the book for you.

It's more than thirty years since I was a novice developer so I can't say this should be your very first programming book. It doesn't teach C#. It doesn't teach general programming skills. So maybe you could get lost if you'd never built a real application before.

Let's just say I've had more than a little experience building commercial applications. So when my next project was in .NET, I bee-lined to the big box bookstore and settled in for a long day of skimming every relevant book I could find. Most were easily discarded ... the 800 pound regurgitations of MSDN, the illiterate tours of the obvious, ... you know the breeds.

Then I picked up Sells on WinForms. My next few hours, wedged among the stacks, were rewarded with thoughtful, informative, clear, well-illustrated and entertaining accounts of subjects I desperately needed to know. If you are the least bit uncomfortable with delegates and events (or can't admit it to yourself but know someone who does), read the fairy tale in appendix `B'.

The early chapters on Forms and User Controls are a model of good pacing and rich detail. Sells doesn't tell us everything we could know. He tells us what we might want to know ... and why. He is superb at motivating each concept and example. Motivation aids our understanding and propels us forward through the chapters, certain of their direction and significance.

This wonderful book doesn't cover every topic and indulges some I could do without. I skipped the two long chapters on drawing, something I've never used in a business application. On the other hand, the "Applications and Settings" and "Data Binding" chapters are without peer.

Many months later, I've finished several WinForms projects ... and been well-paid for them. I'm still going back to this book, now mostly to compare notes. I've got my quarrels but I always find over-looked gems and subtleties that escaped my first few readings. Maybe I'll get around to those Drawing chapters.

One reason I come back is that I'm doing my own training these days. My company hires and trains seasoned developers and we train our clients too. Not all have .NET experience. I'm grateful to lean on Sells and I tell everyone: buy this book.

Everything changes in the Microsoft .NET Framework and the C# language, including the creation of graphical user interfaces (GUIs). Windows Forms Programming in C# explains the Windows Forms (WinForms) environment to programmers who have some experience with .NET programming, and in the process (thanks to a clear and deliberate expository style) reveals a lot about .NET to less experienced developers. The overall effect is that almost every reader comes away with better knowledge of .NET, not just its user-interface libraries and behaviors.

I have a lot of technical books that are purely "shelfware" and few that I've read cover to cover. I've read this book cover to cover and am starting over again to make sure I didn't miss anything. Even though I've developed in .NET and C# for over 2 years, this book has brought numerous time savings and good coding practices to my attention. I've recommended this to others in my development teams and they are equally impressed.

There are definitely elements for programmers new to .NET as well as seasoned pros. Topics are short and to the point with well written example code.

The only missing piece of the puzzle so far in the
AW Microsoft .NET Development Series was a
good WinForms title and Chris Sells has answered that call
very elegantly. In a market where .NET books are churned out
by the hundreds and good .NET books are hard to find this
definitely falls under the latter category.

The book starts with the basics of Windows forms development
and the author gently eases the reader into the more advanced
topics in a clever and un-intimidating fashion. This book covers
everything under the WinForms gamut for all kinds of developers be
it the novice or the sophisticated. It also throws light on several
obscure and hard to digest topics. It certainly is the most
comprehensive and easy to read WinForms title available in
the market today.

As an instructor I have recommended it to all my students
who is doing any kind of work in Windows Forms and plan to
use it myself in my class.

It is nice to see other authors of .NET titles to take their
time to write reviews here. That in itself speaks volumes!

Kudos to Mr. Sells for a job well done!

A thorough reference to the wide world of WinForms -- though actually, Sells wisely leaves the reference material to the SDK documentation, so you won't find long boring tables of properties here. What you will find is everything you need to know about Windows Forms, starting with the basics of using forms and controls and events, on into advanced and non-obvious topics like drag-and-drop, multithreaded UI processing, "no-touch" deployment, and data binding. There is thorough coverage of the things you can do with GDI+ and printers as well. If you don't want to try to ferret details out of the SDK, this one will bring you up to speed on designing rich .NET user interfaces.

This is an excellent book, covers the entire C#/WinForms part of .NET about as well as any single book could. Unlike other books this one is intended for those who are able to digest the MSDN and wish to take their C#/WinForms knowledge even further. After browsing through countless books that introduce me to WinForms basics, it is refreshing to find a book that dives right into some real hard-core programming. This book is not for beginners, but is indispensible for experienced C#/.NET programmers who are looking to improve their skills. This is, without a doubt, the best and most useful C#/ WinForms book I have ever read. I would suggest this book to be an essential reading for every serious .NET/WinFroms developer who wants to work smarter instead of harder. Absolutely no fluff here, every page contains interesting and useful info and the book as a whole is full of useful techniques you can use in real-world projects. It shows you loads of really neat tricks and ideas which are not available in any other books on the markert. Some of the examples are a bit raw, but the underlying concepts can be converted into successful commercial products.

First of all this book is extremely helpful in explaining the short path to mastering Windows Forms especially in the visual design mode.

The author successfully persuades the case that the design-time use of the Windows Forms library is preferred over working in an text editor.

What really made this book indispensable to me was the section on Components. Taking ideas from a Software Architecture course along with what is explained about Components in this book led me to design a series of domain-specific components.

I can now drop and interconnect these components into a form host thereby solving the problems of encapsulating non-presentation code away from the form host. Secondly these components, that contain some of the more challenging aspects of .NET, will allow me to delegate the form design work to less experienced workers.

Without this book I would not have made the leap towards a better and much more productive form of system development.

Finally the book is well-written by any standard. The writing falls within the top standard of any technical or computer book.
The table of contents and index are very useful as well.

Looking forward to the next edition.

I am coming from C++/MFC and this book was just what I needed. Great reference even after you have gone through the initial learning curve. If you only get one book on programming Windows Forms, get this one.

I have purchased several WinForm books but this is the one I use most. Chris does a great job covering the basics while at the same time providing a great deal of advanced material.

Every topic covered is provided with code examples which makes it very easy to understand AND apply.

The only thing missing from the book is a complete sample application that draws everything together. But to be fair the book covers so much material such a sample application would probably be beyond the scope of the book.

If you are trying to decide on a winform book I highly recommend this book. Rest assured this book will help you get to the essence of .net winforms!

Even if you don't get the book, do some searches on Chris and you'll come up with a lot of great .net stuff!

This book is one of the finest technical books written. I'm not just saying that.?I've read about half of it, and I can't tell you how many times I read something and thought "how would I use that" or "when would I use that feature/overload/option?" and found a clear example in the next sentence or paragraph explaining the differences or usefulness of that feature.

This book is in the Addison-Wesley .NET series, so it doesn't cover .NET from-the-ground-up, instead it explains every nook and cranny of Windows Forms applications. It is so packed with info that if you open the book to the middle, you realize that if the book were just half its length, it would cover a huge amount of information.

I learned as a technical writer in a seminar that by writing concisely and using whitespace and simple, effective illustrations, a writer should make it as easy for the reader to extract the information off the page as "pancakes coming off a hot griddle."? The reader shouldn't have to scrape with a spatula to get the point. I told a friend talking about this Winforms book that you can learn a lot just by looking at the illustrations while flipping through the pages. A hot griddle indeed.

To build Windows Forms applications with all the features of leading commercial software, you need this book.

The reason I gave it 5 stars out of 5? Because 6 stars was not offered me as a choice.

If you are currently, or aspire to be, a serious .NET developer, then buy this book. Buy it now. Do not hesitate.

After fully assimilating Francesco Balena's "Programming Visual Basic.NET" (coming from a VB6 background) and Jeff Prosise's "Programming .NET" (during my C# transition), both of which I feel are excellent books in a general coverage sense, and after wading through countless MSDN how-to's, whitepapers, and technical articles, I felt generally rounded in .NET development and what the framework has to offer. This book, however, fills in all the gaps and causes everything else to fuse together is a way that feels almost transcendent.

You will come away from it feeling an increased oneness with the .NET framework. You will feel like you have "insider" information on many topics that simply aren't covered adequately, if at all, in the MSDN material. You will have a much more complete understanding of all the various properties exposed by the intrinsic and third party controls in the designer and how to implement rich, professional grade, designer features in your own controls and components.

There simply isn't any doubt this book belongs on the shelf of anyone doing any kind of .NET development. The author's ability to so smoothly impart such a vast amount of knowledge in such a concise, readable, and enjoyable manner is truly wonderful. When they come out with the leather bound edition, I shall not hesitate to order another copy for proper placement next to Knuth, Petzold, and Douglas Adams.

In Windows Forms Programming in C#, Chris Sells introduces Windows developers to Windows Forms programming using the C# language. The author is very selective of the topics he discusses, thus not overwhelm some developers with, for example, an in-depth analysis on multithreading and synchronization. Nonetheless, the chapter on multithreaded UI is still thorough enough for understanding multithreading within the .NET framework.

Sells discusses the essential topics, making this book a practical reference to WinForms in C#. His teaching approach in this book is very practical simply because the topics he discusses are what developers need to immediately begin designing and implementing Windows client applications via WinForms in C#. For example, after reading the first three chapters the developer will have a good idea of the layout for a client application. In general, WinForms and C# are relatively simple tools, allowing Sells to discuss the essential topics effectively and leave everything else to MSDN. His discussion on Printing, Controls, Resources, and Applications and Settings is a good reference.

This book is not about the C# programming language. It is about WinForms development in C#. Sells leaves core C# to MSDN. C/C++ programmers will easily understand the C# in this book. Win32 API and MFC developers will quickly see similar concepts including delegate (function pointer) and event (message).

I recommend Windows Forms Programming in C# to all real-world Windows developers.

Kuphryn

It wouldn't be hard to write a bad book about Windows Forms: group the controls into chapters (in fact Microsoft has already done that for you, by so neatly organizing the pertinent namespaces and classes), write a page about each property, give a single code sample to illustrate each one...charge $40! That't not what Chris Sells has done. First of all, his prose is crystal clear. Second, he doesn't repeat himself unnecessarily. Third--and this is quite unusual--he's considered his examples very rigorously. When you're done with this book, you will know what every class does and *doesn't* do, and you will know how to put them together inside a GUI.

I had never been a GUI programmer before. After reading this book carefully, *once*, I can get around in the Forms namespace very easily. The book is readable *and* a useful reference.

If you are just starting out writing WinForm-based apps, this book is the place to start. If you are already an experienced .NET developer, the chapters on multithreading and code access security alone are worth the price of the book.

I am a long time windows developer going back to version 2.03 and plain old C. This book is simply packed with insight and clearly explained, well articulated Know-how!! It is not, like so many others are, a refactoring of the documentation. The author, Chris Sells, gives you his direct understanding of WinForms and C#. If you are just learning Win Forms, I believe strongly that you are far better served with this book than you would be with something like Petzold's. As much as I owe to Petzold's teachings over the years, I sure wish books like this had existed when I was learning Windows. If you are a journeyman, hardcore developer as I suppose I am, you will appreciate Chris's insights and delivery style even more than the novice. All of the books in this series are at the top of the field and this effort is certainly no exception. I think you will learn far faster, and have much more fun with this text!

Windows Forms programming in C#, (the title is a little deceptive as it covers more than mere Forms) provides the necessary details to get you going on your projects. I basically bought the book because it covered the GDI+ in detail but I have since found it valuable for authoring controls as well. The book comes with example source code (downloadable from Chris' website) and Chris himself even helped me get over a couple of spots I was having trouble with. Sometimes a book is only as good as its support and Chris does not hesitate in that category. I'm glad I bought the book and I use it as an essential reference.

My favorite aspect of the book is its clear language and informal style. It's easy and even fun to read so it's not just sitting on my shelf looking cool - I'm actually making my way through it.

I surprised myself by enjoying even the overview chapter at the beginning of the book - I usually think those can't hope to cover enough to make them useful - but I learned a bunch of stuff I'd been curious about (embedded resources, isolated storage, etc.).

I am not really a big WinForms developer (ASP.NET is where I spend most of my time these days) but when I now and again find myself developing Winforms applications, this book will be by my side. Lots of cool graphics related stuff that I likely will not use (but lots of other folks will) and lots of the things that I certainly will need. The chapters covering Threading and deployment jump out as chapters that I will have dog-eared in no time. This is one of those books that any developer of WinForms apps should have.

This book rocks! Its just under 700 pages and I haven't touched my Petzold (1200+ pages) after laying my hands on this. As clear and consise as it can get.

Chris Sells has used his knowledge and writing talents to provide a clear picture of the WinForm world, browsing each notion in the right order and explaining one complicated notion at a time when needed.

After digesting the WinForms basis in the chapters 2 and 3, you'll understand how the pieces are working all together, from the Application class to the WndProc method, last frontier with the old Win32 world without forgetting features not often detailed such as the HTML help system or the MDI layout.

The Chapters 4 to 6 are dedicated to GDI+ and give you a complete reference of color, brush, pen, shape, path, images, font and text. You'll see the basic stuff but also how to handle transparency, animation and optimized drawing, advanced string formatting and Transforms.

If you have to send your rendering code to a printer, chapter 7 is for you: you'll learn how to use the common dialogs and how to put your code in the right place during the printing workflow. Maybe a complete document printing example would have been better for code reuse than the different smaller examples.

From here, the chapters dig deeper in complicated notions and this is where its value shines. With the chapters 8, 9 and 10, you'll see how to use the existing controls and how to build your own controls that smoothly integrate the Visual Studio IDE and enhance code reuse. The localisation and resource usage in the managed world are clearly described and you won't loose hours trying to access resources in your code anymore!

The chapter 11 focuses on your program execution through the Application, Registry/RegistryKey and Environment classes. The section related to the application settings and Isolated Storage itself is worth the price of the book!

The mecanisms behind data access, dataset and data binding are detailed in Chapter 12 and 13.

If you want to check that this book is really for you, look for Chris Sells articles on MSDN and MSDN Magazine web sites. The last two chapters about Web based deployment and multi-threaded GUI treat how to solve the same kind of problems. As you'll see, the rest of the book offers the same level of quality, with details and solutions you'll find nowhere else.

I have a tiny regret: I would have expected more "under the cover" journeys based on decompiled views of .NET assemblies for an even better understanding of the relationship between classes of the Framework. I'll have to keep on playing with Anakrino and Reflector, waiting for your next "Inside/Undocumented WinForms" book Chris :^)

Finally I found a book which devotes an entire chapter on one topic. This books goes into great depth on each topic discussed. There are plenty of code examples which help to "nail-it". This is a must-have book for anyone who is serious about .Net.

This book really is great. If you don't know exactly how windows form programming is supposed to be done this will help you. I have been programming in C# for some time ( 1 1/2 years ) now. When building programs before this book I would guess and miss on how to get things done. This book showed me exactly how to add all the important functionality I saw in other applications into your own Windows Forms.

I bought this book with Erik Brown's Windows Programming Using C#, but I always read this book.
The writing style is concise and easy to read, and the sample code is just enough and get to the point. In a word, excellent!

If I could have just one book about .Net WinForms programming, this would be the book. I turn to this book 10 times more often than any other book, and it's rare not to find what I'm looking for quickly. If you do Winforms for a living, you need this book. If you do .Net for a living, this is somewhere in the top 3 or 4 books to have. Not only is it worth your money, more importantly, it's worth your time.

It is the best book about WinForms, I have ever read. It is good for beginner and advanced users too, who want to write Winforms applications in c#.

Chris Sells and Justin Gehtland (VB.NET version) have done a nice job introducing us to WinForms development in .NET. I must admit, I have not read the entire book. I purchased the book mainly for it's discussion on No Touch Deployment, Data Validation and Data Binding.

The book taught me quite a bit on NTD and has saved me a lot of headaches and research time. In addition, Chris's tips on NTD performance defintely increased the performance of our application.

This book is a definite read for someone new to WinForms development, or for someone whose been working with it for a while and needs a reference. I find myself turning to the book at least 1-2x a week.

I really enjoyed the book and found it quite useful. Wish I would have had it a year ago when I started working with C# forms. Did not take long to realize even my "OK", "Cancel" forms could stand a *bit* of improvement. I liked the humor - helps with otherwise dry reading. Section on multi-threading was great. This should be your first book on programming Windows forms in C#.

Windows Forms Programming in C# is a well written Windows Forms tutorial. Chris thoroughly and exhaustively examines different facets of Windows Forms programming. I picked up this book after programming Windows Forms for 3 years, and I did have a lot to learn from Mr. Sells. This book has been adopted for a UCLA Extension Windows Forms course. To learn more about the book and the author, read an interview with the author at csharpcomputing.com/Interviews/sells.htm.

This is one of those rare books you'd treasure long after you have finished reading it. Chris Sells' writing style makes it easy to read and follow. His examples are concise and to the point and makes C# look simple and elegant. After reading the first few chapters I was very excited and I couldn't wait to get started on a project. Highly recommended.

I've said good things about this book before, but I have to do it again. Just yesterday, I needed some help with doing a custom control. I pulled out WinForm Programming in C# and was able to practically open the book to the information I needed.

Within fifteen minutes, I was able to accomplish my goal by following the simple example given in the book. To put my feelings into words:

Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you! Thank you!

This is the book to start with!

As a person needing to take my programming game to another level, Windows Forms Programming in C# has taken it there. This is by far the most complete, exhaustive literature on the topic. I have purchased other books on the topic but none of them come close to this. If you want to be a professional WinForms developer, this book is a must have hands down! I am now looking forward to a bright future. Thanks Chris!

This is by far the most amazing book I've ever read regarding smart clients. It explains features I didn't even know existed. Really a must read...

I am currently in my senior year of Software Engineering and started using C# as my primary development language last year. Soon after its release, I bought "Windows Forms Programming in C#" and found it the most commonly used reference on my extensive bookshelf.

Whether you need to know how to lay out forms, create multiple threads, bind to data grids, or a host of other topics, this is the book to get you started programming with C#.

No C# bookshelf should be without this book!

I am not the best programmer in the world, but have been able to write the programs I need for Windows using VB. When Microsoft introduced the .NET Framework I wanted to change to the new C# language, particularly to write both Windows Forms and ASP.NET programs.
I had looked at several books, and was still struggling with the differences between VB and C#. While the focus of this book is on Windows Forms, I found its examples really good at filling in the gaps in my C# and for that matter Windows programming knowledge.

I am new to programming winforms ... and spent a decent amount of time hunting around here on amazon looking for a book to introduce me to the topic. I would up buying two books. I am sending the other book back. Not only does this book give me the necessary basics to get started, it is clear that I will still be using this book even when I know my way around.

If you plan on doing winforms, this is a must read.

This book should be always next to us. So far twice I read this book. Each time I found new things. Particularly Design Time Integration. No one has touched this subject so elegantly. Even though there were some articles in MSDN. Once I wrote to Chris Sells asking him to write exclusively on Custom Control. He has satisfied my wish through this book.

Another topic that I should mention is Resources. This explains from basics to in-depth.

This book provides developers with a practical guide for building a Windows Forms application. If you buy just one book on Windows Forms, this should be the one!

This book is excellent in leading the reader through new concepts in a conversational direction, including the missteps that you are likely to make while learning this technology.

It does have a C# focus and is assuming that the reader is coming from a C++ background, but even if you are coming from other technologies (such as VB), you will find much wealth of information.

I was most impressed with the walkthroughs on resource localization, and if you are interested in low-level graphics, you will find much to study.

Highly recommended book.

Even if you think you know everything about Windows forms, this book will teach you a bunch of tricks. One of the main strengths of this book is that it is very detailed and yet pretty easy to read. Great job Chris!

*but where afraid to ask.

This is the only book on WinForms, delving to the deepest reaches the of the WinForms framework. If you loved Petzold for Win32 and you think that Don Box is the deliverer from evil (COM), then you have to read this book. Even if you are just starting down the road on your .NET journey, have lost your way, or need someone to shine the light on the path, Chris will be there with you all the way.

Windows Forms Programming in C# is both an excellent place to get started as well as a valuable source of reference to assist in learning more advanced tasks. The book is very well laid out providing easy to follow tutorials acts as an excellent reference. This title has earned a permanent place on my bookshelf.

Disclaimer: I had the privilege to help work on one of the initial drafts of the design-time chapter. Thanks to that experience, I've had access to the book for a little while. While my comments may be bias, I assure you they would be the same if I hadn't seen this book before.

What strikes me most about the book as that it is very accessible. By this, I mean easy (if not entertaining) to read and easy to understand.

Accessibility to what, you ask? Frankly, a myriad Windows Forms topics. You will not be disappointed by the width and depth of material discussed in the book (although, if you are, the book errata site is at http://www.sellsbrothers.com/writing/wfbook/). Where Petzold's book focuses on specific Windows Forms areas, Chris' book describes each of the key building blocks you might need for a Windows Forms application, from development to deployment. The material covers beginner, intermediate and advanced topics so there's something for everyone.

I think the content is presented at just the right level (for me). As a comparison, it's why I tend to go to MSDN Magazine first: the articles there usually provide me with enough information to solve a problem immediately and, if not, enough information to solve the problem more rapidly.

Once again, I worked on a very small part of it. Irrespective of whethery I have or not, it would be my number one Windows Forms book.

At the very least, go to a book store. Hold it. Flick through it. Peruse the topics that interest you. Smell it if you so desire. I think you'll find it very hard to leave the book store without a copy (preferably via the sales counter :)

Most books on .NET cover winforms..after all, it's probably the first thing you address as a programmer. However, this book had wonderful examples of real world things you do with forms. The writing is great, the layout is very easy on the eyes, and whether you are using it for a reference, or trying to get new ideas from it...you'll be glad you bought this book.

Microsoft should make it mandatory to ship this with Visual Studio .NET for WinForm development. It contains more practical and usable information in one book than trying to search the help, MSDN, Codeproject, the tons of books in your current collection, or . It even contains a center section of color pages of important figures that really need convey the importance of that particular demo. If your company doesn't buy it for you, suck it up and buy it yourself - you won't regret it!

This is the best book on windows forms programming. Everything is explained in a simple manner. The author does not assume the reader to posses extensive programming experience. If you are comfortable with basic c#, then this is the book to read. This book is worth 10 times its cost.

Contains all the essential information and a little bit more but not much more. Over all a pretty good starter book.

Very good book! Windows Programmer must have.

Easy to follow.

Being primarily an ASP.NET developer, I figured it wasn't too hard to develop a windows forms app, so I started. About 2 weeks into the project (which was going along fairly smoothly) I picked up this book.

I came to 2 conclusions after reading it:
1) I *couldn't* develop windows forms properly before (you tend to think differently when doing 100% web development)
2) now I CAN develop a windows forms app :)

I thoroughly enjoyed the book. His expertise shows through all of the details. There is great detail about GDI, which is one of the biggest things that windows forms have over asp.net, so that was an area I spent a lot of time in.

One of the things I REALLY respect about the book is the fact that he demonstrates the design-time "magic"... but he also gives solid examples of well-structured code -- not always using designer generated code. (This is something I frequently find in books that I cannot stand. Most people just show you the quick & dirty, without emphasis on proper code structure -- Chris Sells gets a thumbs up for not doing this)

All in all the chapters were very informative, it was a good read, and I'd recommend it to anyone building windows forms in .NET 1.1.

I can't wait for his 2.0 book!

I liked this one.

It's friendly, and to the point.

It helped me solve many of my WinForms problems.

...and the code samples don't suck.

Personally, I think this book is magic. Writing my very first C# app I did these way cool non-rectangular dialogs and then couldn't figure out how to get them to be moveable...and just then Chris's book fell open to just the page that showed how to override the wndproc and do what I wanted. Wowzers!

If you're planning on doing any coding for Windows, this is the book for you!

This book provides really good, clear simple explanations. I especially liked the chapter on building a multi-threaded WinForms application. It's by no means an exhaustive explanation of threading, but it does provide a good solid foundation for building a typical WinForms app that needs to perform some long running process.

Of ATL and MFC fame, Chris Sells brings his Windows knowledge to .NET through this great piece of writing. It is extremely solid in the technical part but also contains an intangible cool factor unseeing in any book I've read. He discusses things that Mr. Petzold left out of the Windows for .NET core reference. Chris' writing style makes you follow along as if you were reading an epic novel instead of a geek manual. Awesome read, I can' say enough. Although there is a VB.NET version this books suits any developer, I think even the Linux guys can learn a thing or 2 for implementing Mono. Chris clearly walks the talk since he has many free .NET components and wrote an amazing Caller ID for MSN messenger. If all this sounds interesting, then what are you waiting for and pick up the book already!

There are few books that focus on only windows forms. Most are .NET general books so don't have the coverage a GUI developer would like. This book I found to be the best coverage of forms so far, offering plenty of samples and details from basic to complex. The author is also a regular writer for MSDN mag as well.

If you are going to do forms this is one of the books you want in your collection.

As you would expect from Chris, all the important topics are covered in good depth (though sensibly he defers to the equally good "Essential .NET: Volume 1" in certain areas). Even advanced topics, such as data binding and design-time integration (which are nevertheless very relevant in "real world" scenarios), are made extremely approachable by the clear descriptions and useful advice given.

Building a cool UI is a must for any production program, and this book will get you there. Lot's of practical information, that's well written, easy to use and interesting. There are a lot of books on manipulating WinForms and I've liked most of what I read. For someone to write on a well discussed subject and make it cool and interesting takes some talent, and Chris does just that!

This book is really good. The main ideas of C# programing short and clear. By the way,this isn't a reffence book.

The book divides naturally into two parts. Both use the .NET forms package that Microsoft developed to simplify low level coding. The first part is very straightforward graphics programming. Someone who has used X11 on unix, or java's AWT/Swing or, of course, earlier MFC graphics will see no surprises. Font properties, drawing of curves, pens etc are all here. A very complete graphics package.

By placing the above discussion as the first part, the author lets you have easy immediate visual feedback if you choose to code the examples. It is always good for readers to tinker; helps retention.

The second half is slightly more abstract. Issues like resources - internationalisation of labels for widgets you made in the first part. Plus, how to connect to data objects or databases. He gives a brief discussion of ADO.NET. Along the way, there is a simple exposition of XML.

As you can guess, the second part deals with backend, under-the-bonnet tasks. Slightly more abstract than GUI building. The WinForms do indeed seem to handle all these issues clearly, which is vital to your ease of learning and use.

I stayed up all last night reading Chris' new book. As with his previous books, this is easy to read and I enjoyed every single page. I will be keeping it by my side for quite some time as I delve more into WinForms programming. Thanks Chris for your excellent insights and once again, a fabulous book.