“For nearly two decades, Paul Yao and David Durant have been acknowledged as experts on the Windows platform, so it’s only natural that they would bring their experienced point of view to the .NET Compact Framework. With a unique combination of historical perspective and in-depth understanding of the subject matter, Yao and Durant take the reader through not only the technical guts of the Compact Framework but also the reasons behind the design decisions.”
—Joshua Trupin, Executive Editor, MSDN Magazine
“Yao and Durant have written a book that, although it assumes no prior experience with the .NET Framework, serves both the rookie and advanced programmer equally well. This is definitely a rare quality among technical books and is certainly not an easy thing for an author to accomplish.”
—Doug Holland, Precision Objects
“This is a very good hands-on book with plenty of sample code illustrating programming tasks and techniques, which any serious development effort for Windows CE or Pocket PC will require.”
—Bill Draper, Director of Software Development
“This book serves as both a great reference and tutorial when building .NET Compact Framework applications. My only wish is that it had been available sooner.”
—Greg Hack, Senior Software Engineer, Allscripts Healthcare Solutions
“Of the handful of books on Compact Framework, this book takes the cake. Paul Yao and David Durant’s expertise with .NET Compact Framework is evident from their excellent and very insightful coverage of sections such as Building the User Interface, Managing Device Data, and Creating Graphical Output. The chapter discussing the topic of P/Invoke is unparalleled. After reviewing this book, I am certain that if there is one book that will help you understand .NET Compact Framework, this is the one.”
—Deepak Sharma, Senior Systems Specialist, Tata Infotech Ltd.
“Yao and Durant’s fresh, innovative, and in-depth look at the .NET Compact Framework gets developers up to speed using C# to develop robust and scaleable handheld software solutions. A definite must-read for mobile handheld developer enthusiasts!”
—Andrew Krowczyk, Software Architect, Zurich North America
.NET Compact Framework Programming with C# is the definitive tutorial and reference for the .NET Compact Framework (CF). It shows you how to transfer your skills and your code to the Pocket PC 2003 and other mobile and embedded smart devices.
Authors Paul Yao and David Durant draw upon their years of research and experience with members of the Microsoft .NET CF team to show you exactly how the best CF programming gets done in C#. This is the only book a programmer needs to master the art of CF coding. Throughout the book, sample code and examples illustrate best practices and programming techniques. In addition, the companion Web site includes downloadable code for all these examples, along with a set of development tools to help you with your CF development projects.
The authors expertly zero in on what programmers need to understand for successful smart device programming, including:
.NET Compact Framework Programming with C# is your single resource for everything you really need to know about CF programming.
Die Inhaltsangabe kann sich auf eine andere Ausgabe dieses Titels beziehen.
Paul Yao is president of The Paul Yao Company, which provides educational and consulting services to software engineers on software technologies based on Microsoft Windows. He has authored/coauthored seven books on Windows programming, including with David Durant the first book published on the subject, Programmer’s Guide to Windows (Sybex, 1987). Paul is a contributing editor to MSDN Magazine, writing regularly on topics of interest to Windows CE and Pocket PC developers.
David Durant is principal of Durant Associates and lead author of the groundbreaking book Programmer’s Guide to Windows (Sybex, 1987), the first book published on the subject. David was an early proponent of .NET, is a frequent contributor to industry journals and forums, and leads seminars on .NET-based technologies for corporate clients worldwide.
We feel pretty fortunate. During the past two decades, we have traveled the world teaching programmers what we know. The two of us have led many classes and together have taught thousands of smart, highly motivated software engineers, test engineers, and development managers. We enjoy working with the people who are inventing the future, and we enjoy being at the cutting edge of each successive wave of software development technology. We have learned much from the discussions we have had with these students. This book represents one way we can thank them for all their support.
We worked together on the first book published on the subject of Windows programming, Programmer’s Guide to Windows (Sybex, 1987). Long out of print, in its day the book helped many programmers tackle the challenges presented by Windows version 1.01. That version of Windows came out in November 1985, and in those days developers typically worked on computers running MS-DOS with no hard drive, no network support, and no network servers to rely on.
Things have changed a lot during the 17 years since our first book came out. A pocket-sized computer now has more memory and CPU power than the typical desktop system of the 1980s. A typical desktop system has more raw computing power than a roomful of computers had back then. With this increase in capacity has come a dramatically improved set of development tools available to software developers: Online programming references, context-sensitive help, and graphical editors all help support the task of software development. Programmers can be more productive today thanks to all these tools.
With this increase in computing power and tool support has also come an increase in the complexity of programming interfaces. While the .NET initiative provides a new set of programming interfaces that are better organized than any other Microsoft has created, it is still very large and very intricate. Given enough time, most programmers can master these intricacies. But most programmers do not have enough time to learn about a new technology while also building new software, yet that is what their employers require of them.
Our primary mission is to support you, the software engineer, in saving time. In this book, we distill many years of research and sample code to give you the information you need in a way you can use. We do the same thing in our training classes, in our magazine articles, and in the talks we give at conferences. We concentrate our efforts on helping software engineers become more productive. Time saved in learning about software development issues can be focused on meeting the specific needs of the end users whom you are supporting (or, perhaps, on taking some time off between projects to recharge your mental and physical batteries).
What You Need to Use This Book
To make the most of what this book has to offer, you are going to need a few things, as described in the following subsections.
Software developers have historically had the fastest and most capable computer systems they could get their hands on. Developing for smart devices like the Pocket PC and the Smartphone is no different. To get started, we recommend you have the following:
Strictly speaking, you do not need a Windows CE device because you can run your software on an emulator that runs on your development system. You will, however, eventually want to test your software on real devices, the same ones you expect your users to use. The emulator technology is very good—more than good, in fact. Today’s emulators provide an excellent replication of the software on a device.1 But the hardware and associated device drivers are not going to be the same on an actual device as on an emulator running on a PC. This is the major cause of differences between an emulator and an actual device. When we teach our Pocket PC programming classes, we always recommend to participants that a major portion of testing be done on devices.
While the focus of this book is on writing code, the reality of software development is that you spend a lot of time debugging your code. For that reason, you want to remove anything that slows down your debugging. We suggest you invest in a network connection between your development system and your smart-device system, which means you need the following:
The development tools can run on any supported version of Microsoft Windows. However, an emulator requires that you run on a 32-bit version of the operating system. This means you want one of the following:
With the right operating system in place, you can then use the software development tools. The first item in the following list is required; the other items are “nice-to-have” tools.
The Latest Version of the .NET Compact Framework
As we were finishing this book, Microsoft made available Service Pack 2 of the .NET Compact Framework. Should you upgrade to this latest version (or whatever later version might be available by the time you read this)? We must say yes! This is a new technology, and the .NET Compact Framework team is still working on improvements and upgrades to make the library work better and faster. After shipping a new library, the .NET Compact Framework team members—like most development team members at Microsoft—take a weekend or two off, and then their reward for their hard work is that they get to start all over again, working to create something even better. It’s a good thing that they like what they are doing—and that they are so good at it.
The Sample Code
You can download the code for this book from the following URL: http://www.paulyao.com/cdbook/code.
When you install the sample code directory tree from the Web site, you see four top-level directories.
- ..\CS contains all the C# samples.
- ..\VB contains all the Visual Basic .NET samples.
- ..\CPP contains C/C++ samples.
- ..\Tools contains binaries of useful tools.
Each of the .NET Compact Framework samples is available in two languages: C# and Visual Basic .NET. Some samples are written in C++, using the Windows API (also known as Win32).
Within the three samples directories (..\CS, ..\VB, and ..\CP) you find a directory for each chapter. Within each chapter directory you find another set of directories for all the samples in that directory.
For example, one of the samples in Chapter 5 is named “FormEvents.” The C# version is at this location: ..\CS\Ch05_CreatingForms\FormEvents. The Visual Basic .NET version is at this location: ..\VB\Ch05_CreatingForms\FormEvents.
The Target Audience for This Book
We wrote this book to help programmers with the .NET Compact Framework. We assumed that no prior programming experience with Windows 95/98/2000/XP, with Windows CE, or with .NET was required. At the same time, if you have experience with programming for Windows on the desktop, with Windows CE, or with the .NET Framework, that experience will help you.
For Programmers Experienced with Windows CE
If you already have experience writing Windows CE programs, you might be wondering if you even need to use the .NET Compact Framework. Whether you do or not depends on what tools you have been using and what type of work you expect to do.
If you have been using eMbedded Visual Basic (eVB) to write Windows CE programs, you are probably already aware that Microsoft plans to discontinue support for eVB. As of this writing, the Pocket PC 2003 supports eVB; that is the last platform to be supported. The .NET Compact Framework is a great replacement. It is well designed, and it provides Visual Basic programmers with support that puts them on a level playing field with C# programmers.
If you have been using the Microsoft Foundation Class (MFC) Library, the ActiveX Template Library (ATL), or the Windows Template Library (WTL), then the case for the .NET Compact Framework is still pretty good. Chapter 1 describes the .NET Compact Framework and its benefits. The new .NET programming paradigm provides many benefits for programmers who have worked with other frameworks. Getting involved with .NET Compact Framework programming is a great way to get into the world of .NET because the libraries are scaled back from the (sometimes) overwhelming number of classes and features found on the desktop .NET Framework. And there is an added bonus for making the move to the .NET Compact Framework: The fundamental elements of programming for the .NET Compact Framework programming are the same as the fundamental elements for all .NET-based technologies. So learning the .NET Compact Framework today will help you learn to build Web applications using ASP.NET, Windows Forms applications for the desktop, and managed-code stored procedures for Yukon (the code name for the next version of SQL Server).
If you have been using the core Windows API/Win32, then you might wonder whether to continue writing Win32 code or to jump into the .NET Compact Framework. For some things, including the following, you must continue using Win32.2
For Programmers Experienced with the .NET Framework
If you are experienced with writing programs that use the .NET Framework, you are going to find much that is familiar. The C# and Visual Basic .NET languages, for one thing, use the same syntax for two very popular languages that are available for desktop .NET development. The fundamental data types that support interoperability between different languages on the desktop also play a core part of interoperability with smart-device programs.
One thing that may be surprising to desktop .NET Framework developers is the extent to which they might need to rely on P/Invoke support to call the underlying Win32 API functions that Windows CE supports. While the desktop .NET Framework provides an extensive set of classes that minimizes the need to call outside the framework, the .NET Compact Framework provides a reduced set of classes to meet the size constraints of mobile and embedded devices.
To help programmers move from the .NET Framework to the .NET Compact Framework, throughout the book we provide some detailed discussions of differences between the two frameworks. In the many workshops we have taught, we have observed the knowledge and skills of programmers who are experienced with the .NET Framework transfer quite readily to the .NET Compact Framework.
The primary challenge comes from an experience we refer to as “stubbing your toe”—tripping over a familiar desktop feature (whether a class, an enumeration, an attribute, or an operating system feature) that is not present on smart mobile devices. When this happens, you have found a limit on the support available in the .NET Compact Framework (or, perhaps, a limit on the support of the underlying Windows CE operating system). The attitude you take in dealing with such experiences will play a big role in determining how successful you are in .NET Compact Framework programming—and how enjoyable you will find it. We have observed that the programmers who excel with device development are the ones who are able to see in these limitations an enticing challenge and an opportunity to explore new ways to solve old problems.
We extend our very best wishes to you on your .NET Compact Framework development, whether for the Pocket PC, the Smartphone, or some other Windows CE-powered smart device. We look forward to seeing you in one of our workshops or at an industry conference, or trading comments with you online (contact us via e-mail at email@example.com).
Paul Yao, Bellevue, Washington
David Durant, Goldendale, Washington
1. Historically, not all emulators have provided high fidelity to device software. In particular, Windows CE 1.x and 2.x emulators were based on an older technology that was good but not great. The last emulator to use this older technology was the Pocket PC emulator that shipped with Microsoft eMbedded Visual C++ 3.0. All emulators for Visual Studio .NET 2003 use the newer emulation technology.
2. For a detailed discussion of these, see the following white paper on the Microsoft Web site: http://msdn.microsoft.com/library/en-us/dncenet/html/choose_api.asp.
„Über diesen Titel“ kann sich auf eine andere Ausgabe dieses Titels beziehen.