book

.NET Compact Framework Programming with Visual Basic .NET

Name: .NET Compact Framework Programming with Visual Basic .NET
ISBN: 0321174046

by Paul Yao, David Durant

June 2004

Intermediate to advanced

1424 pages

28h 58m

English

Addison-Wesley Professional

Read now

Unlock full access

Copyright
Dedication
Praise for .NET Compact Framework Programming with Visual Basic .NET
Microsoft .NET Development Series
Titles in the Series
Foreword
Preface
What You Need to Use This BookHardwareSoftwareThe Latest Version of the .NET Compact FrameworkThe Target Audience for This BookFor Programmers Experienced with Windows CEFor Programmers Experienced with the .NET Framework
Acknowledgments
About the Authors
I. Foundations
1. .NET Compact Framework Architecture
Windows CE OverviewDesign GoalsSmallModularPortableCompatibleConnectedReal TimePlatforms and Platform BuildereMbedded Visual C++Remote ToolsDocumentationObtaining eMbedded Visual C++What Is .NET?Available .NET ImplementationsThe Scale and Scope of .NETThe Scale of .NETThe Scope of .NETThree .NET Application ClassesWindows Forms and Web FormsWeb ServicesCommon Programming ElementsWell-Designed Programming InterfaceCommon Intermediate LanguageCommon Language RuntimeCommon Language SpecificationCommon Type SystemCommon Language InfrastructureThe .NET Compact FrameworkDesign GoalsBuild on the Benefits of the .NET FrameworkMaintain Consistency with the Desktop VersionEnsure That the Framework Runs Well on Mobile and Embedded DevicesExpose the Richness of Target PlatformsPreserve the Look and Feel of PlatformsProvide Portability to Other Mobile Operating Systems.NET Compact Framework Files.NET Compact Framework CapabilitiesSupported Runtime ElementsSupported .NET Application ClassesGraphical OutputSupported ADO.NET ElementsXML Support.NET Compact Framework LimitationsCONCLUSION
2. What Is a .NET Compact Framework Program?
The Essence of a .NET Compact Framework ProgramUses the .NET Compact Framework LibrariesHas a Graphical User InterfaceIs Defined Entirely in Source CodeHas One or More Classes Derived from System.Windows.Forms.FormUsing Visual Studio .NET 2003Using the Development EnvironmentExamining Designer-Generated CodeRegionsThe Cistern Sample ProgramStep 1: Adding Controls Using the DesignerStep 2: Adding Code to the ProgramAdding a New Form to an ApplicationUnderstanding Events and Event HandlersCreating and Displaying a Second FormCreating Controls at RuntimeAdding ClassesCreating the WaterMath ClassesOverloading FunctionsUsing the WaterMath ObjectDefining and Using Shared MethodsUnderstanding NamespacesUsing IntelliSenseCONCLUSION

