Microsoft Visual C++/CLI Step by Step

Introduction
Part I: Getting started with C++ .NET
Chapter 1: Hello C++!
What is C++/CLI?
Your first C++/CLI application
The main function
C++ keywords and identifiers
Creating an executable application—theory
Editing the application source files
Compiling the source files
Running and testing the application
Creating an executable application—practice
Creating a project
Editing the C++ source code
Building the executable
Executing the application
Conclusion
Quick reference
Chapter 2: Introducing object-oriented programming
What is object-oriented programming?
Features of object-oriented programming languages
Encapsulation
Inheritance
Polymorphism
Classes and objects
Benefits to the development life cycle
A simple example
Quick reference
Chapter 3: Variables and operators
What is a variable?
The fundamental data types
Declaring a variable
Variable naming
Declaring multiple variables
Assigning values to variables
Handles and pointers
Arrays
Constants
Typedefs
The .NET Framework String class
Operators and expressions
Assignment operators
Arithmetic operators
Relational and logical operators
Bitwise operators
The ternary operator
Type casting
Operator precedence and associativity
Quick reference
Chapter 4: Using functions
Declaring function prototypes
Declaring a simple function prototype
Declaring parameters in a function prototype
Declaring the return type in a function prototype
Declaring default values for function parameters
Defining function bodies
Calling functions
Stepping through the application by using debugger
Understanding local and global scope
Quick reference
Chapter 5: Decision and loop statements
Making decisions by using the if statement
Performing one-way tests
Performing two-way tests
Performing multiway tests
Performing nested tests
Making decisions by using the switch Statement
Defining simple switch statements
Using fall-through in a switch statement
Performing loops
Using while loops
Using for loops
Using do-while loops
Performing unconditional jumps
Quick reference
Chapter 6: More about classes and objects
Organizing classes into header files and source files
Declaring a class in a header file
Implementing a class in a source file
Creating objects
Initializing objects by using constructors
Defining constructors
Member initialization lists
Defining class-wide members
Defining class-wide data members
Defining class-wide member functions
Class constructors
Using constants in classes
Using class-wide constants
Using instance constants
Defining object relationships
Defining the LoyaltyScheme Class
Implementing the LoyaltyScheme class
Creating and using LoyaltyScheme objects
Testing the application
Quick reference
Chapter 7: Controlling object lifetimes
The .NET approach to object lifetimes
Destruction and finalization
Destructors
Finalizers
Implementing the destructor and finalizer for a class
Objects and stack semantics
Copy constructors
Relating objects with stack semantics
Quick reference
Chapter 8: Inheritance
What is inheritance?
Inheritance terminology
Inheritance and code reuse
Designing an inheritance hierarchy
A word on substitutability
Defining a base class
Defining a derived class
Creating derived class objects
Concrete and abstract classes
Overriding member functions
Protected access
Defining sealed classes
Abstract and sealed
Defining and using interfaces
Quick reference
Part II: Microsoft .NET programming basics
Chapter 9: Value types
Reference types and value types
The need for value types
Properties of value types
Structures
Creating and using a simple struct
Investigating the structure
The differences between structures and classes
Implementing constructors for a structure
Using one structure within another
Copying structures
Enumerations
Creating and using an enumeration
Using enumerations in applications
Using memory efficiently
Quick reference
Chapter 10: Operator overloading
What is operator overloading?
What types need overloaded operators?
What can you overload?
Rules of overloading
Overloading operators in managed types
Overloading arithmetic operators
Using static operator overloads
What functions can you overload?
Implementing logical operators
Implementing increment and decrement
Operators and reference types
Guidelines for providing overloaded operators
Quick reference
Chapter 11: Exception handling
What are exceptions?
How do exceptions work?
Exception types
Throwing exceptions
Handling exceptions
Using the try and catch construct
Customizing exception handling
Using the exception hierarchy
Using exceptions with constructors
Nesting and rethrowing exceptions
The finally block
The catch(…) block
Creating your own exception types
Using safe_cast for dynamic casting
Using exceptions across languages
Quick reference
Chapter 12: Arrays and collections
Native C++ arrays
Passing arrays to functions
Initializing arrays
Multidimensional arrays
Dynamic allocation and arrays
Generic types
Managed arrays
The .NET array class
Basic operations on arrays
More advanced array operations
Using enumerators
Other .NET collection classes
The List class
The SortedList class
Generics and templates
The STL/CLR library
Quick reference
Chapter 13: Properties
What are properties?
The two kinds of properties
Implementing scalar properties
Errors in properties
Auto-implemented properties
Read-only and write-only properties
Properties, inheritance, and interfaces
Implementing indexed properties
The Bank example
Creating Account class properties
Adding accounts to the Bank class
Implementing the Add and Remove methods
Implementing an indexed property to retrieve accounts
Quick reference
Chapter 14: Delegates and events
What are delegates?
What is the purpose of delegates?
Defining delegates
Implementing delegates
What are events?
Implementing an event source class
Implementing an event receiver
Hooking it all together
Quick reference
Chapter 15: The .NET Framework class library
What is the .NET Framework?
The Common Language Runtime
The Microsoft Intermediate Language
The Common Type System
The Common Language Specification
The .NET Framework class library
Assemblies
Metadata
The .NET Framework namespaces
Using namespaces in C++ applications
The System namespace
The Collections namespaces
The Collections interfaces
The Diagnostics namespace
The IO namespace
The Windows namespaces
The Net namespaces
The ServiceModel namespaces
The Xml namespaces
The Data namespaces
The Web namespaces
Quick reference
Part III: Using the .NET framework
Chapter 16: Working with files
The System::IO namespace
Implementing text I/O by using readers and writers
Using TextWriter
The FileStream class
Using TextReader
Working with files and directories
Getting information about files and directories
Binary I/O
The BinaryWriter class
The BinaryReader class
Quick reference
Chapter 17: Reading and writing XML
XML and .NET
The .NET XML namespaces
The XML processing classes
Parsing XML by using XmlReader
Parsing XML with validation
Writing XML by using XmlTextWriter
Using XmlDocument
What is the W3C DOM?
The XmlDocument class
The XmlNode class
Quick reference
Chapter 18: Using ADO.NET
What is ADO.NET?
ADO.NET data providers
ADO.NET namespaces
ADO.NET assemblies
Creating a connected application
Connecting to a database
Creating and executing a command
Executing a command that modifies data
Executing queries and processing the results
Creating a disconnected application
Disconnected operation using a DataSet
Quick reference
Chapter 19: Writing a service by using Windows Communication Foundation
What is Windows Communication Foundation?
Distributed systems
Services
Connectivity
The ABCs of WCF
Endpoints
Address
Binding
Contract
Message exchange patterns
Behaviors
Creating a service
Writing a service client
Adding metadata to the service
Accessing a service by using a proxy
Quick reference
Chapter 20: Introducing Windows Store apps
A (brief) history of writing Windows user interface applications
The Win32 API
Microsoft Foundation Classes
Windows Forms
Windows Presentation Foundation
Windows 8 and Windows Store
Which UI library to choose?
Introducing Windows Store apps
Main features of Windows Store apps
Writing a Windows Store app
Creating your first Windows Store app
Examining the project
Introducing XAML
What is XAML?
XAML syntax
XAML controls
Layout controls
Event handling
C++/CX and Windows RT
Windows RT
Metadata
C++/CX syntax
Common namespaces
Quick reference
Chapter 21: More about Windows Store apps
Building the basic calculator
Laying out the number buttons
Handling number input
Adding arithmetic operations
Performing calculations
Testing the calculator
Improving the graphics
Handling different number bases
Using app bars
Adding sharing
Where next?
Quick reference
Part IV: Advanced topics
Chapter 22: Working with unmanaged code
Managed vs. unmanaged code
Mixed classes
The GCHandle type
Pinning and boxing
Interior pointers
Pinning pointers
Boxing and unboxing
Boxing
Unboxing
Using P/Invoke to call functions in the Win32 API
The DllImportAttribute class
Passing structures
Quick reference
Chapter 23: Attributes and reflection
Metadata and attributes
Using ILDASM
Using predefined attributes
The AssemblyInfo.cpp file
Using the predefined attribute classes
Defining your own attributes
Attribute class properties
Design criteria for attribute classes
Writing a custom attribute
Using reflection to obtain attribute data
The Type class
Accessing standard attributes
Accessing custom attribute data
Quick reference
Chapter 24: Living with Component Object Model
COM components and the COM Interop
Using COM components from .NET code
How do RCWs work?
Creating and using RCWs
Handling COM errors
Late binding to COM objects
Using .NET components as COM components
What must .NET types implement to be used as COM objects?
Quick reference
Index