Getting Started With Smart Device Extentions

Embedded Applications: Getting
Started with Smart Device

Extensions for Visual Studio .NET
Embedded Applications - Getting Started with Smart Device Extensions for Visual Studio .NET
The information contained in this document represents the current view

of Microsoft Corporation on the issues discussed as of the date of
publication. Because Microsoft must respond to changing market
conditions, it should not be interpreted to be a commitment on the part
of Microsoft, and Microsoft cannot guarantee the accuracy of any
information presented after the date of publication.
This White Paper is for informational purposes only. MICROSOFT
MAKES NO WARRANTIES, EXPRESS OR IMPLIED, AS TO THE
INFORMATION IN THIS DOCUMENT.
Complying with all applicable copyright laws is the responsibility of
the user. Without limiting the rights under copyright, no part of this
document may be reproduced, stored in or introduced into a retrieval
system, or transmitted in any form or by any means (electronic,
mechanical, photocopying, recording, or otherwise), or for any
purpose, without the express written permission of Microsoft
Corporation.
Microsoft may have patents, patent applications, trademarks,
copyrights, or other intellectual property rights covering subject matter
in this document. Except as expressly provided in any written license
agreement from Microsoft, the furnishing of this document does not
give you any license to these patents, trademarks, copyrights, or other
intellectual property.
2001 Microsoft Corporation. All rights reserved.
Microsoft, ActiveSync, ActiveX, Visual Basic, Visual C++, Visual C#,
Visual Studio and Windows are either registered trademarks or
trademarks of Microsoft Corporation in the United States and/or other
countries.
The names of actual companies and products mentioned herein may be
the trademarks of their respective owners.
Page 2
Table of Contents
INTRODUCTION
What Is Included with Smart Device Extensions
Why Not eMbedded Visual Basic 4.0?
5
5
6
THE .NET COMPACT FRAMEWORK

What Is in the .NET Compact Framework?
Features of the Common Language Runtime
.NET Compact Framework Class Library
Form-Related Classes
Data and XML Classes
Web Services
Visual Basic Support
GDI Support
Base Classes
6
6
7
7
8
8
8
8
9
9
USING THE DEVELOPMENT ENVIRONMENT

Creating a New Project
Constructing a User Interface
The New Toolbox
Controls Provided with Smart Device Extensions
Adding Controls to Your form
Managing Your Project
Project Items
Configuring Properties
Adding Code
The Code Behind a Visual Basic .NET Form
Configuring Your Project
Building Your Application
Configuration Manager Dialog Box
Testing Your Application
The Smart Device Extensions Emulator
Working with Emulator Images
Saving and Restoring Images
Image Functionality
Localization Issues
Automated Testing Environment
Obtaining Additional Images
Summary of the New Emulator
Testing on a Device
Remote Tools Included with SDE
Page 3
9
10
12
13
14
15
16
16
18
19
20
22
23
24
24
25
25
25
26
26
26
26
26
26
26
DIFFERENCES BETWEEN EMBEDDED VISUAL BASIC AND VISUAL

BASIC .NET
Variant Is No Longer Supported
Integer Data Types
Declaring Values While Dimensioning a Variable
Fixed-Length Strings Are Not Supported
Use Zero Bound Arrays
Default Properties
Subs and Functions Require Parentheses
Optional Arguments Are Not Allowed
New Assignment Operators
New Error Handling
Support for APIs
Accessing Data
What Are Datasets?
Visual Basic .NET Compact and XML
XML Functionality Included Under the .NET Compact Framework
Local Data Storage Using XML
Working with Files Under SDE
Working with XML Web Services
27
27
27
27
27
27
27
28
28
28
28
29
29
31
31
31
32
32
33
GETTING STARTED WITH SMART DEVICE EXTENSIONS
33
WHERE TO GO FROM HERE
34
APPENDIX A FUNCTIONALITY NOT INCLUDED IN THE .NET COMPACT

FRAMEWORK
35
Features Not Included in the .NET Compact Framework
35
General Functionality Not Included in the .NET Compact Framework
35
XML Functionality Not Included in the .NET Compact Framework
35
Page 4
Introduction
To the developer experienced with Microsoft eMbedded Visual Basic, the prospect of
gaining access to Visual Basic .NET capabilities on a mobile platform may seem too
good to be true. With the release of Smart Device Extensions (SDE) for Visual
Studio .NET, Microsoft has done just that. SDE provides a compact version of
theMicrosoft .NET Framework, allowing you to build applications in Visual Basic .NET
without the previous limitations that thwarted and restricted mobile developers. With
SDE, developers have a tool based on the Visual Basic language that can be used to
create robust applications, with all of the power and flexibility that previously was
reserved for applications created with Microsoft eMbedded Visual C++.
For those who have yet to work with Visual Basic .NET, the scope of the changes
between this most recent version of Visual Basic and the previous versions are too great
to cover in this document. Instead, you will be given a general overview of the .NET
Compact Framework, and you will learn about the new integrated development
environment (IDE) and language differences, as well as the key features provided by
SDE for Visual Studio .NET.
What Is Included with Smart Device Extensions