3. The .NET Type System
Using Type Information: Namespace References and Assembly ReferencesNamespace ContentsAccessing NamespacesAssembly ReferencesStandard TypesValue TypesInteger and Floating-Point Value TypesData StructuresReference TypesDeclaration, Initialization, and AllocationValue Types and Reference Types as ParametersValue Types as ParametersReference Types as ParametersStringsLiteral StringsThe System.String ClassString Properties, Methods, and OperatorsValue Type or Reference Type?Strings Are ImmutableThe Other Side of ImmutabilityThe System.Text.StringBuilder ClassString ResourcesType ConversionNumeric ConversionExplicit ConversionThe Overflow ExceptionHandling ExceptionsConverting Strings to NumbersString ConversionNumeric FormattingCharacter Set ConversionCreating Formatted StringsConverting Values to ObjectsMemory ManagementMetadata MapsThe JITted Code PoolGarbage Collector PoolsGarbage Collection and DataAutomatic Garbage CollectionPhase 1: Mark and SweepPhase 2: Compact the HeapPhase 3: Flush the JITted Code PoolSpecial Handling of Managed DataCalling the Garbage CollectorManual Cleanup Using the Dispose MethodImplementing Class-Specific Cleanup Methods: Dispose and FinalizeWeak ReferencesManual Memory Management of Native DataCONCLUSION
4. Platform Invoke
Overview of P/InvokeWhen to Use P/InvokeWhy We Prefer .NET Compact Framework Classes over Win32 FunctionsPorting Unmanaged Code to Managed CodeCreating P/Invoke DeclarationsA Simple Function: MessageBoxUnmanaged Function DetailsFunction Return ValuesGetting Started: C-Style Function DeclarationsSupported P/Invoke Function ParametersThe Limits of Parameter PassingSimple Data TypesBooleanSigned versus Unsigned IntegersPassing Parameters by Value versus by ReferencePassing String Parameters by ValueStructuresExample: MemoryStatusType of Types versus Type of ParametersValue Types as ParametersReference Types as ParametersArraysExample: Passing an Array of IntegersA Sample Program: CallWin32Writing Win32 Dynamic Link LibrariesDevelopment ToolsDeclaring C++ Functions in a DLLManual P/Invoke Parameter PassingThe Marshal ClassAllocating Unmanaged MemoryCopying to Unmanaged MemoryCreating Objects from Unmanaged MemoryExample: FindMemoryCardCommunicating between Unmanaged and Managed CodeThe MessageWindow ClassOther Ways to Communicate between Unmanaged and Managed CodeComparing P/Invoke SupportWindows CE–Specific DifferencesLimitationsNo Support for COM InteropNo Support for Callback FunctionsNo Support for the StructLayout AttributeNo Support for the MarshalAs Attribute.NET Compact Framework Implementation DetailsCONCLUSION
II. Building the User Interface
5. Creating Forms
What Are Forms?Deriving Forms from the Form ClassProperties, Methods, and EventsPropertiesMethodsEventsAn Event-Capturing ApplicationManipulating FormsCreating FormsDisplaying FormsClosing FormsOrphaned FormsThe Weather Sample ApplicationTracking FormsThe Controls CollectionMultithreadingInheritance and Visual InheritanceCONCLUSION
6. Mouse and Keyboard Input
Overview of InputEvent-Driven InputThe Foreground WindowEnabled versus DisabledVisibilityKeyboard InputMouse InputUsing Controls for Mouse and Keyboard InputControl Support for Input EventsInput to Label ControlsCarets and CursorsProgramming for Mouse InputMouse EventsAutomatic Mouse CaptureMouse Event HandlersA Sample Program: DrawRectanglesDrawing Stretchable Rubber RectanglesCollecting the PointsDrawing the RectanglesMouse Debugging Tip: Echoing Mouse Coordinates as TextSetting the Mouse Cursor with the Cursor ClassSetting the Mouse Cursor with Win32 FunctionsProgramming for Keyboard InputSources of Keyboard InputDevice ButtonsSoftware Input PanelKeyboardsThe Win32 keybd_event FunctionKeyboard EventsFocus EventsActivation EventsKeyboard Event SequencesPrintable Character KeysNonprintable KeysPocket PC Device ButtonsKeyboard Event HandlersA Sample Program: KeyInputResponding to SIP Changes by Using the InputPanel ControlSubclassing versus Event HandlersSubclassing a TextBox ControlSubclassing and the Windows Forms DesignerIdentifying Methods to OverrideA Sample Program: KeyStateA Sample Program: CaretCreating and Destroying a CaretMoving a CaretA Sample Program: SleepPushing the Power ButtonReading and Writing System Timeout ValuesCONCLUSION
7. Inside Controls
What Are Controls?Visible ObjectsDescended from the Desktop .NET FrameworkMaintain Consistency with the Desktop VersionEnsure That the Framework Runs Well on Mobile and Embedded DevicesExpose the Richness of Target PlatformsPreserve the Look and Feel of PlatformsDocumentation, Development, and ConfusionCategories of ControlsThe Ultimate Parent ControlsThe Container ControlsThe Single-Item ControlsThe Multi-Item ControlsThe Command Input ControlsThe Visual Numeric Value ControlsThe Background ControlsProperties, Methods, and EventsThe Core EventsThe Disposed EventThe ParentChanged EventThe Validating and Validated EventsThe EnabledChanged EventThe GotFocus and LostFocus EventsThe Core PropertiesThe Parent/Child PropertiesThe Positional PropertiesThe Data-Binding PropertiesThe Control State PropertiesThe Core MethodsThread-Safe Function CallsObject CleanupCoordinate ConversionZ-OrderingVisibilityWorking with Control Type InformationTypecasting ControlsComparing Two Control ReferencesChecking a Control's TypeFive Commonly Used ControlsA Sample Program: TimeTrackerWriting the CodeThe Application InterfaceCoding Event HandlersThe Label ControlDisplay, Yes; Update, NoTransparencyThe TextBox ControlDisplay, Yes; Input, YesThe ListBox and ComboBox ControlsThe List in ListBox ControlsUsing the ComboBox Control in the Sample ApplicationThe Button ControlTriggering ActionsAdding a Control at RuntimeHandling the Click Event for the New ButtonHandling the Click Event for the Add ButtonHandling the Click Event for the Cancel ButtonThe RadioButton and CheckBox ControlsA Sample Program: RegisterMembersUsing Radio ButtonsBuilding RegisterMembersUsing Check BoxesImproving RegisterMembersCONCLUSION
8. Data Binding to Controls
Data BindingData-Bindable ControlsData-Bindable ObjectsComplex Data BindingUsing Complex Data Binding with ListBox and ComboBox ControlsSimple Data BindingThe BindingsCollection PropertyFormatting and ParsingThe DataGrid ControlUsing Complex Data Binding with the DataGrid ControlStyling the Display of Data in a DataGrid ControlCreating Table and Column StylesCreating Styles at RuntimeResponding to User InputUsing Simple Data Binding with the DataGrid ControlAccessing DataGrid InformationProviding Drill-Down CapabilityProviding In-Place Editing CapabilityProviding Automated In-Place Editing CapabilityCONCLUSION
9. Inside More Controls
Detecting Support for Properties, Methods, and EventsA Tool: ControlPME.NET Compact Framework Controls in a Desktop .NET Framework ProgramMenusThe Start MenuProgram MenusA Sample Program: ProgramMenuContext MenusA Sample Program: TextBoxClipboardThe Context MenuClipboard Support in a TextBox ControlGrabbing EventsSubclassing to Intercept Win32 MessagesGetting Messages into Managed Code by Using the MessageWindow ClassThe ToolBar and ImageList ControlsToolbarsToolbar ButtonsImageList Controls and ImagesA Sample Program: ToolBarDialog BoxesBuilt-in Dialog BoxesA Sample Program: FileDialogsCreating Custom Dialog BoxesDesigning Pocket PC Dialog BoxesProgramming Custom Dialog BoxesFixing a Pocket PC Task List ProblemA Sample Program: DialogBoxesCreating the Options Dialog BoxControlling the Options Dialog BoxCONCLUSION
10. Building Custom Controls
Custom ControlsControls as ObjectsDesign RecommendationsMost Controls Are Wrappers around Native Windows ClassesThe Possible Base Classes for Your Custom ControlThe Foundation of All Controls Are PMEs“Inherited Does Not Mean Supported”Consider Using Context Menus in Custom ControlsThe Methods for Testing ControlsAbout Properties and MethodsProperties Are Executable Code and Can Be Overridden Just Like MethodsOverriding a Method or Property to Replace the Base Class MethodYou Can Supplement a Method or Property Instead of Replacing ItA Private Version of a Method or Property “Shadows” the Base Class MethodTo Extend a Method, Call the Base Class MethodHardware Input Bypasses Property AccessorsAbout EventsYou Cannot Override Events, but You Can Override the Methods That Raise EventsCustom Control Classes Can Either Respond to Events or Override the Base Event HandlerThe OnLostFocus Method Raises Three Events: Validating, Validated, and LostFocusDeriving Custom Controls from an Existing .NET ControlThe DateBox Control ExampleDesign Decision #1: Exposing Custom Control ContentDesign Decision #2: Where to Validate/Filter Incoming DataThe DateBox CodeThe Date PropertyThe Text PropertyThe MinValue and MaxValue PropertiesThe Format PropertyThe Default ConstructorThe Validating Event HandlerThe Context Menu RoutinesTesting the DateBox ControlThe WaterTemp Object ExampleMore Design DecisionsThe WaterTemp ObjectThe WaterBox ObjectCreating Composite ControlsThe TaskStatus Control ExampleProgramming for the Relationship between ComponentsCreating New ControlsDesign TipsCustom Controls Support More Events Than Built-in ControlsYou Can Override the Drawing Only for Controls Directly Derived from ControlA Redrawing Can Be Requested by the Runtime or Initiated by the ApplicationDrawing in a Custom ControlProviding Our Own Display for the TaskStatus ControlAdding Animation to a Custom ControlThe Game of LifeProviding Consistent Speed and Minimal FlickerObject ReuseAuthoring Custom Controls for the Multithreaded EnvironmentA Control's Main Thread and Its Service ThreadsThe Multithread ExampleThe Testing FormThe Custom ControlAdding a Custom Control to the Visual Studio .NET ToolboxObstacles to Putting Custom Controls in the ToolboxA .NET Compact Framework Control Cannot Be Added to the ToolboxYou Are Developing a Desktop Control That Is Different from a Normal Desktop ControlYou See Build ErrorsTesting Design-Time Controls Takes a Bit More EffortFreeze Version Numbers during TestingOne or Two Sets of Source Files?Developing a Design-Time Custom ControlThe Setup Process for a Design-Time Control ProjectThe Development Process for a Design-Time Control ProjectAn Example of Setting Up a Project with the DateBox Custom ControlBuilding and Installing the Design-Time DateBox ControlSetting Default Property ValuesCONCLUSION
III. Managing Device Data
11. Storage
Smart-Device Data StorageThe Object StoreSystem Power StatesInstallable File SystemsThe Windows CE File SystemROM-Based FilesRAM-Based FilesFile I/OThe File and Directory ClassesByte-Level I/OHigher-Level I/OEncoding and Decoding DataUsing the I/O ClassesText File I/OBinary File I/OWriting Binary DataReading Binary DataI/O and StructuresXML File I/ORegistry AccessOpening a Registry KeyThe Need for P/Invoke WrappersMapping Registry Types to Managed TypesOpening and Accessing Registry KeysReading Registry ValuesWriting Registry ValuesUsing Function Overloading for Registry AccessUsing Registry Utility ClassesUpdating the Storage Sample Application to Use the RegistryCONCLUSION
12. ADO.NET Programming
Examining ADO.NETA Layered ApproachThe ADO.NET ClassesNamespace References and Assembly ReferencesFunctionality: Super Sets and SubsetsADO.NET Error HandlingWorking with Data SetsCreating and Accessing DataSet, DataTable, and DataView ObjectsUnderstanding Data TablesWorking with Data RowsIntroducing Data ViewsData BindingBinding to Multi-Item ControlsBinding to Single-Item ControlsDesignating the Row to Be DisplayedMatching BindingIndexingSearch KeyAssigning the Controls to a RowUpdating the Bound Data TableReading and Writing a Data Set as XMLMicrosoft SQL Server CESQL Server CE FilesSQL Server CE SyntaxSQL Server CE Query AnalyzerCreating a SQL Server CE DatabasePopulating a SQL Server CE DatabaseThe SqlCeConnection and SqlCeCommand ClassesRetrieving and Displaying DataThe SqlCeDataReader ClassUpdating a SQL Server CE DatabaseThe SqlCeDataAdapter ClassUsing a SqlCeDataAdapter Object to Retrieve DataUsing a SqlCeDataAdapter Object to Update a DatabaseQuerying Schema InformationMicrosoft SQL ServerConnecting to SQL ServerCreating Command ObjectsUsing SQL Server Stored ProceduresUsing Stored Procedures with DataSet ObjectsDataSet Objects and ConcurrencyWeb ServicesXML, XSD, and SOAPA Web Services ApplicationA Web Services Client ApplicationCONCLUSION
13. Synchronizing Mobile Data
Understanding Remote Data ApplicationsRDA and Merge ReplicationIIS ConnectivityDatabase ConnectivityInstalling Remote Data ConnectivityCreating the Virtual DirectoryConfiguring Additional ComponentsUsing RDARDA Capabilities and OverheadProgramming for RDAPulling DataFixing the IDENTITY PropertyViewing the Pulled SchemaModifying Pulled Data LocallyPushing DataThe SubmitSQL MethodUsing Merge ReplicationUsing Good Design to Avoid Synchronization FailuresConfiguring Merge ReplicationProgramming for Merge ReplicationSubscribing to a PublicationSynchronizing the DataModifying the Data at the DeviceChoosing between Merge Replication and RDACONCLUSION
14. The Remote API
What Is ActiveSync?Partners and GuestsActiveSync LimitationsOnly One Active ConnectionNo Emulator SupportNo Synchronization between DevicesNo Synchronization with ServersActiveSync Compared with Web ServicesActiveSync Programming InterfacesShould You Build Managed-Code ActiveSync Applications?RAPI FundamentalsAvailable RAPI FunctionsBuilding .NET ActiveSync ApplicationsRAPI Startup and ShutdownCeRapiInit versus CeRapiInitExShutdown with CeRapiUninitTwo Approaches to StartupApproach 1: Simple, Single-Threaded RAPI StartupApproach 2: Multithreaded RAPI StartupDefensive CodingAccessing the Object StoreUsing RAPI to Access Device FilesFindPrograms: Using RAPI to Find Files in the Device File SystemFindProgramsFaster: Speeding Up a File SearchRemote Access to Device Registry EntriesRemote Access to Device Property DatabasesDetecting Changes in Device Connection StateThe Auto-Start ApproachThe Callback ApproachLoading Programs and DLLsRunning Device-Side ProgramsLoading Device-Side DLLsBuilding a DLL Using eMbedded Visual C++Calling a DLL Function with CeRapiInvokeCONCLUSION
IV. Creating Graphical Output
15. .NET Compact Framework Graphics
An Introduction to .NET Compact Framework GraphicsDrawing SurfacesDisplay ScreensPrintersBitmapsMetafilesSupported Drawing SurfacesDrawing Function FamiliesText OutputRaster OutputVector Output.NET Compact Framework GraphicsThe Role of the Graphics ClassDrawing Support for Text OutputDrawing Support for Raster OutputDrawing Support for Vector OutputDrawing on the Display ScreenAccessing a Graphics ObjectDrawing in ControlsThe Paint EventNon–Paint Event DrawingRaster GraphicsSpecifying ColorsSystem ColorsNamed ColorsColors from RGB ValuesCreating BrushesCreating Brushes with System ColorsCreating Brushes with Named ColorsCreating Brushes with RGB ValuesCreating BitmapsBitmaps: Drawing Surface or Drawing Object?The Bitmap ClassCreating an Empty BitmapCreating a Bitmap from an External FileCreating a Bitmap from a ResourceTyped ResourcesUntyped ResourcesImage File SizesDrawing BitmapsDrawing the Entire Bitmap at the Original Image SizeDrawing Part of a Bitmap at the Original Image SizeDrawing Part of a Bitmap with a Change to the Image SizeDrawing Part of a Bitmap with a Change to the Image Size and with TransparencyA Sample Program: ShowBitmapVector GraphicsCreating PensA Game: JaspersDotsCONCLUSION
16. Text and Fonts
Drawing TextText-Drawing Support in the .NET Compact FrameworkThe DrawString MethodA Sample Program: SimpleDrawStringFont SelectionThe Font Property of ControlsGeneric FontsA Sample Program: GenericFontsCreating Named FontsEnumerating FontsA Sample Program: FontPickerA Sample Library: FontList, a Win32 Font Enumeration DLLNative-Code FontsCreating Fonts in Unmanaged CodeDrawing with Fonts in Unmanaged CodeCleanupA Sample Program: RotateTextPlacing TextText Size and the MeasureString MethodA Sample Program: MeasureStringText AlignmentA Sample Program: TextAlignWord WrapA Sample Program: WordWrapText ColorForeground and Background Text ColorsA Sample Program: TextColorCONCLUSION
17. Printing
The Printing PipelinePrinterPage Description Languages (PDLs)PCLPostscriptI/O ChannelPrint JobGraphics SubsystemPrinting ProgramProgramming for Printed OutputOverview of Printing Sample ProgramsTiming Tests for the Sample Printing ProgramsOur ResultsPocket PC Printing SupportThe Print Dialog BoxDirect PrintingDirect Printing to a PCL PrinterA Sample Program: PrintDirectRendering with GDIGDI Design NotesDevice-Independent Logical Drawing ModelDevice-Independent Programming InterfaceWindows CE Support for GDI FunctionsGDI Query FunctionsGDI Printing and Drawing FunctionsGDI Drawing AttributesA Sample Program: PrintGDIHP Mobile PrintingHP Mobile Printing for Pocket PCHP Mobile Printing Software Development KitsHP Mobile Printing SDKHP Mobile Printing SDK with Microsoft Visual Studio .NET SupportA Sample Program: PrintHPMobileRendering with PrinterCEThe PrinterCE LibraryA Sample Program: PrintFieldCONCLUSION
V. Appendixes
A. Hungarian Notation for .NET Programs
Goals and ObjectivesGuidelines.NET Naming GuidelinesHungarian NotationOur Use of Hungarian NotationThe m_ Prefix for Private DataHungarian Prefixes for CTS Value Types
B. Supported PMEs for .NET Compact Framework Controls
C. Data Synchronization Wizards
The Virtual Directory Creation WizardThe Create Publication Wizard
D. Windows API Allocation and Cleanup Functions
Glossary

Content preview from .NET Compact Framework Programming with Visual Basic .NET

Chapter 10. Building Custom Controls

In this chapter, we describe how to develop custom controls, including extending existing controls, building composite controls, and creating controls that provide their own rendering. Coverage includes adding animation to custom controls, creating controls for multithreaded applications, and incorporating your custom controls into the Windows Forms Designer Toolbox in Visual Studio .NET. We also present key background information, discuss design issues, and demonstrate recommended coding practices.

Custom Controls

The .NET Compact Framework provides you with a variety of features for creating applications. Included among these features are the controls in the Toolbox. Sometimes the functionality of the built-in ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Programming .NET Compact Framework 3.5 Second Edition

Publisher Resources

ISBN: 0321174046Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

.NET Compact Framework Programming with Visual Basic .NET

by Paul Yao, David Durant

Chapter 10. Building Custom Controls

Custom Controls

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.