Save Big On Open-Box & Used Products: Buy "Programming Microsoft® Windows® with C# (Develope...” from Amazon Open-Box & Used and save 80% off the $59.99 list price. Product is eligible for Amazon's 30-day returns policy and Prime or FREE Shipping. See all offers from Amazon Open-Box & Used.
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Programming Microsoft® Windows® with C# (Developer Reference)
Use the Amazon App to scan ISBNs and compare prices.
Top 20 lists in Books
View the top 20 best sellers of all time, the most reviewed books of all time and some of our editors' favorite picks. Learn more
Customers who bought this item also bought
Customers who viewed this item also viewed
Special offers and product promotions
Aimed at aspiring C# programmers of all levels, legendary Windows expert Charles Petzold's Programming Windows with C# provides an extremely in-depth and intelligent tutorial to the APIs underpinning Microsoft's .NET Framework.
For a generation of programmers, Petzold's Programming Windows: The Definitive Guide to the Win32 API provided a virtual bible on how to get started with Windows development. This massive, handsomely bound hardcover edition attempts the same breadth of coverage for Microsoft's new C# language and the new .NET. With several examples clearly inspired by the earlier C title, this book demonstrates the author's keen eye for showing off and explaining the capabilities of low-level APIs to good effect.
The book first outlines basic "Hello World" examples for both a console and Windows Forms. Next, there's coverage of basic support classes (like points and rectangles) before turning toward using these structures in extensive sections on graphics programming. Petzold's traditional strengths as a computer author are in ample evidence here, with many short examples that exercise the capabilities of the new .NET APIs.
Veteran readers will recognize the basic shape of the early Win32 title in the organization of this (completely rewritten) C# version in the flow of topics from graphics, keyboard, mouse and timers, and the like. (One production note here is that the order of later chapters does jump around somewhat, circling back to graphics topics several times instead of presenting related APIs in order.)
The sections on graphics transforms and how to manipulate images are worthy of note. There's excellent coverage of the possibilities of working with text and fonts output in .NET. Nifty working samples for several types of clocks and shape-drawing demos will let you explore graphical APIs in detail.
Several chapters cover basic Windows Forms control programming with buttons, labels, and edit controls and then splitters, ListView, and TreeView controls. This volume closes out with references to files and streams, and math and string APIs. For any developer who wants to create state-of-the-art, "traditional" client-side software, this book is sure to be required reading for its in-depth look at graphics and other leading-edge .NET features. It proves once again that learning low-level APIs in detail is still a good way to learn Windows programming. --Richard Dragan
Topics covered: Overview of C# and .NET Windows programming fundamentals; a "Hello World" console application; C# language and object basics; a simple Windows Forms application (creating a main window and handling the paint events); basic .NET structures (including rectangles, points, and colors); text output and scrolling; exploring .NET system information; in-depth tutorial for GDI+ programming: pens, lines, rectangles, and polygons; keyboard processing (plus a custom class for caret processing); graphics transformations (including scaling, linear transforms with matrices); mouse processing (plus processing the mouse wheel); text and fonts (TrueType and OpenType fonts, antialiasing, measuring text); using timers; date and time APIs; a sample code for clocks; drawing and transforming images (displaying JPG and BMP files); simple animation; basic control programming (buttons, labels, scroll bars, and track bars); exploring Bezier curves and splines; menus (basic and custom); graphics paths and regions; clipping techniques; basic dialog box programming (modal and modeless forms); edit, list, and spin controls; font transforms and special effects, using toolbars and status bars, printing techniques (including print dialogs), splitter, TreeView, and ListView controls; programming with the clipboard, drag-and-drop support, reference sections on APIs for programming with files and streams, math functions, and strings.
About the Author
Charles Petzold has been writing about programming for Windows-based operating systems for 24 years. A Microsoft MVP for Client Application Development and a Windows Pioneer Award winner, Petzold is author of the classic Programming Windows, currently in its fifth edition and one of the best-known programming books of all time; the widely acclaimed Code: The Hidden Language of Computer Hardware and Software; and more than a dozen other books.
If you are a seller for this product, would you like to suggest updates through seller support?
Top customer reviews
I'm a CS student with a few semesters of C/C++ under my belt and this book was exactly what I needed to move beyond console programming in C++ and into the world of C# and .NET.
The author breaks down code line by line, explaining subtle differences between C/C++ and C#, in a highly readable manner. He seems to have an uncanny knack at anticipating my questions right as they form in my mind.
Other C# books I own start with a Visual Studio boot camp, then jump into building Windows Forms without adequately explaining/breaking down the auto-generated code that Visual Studio creates along the way.
The author has you start each project with an empty code file. No unnecessary using statements. No auto-generated boiler-plate code that you are just supposed to accept as an integral part of your program without explanation.
It's old school, but I really feel like I'm building a solid understanding of the language.
Petzold's approach is great on many levels. He codes all his controls and forms by hand, so you know what the underlying code behind the Visual Studio GUI editor does (and does this without deriding the GUI editor one bit!). For the most part, you learn C# and Windows Forms concurrently - there are a few sections where he presents material in what I would call a confusing order, however.
The weakest part of this book is its size. There is a lot of source code, which is good, and Petzold's explanations of new features are thorough, which is good too. But a large portion of the text is consumed by anecdotes and protracted explanations of simple features.
On the one hand, he assumes the readers are familiar with some sort of object-oriented programming (although you need not be an expert). But on the other hand, several concepts are explained so exhaustively (transforms, fonts, some graphics) that I found myself skipping page after page because I already understood the topic and was ready to move on.
I still highly recommend this book. I just wish they had cut the size down and made it a paperback!
There is virtually nothing in this book that is not focused on .NET Windows Forms using C#. Mercifully, VB.NET isn't even mentioned. Also, you won't find diversionary chapters on ADO.NET or ASP.NET. The book treats Windows Forms basics (from the classic "Hello, World", through essential data structures and basic text output), and then alternates the chapters between topics on graphics (GDI+) and user interface elements (mouse, keyboard, timers, buttons, menus, toolbars, etc.). GDI+ is an enhancement to the old GDI and the book contains uncompromising chapters on such graphical topics as Bezier curves and other splines, including all the necessary mathematical background. In the chapter on Pages and Transforms, he presents* all the mathematical background necessary to perform the linear transformations needed to utilize the GDI+ graphical transforms. This is what I mean about uncompromising. He doesn't avoid topics in the .NET Windows Forms classes because they might require a little college algebra that most of us have probably forgotten. He just dives right in and presents everything necessary to come to grips with the deepest .NET classes in Windows Forms. About the only subject he doesn't treat is Image Color Management, a topic so vast it really deserves a book of its own (although "Windows 2000 Graphics API Black Book" has an excellent chapter on the Win32 API).
With such an exhaustive treatment of his subject matter, you might think this book might be pretty dry reading. Not true. Petzold writes with supreme confidence and wry wit, never cloying, always with just the right touch. This book is fun reading, his enthusiasm for his subject matter always in evidence, even when he's exhaustively presenting the methods of a class or an enumeration. You can tell he is having a ball.
There are lots of tables and code in the book. The code is available on an included CD. A minor problem I had is that sometimes the Beta 2 produced a bunch of "System.Byte not defined in the workspace" errors. If this happens to you, just choose Yes when it asks if you want to go ahead anyhow. The applications still work.
His examples are short and are easily typed in by hand, something Petzold recommends anyhow. The way I worked with this book was to embellish little programs of my own anyhow, trying out the facilities he was expositing within my own framework. I probably learned even more taking this approach rather than using his examples literally.
So overall, it is hard to imagine that this book could ever be surpassed. This book deservers an extra rosette, beyond the five stars for those extremely rare computer books that are destined to become a classic teaching a whole generation of programmers.
After those couple of chapters, it provides rather wordy coverage of Windows Forms and drawing graphics with .Net. The title should reflect this more clearly, in my opinion. The book does not talk about programming Windows in general (assemblies, threading, XML, etc.); it focuses solely on the graphical aspects, with some brief look at file I/O.
The coverage of Windows Forms and drawing is great, if a somewhat verbose.
Most recent customer reviews
But that way you learn and understand more about C#, you have to do it all by yourself(if you wish).Read more