SDE for Visual Studio .NET offers developers a scaled-down version of the .NET
Framework, called the .NET Compact Framework. SDE is a Visual Studio Integration
Package, or VSIP, which plugs into Visual Studio .NET. Unlike eMbedded Visual Basic,
SDE cannot operate without Visual Studio .NET installed. Other than that, no other
products are required for developing and deploying applications for the Pocket PC or the
Pocket PC 2002 built using SDE.
Included as part of the SDE is a set of prebuilt device profiles. An embedded device
profile contains information necessary to build specific types of applications that target
specific devices. For example, one profile enables you to create applications for a Pocket
PC, Pocket PC 2002, or Microsoft Windows CE .NET device by using WinForms,
Microsoft ADO.NET, and the ability to consume XML Web services. Other profiles could
be provided that would allow you to create applications that would target cell phones or
third-party personal digital assistants (PDAs).
Profiles may target specific devices, such as the Pocket PC. Less specific profiles may
target the Windows CE platforms in general. Generic profiles may target any platform to
which the .NET Compact Framework has been ported.
In addition, the SDE will include device kits (formerly known as SDKs). As with
eMbedded Visual Basic, device kits are separate from SDE and may be installed and
updated independently.
Page 5
Why Not Offer eMbedded Visual Basic 4.0?

You may be wondering why such a drastic change was made to the Visual Basic-based
development tool for Windows CE. The answer is fairly simple. The current eMbedded
Visual Basic 3.0 product is not suited for advanced development. Based on Visual Basic
Scripting Edition (VBScript), its engine works well enough for simple applications, but it
is cumbersome and lacks some of the key features required for advanced
development. Developers using eMbedded Visual Basic end up spending a significant
amount of their time learning tricks to work around its inherent limitations. As the
popularity of mobile devices has increased, device developers have been requesting a
rich, strongly typed, object-oriented Visual Basic development tool, similar to what is
now offered in Visual Basic .NET. They want to be able to build wireless solutions that
leverage the Internet and XML Web services. SDE for Visual Studio .NET delivers on
these requests. Microsoft has ported the .NET Framework to Windows CE .NET, which
enables applications written in Microsoft Visual C# .NET and Visual Basic .NET to
target the device platform.
The .NET Compact Framework

Any discussion of SDE would be incomplete without including an overview of the
fundamentals of the .NET Compact Framework. In developing applications using .NETbased technologieswhether you are targeting the .NET Framework or the .NET
Compact Frameworkyou can take advantage of the functionality provided by the .NET
Framework classes, and you can use the same programming model. In the case of
applications developed with SDE, you target the .NET Compact Framework.
What Is in the .NET Compact Framework?

The .NET Compact Framework simplifies application development on smart devices by
providing two main components: the common language runtime and the .NET Compact
Framework class library.
The common language runtime is the foundation of the .NET Compact Framework. It is
responsible for managing code at execution time and providing core services, such as
memory management and thread management, while enforcing code safety and accuracy.
Code that targets the runtimefor example, code written in Visual Basic .NET and
Visual C# .NETis known as managed code; code that does not target the runtimefor
example, code written in eMbeddded Visual C++, is known as unmanaged or native code.
In a way, you can think of the common language runtime as the eMbedded Visual Basic
runtime on performance-enhancing drugs.
NOTE Managed code, such as that generated by Visual Basic .NET (targeting either the
.NET Framework or the .NET Compact Framework), is handled by the common language
runtime.
The .NET Compact Framework class library is a collection of reusable classes that you
can use to develop applications quickly and easily. This framework is designed so that it
can be ported to other platforms, whether they are created by Microsoft or other vendors.
What does this mean to you? The coding techniques and the applications you create today
Page 6
to run on a Pocket PC, for example, could just as easily run on other platforms, such as a
cell phone or another vendors PDA, if a version of the .NET Compact Framework was
created for that platform. For that matter, the coding skills you have already developed
with Visual Studio .NET can also be used with any of the platforms that support the .NET
Compact Framework.
Features of the Common Language Runtime

The common language runtime provides a code-execution environment that manages
code targeting the .NET Compact Framework. Code management can take the form of
memory management, thread management, security management, code verification and
compilation, and other system services.
Even though your mobile applications are written in Visual Basic .NET, and as such are
managed code, they are still able to incorporate functions in dynamic-link libraries
(DLLs). In fact, Visual Basic .NET provides extensive support for data types and
structures, so you are able to use the Windows CE APIs in ways you could only dream of
with eMbedded Visual Basic.
NOTE Unlike eMbedded Visual Basic, Visual Basic .NET provides the data types and includes
support for structures that allow you to easily incorporate functions from the Windows CE
APIs into your applications. While the need for these functions is far less in Visual Basic .NET
in comparison to eMbedded Visual Basic, that capability allows you to create mobile
applications that match the functionality found in applications written in eMbeddded Visual C+
+.
The common language runtime is designed to enhance performance. It makes use of Justin-Time (JIT) compiling, which enables managed code to run in the native machine
language of the target platform. This feature allows you to create applications that can
target a variety of platforms without recompiling or generating separate executables for
each specific platform on which your application will run.
The .NET Compact Framework Class Library

The .NET Compact Framework class library is a collection of reusable classes that tightly
integrate with the common language runtime. Your Visual Basic .NET applications derive
functionality from these libraries.
As you would expect from an object-oriented class library, the .NET Compact
Framework types enable you to accomplish a range of common programming tasks,
including string management, data collection, database connectivity, and file access.
NOTE: Unlike eMbedded Visual Basic, which had many differences in functionality from Visual
Basic, Smart Device Extensions implements a true subset of the .NET Framework. The
classes included in the .NET Compact Framework provide an identical interface to their .NET
Framework equivalent, with the exception of functionality that is not supported because of
size constraints, performance issues, or limitations in the target operating system. Class
behaviors, properties, methods, and enumeration values will be the same under both
Page 7
versions of the .NET Framework, so you can use your Visual Basic .NET coding techniques
to create both desktop and device applications.
The following section details functionality available through Smart Device Extensions.
Form-related Classes
The .NET Compact Framework implements a subset of the System.Windows.Forms and
System.Drawing classes. These classes can be used to construct rich, Windows CEbased user interfaces for device applications. Much of the interaction with these classes is
managed for you by the Windows Forms Designer in Visual Studio .NET.
The implementation of Windows Forms under the .NET Compact Framework includes
support for forms, most controls found in the .NET Framework, the ability to host thirdparty controls, as well as support for bitmaps and menus.
Data and XML Classes

