Microsoft Windows应用程序设计（英文）

PARTⅠ：REQUIRED READING

CHAPTER ONE ERROR HANDLING

You Can This Too

The ErrorShow Sample Application

CHAPTER TWO UNICODE

Character Sets

Single-Byte and Double-Byte Character Sets

Unicode：The Wide-Byte Character Set

Why You Should Use Unicode

Windows 2000 and Unicode

Windows 98 and Unicode

Windows CE and Unicode

Keeping Score

A Quick Word About COM

How to Write Unicode Source Code

Unicode Support in the C Run-Time Library

Unicode Data Types Defined by Windows

Unicode and ANSI Functions in Winodows

Windows String Functions

Making Your Application ANSI-and Unicode-Ready

Windows String Functions

Resources

Determining If Text Is ANSI or Unicode

Translating Strings Between Unicode and ANSI

CHAPTER THREE KERNEL OBJECTS

What Is a Kernel Object？

Usage Counting

Security

A Process’s Kernel Object Handle Table

Creating a Kernel Object

Closing a Kernel Object

Sharing Kernel Objects Across Process Boundaries

Object Handle Inheritance

Named Objects

Duplicating Object Handles

PARTⅡ：GETTING WORK DONE

CHAPTER FOUR PROCESSES

Writing Your First Windows Application

A Process’s Instance Handle

A Process’s Previous Instance Handle

A Process’s Command Line

A Process’s Environment Variables

A Process’s Affinity

A Process’s Error Mode

A Process’s Current Drive and Directory

The System Version

The CreateProcess Function

pszApplicationName and pszCommandLine

psaProcess，psaThread，and blnheritHandles

fdwCreate

pvEnvironment

pszCurDir

psiStartInfo

ppiProcInfo

Terminating a Process

The Primary Thread’s Entry-Point Function Returns

The ExitProcess Function

The TerminateProcess Function

When All the Threads in the Process Die

When a Process Terminates

Child Process

Running Detached Child Processes

Enumerating the Processes Running in the System

CHAPTER FIVE JOBS

Placing Restrictions on a Job’s Processes

Placing a Process in a Job

Terminating All Processes in a Job

Querying Job Statistics

Job Notifiacations

The JobLab Sample Application

CHAPTER SIX THREAD BASICS

When to Create a Thread

When Not to Create a Thread

Writing Your First Thread Function

The Create Thread Function

psa

cbStack

pfnStartAddr and pbParam

pdwThreadID

Terminating a Thread

The Thread Function Returns

The ExitThread Function

The Terminate Thread Function

When a Process Terminates

When a Thread Terminates

Some Thread Internals

C/C++ Run-Time Library Considerations

Oops—I Called CreateThread Instead of _beginthreadex by Mistake

C/C++ Run-Time Lbbrary Functions That You Should Never Call

Gaining a Sense of One’s Own Identity

Converting a Pseudo-Handle to a Real Handle

CHAPTER SEVER THREAD SCHEDULING，PRIORITIES，AND AFFINITIES

Suspending and Resuming a Thread

Suspending and Resuming a Process

Sleeping

Switching to Another Thread

A Thread’s Execution Times

Putting the Context in Context

Thread Priorities

An Abstract View of Priorities

Programming Priorities

Dynamically Boosting Thread Priority Levels

Tweaking the Scheduler for the Foreground Process

The Scheduling Lab Sample Application

Affinities

CHAPTER EIGHT THREAD SYNCHRONIZATION IN USER MODE

Atomic Access：The Interlocked Family fo Functions

Cache Lines

Advanced Thread Synchronization

A Technique to Avoid

Critical Sections

Critical Sections：The Fine Print

Critical Sections and Spinlocks

Critical Sections and Error Handing

Useful Tips and Techniques

CHAPTER NINE THREAD SYNCHRONIZATION WITH KERNEL OBJECTS

Wait Functions

Successful Wait Side Effects

Event Kernel Objects

The Handshake Sample Application

Waitable Timer Kernel Objects

Having Waitable Timers Queue APC Entries

Timer Loose Ends

Semaphore Kernel Objects

Mutex Kernel Objects

Abandonment Issues

Mutexes vs.Crivical Sections

The Queue Sample Application

A Handy Thread Synchronization Object Chart

Other Thread Synchronization Functions

Asynchronous Device I/O

WartForInputIdle

MsgWaitForMultipleObjects（Ex）

WaitForDebugEvent

SignalObjectAndWait

CHAPTER TEN THREAD SYNCHRONIZATION TOOLKIT

Implementing a Critical Section：The Optex

The Optex Sample Application

Creating Thread-Safe Datatypes and Inverse Semaphores

The InterlockedType Sample Application

The Single Writer/Multiple Reader Guard（SWMRG）

The SWMRG Sample Application

Implementing a WaitForMultipleExpressions Function

