.NET Programming with Visual C++: Tutorial, Reference, and Immediate Solutions

Cover
Title Page
Copyright Page
CONTENTS SUMMARY
Table of Contents
Introduction
CHAPTER 1: Introducing the Microsoft .NET Framework
	What Is .NET?
	When to Upgrade to Visual C++ .NET
		When Not to Upgrade
			* If You Are Not Running Windows 2000 or Windows XP
			* If You Rely on Third-Party Object Modules
			* If You Rely on Third-Party Static Libraries that Statically Link to MFC
	Web Services
		Web Service Architecture
		SOAP and WSDL
		Web Service Discovery
		Web Service Requirements
	Development Challenges
		Introducing Microsoft’s Solution: .NET
		Sun’s Solution—Java
		.NET vs. Java
		Is .NET Strictly About Web Services?
	Inside .NET
		Cross Language Interoperability
		Common Language Specification
		Common Type System
			Value Types
			Enumerations
			Classes
			Interfaces
			Delegates
			Pointers
		Microsoft Intermediate Language
		Managed Execution
		Metadata
		Common Language Runtime
		Assemblies
			Assembly Manifest
			Assembly Functions
			Global Assembly Cache
			Strong Names
			Assembly Version Resolution
			Assembly Security
		Application Domains
		The .NET Framework Class Library
			System Namespace
		In Summary