The .NET Compact Framework includes a set of classes that allow you to easily
incorporate data from either a relational or nonrelational data source. Working with
Extensible Markup Language (XML) content is straightforward in device applications
created using Visual Basic .NET. The implementation of both data and XML classes
under the .NET Compact Framework is a subset of those found in the .NET Framework.
Additional details on both the data and the XML classes are included below.
XML Web Services

The .NET Framework provides deep support for XML Web services. In the .NET
Compact Framework, you have a subset of the capabilities and functionality offered in
the .NET Framework. Most significantly, you can use Visual Studio .NET and SDE to
create applications that allow you to easily consume XML Web services. More on this
subject is included below.
NOTE: When using Visual Basic .NET to target the .NET Framework, you can create both
XML Web service clients and serversbut the .NET Compact Framework is only a consumer
of XML Web services.
Visual Basic Support

Visual Basic .NET makes liberal use of helper functions that are located in a Visual Basic
Helper library. The version of the Visual Basic Helper library included with the NET
Compact Framework offers a subset of these functions. The functions included in the
Visual Basic Helper library are considered by Visual Basic developers to be a core part of
the language, and they include many of the keywords with which developers are
experienced.
The inclusion of the Visual Basic Helper library means that eMbedded Visual Basic
developers will be able use many of their favorite Visual Basic statements and functions
when working in Visual Basic .NET.
Page 8
NOTE: The Visual Basic Helper library included with the .NET Compact Framework is a
subset of the library included with Visual Basic .NET. Refer to the help documentation
included with Smart Device Extensions to verify that particular functions are supported.
Graphics Device Interface Support

The .NET Compact Framework provides support for the basic graphics device interface
(GDI) drawing elements, including bitmaps, brushes, fonts, icons, and pens. The addition
of this functionality offers a great advantage to Visual Basic .NET over eMbedded Visual
Basic, where drawing capabilities have been limited.
Base Classes
The .NET Compact Framework provides a robust set of base classes that expose a wide
range of functionality for use by developers working in Visual Basic .NET. This
underlying infrastructure enables you to write rich .NET-based applications that
incorporate multithreading, access network resources, and work with files.
Using The Integrated Development Environment

Smart Device Extensions for Visual Studio .NET is a Visual Studio Integration Package,
or VSIP, which plugs into Visual Studio .NET. As a VSIP, SDE makes use of the Visual
Studio .NET integrated development environment (IDE). This IDE provides a
development experience that is unmatched in previous versions of the Windows CE
development tools.
This section shows the key components of the Visual Studio .NET IDE as they are used
in creating a Windows CE-based application.
Page 9
Creating a New Project

When Visual Studio .NET is first run, the Start Page is displayed, as shown in Figure 1.
The Start Page is used to open existing projects and to create new projects, including
projects that target the .NET Compact Framework.
Figure 1. The Visual Studio .NET Start page
Page 10
When you click the New Project button, the New Project dialog box is displayed, as
shown in Figure 2. From this dialog box, you can select a template to use for your
application. SDE installs a set of templates in both the Visual Basic and Visual C# project
folders.
The Visual Basic Projects folder includes templates for Pocket PC devices as well as for
devices that use Windows CE .NET. These templates provide the basic project
configuration required for creating applications. A project template for Pocket PC is
highlighted in Figure 2.
Figure 2 shows two additional templates: Device class library templates are used to
construct class libraries for their respective devices, and control library templates are
used to create controls.
NOTE: The addition of control and class libraries to Visual Basic .NET is a significant
enhancement over eMbedded Visual Basic.
Figure 2. The New Project dialog box showing three Pocket PC-related templates
Page 11
The Windows CE Application template included with SDE, as shown in Figure 3, enables
a developer to build a .NET Compact Framework project that targets any device that runs
Windows CE and supports the .NET Compact Framework.
Figure 3. The New Project dialog box showing the Device Project wizard
The Pocket PC project templates, as with all device templates, create the initial files,
references, code framework, property settings, and tasks as appropriate for the selected
project type. Device templates take into account the target platform, which in turn affects
which .NET Compact Framework libraries are available for use by the developer.
Constructing a User Interface

If you have experience working with Visual Studio .NET, you will require little
orientation to begin working with the SDE. For eMbedded Visual Basic developers just
starting with .NET, the following section leads you through the key features of the Visual
Studio .NET IDE.
Page 12
When you create a new project, the Start Page will be replaced by a blank form as shown
in Figure 4.
Figure 4. The Windows Forms designer
At first glance, this part of the Visual Studio .NET IDE appears similar to the forms
designer in eMbedded Visual Basic. On closer inspection, you will notice a set of tabs
along the top of this window. In the figure above, three tabs are shown: Start Page,
Form1.vb, and Form1.vb [Design].
In addition to the Start Page, these other two tabs correlate to the form interface and form
code module in eMbedded Visual Basic. The Visual Studio .NET IDE allows you to
easily switch between user interface design and code windows by using these tabs.
The New Toolbox

The Toolbox in the Visual Studio .NET IDE is located in the same general location as it
was in eMbedded Visual Basic, but initially it is hidden. The Visual Studio .NET IDE
supports panels that automatically hide themselves when not in use. This feature allows
more available screen space for designing forms and writing code.
Page 13
In its hidden state, the Toolbox appears as shown in Figure 5A, aligned along the left side
of the IDE. Placing your cursor over the Toolbox tab will cause it to be displayed as
shown in Figure 5B.
Figure 5A
Figure 5B. The Visual Studio .NET toolbox
Controls Provided by SDE