The WaitForMultipleExpressions Sample Application

CHAPTER ELEVER THREAD POOLING

Scenario1：Call Functions Asynchronously

Scenario2：Call Functions at Timed Intervals

The TimedMsgBox Sample Application

Scenario3：Call Functions When Single Kernel Objects Become Signaled

Scenario4：Call Functions When Asynchronous I/O Requests Complete

CHAPTER TWELVE FIBERS

Working with Fibers

The Counter Sample Application

PARTⅢ：MEMORY MANAGEMENT

CHAPTER THIRTEEN WINDOWS MEMORY ARCHITECTURE

A Process’s Virtual Address Space How a Virtual Address Space Is Partitioned

Null-Pointer Assignment Partition（Windows 2000 and Windows 98）

MS-DOS/16-Bit Windows Application Compatibility Partition（Windows 98 Only）

User-Mode Partition （Windows 2000 and Windows 98）

64-KB Off-Limits Partition（Windows 2000 Only）

Shared MMF Partition（Windows 98 Only）

Kernel-Mode Partition（Windows 2000 and Windows 98）

Regions in an Address Space

Committing Physical Storage Within a Region

Physical Storage and the Paging File

Physical Storage Not Maintained in the Paging File

Protection Attributes

Copy-On-Write Access

Special Access Protection Attribute Flags

Bringing It All Home

Inside the Regions

Address Space Differences for Windows 98

The Importance of Data Alignment

CHAPTER FOURTEEN EXPLORING VIRTUAL MEMORY

System Information

The System Information Sample Application

Virtual Memory Status

The Virtual Memory Status Sample Application

Determining the State of an Address Space

The VMQuery Function

The Virtual Memory Map Sample Application

CHAPTER FIFTEEN USING VIRTUAL MEMORY IN YOUR OWN APPLICATIONS

Reserving a Region in an Address Space

Committing Storage in a Reserved Region

Reserving a Region and Committing Storage Simultaneously

When to Commit Physical Storage

Decommitting Physical Storage and Releasing a Region

When to Decommit Physical Storage

The Virtual Memory Allocation Sample Application

Changing Protection Attributes

Resetting the Contents of Physical Storage

The MemReset Sample Application

Address Windowing Extensions（Windows 2000 only）

The AWE Sample Application

CHAPTER SIXTEEN A THREAD’S STACK

A Thread’s Stack Under Window 98

The C/C++Run-Time Library’s Stack-Checking Function

The Summation Sample Application

CHAPTER SEVENTEEN MEMORY-MAPPED FILES

Memory-Mapped Executables and DLLS

Static Data Is Not Shared by Multiple Instances of an Executable or a DLL

Sharing Static Data Across Multiple Instances of an Executable or a DLL

The AppInst Sample Application

Memory-Mapped Data Files

Method1：One File，One Buffer

Method2：Two File，One Buffer

Method3：One File，Two Buffer

Method4：One File，Zero Buffers

Using Memory-Mapped Files

Step1：Creating or Opening a File Kernel Object

Step2：Creating a File-Mapping Kernel Object

Step3：Mapping the File’s Data into the Process’s Address Space

Step4：Unmapping the File’s Data from the Process’s Address Space

Step5 and 6：Closing the File-Mapping Object and the File Object

The File Reverse Sample Application

Processing a Big File Using Memory-Mapped Files

Memory-Mapped Files and Coherence

Specifying the Base Address of a Memory-Mapped File

Implementation Details of Memory-Mapped Files

Using Memory-Mapped Files to Shore Data Among Processes

Memory-Mapped Files Backed by the Paging File

The Memory-Mapped File Sharing Sample Application

Sparsely Committed Memory-Mapped Files

The Sparse Memory-Mapped File Sample Application

CHAPTER EIGHTEEN HEAPS

A Proess’s Default Heap

Reasons to Create Additional Heaps

Component Protection

More Efficient Memory Management

Local Access

Avoiding Thread Synchronization Overhead

Quick Free

How to Create an Additional Heap

Allocating a Block of Memory from a Heap

Changing the Size of a Block

Obtaining the Size of a Block

Freeing a Block

Destroying a Heap

Using Heaps with C++

PARTⅣ：DYNAMIC-LINK LIBRARIES

CHAPTER NINETEEN DLL BASICS

DLLs and a Process’s Address Space

The Overall Picture

Building the DLL Module

What Exporting Really Means

Creating DLLs for Use with Non-Visual C++ Tools

Building the Executable Module

What Importing Really Means

Running the Executable Module

CHAPTER TWENTY DLL ADVANCED TECHNIQUES

Explicit DLL Module Loading and Symbol Linking

Explicitly Loading the DLL Module

Explicitly Unloading the DLL Module

Explicitly Linking to an Exported Symbol

The DLL’s Entry-Point Function