CHAPTER 2: Managed Extensions to C++
	In Depth
	Introducing Managed Extensions
	Benefits of Managed Extensions
		Simple Memory Management
		Safer, More Robust Code
		Seamless Interoperability
		Wealth of the .NET Framework Class Library
	Tradeoffs and Limitations of Managed Extensions
		Non-deterministic Destruction
		Reduced Performance
		Application Deployment Issues
	When to Use Managed Extensions?
	Managed Code vs. Native Code
	Managed C++ Project Types
	Hello World in Managed C++
	Immediate Solutions
		Compiling Managed C++ Code
		Initializing Character Strings
		Declaring Namespaces (using namespace Keyword)
		Referencing Namespaces (using namespace Keyword)
		Importing Classes and Other Metadata from External Assemblies (#using Precompiler Directive)
		Declaring Managed Classes ( gc Keyword)
			Defining Managed Constructors
			Defining Static Constructors
			Defining Managed Destructors
		Declaring Abstract Classes ( abstract Keyword)
		Declaring Sealed Classes and Sealed Class Members (_sealed Keyword)
		Declaring Identifiers Matching C++ Keywords ( identifier Keyword)
		Declaring Properties ( property Keyword)
			Declaring Indexed Properties
		Declaring Interfaces ( interface Keyword)
		Declaring Value Types ( value Keyword)
			Boxing Value Types ( box Keyword)
			Unboxing Value Types
		Using Primitive Types
		Declaring Managed Pointers
			Using Interior and Whole Pointers
			Pinning Pointers ( pin Keyword
			Using Address-Of Operator
			Dynamic Pointer Casting (dynamic_cast Operator)
			Try-Casting (_try_cast Operator)
			Static Pointer Casting (static_cast Operator)
			Converting Between Unrelated Types (reinterpret_cast Operator)
			Constant Casting (const_cast Operator)
			C-Style Pointer Casting
		Declaring Managed References
		Declaring Managed Arrays
		Exploiting Array Covariance
		Declaring Arrays as Function Return Values
		Declaring Multidimensional Arrays
			Using Aggregate Array Initialization
		Declaring Unmanaged Arrays
		Declaring Unmanaged (_nogc) Classes
		Declaring Nested Classes
		Declaring Managed Enumerations
		Declaring Function Pointers ( delegate keyword)
		Specifying Class Visibility
			Specifying Class Member Visibility
		Declaring Managed Operators
			Implementing Operators in Value Types
			Implementing Operators in __gc-Classes
		Declaring Managed Conversion Operators
			Declaring Convert-To Operators
			Implementing Convert-To Operators in Value Types
			Implementing Convert-To Operators in __gc-Classes
			Declaring Convert-From Operators
			Declaring “Initialize-From” Constructors
		Using Attributes
			Specifying Global Attribute Context
			Specifying Global Assembly Attributes
		Declaring Functions with Variable Number of Arguments
		Mixing Managed and Unmanaged Code
			Using Unmanaged Classes as Members of Managed Types
			Declaring Managed Pointers as Members of Unmanaged Classes
			Passing Managed Pointers to Unmanaged Code
		Creating Managed Applications
		Creating Managed Class Libraries
		Creating Multi-Module Assemblies
		Creating Shared/Strong-Named Assemblies
		Delay-Signing Assemblies
CHAPTER 3: .NET System Namespace: Arrays, Strings, Delegates And Other Essential Classe
	In Depth
	System Namespace Class Hierarchy
		Base Interfaces
		System Namespace Enumerations
		System Namespace Delegates
	Object Class: The Root of the Hierarchy
	Array Class
	String Object
		String Formatting
		StringBuilder Class
	Console I/O
	DateTime Class
	Time Intervals
	Math Class
	Random Number Generator
	Exceptions
	Delegates
		Multicast Delegates
		Events
	Immediate Solutions
		Creating Arrays, Iterating Through Array Elements
		Creating Arrays Dynamically
		Sorting and Searching Arrays
		Creating and Initializing Strings
		Accessing String Characters
		Concatenating Strings
		Formatting Strings
		Using Console I/O
		Using StringBuilder Objects
		Working with Dates and Time Intervals
		Using Math Functions
		Generating Random Numbers
		Obtaining Exception Information
		Working with Delegates
		Using Delegates to Handle Events
CHAPTER 4: NET System Namespace: Attributes, Garbage Collector, and Other Advanced NET
	In Depth
		Custom Attributes
		Attribute
		Specifying Attribute Targets
		Attribute Initialization
	BitConverter Class
	Buffer Class
	Convert Class
	Environment Class
		Special Folders
	Uniform Resource Identifiers
	UriBuilder Class
	Garbage Collector
	Weak References
	Immediate Solutions
		Creating Custom Attribute
		Obtaining Attribute Information
		Accessing Numeric Types on Byte Level
		Accessing Managed Arrays on Byte Level
		Converting Types
		Implementing Custom Type Conversion
		Obtaining Environment Information
		Using Uniform Resource Identifiers
		Forcing Garbage Collection
		Suppressing Finalization
		Protecting Unmanaged Pointers to Managed Objects
		Using Weak References
CHAPTER 5: Multithreaded Programming with .NET
	In Depth
	The System::Threading Namespace Hierarchy
	Pros and Cons of Multithreading
		Reasons Against Using Threads
		Reasons for Using Threads
		Alternatives to Using Threads
	Threads
		Thread States
		Background Threads
		Thread Local Store
		Thread Local Static Fields
	Thread Synchronization
		Critical Sections
	Manual Thread Synchronization
		Wait Handles
		Manual and Automatic Wait Handles
		Mutexes
		Monitors
	Thread Pools
		Wait Notification Callbacks
		Performance of Thread Processing
	Interlocked Exchange
	Single-Writer/Multiple-Reader Access
	Timers
	System::Timers Namespace
		System::Timers::Timer Class
	Synchronized Method
	Immediate Solution
		Creating Threads
		Aborting Threads
		Using Thread Local Storage
		Synchronizing Classes using the Synchronization Attribute
		Synchronizing Instance and Static Methods using the Methodlmpl Attribute
		Synchronizing Code Sections Using Mutexes
		Synchronizing Critical Code Sections Using Monitors
		Synchronizing Threads Using Wait Handles
		Queuing Worker Threads in the Thread Pool
		Registering Wait Notification Callbacks
		Implementing Interlocked Access/Modification of Shared Numeric Variables
		Implementing Single-Writer/Multiple-Reader Access to Shared Data
		Using CLR Timers
		Using OS/Windows Forms Timers
CHAPTER 6: Using .NET Collections
	In Depth
	The System::Collections Namespace
	The System::Collections::Specialized Namespace
	Base Interfaces
		ICollection Interface
		IEnumerator Interface
		IList Interface
	Array List Class
	CollectionBase Class
	ReadOnlyCollectionBase Class
	String Collections
	StringEnumerator Class
	Collections of Sorted Name/Value Pairs
		NameObjectCollectionBase:: KeysCollection Class
	String Lookup Collections
	Object Comparison Support
	Comparer and CaselnsensitiveComparer Classes
	Dictionaries
		IDictionaryEnumerator Interface
		Dictionary Base Class
		DictionaryEntry Class
		ListDictionary and HybridDictionary Classes
		StringDictionary class
	SortedList Class
	Hash Tables
		Hashtable Class
		Case-Insensitive Hash Code Provider
	Queues
	Stacks
	CollectionsUtil Clas
	BitArray class
	Arrays of 32-bit
		Bit Sections
	Immediate Solutions
		Creating Dynamic Arrays, Adding and Removing Elements
		Converting Between Dynamic and Fixed Arrays
		Resizing Fixed-Size Arrays
		Locating Dynamic Array Elements
		Sorting and Searching Sorted Dynamic Arrays
		Deriving Custom Collection Classes
		Working with String Collections
		Using Collections of Sorted Name/Value Pairs
		Creating String Lookup Collections
		Creating Custom Comparer Objects
		Working with Dictionaries
		Using String Dictionaries
		Using Sorted Lists
		Using Hash Tables
		Using Queues
		Using Stacks
		Instantiating Collection Objects with the CollectionsUtil Class
		Using Bit Arrays
		Working with Bit Flags and Bit Sections
CHAPTER 7: .NET File and Stream I/O
	In Depth
	System::IO Namespace Hierarchy
	Files and Directories
		The Directory Class
		File Class
		File System Objects
		Directorylnfo Class
		Filelnfo Class
	Streams
		File Streams
		Asynchronous I/O
	Buffered Streams
	Text Streams
		TextReader Class
	Text Encodings
		7-bit Encoded Format
		Encoded Text Stream Writer
		Encoded Text Stream Reader
	In-Memory Text Streams
		StringWriter Class
		StringReader Class
	Streams for Reading/Writing Primitive Data Types
		Binary Writer Clas
		BinaryReader Class
	In-Memory Binary Streams
	File System Paths
	Watching File System Changes
	Isolated Storage
		Isolated Storage Levels
		IsolatedStorage Class
		Isolated Storage Files
		Isolated Storage Streams
	Immediate Solutions
	Using Directory Class: Retrieving and Changing Current Directory, Obtaining Directory Information
	Using Directory Class: Listing Contents, Creating, Renaming, Deleting Directories
	Using Directorylnfo Class: Initializing, Obtaining Directory Information, Creating Directories and Subdirectories
	Using Directorylnfo Class: Listing Directory Contents, Renaming, Deleting Directories
	Using File Class: Creating Files, Obtaining File Information
	Using File Class: Copying, Moving Files, and Modifying File Attributes
	Using Filelnfo Class: Initializing, Retrieving File Properties
	Using Filelnfo Class: Modifying File Properties, Renaming and Deleting Files
	Reading and Writing Files
		Reading Files Asynchronously
	Writing Encoded Text Streams
	Reading Encoded Text Streams
	Reading and Writing Primitive Data Types
	Reading and Writing In-Memory Text Streams
	Reading and Writing In-Memory Binary Streams
	Working with Paths
	Detecting File System Changes
	Working with Isolated Storage
CHAPTER 8: ADO.NET: DataSets, DataTables, and XML
	In Depth
	ADO.NET
		ADO vs.ADO.NET
	ADO.NET Namespaces
	System::Data Namespace Hierarchy
	DataSet Class
		Dataset Merging
	XML Documents, XSD Schemas, and Datasets
		Writing XML Data
		DataRow Changes and XML DiffGrams
		Reading XML Data
		Reading/Writing XSD Schemas
		Inferring Schemas
	DataTable Class
		Selecting Rows
		Primary Keys
		Aggregate Expressions
		DataTable Notifications
	Data Table Collections
	DataColumn Class
	Data Column Collections
	DataRow Clas
		Data Row Versions
	Data Row Collections
	Describing Relations Between Tables
	Data Relation Collections
	Constraints
	Foreign Key Constraints
		Constraint Rules
	Unique Constraints
	Constraint Collections
	Views
	DataRowView Class
	Default Data View Settings
	DataViewSetting Class
	Data View Setting Collection
	Immediate Solution
		Creating Tables, Adding Columns, and Specifying Primary Keys
		Using Expressions in Data Columns
		Adding/Navigating Rows and Computing Aggergate Expressions
		Adding/Deleting Rows and Handling DataTable Notifications
		Creating Datasets, Adding Tables, and Establishing Relations
		Navigating Hierarchal Datasets
		Creating Unique and Foreign Key Constraints
		Writing Dataset Data/Schema as XML/XSD Documents
		Saving/Loading Dataset Changes as an XML DiffGram
		Loading/Inferring Dataset Schemas from XSD and XML Documents
		Creating Data Views
		Specifying Default View Settings
CHAPTER 9: ADO.NET: OLE DB and SQL Server Data Providers
	In Depth
	ADO.NET Data Providers
	OLE DB and SQL Server Data Providers
	Database Connections
		IDbConnnection Interface
		Connection States
		OleDbConnection and SqlConnection Classes
	Data Adapters
		IDataAdapter and IDbDataAdapter Interfaces
		Missing Mapping Action
		Missing Schema Action
		DataAdapter and DbDataAdapter Classes
		Filling Datasets
		FillError Event
		OleDbDataAdapter and SqlDataAdapter Classes
		RowUpdating and RowUpdated Events
		Bridge between ADO and ADO.NET
	Table Mappings
	Table Mapping Collections
	Data Column Mappings
	Data Column Mapping Collections
	Database Commands
		IDbCommand Interface
		Command Types
		Update Commands
		OleDbCommand and SqlClientCommand Classes
	Database Command Parameters
		IDataParameter Interface
		OleDbParameter and SqlParameter Classes
		Identifying Command Parameters
	Parameter Collections
		OleDbParameterCollection and SqlParameterCollection Classes
	Database Command Builders
		OleDbCommandBuilder and SqlCommandBuilder Classes
		Deriving Stored Procedure Parameters
	Data Readers
		Sequential Access to Row Data
		OleDbDataReader and SqlDataReader Classes
	Database Transactions
		Data Transaction Levels
		OleDbTransaction and SqlDbTransaction Classes
		Get/Set Type Property Description
	Immediate Solutions
		Creating Database Connection String
		Creating an OLE DB Connection String
		Creating a SQL Server Connection String
		Controlling Connection Pooling
		Creating Database Connections
		Creating and Executing Database Commands
		Creating and Executing Parameterized Commands
		Invoking Stored Procedures
		Using Data Readers to Retrieve Database Data
		Reading Hierarchal OLE DB Result Sets
		Using Data Readers with Sequential Access to Read BLOB Data
		Filling Dataset Schemas
		Using Data Adapters to Fill Datasets
		Setting Up Column and Table Mappings
		Building Update, Delete and Insert Commands and Updating a Database with Dataset Changes
		Handling Data Adapter Events
		Working with Transactions
CHAPTER 10: Creating ASP.NET Web Services
	In Depth
	Web Services as Components of Distributed Computing
		The Pros and Cons of Web Services
		Future of Web Services
		Why Use Web Services?
		Minimizing Risk by Implementing a Fall Back Scheme
	XML Web Services and ASP.NET
		ASP.NET Web Service Overview
	System::Web Namespace
		ASP.NET Architecture Overview
		HttpApplicationState Class
	HttpSessionState Class
	HttpServerUtility Class
	System::Web::Services Namespace
		WebService Attribute
		WebServiceBinding Attribute
		WebService Class
		Immediate Solutions
			Creating ASP.NET Web Services Using ClassWizard
			Creating ASRNET Web Services Manually
			Adding Web Methods to a Web Service
			Debugging Web Services Locally and Remotely
			Creating Web Services That Use Database Access
			Using Web Services in Place of ISAPI Extensions
CHAPTER 11: Consuming Web Services Made with HTTP-GET, HTTP-POST, and SOAP
	In Depth
	Web Service Protocols
		HTTP-GET and HTTP-POST Protocols
		Simple Object Access Protocol (SOAP)
		SOAP Message Architecture
			SOAP Header
			SOAP Body
			SOAP Fault
			SOAP Binding to HTTP
		System:Web::Services::Protocols Namespace
		Consuming Web Services
		WebClientProtocol Class
		HttpWebClientProtocol Class
		HTTP-GET/HTTP-POST Proxy Classes
		SoapHttpClientProtocol Class
		SoapMessage Class
		SoapClientMessage and SoapServerMessage Classes
		SoapHeader Class
		SoapHeaderCollection Class
		SoapUnknownHeader Class
		HttpMethod Attribute
		SoapDocumentService and SoapRpcService Attribute
		SoapDocumentMethod and SoapRpcMethod Attribute
		SoapHeader Attribute
		Immediate Solutions
			Creating Web Service Proxies Using ClassWizard
			Manually Creating Web Service Proxies That Use SOAP over HTTP
			Manually Creating Web Service ProxiesThat Use HTTP-GET/HTTP-POST
			Invoking Web Service Methods Synchronously and Asynchronously
			Handling and Throwing Exceptions in Web Services
			Managing Application and Session State
			Using SOAP Headers for Exchanging Data with a Web Service
CHAPTER 12: Web Services: Definition Language (WSDL), Discovery, Security, and Configuration
	Web Service Description Language (WSDL)
		System::Web::Services::Description Namespace
		ServiceDescription Class
	Web Service Discovery
		Static Discovery Files (.disco)
		Dynamic Discovery Files (.vsdisco)
		System::Web::Services::Discovery Namespace
		DiscoveryClientProtocol Class
		Discovery Document Class
	The UDDI Service
	Web Service Configuration
	Web Service Authentication
	Immediate Solutions
		Discovering Web Service
		Retrieving Web Service WSDL
		Securing a Web Service Using Basic and Integrated Windows Authentication
		Securing a Web Service Using SSL
		Securing a Web Service Using Encrypted SOAP Header Authentication
CHAPTER 13: .NET Interoperability with Unmanaged Code and COM
	In Depth
	Interoperability with Unmanaged Code
	Runtime Callable Wrappers and COM Callable Wrappers
	Data Marshalling
	Exception Marshalling
	Class Interfaces
	Generating Runtime Callable Wrappers
		Metadata Conversion
	Generating Runtime Callable Wrappers
		Method Signature
		Overloaded Methods
		Assembly Registration
		Importing Type Libraries
		COM Smart Pointers
	Deploying COM Interoperability Applications
	Consuming Unmanaged DLLs
		Function Prototypes
		Passing Structures
	COM Interoperability Attributes
	Immediate Solutions
		Consuming COM Components in .NET Applications
		Handling COM Events in Managed Code
		Consuming .NET Classes in Unmanaged Code
		Handling .NET Events in Unmanaged Code
		Consuming Unmanaged DLL Functions in .NET Applications
CHAPTER 14: Microsoft Extensions to C++ Languag
	In Depth
	Microsoft Extensions
	ANSI C and C++ Standard Compliancy
	Data Alignment
		alignof Function
		declspec(align) Keyword
		aligned_xyz Functions
	MMX, 3DNow!, SSE, and SSE2 Intrinsics
	Immediate Solutions
	Writing Portable Code
	Using Interfaces
	Resolving Ambiguous Interface Method Names
	Catching Exceptions Thrown from Constructor’s Initialization List
	Invoking Base Class Members
	Overloading Functions with Covariant Return Types
	Indicating Exceptions Thrown by Functions
	Managing Data Alignment
	Using SIMD Instruction Sets
	Deprecating Functions
	Managing Function Inlining
	Resolving Multiple Symbol Definitions
	Generating Code Conditional on Symbol Existence
	Obtaining a Function Return Address
	Adding Break Points Programmatically
	Selectively Eliminating Function Calls
CHAPTER 15: C Runtime Library Enhancements
	In Depth
	C Runtime Library
	Runtime Error Checking
		#pragma runtime_check
	Buffer Overrun Detection
	Stack Overflow Recovery
	Throwing new Operato
	Support for Dates Beyond Year 2038
	New Math Constants
	Aligned Memory Allocation
	Efficient Byte Swapping
	Accelerating Transcendental Math Functions
	Immediate Solutions
		Handling Runtime Errors
		Detecting Buffer Overruns
		Recovering from Stack Overflows
		Using Throwing new Operator
		Measuring Formatted Strings
		Reading Fixed-Length Formatted Data
		Allocating Aligned Memory
		Accelerating Math Functions with SSE
		Accelerating Math Functions with 3DNow!
APPENDIX A: Visual C++ .NET Development Environment
	In Depth
		First Look at the Development Environment
		Visual C++ .NET Installation
		Setting Visual C++ .NETPreferences
		Checking for Updates
	Immediate Solutions
		Using Solution Explorer
		Using Class Wizard’s Replacement
			Adding New Class Members
			Adding New Classes
			Adding User Interface Event Handlers
		Modifying Class Properties
			Using Property Window
			Adding Event Handlers
			Editing and Deleting Event Handlers
			Adding Message Handlers
			Overriding Functions
		Adding New Dialog Classes
		Using Resource Templates
		Using Server Explorer
			Setting Up Database Connections
			Managing Event Logs, Message Queues, Performance Counters, and Services
		Editing Source Code
			Listing Class Members
			Obtaining Parameter Information
			Auto-Completing Keywords
			Using Quick Info
		Using Task List
			Adding Task List Short Cuts
			Removing Task List Short Cuts
		Browsing Source Code
		Synchronizing Class View
		Outlining Source Code
		Specifying Include and Library Directories
			Using Configuration Manager
		Setting Active Project Configuration
		Building Project
		Debugging Locally
		Attaching to a Process
		Setting Break Points
		Breaking on Exceptions
		Watching Variables
		Using Other Debug Windows
		Stepping Through Code and Stopping Debugging
APPENDIX B: MFC Application Wizard Reference
	The Overview
	The Application Type Page
	The Compound Document Support Page
	The Document Template Strings Page
	The Database Support Page
	The User Interface Features Page
	The Advanced Features Page
	The Generated Classes Page
APPENDIX C: Visual C++ .NET Project Property Pages Reference
	General Page
	Debug Page
	C/C++ Folder
		General Page
		Optimization Page
		Preprocessor Page
		Code Generation Page
		Language Page
		Precompiled Headers Page
		Output Files Page
		Browse Information Page
		Advanced Page
	Linker Folder
		General Page
		Input Page
		Debug Page
		System Page
		Optimization Page
		Embedded IDL Page
		Advanced Page
		Resources Folder
		MIDL Folder
		Browse Information
		Build Events Folder
		Custom Build Step Folder
		Web References Folder
		Web Deployment Folder
APPENDIX D: .NET Framework System Namespace Hierarch
APPENDIX E: .NET Framework System: :Data Namespace Hierarchy
APPENDIX F: .NET Framework System: :Data:: Common, System::Data::OleDb and System::Data::SqlClient Namespace Hierarchy
Index