While eMbedded Visual Basic provided a limited set of controls, SDE includes a far more
comprehensive set, many of which support data binding. A list of the controls is shown in
Table 1 below.
Button
DateTimePicker
ImageList
MainMenu
PictureBox
TabControl
TrackBar
CheckBox
DomainUpDown
Label
MonthCalendar
ProgressBar
TextBox
TreeView
ColorDialog
ErrorProvider
LinkLabel
NumericUpDown
RadioButton
Timer
VScrollBar
Table 1. The controls included with SDE
Page 14
ComboBox
GroupBox
ListBox
OpenFileDialog
SaveFileDialog
ToolBar
ContextMenu
HScrollBar
ListView
Panel
StatusBar
ToolTip
Adding Controls to Your Form

Working with the Visual Studio .NET Toolbox is identical to the eMbedded Visual Basic
approach. Simply select the control in the Toolbox, and then draw the control on your
form. In Figure 6, a button has been added to a form. Visual Studio .NET offers a
complete set of user interface configuration tools under the Format menu, so the
developer can align, size, space, center, and lock the control in position.
Figure 6. Adding a button to a form
Page 15
Managing Your Project

You manage your .NET Compact Framework projects using the Solutions Explorer
window. Similar in functionality to the Project Explorer window in eMbedded Visual
Basic, the Solutions Explorer window, shown in Figure 7, is used to access and configure
your project and its components.
Figure 7. The Visual Studio .NET Solution Explorer window
Project Items
While eMbedded Visual Basic was limited in the scope of supported project items, with
only form and standard modules, SDE provides a broad set of project items from which
to choose. Table 2 details the supported items along with their file extensions.
Project Item
File Extension Description
Assembly Info File
.vb
A file used to store assembly information, such as versioning and

assembly name.
Assembly Resource .resx

File
A file containing localization information for a project when the

Localized property is set to true.
Bitmap
.bmp
A blank bitmap image file, which can be used to create simple

images.
Class
.vb
A code file that initially contains a single empty class declaration.
Code File
.vb
An empty Visual Basic or Visual C# code file.
Component Class
.vb
A class (a business object) for which a visual designer exists.
Cursor File
.vb
An image file for creating custom cursors.
Page 16
Custom Control
.vb
A Windows-based control that is not visually designed (it does not

have a graphical design surface). You must create the control by
writing code.
Data Form
.vb
A data form that assists in creating data connections.
Data Set
.xsd
An XSD schema that generates classes you can use to access the
dataset programmatically.
Dynamic Discovery
Document
.vsdisco
Sometimes called a disco file, this provides a means to enumerate

all Web services and all schemas in a Web project.
Icon File
.vb
An image file for creating a custom icon.
Inherited Form
.vb
A Windows form that you derive from another form by using visual
inheritance. When you inherit from another form, you receive this
form as your initial form. You can then visually add to it or change
its contents.
Inherited User
Control
.vb
A User Control that is derived from another existing user control.
Module (Visual
Basic only)
.vb
A code file that initially contains a single file for storing functions.
Static Discovery
File
.disco
A file used to publish information about an XML Web service.
Text File
.txt
An empty text file.
User Control
.vb
A control (a visual element) that you can place on a Windows form.

It has a visual designer.
Windows Form
.vb
A basic Windows form that you use for local applications. It has a
graphical design surface.
XML File
.xml
An XML document file.
XML Schema
.xsd
An XSD schema file without the generated classes.
Table 2. Supported file types provided br SDE
Page 17
Configuring Properties
The Visual Studio .NET Properties window enables you to configure the properties of
forms and controls. The Properties window, as shown in Figure 8, offers both a
categorized and alphabetic view. The categorized view can be collapsed or expanded to
facilitate working with particular sets of properties.
Figure 8. The Visual Studio .NET Properties window
NOTE: In Visual Basic .NET, some property names of controls have been altered from those
used in eMbedded Visual Basic. For example, the Visual Basic .NET button offers a Text
property in place of the expected Caption property.
Page 18
Adding Code
The Visual Studio .NET code window, as shown in Figure 9, is similar to the eMbedded
Visual Basic version. The main editing area enables you to collapse and expand sections
of code. The combo box at the top left of this window allows you to select a class, where
eMbedded Visual Basic allowed you to select an object. The combo box at the top right
of the code window allows you to select a method, whereas eMbedded Visual Basic
allowed you to select a procedure. The Visual Studio .NET code window features
Microsoft IntelliSense statement completion, including automatically listing members
and providing parameter information.
Figure 9. The Visual Studio .NET code window demonstrating IntelliSense
NOTE: Visual Basic .NET supports overloading methods. For the typical eMbedded Visual
Basic developer, overloading is a new concept. Simply stated, overloading allows you to
declare a method multiple times, each time with a different parameter list. In the figure above,
you can see the addition of a navigational feature at the left side of the method description
window. This navigational tool allows you to select the method description that best suits your
development needs. On a related note, Visual Basic .NET requires that you provide values
for all parameters defined for a method. Visual Basic .NET does not support optional
arguments.
Page 19
The Code Behind a Visual Basic .NET Form

When you create a form using Visual Basic .NET, you are, in fact, creating the code used
to define your forms interface. This is unlike eMbedded Visual Basic, in which form
definitions were described separately from the forms code.
The Windows Form Designer automatically generates this code and adds it to the forms
code module as shown in Figure 10. This code is normally hidden from the developers
view in what is referred to as a region. The region carries a label titled: Windows Form
Designer generated code.
NOTE: This section of your form is created and maintained by the Windows Form Designer
component of Visual Studio .NET. You should not manually modify this section of code as it
may produce unpredictable results.
Figure 10. Code file with generated code hidden
Page 20
Regions can be expanded and collapsed by clicking on the plus (+) and minus (-) symbols
at the far left of the code window. Expanding the code generated by the Windows Form
Designer reveals the code used to define the forms interface as shown in Figure 11.
Figure 11. Code file with generated code exposed, note the form and control definitions
Page 21
Configuring Your Project