The DLL_PROCESS_ATTACH Notification

The DLL_PROCESS_DETCH Notification

The DLL_THREAD_ATTACH Notification

The DLL_THREAD_DETACH Notification

Serialized Calls to D//Main

D//Main and the C/C++ Run-Time Library

Delay-Loading a DLL

The DelayLoadApp Sample Application

Function Forwarders

Known DLLs

DLL Redirection

Rebasing Modules

Bind Modules

CHAPTER TWENTY-ONE THREAD-LOCAL STORAGE

Dynamic TLS

Using Dynamic TLS

Static TLS

CHAPTER TWENTY-TWO DLL INJECTION AND API HOOKING

DLL Injection：An Example

Injecting a DLL Using the Rgistry

Injecting a DLL Using Windows Hooks

The Desktop Item Position Saver（DIPS）Utility

Injecting a DLL Using Remote Threads

The Inject Library Sample Application

The Image Walk DLL

Injecting a DLL with a Trojan DLL

Injecting a DLL as a Debugger

Injecting Code with a Memory-Mapped File on Windows 98

Injecting Code with CreateProcess

API Hooking：An Example

API Hooking by Overwriting Code

API Hooking by Module’s Import Section

The LastMsgBoxInfo Sample Application

PARTⅤ：STRUCTURED EXCEPTION HANDLING

CHAPTER TWENTY-THREE TERMINATION HANDLERS

Understanding Termination Handlers by Example

Funcenstein1

Funcenstein2

Funcenstein3

Funcfurter1

Pop Quiz Time：FuncaDoodleDoo

Funcenstein4

Funcarama1

Funcarama2

Funcarama3

Funcarama4：The Final Frontier

Notes About the finally Block

Funcfurter2

The SEH Termination Sample Application

CHAPTER TWENTY-FOUR EXCEPTION HANDLERS AND SOFTWARE EXCEPTIONS

Understanding Exception Filters and Exception Handlers by Example

Funcmeister1

Funcmeister2

EXCEPTION_EXECUTE_HANDLER

Some Useful Examples

Golbal Unwinds

Halting Golbal Unwinds

EXCEPTION_CONTINUE_EXECUTION

Use EXCEPTION_CONTINUE_EXECUTION with Caution

EXCEPTION_CONTINUE_SEARCH

GetExceptinCode

Memory-Related Exceptions

Exception-Related Exceptions

Debugging-Related Exceptions

Integer-Related Exceptions

Floating Point-Related Exceptions

GetExceptionInfomation

Software Exceptions

CHAPTER TWENTY-FIVE NUHANDLED EXCEPTIONS AND C++ EXCEPTIONS

Just-In-Time Debugging

Turning off the Exception Message Box

Forcing the Process to Die

Wrapping a Thread Function

Wrapping All Thread Functions

Automatically Invoking the Debugger

Calling UnhandledExceptionFilter Yourself

Inside the UnhandledExceptionFilter Function

Exceptions and the Debugger

The Spreadsheet Sample Application

C++ Exceptions Versus Structured Exceptions

Catching Structured Exceptions with C++

PARTⅥ：WINDOWING

CHAPTER TWENTY-SIX WINDOW MESSAGING

A Thread’s Message Queue

Posting Messages to a Thread’s Message Queue

Sending Messages to a Window

Waking a Thread

The Queue Status Flags

The Algorithm for Extracting Messages from a Thread’s Queue

Waking a Thread with Kernel Objects or with Queue Status Flags

Sending Data with Messages

The CopyData Sample Application

How Windows Handle ANSI/Unicode Characters and Strings

CHAPTER TWENTY-SEVEN THE HARDWARE INPUT MODEL AND LOCAL INPUT STATE

The Raw Input Thread

Local Input State

Keyboard Input and Focus

Mouse Cursor Management

Attaching Virtualized Input Queues and Local Input State Together

The Local Input State Laboratory（LISLab） Sample Application

The Local Input State Watch（LISWatch）Sample Application

APPENDIX A THE BUILD ENVIRONMENT

The CmnHdr.h Header File

Windows Version Build Option

Unicode Build Option

Windows Definitions and Warning Level 4

The Pragma Message Helper Macro

The chINRANGE and chDIMOF Macros

The chBEGINTHREADEX Macro

DebugBreak Improvement for 86 Platforms

Creating Software Exception Codes

The chMB Macro

The chASSERT and chVERIFY Macros

The chHANDLE_DLGMSG Macro

The chSETDLGICONS Macro

The OS Version Check Inline Finctions

Making Sure the Host System Supports Unicode

Forcing the Linker to Look for a（w）WinMain Entry-Point Function

APPENDIX B MESSAGE CRACKERS，CHILD CONTROL MACROS，AND API MACROS

Message Crackers

Child Control Macros

API Macros

Index