Customer Reviews

Windows Forms Programming in C#

5 star:		(74)
4 star:		(7)
3 star:		(4)
2 star:		(4)
1 star:		(3)

 

 

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.

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.)

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.

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.

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.

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.

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'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.

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 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.