Project properties are configured through the Property Pages dialog box. This dialog box
can be accessed by selecting Properties under the Project menu, or by right-clicking
your project in the Solution Explorer and then selecting Properties from the pop-up
menu as shown in Figure 12.
Figure 12. Accessing project properties
Page 22
The Property Pages dialog box, shown in Figure 13, allows you to configure all facets of
your project, including device deployment details such as the platform, device type, and
the target output folder.
Figure 13. Configuring project properties
Building Your Application

To build an application, select Build from under the Build menu. If it is not already
displayed, the Output Window will appear as shown in Figure 14.
Page 23
Figure 14. The Visual Studio .NET Output window displaying the results of a project build
The Output window is used to display deployment messages, exception handling, and
status notifications. Deployment messages include device information, source and
destination folders, file information, and memory usage. Exception-handling information
includes connection time out, insufficient memory, path not found, access denied, sharing
violations, cancelled deployments, and other unexpected errors. Status information
includes successes, failures, and items that are skipped. You can reference the Output
window to aid in the resolution of compilation and deployment issues.
Configuration Manager Dialog Box

The Configuration Manager dialog box, shown in Figure 15, allows the developer to
specify whether to build or deploy a project. To access this dialog box, select
Configuration Manager from the Build menu. These configuration settings are
referenced when a developer selects to build or deploy an application.
Figure 15. The Visual Studio .NET Configuration Manager dialog box
Testing Your Application

Like eMbedded Visual Basic, Smart Device Extensions allow you to test your application
in either an emulator or on a device. Similar to the eMbedded Visual Basic IDE, the SDE
enhancements to the Visual Studio .NET IDE provide a menu bar interface, as shown in
Figure 16, which allows you to select the target for testing.
Page 24
Figure 16. Selecting a deployment target
The SDE Emulator

SDE improves emulation testing for devices. Previous emulators included with the H/PC,
P/PC, H/PC Pro and Pocket PC system development kits were simply Windows-based
applications simulating a device environment. The emulator included with SDE runs a
binary image of the devices operating system. For all practical purposes, it is a device
running inside of Windows. Accordingly, the emulator will act and operate in the way
you would expect your device to function, providing a true representation of the actual
device. This type of emulation is referred to as true emulation.
NOTE: The capabilities of the SDE emulator enable application developers to start
programming before they have access to the device hardware.
This new emulator runs device operating systems within the computer operating system.
The SDE emulator can be used with either Microsoft Windows 2000 or Microsoft
Windows XP Professional. This emulator is a separate and complete instance of a virtual
machine. Any operating system calls that are made by an application from within the
emulator are not patched through to the host operating system.
Working with Emulator Images
Not only does the emulator, included with SDE, provide a far better representation of the
actual device, it also allows the developer to modify, save, and restore custom
configurations of operating system images.
Saving and Restoring Images
Operating system images can be customized by including additional software, files, and
registry settings. These customized images can be saved and restored for use with the
emulator to meet your development needs.
You can access and configure operating system images running in the emulator by using
Microsoft ActiveSync technology. When you close the emulator, you are asked whether
you would like to save or discard changes made to an image.
You can return an image to its original state by using the reset command within the
emulator. If it is a default image, it will revert to its shipped state. If it is a developersaved image, it will revert to the image as it appeared the last time it was saved by the
developer.
To use a previously saved image, you simply need to select the desired image from the
target device drop down menu within the Visual Studio .NET IDE.
NOTE: Support for saving and restoring images is not included in the beta for Smart Device
Extensions.
Page 25
Image Functionality
Images running in the emulator act like the actual device. Applications running in the
emulator can access the network, consume XML Web services, install software, and
perform any other action, just as they would on a device.
Localization Issues
The emulator enables developers to test applications for localization issues more easily.
By obtaining an additional image for each localized version of the target operating
system, developers can determine how their applications react without needing to acquire
multiple devices.
Automated Testing Environment
One of the benefits of SDE integration within Visual Studio .NET is that SDE can make
use of its native functionalityfor example, the Visual Studio .NET scripting
capabilities. SDE developers can leverage these scripting capabilities in conjunction with
the new emulator to automate testing plans and exercise their applications.
Obtaining Additional Images
Images not included with SDE will be delivered with device kits (formerly known as
SDKs). The flexibility offered by this new emulator will allow it to support future
versions of Windows CE as they become available.
Summary of the New Emulator
Unlike eMbedded Visual Basic, the emulator included with SDE offers a high-fidelity
environment for testing. The features and enhanced functionality of the SDE emulator
offer a suitable environment for developers to test and debug their applications.
NOTE: While the new emulator that is included with SDE provides a robust development
environment, it should not be used as your sole means of testing. Final testing should always
be performed on the target device.
Testing on a Device
As with previous versions of the Windows CE development tools, SDE allows you to test
your applications on a target device. SDE copies your application and required supporting
components to your device, launches your application, and enables you to debug your
logic using the SDE IDE.
Remote Tools Included with SDE

SDE includes a set of remote tools that enable developers to monitor, alter, and control
applications running on a connected device. Access to these tools is provided through the
Tools menu within the Visual Studio .NET IDE.
Page 26
Differences Between eMbedded Visual Basic and Visual

Basic .NET
When migrating from eMbedded Visual Basic to Visual Basic .NET, developers will need
to adjust to the differences in the Visual Basic languages as they are implemented in each
of these tools. This section highlights some of the key differences between these two
versions of the Visual Basic language.
Variant Is No Longer Supported

