The primary goal of .NET Compact Framework is to bring the familiar
experience of developing .NET applications for the desktop to the device world.
Of the approximately six million Microsoft desktop developers in the world, it
is estimated that perhaps two hundred thousand will turn their attention to the
device world using the enabling technology of the .NET Compact Framework.To
facilitate the goal of showing readers how to develop applications for the .NET
Compact Framework, the book contains in-depth treatment in the following topic
areas: Windows Forms and Threading, Network Programming, ADO.NET Dataset, XML
Serialization, SQL CE, Web Services, and performance management. Each concept is
accompanied with a sample application that illustrates its implementation on the
.NET Compact Framework. For the convenience of the reader, each sample
application will be offered in both C# and Visual Basic .NET. Developers can use
this source code as a springboard for creating their own device side database
Table of Contents
What's in This Book. Conventions Used in This
Book. What You'll Need. Online Resources.
1. Setting Up Your Development Environment.
Smart Device Extensions and the .NET Compact
System Requirements. The Development Process
Using Smart Device Extensions. Creating a New Application for Pocket PC Devices.
Opening an Existing Smart Device Extensions Project.
Targeting Nonstandard Devices.
How Visual Studio Communicates with Devices.
Installing the .NET Compact Framework Manually. Devices with Unusual Memory
Maps. Connectivity Summary and Troubleshooter.
2. Introducing the .NET Compact Framework.
Why the .NET Compact Framework? Examining the
.NET Compact Framework in Detail.
The Common Language Runtime. Comparing the .NET
Compact Framework CLR to the Desktop CLR. The .NET Compact Framework Class
3. Designing GUI Applications with Windows Forms.
Investigating Unsupported Controls in the .NET
Compact Framework. Investigating Unsupported System.Windows.Forms Functionality
in the .NET Compact Framework. Working with the Visual Studio .NET Form
The Form Designer Window. The ToolBox Window.
The Properties Window. Adding Events Handlers.
Understanding the Different Windows Forms Target
Understanding Windows CE .NET Projects.
Understanding Pocket PC Projects.
Working with the Form Control.
Understanding the Effects of the FormBorderStyle
Property. Using the ControlBox Property. Understanding the MinimizeBox and
MaximizeBox Properties. Understanding the WindowsState Property. Understanding
the Size Property. Setting the Location of the Form by Using the Location
Programming the Button Control. Using the
TextBox Control. Using the Label Control. Working with RadioButton Controls.
Using the CheckBox Control. Using the ComboBox Control. Using the ListBox
Control. Using the NumericUpDown Control. Using the DomainUpDown Control.
Programming the ProgressBar Control. Using the StatusBar Control. Using the
TrackBar Control. Using the ToolBar Control.
Adding a ToolBar Control to an Application.
Handling a ToolBar's ButtonClick Event.
Adding Menus with the MainMenu Control. Using a
ContextMenu Control in an Application. Using the Timer Control. Using the
OpenFileDialog and SaveFileDialog Controls. Using the Panel Control.
Using the HScrollBar and VScrollBar Controls.
Using the ImageList Control. Using the PictureBox Control. Using the ListView
Adding Columns to the ListView. Adding Items to
the ListView Control. Determining the Selected Item. Additional ListView Control
Using the TabControl Control. Using the TreeView
Understanding TreeView Properties. Adding
TreeNodes to a TreeView Control. Determining the Selected TreeNode.
Working with the DataGrid Control.
Populating the DataGrid Control. Customizing the
DataGrid Control. Determining the Selected Row or Selected Cell in the DataGrid.
4. Using Threads and Timers in the .NET Compact Framework.
Threads, Timers, and Windows CE. The Thread
Class. Understanding Thread Basics.
Creating and Starting a Thread. Writing Code to
Start a Thread. Suspending a Thread. Using Threads with User Interface Controls.
Quitting Threaded Applications. Coding a Multithreaded Application:
Coordinating Threads with the Mutex Class.
Suspending and Resuming Threads with Mutexes.
Examining a Sample Application: SuspendAndTerminateThreads.
Blocking until a Thread Finishes.
Waiting for a Thread: The JoinDemo Application.
Controlling Access to Data Objects with the
Simulating the Producer-Consumer Problem.
Managing Multiple Threads with a Thread Pool.
Controlling Threads with the ThreadPoolDemo
Creating a Timer. Setting the Tick Interval.
Suspending and Resuming Timers. Manipulating Timers with a Sample Application.
Updating Variables with the Interlocked Class.
Incrementing a Variable. Decrementing a
Variable. Exchanging a Value into a Variable.
5. Network Connectivity with the .NET Compact Framework.
Working with Sockets.
Choosing a Protocol: TCP/IP versus UDP.
Understanding IP Implementations: IPv4 versus IPv6.
Socket Programming with the .NET Compact
Making a Connection as a Client. Receiving a
Connection as a Host. Reading and Writing with a Connected Socket. Sample
Application: Remote Hello.
Serializing Objects for Transmission through a
Serializing Packets: Sample Application.
Using UDP Packets.
Writing Code for UdpClient. Writing for the
UdpClient: Sample Application.
Multicasting with UDP Packets.
Sending Multicast Packets. Receiving Multicast
Communicating with Remote Servers through the
Nuts-and-Bolts Usage of HttpWebRequest. Coding
Sample for HttpWebRequest. Writing Applications with the HttpWebRequest:
Communicating with Remote Servers through the
HTTPS Protocol. Communicating through the Device IrDA Port.
Using the IrDAClient to Access the Device IrDA
Port. Connecting to an IrDA Port as a Client. Establishing an IrDA Connection as
a Server. Reading Data from an IrDAClient. Writing Data to an IrDAClient. Sample
6. ADO.NET on the .NET Compact Framework.
Introducing ADO.NET on the .NET Compact
Framework. Caching Data with the DataSet.
Looking Inside the DataSet: DataTables,
DataRows, and DataColumns. Inserting Data into a DataSet. Building a DataSet to
Hold a Phone Book. Extracting Data from a DataSet. Altering Data in a DataSet.
Designing a PhoneBook Application with a DataSet. Troubleshooting Common
Adding Constraints to a DataSet. Adding a
UniqueConstraint. Working with a UniqueConstraint by Example. Preventing NULL
Values in a DataColumn.
Setting Up Autoincremented Fields.
Creating Autoincremented Field Code by Example.
Updating the PhoneBook Application with Constraints and Autoincremented Fields.
Modeling Relational Data with the DataSet.
Deriving DataColumn Values with Expressions and
Computed Fields. Expressing Parent-Child Relationships in a DataSet.
Creating Bindable Views of Data with a DataView.
Sorting with the DataView. Sorting and Filtering
Data in a Sample Application. Tracking Changes in a DataRow. Filtering with the
DataView. Adding Data into a DataView. Using a DataView in a Sample Application:
Binding Data to a Control.
Binding to a DataGrid. Using Data Binding in a
Comparing the Compact DataSet with the Desktop
DataSet. In Brief.
7. Programming with Microsoft SQL Server CE.
Investigating the Features Supported by
Microsoft SQL Server 2000. Creating a Microsoft SQL Server CE Database. Adding
Structure to a Microsoft SQL Server CE Database. Populating a Microsoft SQL
Server CE Database. Retrieving Data by Using SqlCeDataReader.
Using Parameterized SQL Commands.
Filling a DataSet by Using the SqlCeDataAdapter.
Handling the FillError Event.
Updating the Microsoft SQL Server CE Database by
Using the SqlCeDataAdapter.
Handling SqlCeDataAdapter Update Events.
Generating SqlCommand Objects with the
SqlCeCommandBuilder. In Brief.
8. XML and the DataSet.
XML and the .NET Compact Framework DataSet.
Loading XML into a DataSet.
Loading from a File. Loading Data from a Stream.
Saving a DataSet as XML.
Saving to a File. Saving Data to a Stream.
Writing Schema with the XML Data.
Loading and Saving XML in a Sample Application.
Modeling Relational Data with XML Schemas.
Examining XML with the XML_DataSetView Utility.
Examining a Simple Schema that Describes a Single Table. Autoincremented Fields
and Unique Constraints. Describing Multiple Tables, ForeignKeyConstraints,
DataRelations, and Computed Fields with XML Schema. Creating XML Data with the
Loading and Saving Schema Alone. Writing a
DataSet to XML without Schema Information. Reading a DataSet from XML, Ignoring
Schema Information. Inferring Schema. Using XML to Design a DataSet.
Schema Editing with the IDE.
Saving and Loading DataSets as XML DiffGrams.
How to Read a DiffGram. When to Use DiffGrams.
9. Using XML Web Services.
Creating a Simple XML Web Service. Understanding
the .NET Framework Web Service Client. Creating a Client for the Simple XML Web
Adding a Web Reference to a Client Application.
Viewing the Proxy Class. Consuming the QuotableQuotes Web Service. Asynchronous
Consumption of the Simple Web Service.
Consuming a Web Service That Uses a DataSet.
Consuming Web Service That Exposes a Typed DataSet. In Brief.
10. Manipulating XML with the XmlTextReader and the XmlTextWriter.
XML Architecture Overview. Working with the
XmlTextReader. Loading XML Data into an XmlTextReader.
Loading an XML Stream from the Local File
System. Loading an XML File from a Remote Location.
Using the XmlTextReader's Namespaces Property.
Understanding the Normalization Property. Controlling White-Space Interpretation
with the WhitespaceHandling Property. Using the XmlResolver Property. Reading
Reading XML Nodes with the Read Method. Reading
the Start Element Tag. Reading Element Content as a String. Jumping to an
Reading XML Attributes.
Reading Attributes without Moving the Reader.
Reading Attributes by Using Horizontal Movement.
Understanding How to Perform Full-Content Reads.
Reading All Content as String Data. Reading
String Data in Chunks. Reading Binary-Encoded Data. Reading Element Content as
Skipping over Nodes. Closing the XmlTextReader.
Working with the XmlTextWriter.
What Is Not Supported?
Creating the XmlTextWriter. Manipulating
Namespace Support. Formatting the XmlTextWriter's Output. Writing an XML
Declaration. Writing XML Elements. Writing XML Attributes. Writing xml:space and
xml:lang Attributes. Writing Element and Attribute Content. Converting .NET
Compact Framework Data Types through XmlConvert. Writing Raw XML Markup. Writing
Writing Comments. Writing CDATA Sections.
Writing Processing Instructions. Writing
White-Space Characters. In Brief.
11. Working with the XML Document Object Model.
Processing XML by Using the Document Object
Model. Differences from the Desktop .NET Framework. Loading the XML DOM.
Navigating the XML DOM.
Navigating Using HasChildNodes and ChildNodes.
Navigating by Using Item Indexer Properties. Navigating by Using FirstChild and
NextSibling. Navigating by Using ParentNode and OwnerDocument.
Accessing Text from Elements. Accessing Markup
from Nodes. Accessing an Element's Attributes. Accessing Other XmlNodes.
Searching an XML Document Node Tree. Creating XmlNodes. Creating
XmlDeclarations. Creating XmlElements. Creating XmlAttributes. Creating Other
Node Types. Inserting XmlNodes. Using the AppendChild and PrependChild Methods.
Working with the InsertBefore and InsertAfter Methods. Inserting XmlAttributes
into an XmlDocument. Replacing the XmlNodes within an XmlDocument. Removing
XmlNodes for an XmlDocument. Removing XmlAttributes from their XmlElements.
Writing the XmlDocument. In Brief.
12. Interacting with Native Code.
Understanding When to Call Native Code. Calling
Native Code: Quick Start.
Calling Native Code with Minimal Steps.
Marshalling the Fundamental Data Types.
Passing 32-bit Signed Integers. Passing 32-bit
Unsigned Integers. Passing Single Precision Floating-Point Types. Passing Signed
Long Integer Types. Passing Unsigned Long Data Types. Passing Short Integers.
Passing Unsigned Short Integers. Passing Single Characters. Passing Bytes.
Passing Boolean Values. Passing a DWORD. Passing an IntPtr. Passing Non-Mutable
Strings. Passing Mutable Strings with System.Text.StringBuilder. Converting Data
to Strings with the FundamentalToString Sample Application.
Marshalling Simple Structures.
Marshalling Shallow Structures with the
MarshalShallowStruct Sample Application.
Passing Nested Structures by Using Custom
Marshalling Deep Structures with the
MarshalDeepStruct Sample Application.
Calling the Windows CE Operating System.
Calling the Windows CE API to Play a Sound.
Putting It All Together with a Sample Application: PlaySound.
Accessing COM Components from the .NET Compact
Framework. In Brief.
13. Exploring .NET Reflection.
Understanding the .NET Compact Framework
Reflection API. Loading .NET Assemblies. Discovering Type Information.
Retrieving Type Information with the GetType
Method. Retrieving Type Information from a Loaded Assembly.
Creating Type Instances by Using
Using the GetConstructors Method. Retrieving
Individual ConstructorInfo Objects with GetConstructor. Creating Object
Instances with the ConstructorInfo Class.
Invoking Methods by Using the MethodInfo Class.
Working with the GetMethod Method. Invoking a
Method with the MethodInfo Class.
Using Reflection to Manipulate Object State.
Discovering a Type's Field Information by Using
the GetFields method. Discovering a Type's Field Information by Using GetField
Method. Using the FieldInfo Class to Retrieve a Field's Value. Using the
FieldInfo Class to Change a Field's Value. Discovering a Type's Property
Information by Using the GetProperties Method. Discovering a Type's Field
Information by Using the GetProperty Method. Using the PropertyInfo Class to
Retrieve and Change the Value of the Property.
Adding Custom Metadata to .NET Elements.
Defining a Custom Attribute. Retrieving Custom
Cryptography on the .NET Compact Framework.
Performing Cryptography with the
Invoking the CryptoAPI.
Using Handles to Interact with CryptoAPI.
Understanding the CryptoAPI Context.
Computing a Hash.
Looking Inside ManagedComputeHash. Computing a
Hash with a Sample Application.
Encrypting and Decrypting Data by Using a
Looking Inside PasswordEncrypt. Looking Inside
Using Session Keys to Encrypt and Decrypt Data.
Storing a Session Key for Use Only by the Device
That Created It. Importing a Previously Saved Session into the Same Device That
Created It. Sharing a Session Key with a Remote Device. Encrypting and
Decrypting by Using a Handle to a Session Key.
Determining CryptoAPI Constants with the
ConstFinder Sample Application. In Brief.
15. Measuring the Performance of a .NET Compact Framework
Using a Stopwatch Timer to Measure Code
Execution Time. Using .NET Compact Framework Performance Counters.
Turn On the .NET Compact Framework Performance
Counters. Viewing the Performance Counters. Understanding the Performance
Counters. Understanding the .NET Compact Framework's Garbage Collector. The
NetCF Performance Counter Explorer.
16. Deploying a .NET Application.
Packaging a .NET Compact Framework Application.
Using Visual Studio .NET to Package an Application. Using CAB Wizard to Package
Specifying the Application Version in the
Version Section. Understanding the CEStrings Section. Specifying Custom
Substitution Strings in the Strings Section. Understanding the DefaultInstall
Section. Specifying the Desktop Location of the Application in SourceDisksNames
Section. The SourceDisksFiles Section. Specifying the Final Application
Destination Directory in the DestinationDirs Section. Running the CAB Wizard.
Distributing a .NET Compact Framework
Distributing Your Application from a Web Site.
Distributing Your Application from a File Share. Distributing Your Application
on a Memory Card. Distributing Your Application Through ActiveSync.
17. Developing for the SmartPhone.
Introducing the SmartPhone. Developing for the
SmartPhone by Using the .NET Compact Framework.
Miscellaneous SmartPhone OS Issues.
Writing an Application for
Building the DataSetViewer from Scratch-Tutorial
Steps. Using the XMLDataSetViewer.