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.
Hardware
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:
- Desktop system compatible with Microsoft Windows 2000 or Windows XP
- Minimum 128MB RAM (256MB recommended)
- Minimum 4GB hard drive (10GB recommended)
- Windows CE-powered device (Pocket PC, Pocket PC 2002, Pocket PC 2003, Smartphone 2003, or other Windows CE-powered device)
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:
- Network card (wired or wireless) for the desktop development system
- Network card (wired or wireless) for the Windows CE-powered device
Software
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:
- Microsoft Windows 2000 (with Service Pack 2 or later)
- Microsoft Windows XP Professional
- Microsoft Windows Server 2003
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.
- Microsoft Visual Studio .NET 2003 (required).
- (Optional) Microsoft eMbedded Visual C++ 3.0 (for Pocket PC and Pocket PC 2002).
- Microsoft eMbedded Visual C++ 4.0 (for Pocket PC 2003, Smartphone 2003, and later).
- P/Invoke Wizard, available from The Paul Yao Company, for help in creating declarations needed to call native code from the .NET Compact Framework. (Learn more about this tool and download a demo version from http://www.paulyao.com/pinvoke.)
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
- Fastest executables
- Best real-time support
- Source code portability between platforms
- Ability to wrap Component Object Model (COM) for access by .NET Compact Framework applications
- Ability to create device drivers
- Ability to create control panel applets
- Support for custom user interface skins
- Support for security extensions
- Ability to build Simple Object Access Protocol (SOAP) Web Service servers
- Support for Pocket PC shell extensions
- Ability to use existing Win32 code
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 info@paulyao.com).
Paul Yao, Bellevue, Washington
David Durant, Goldendale, Washington
March 2004
Notes
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.