The variant data type, the only data type supported in eMbedded Visual Basic, is not
available under Visual Basic .NET. In its place, Visual Basic .NET offers a wide variety
of data types to meet your programming needs.
Integer Data Types

There are three integer data types:
16-bit, which are called Short
32-bit, which are called Integer
64-bit, which are called Long.
Declaring Values While Dimensioning a Variable

Visual Basic .NET allows you to declare the value of a variable at the time you are
dimensioning the variable. For example:
Dim intFactor As Integer = 5
Fixed-Length Strings Are Not Supported

In Visual Basic .NET, fixed-length strings are not supported. For example, the following
eMbedded Visual Basic statement would result in a compilation error under Visual
Basic .NET.
Dim strDemo As String*50
Use Zero-Bound Arrays

eMbedded Visual Basic allowed you to specify the lower and upper bounds for an array.
In Visual Basic .NET, you must use zero for the lower bound.
Default Properties
With eMbedded Visual Basic, you could use default properties. When you referenced an
object without specifying a property, it would be resolved to the default property for the
specific object. For example, the following lines of code operate identically under
eMbedded Visual Basic:
Text1 = "something"
Text1.Text = "something"
Page 27
Visual Basic .NET does not support default properties. In all instances, you must specify
the desired property.
Subroutines and Functions Require Parentheses

Under Visual Basic .NET, all calls to subroutines or functions require the use of
parentheses. For example, the following eMbedded Visual Basic code:
MsgBox "test..."
will need to be written in Visual Basic .NET as:

MsgBox ("test...")
Optional Arguments Are Not Allowed

Visual Basic .NET does not support optional arguments. Any calls to methods or
procedures must include values for each argument that is defined.
New Assignment Operators

Visual Basic .NET supports a new set of assignment operators that are borrowed from the
C language. These new operators include:
Type of Operator
Addition
Subtraction
Multiplication
Division
String concatenation
eMbedded Visual Basic Syntax

intValue = intValue + 1
intValue = intValue - 1
intValue = intValue * 5
dblValue = dblValue / 5
strValue = strValue & "demo"
Visual Basic .NET Syntax

intValue += 1
intValue -= 1
intValue *= 5
dblValue /= 5
strValue &= "demo"
NOTE: Visual Basic .NET supports these new operators in addition to the operators
available in eMbedded Visual Basic.
New Error Handling

eMbedded Visual Basic lacked adequate error handling. Since eMbedded Visual Basic
was built using the VBScript language, it supported only On Error Resume Next.
Developers who have worked with this method of error handling are well aware that it
often leads to more problems than it solves.
Page 28
Visual Basic .NET offers a far more robust approach to error handling, if implemented
with Try-Catch-Finally structure. An example of this structure is shown in the code
sample below.
Try
' Your normal application code goes here.
Catch
' This code gets executed if an error occurs.
Finally
' This code would get executed every time. Typically it is used
' as a clean-up area for the error handler.
End Try
Support for APIs

The .NET Compact Framework supports calling functions stored in dynamic-link
libraries (DLLs) written in eMbeddded Visual C++, Visual C#, and Visual Basic .NET.
Like eMbedded Visual Basic, Visual Basic .NET uses the Declare statement to define
these functions. With its support of structures, Visual Basic .NET can call the Windows
CE APIs in a far more robust fashion than was allowed with eMbedded Visual Basic.
Visual Basic .NET support for calling DLLs is limited by the following restrictions:
o The number of arguments passed to a DLL function is limited to 12 in total.
o American National Standards Institute (ANSI) strings will not be supported. Since
Windows CE is UNICODE based, only UNICODE strings may be used.
o Simple types will be supported, but not nested types.
Accessing Data
Visual Basic .NET allows developers to interact with device-based databases, such as
Microsoft SQL Server CE, using the System.Data class. This class includes support for
disconnected datasets, which allows developers to work easily with both relational and
nonrelational data using the same model that is used with the .NET Framework. Data is
passed as XML, allowing rich, open standards-based communication and interoperability.
The Data Connector object exposes managed APIs that can be used to access the local
database. Each connector is database-specificthat is, the data connector for SQL Server
CE is the SQL Server CE Data Connector.
NOTE: Presently, there are no plans to provide a Data Connector for Pocket Access or
the native Windows CE database structure.
In addition to providing local support to SQL Server CE databases, SDE includes a SQL
Data Adapter that will provide access to remote SQL Server databases.
Page 29
NOTE: Support for SQL Server CE is not included in the beta version of SDE. It will be
provided in the final version of SDE.
There is no support for ADOCE in Visual Basic .NET, nor will there be any support for
ADOCE on Windows CE .NET. In its place, you can use ADO.NET to access datasets.
NOTE: ADOCE will still be available for use with native, or unmanaged, development tools
such as eMbeddded Visual C++ and eMbedded Visual Basic.
From your Visual Basic .NET application, you can access data through the System.Data
classes of the .NET Compact Framework. An example of this is shown in the code
fragment below.
To begin working with these classes, they must be incorporated into your project.
' These lines must be added to your project declarations:
Imports System.Data
Imports System.Data.ADO
Instances of the ADO Connection, Command, and Data Reader objects are created. These
instances are, in turn, used to connect to and retrieve data from a local SQL Server CE
database.
' Declare the ADO object variables.
Dim strConnectionInfo As String = _
"Provider=Microsoft.SQLServer.OLEDB.CE.1.0; Data Source=Northwind.sdf"
Dim demoConnection As New ADOConnection(strConnectionInfo)
Dim demoCommand As New ADOCommand("SELECT * FROM Employees", demoConnection)
Dim demoReader As ADODataReader
' Open the database and retrieve the data.
Try
demoConnection.Open()
demoCommand.Execute(demoReader)
' Did an error occur?
Catch demoException As Exception
MessageBox(demoException.ToString())
' Clean-up before exiting.
Finally
' Close the connection if it is open.
If (demoConnection.State = Data.DBObjectState.Open) Then
demoConnection.Close
End If
' Dispose of the Data Reader.
If Not demoReader Is Nothing Then
demoReader = Nothing
End If
End Try
Page 30
What Are Datasets?

Developers experienced with ADO are accustomed to working with recordsets. The
ADO.NET equivalent to a recordsets is the dataset. A dataset is a disconnected cache that
developers can use within their applications. It offers a relational view of the database
query stored in XML format. Through datasets, developers can access table, row, and
column data. Since datasets are disconnected, they inherently support a scalable model,
since the client application does not maintain a database connection for the entire time
that the application runs. The SQL Data Connector accesses the database to populate a
dataset. The dataset can then be used programmatically or bound to controls, such as text
boxes, list boxes, and grids.
NOTE: Recordsets are not included in ADO.NET. Datasets offer a far more flexible approach
to working with data sources.
Visual Basic.NET support for datasets and for binding datasets to controls will allow
developers to quickly build data-enabled applications. This is a great improvement over
eMbedded Visual Basic, in which developers were solely responsible for displaying and
managing data.
NOTE: The data grid control is not included in the beta version of SDE. It will be included in
the final release of SDE.
Visual Basic .NET and XML

XML is the universal format for data on the Internet. XML allows developers to easily
describe and deliver rich, structured data between applications, varied data sources, and
different operating systems in a standard, consistent way.
While eMbedded Visual Basic offered low-level support for XML, the .NET Compact
Framework provides Visual Basic .NET with a set of tools that make it simple and
straightforward to work with XML structures.
XML Functionality Included Under the .NET Compact Framework

As with other components of the .NET Compact Framework, the XML-related classes
offer a subset of the functionality found in the .NET Framework. The support for XML in
the .NET Compact Framework:
o Adheres to the SOAP standards.
o Allows developers to create applications that consume dataset from and post
datasets to XML Web services.
o Enables developers to read an XML document, manipulate the document, post the
document to a server and maintain the document on the device.
The .NET Compact Framework provides support for the following XML functionality:
Page 31
XML Reader. Provides a forward-only, read-only stream of parsed XML tokens.

XML Writer. Provides a forward-only, write-only method for generating well-formed
XML documents.
XML Document. Provides access to the XML Document Object Model (DOM).
Local Data Storage Using XML

The XML support provided by the .NET Compact Framework, and accessible from
Visual Studio .NET, allows developers to keep a persistent XML stream in a serialized
manner to a local text file. This provides developers with an alternative to relational
databases and standard files as a method of storing data.
Developers can use this technique to store configuration information, as well as for
offline caching of small, simple data volumes. This method provides a simple yet
effective alternative for situations in which a full-functioned relational database is not
required.
The following code fragment demonstrates persisting and then retrieving an XML stream
from a text file.
Dim demoDataSet As DataSet
Me.demoDataSet = New DataSet()
Me.demoDataSet.WriteXml("demo.xml")
Me.demoDataSet.ReadXml("demo.xml")
Working with Files Under SDE

With eMbedded Visual Basic, file access and directory information was provided by the
File System and File Microsoft ActiveX controls. In SDE, similar functionality is
provided by the .NET Compact Framework System.IO namespace.
The following code fragment demonstrates opening a text file, writing a line of text to the
file, and then closing the file in Visual Basic .NET.
Sub DemoWriteFile()
Dim demoStreamWriter As System.IO.StreamWriter
demoStreamWriter = New System.IO.StreamWriter("\demo.txt")
demoStreamWriter.WriteLine("This is a test.")
demoStreamWriter.Close()
End Sub
NOTE: The file capabilities provided under the Microsoft.VisualBasic namespace are not
supported by the .NET Compact Framework. Methods such as FileOpen, FileAttr, and
FileCopy, along with many others, are not included.
Page 32
Working with XML Web Services

One of the most powerful new features of Visual Basic .NET is the ability to create
applications that access, or consume, an XML Web service. XMLWeb services, running
on standard Internet Web servers, expose methods that can be called from your Visual
Basic .NET-based applications. Developing an XML Web service client with Visual Basic
.NET is simple. It involves adding a reference to the XML Web service, creating an
instance of the XML Web service, and then calling the methods provided by the XML
Web service.
NOTE: The implementation of an XML Web service under the beta of the SDE is limited and is
missing key .NET Framework classes. As such, some additional work needs to be done to
construct XML Web service clients. Refer to the Stock Quote and Inventory samples included
with the beta for examples of how to work around this issue.
Getting Started with Smart Device Extension

For the eMbedded Visual Basic developer migrating to SDE for Visual Studio .NET,
there are several considerations:
o SDE requires Visual Studio .NET. It is a Visual Studio Integration Package, or
VSIP, that plugs into Visual Studio .NET. Unlike eMbedded Visual Basic, SDE
cannot operate as a stand-alone product. No additional products are required.
o Smart Device Extensions support both Pocket PC and Pocket PC 2002, Windows
CE .NET, and third-party licensees of the .NET Compact Framework.
o SDE is best run under Windows 2000 with Service Pack 2, or Windows XP
Professional. While Windows NT is supported, either Windows 2000 or Windows
XP is needed for the new true emulator.
NOTE: Windows NT is not supported under the beta of Smart Device Extensions.
o Converting your existing eMbedded Visual Basic applications to Visual Basic

.NET is a manual process. You will need to recreate your forms as Windows
Forms forms. Your code will need to be modified as well.
o Third-party ActiveX controls that were developed for use with eMbedded Visual
Basic will not work with Visual Basic .NET.
o The implementations of the Visual Basic language in Visual Basic .NET and
eMbedded Visual Basic are different. You will need to have a solid understanding
of Visual Basic .NET and the .NET Compact Framework.
o Certain Visual Basic language keywords will be supported as part of the
Microsoft.Visual Basic namespace included with the .NET Compact Framework.
This will allow eMbedded Visual Basic developers to use such common
statements as MsgBox, InputBox, the Is functions, and standard BASIC string
manipulation functions, such as Trim and Instr.
o SDE does not natively support Pocket Access. While it is possible that a thirdparty vendor may choose to provide this functionality, converting existing
eMbedded Visual Basic applications that utilize a Pocket Access database may
require moving the data to another source, such as SQL Server CE.
Page 33
o Visual Basic .NET-based applications can leverage data binding to quickly build
data-enabled applications.
Where to Go from Here

Going from eMbedded Visual Basic to Smart Device Extensions for Visual Studio .NET
will require you to learn how to program in Visual Basic .NET and to acquire a solid
understanding of the .NET Framework. Reading third-party books on getting started with
Visual Basic .NET will aid in shortening your learning curve and will help you get started
creating robust mobile applications with SDE.
Page 34
Appendix A: Functionality Not Included in the .NET

Compact Framework
This appendix notes some of the key components and functionality that were not included
in the .NET Compact Framework.
Features Left Out of the .NET Compact Framework

To optimize for size, support for the following features has been excluded from the .NET
Compact Framework.
General Functionality Not Included in the Compact Framework

Printing. As with eMbedded Visual Basic, printer management and printing APIs will
not be supported in the .NET Compact Framework.
MDI forms. Windows CE .NET does not support the Multiple Document Interface
(MDI) and, as such, this functionality is not included in the .NET Compact Framework.
GDI+. Windows CE .NET does not support GDI+, so it is not included in the .NET
Compact Framework.
Drag-and-drop editing. Windows CE does not support OLE drag-and-drop editing
functionality, so it is not included in the .NET Compact Framework.
Binary serialization. Support for binary serialization is not included in the .NET
Compact Framework.
XML Functionality Not Included in the .NET Compact Framework

The initial version of the .NET Compact Framework will not support:
XMLDataDocument. This offers a data-friendly document object model (DOM), which
makes it easier for developers to work with both relational and nonrelational, or
hierarchical, data. Without the XMLDataDocument, developers will need to traverse the
document object model manually to access or modify its content.
XMLPathDocument (XPath). XPath enables accessing, selecting, and addressing a
node or collection of nodes within an XML document for well known elements and
attributes. As in the case with XMLDataDocument, developers will need to code this
functionality manually.
XSLTransform (XSLT). XSLT allows a developer to programmatically transform an
XML document into another form, whether that form is another XML document, an
HTML representation of the data, or a comma-delimited file. Without XSLT, any
transformation of XML documents will need to be done with code using the DOM.
Page 35

Getting Started With Smart Device Extentions

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Getting Started With Smart Device Extentions

Enviado por

Direitos autorais:

Formatos disponíveis

Embedded Applications: Getting

Started with Smart Device

The information contained in this document represents the current view

THE .NET COMPACT FRAMEWORK

USING THE DEVELOPMENT ENVIRONMENT

DIFFERENCES BETWEEN EMBEDDED VISUAL BASIC AND VISUAL

GETTING STARTED WITH SMART DEVICE EXTENSIONS

WHERE TO GO FROM HERE

APPENDIX A FUNCTIONALITY NOT INCLUDED IN THE .NET COMPACT

What Is Included with Smart Device Extensions

Why Not Offer eMbedded Visual Basic 4.0?

The .NET Compact Framework

What Is in the .NET Compact Framework?

Features of the Common Language Runtime

The .NET Compact Framework Class Library

Data and XML Classes

XML Web Services

Visual Basic Support

Graphics Device Interface Support

Using The Integrated Development Environment

Creating a New Project

Figure 1. The Visual Studio .NET Start page

Constructing a User Interface

Figure 4. The Windows Forms designer

The New Toolbox

Figure 5B. The Visual Studio .NET toolbox

Controls Provided by SDE

Table 1. The controls included with SDE

Adding Controls to Your Form

Figure 6. Adding a button to a form

Managing Your Project

Figure 7. The Visual Studio .NET Solution Explorer window

File Extension Description

Assembly Info File

A file used to store assembly information, such as versioning and

Assembly Resource .resx

A file containing localization information for a project when the

A blank bitmap image file, which can be used to create simple

A code file that initially contains a single empty class declaration.

An empty Visual Basic or Visual C# code file.

A class (a business object) for which a visual designer exists.

An image file for creating custom cursors.

A Windows-based control that is not visually designed (it does not

A data form that assists in creating data connections.

Sometimes called a disco file, this provides a means to enumerate

An image file for creating a custom icon.

A User Control that is derived from another existing user control.

A file used to publish information about an XML Web service.

An empty text file.

A control (a visual element) that you can place on a Windows form.

An XML document file.

An XSD schema file without the generated classes.

Table 2. Supported file types provided br SDE

Figure 8. The Visual Studio .NET Properties window

Figure 9. The Visual Studio .NET code window demonstrating IntelliSense

The Code Behind a Visual Basic .NET Form

Figure 10. Code file with generated code hidden

Configuring Your Project

Figure 12. Accessing project properties

Figure 13. Configuring project properties

Building Your Application

Configuration Manager Dialog Box

Testing Your Application

Figure 16. Selecting a deployment target