search for books and compare prices
Tables of Contents for Visual C++ .Net
Chapter/Section Title
Page #
Page Count
Introduction
1
1
What does this book cover?
2
1
What you need to use this book
2
1
Style conventions
2
1
Customer support and feedback
3
4
Source code and updates
3
1
Errata
3
1
Technical support
4
1
p2p.wrox.com
4
3
What's new in Visual C++?
7
24
The .NET Framework
8
4
The common language runtime
8
1
Garbage collection
9
1
Code portability
9
1
Language interperability
9
1
Code security
9
1
Access to the .NET Framework class library
10
1
Properties of managed code
10
1
Deployment
10
1
Versioning
10
1
The .NET Framework class library
10
1
ASP.NET applications
11
1
Windows applications
11
1
Console applications
12
1
Web services
12
1
New features of Visual Studio .NET
12
10
Old Wizards with new looks
14
1
MFC Application
14
4
MFC DLL
18
1
MFC ActiveX Control
18
1
MFC ISAPI Extension DLL
19
1
Makefile Project
19
1
Win32 Project
19
1
Custom Wizard
20
1
Extended Stored Procedure DLL
20
1
The new Wizards
20
1
Managed C++ Application
20
1
Managed C++ Class Library
21
1
Managed C++ Empty Project
21
1
Managed C++ Web Service
21
1
ATL Project
21
1
ATL Server Project
22
1
ATL Server Web Service
22
1
Cross-language development and debugging
22
7
Cross-language example
22
2
Writing a class using C++
24
1
Writing a class using Visual Basic .NET
25
1
Writing a class using C#
26
2
Debugging
28
1
Summary
29
2
Introduction to Managed C++
31
50
Language interoperability
32
6
Metadata
32
1
Common Type System (CTS)
33
1
The .NET Framework class library
33
1
Strings
34
4
The managed environment
38
5
Managed code and managed data
38
1
Garbage collection
39
1
Reference types and value types
39
1
Creating managed code
40
1
Compiler options
40
2
Simple example
42
1
Using Managed Extensions
43
35
gc types
44
1
Classes and structures
44
7
Interfaces
51
1
Pointers
52
3
References
55
1
Arrays
55
4
value types
59
1
Declaring___value classes and structures
60
2
Boxing and unboxing
62
1
value enums
63
1
Properties
64
1
Scalar properties
64
1
Indexed properties
65
2
Delegates
67
2
Multicasting
69
1
Events
70
2
Exceptions
72
1
Throwing, try/catch, and___finally
72
5
The___identifier keyword
77
1
Summary of keywords
77
1
Summary
78
3
Assemblies
81
38
What are assemblies?
82
3
Assembly structure
82
1
Linker options
83
1
Key features of assemblies
84
1
Building assemblies
85
5
Creating a class library
85
2
Type accessibility
87
1
Creating an application
88
2
Examining assemblies using ILDasm
90
5
The assembly manifest
93
1
AssemblyInfo.cpp
94
1
Shared assemblies and private assemblies
95
9
Creating shared assemblies
96
1
Shared assembly names
96
1
Generating a strong name
97
1
Signing the assembly
97
1
Signcode digital signature
98
1
Setting the version number
98
1
Getting the version number programmatically
99
1
The global assembly cache
100
1
Global assembly cache viewer
100
2
Installing a shared assembly into the GAC
102
1
Native image generation
103
1
Using a shared assembly
103
1
Replacing the strong name key for delivery
103
1
Versioning support
104
1
Working with resources
105
4
Creating a resource file
105
1
ResGen
106
1
ResourceWriter
106
1
Using Visual Studio .NET to build .resources files
106
3
Localization
109
4
Accessing resource files
110
1
ResourceManager
110
1
ResourceReader
111
1
Dynamic resources
112
1
Deploying assemblies
113
4
Summary
117
2
Attributes and reflection
119
36
Attributes
120
17
C++ attributes
121
1
.NET attributes
122
1
The predefined .NET attributes
123
7
Attributes as classes
130
2
The AttributeUsage attribute
132
2
Writing custom attributes
134
3
Reflection
137
12
The ListColors sample
138
2
Invoking a member
140
2
The System::Type class
142
1
Obtaining a System::Type reference
142
1
System::Type properties and methods
143
2
Listing types: the musical instruments sample
145
4
Combining attributes and reflection
149
3
Summary
152
3
.NET Framework utility classes
155
48
Text handling
155
6
StringBuilder
156
2
Regex
158
1
Pattern matching
159
2
File handling
161
3
File and FileStream
161
1
Opening files
161
1
Reading from and writing to files
161
1
Closing files
162
1
StreamReader and StreamWriter
163
1
Collections
164
12
ArrayList
165
1
Sorting
166
1
SortedList
166
2
The IComparer interface
168
1
Implementing IComparer
169
3
The IEnumerator interface
172
1
Implementing IEnumerator
172
3
Building a client
175
1
Threading
176
24
Threading types
176
1
Thread class
176
3
ThreadPool class
179
3
Thread synchronization types
182
1
Interlocked
182
3
WaitHandle
185
4
Monitor
189
4
ReaderWriterLock
193
4
Thread exceptions
197
1
SynchronizationLockException
198
1
ThreadAbortException
199
1
ThreadInterruptedException
199
1
ThreadStateException
200
1
Summary
200
3
Windows Forms
203
42
Windows Forms and MFC
204
1
A Windows application in Managed C++
204
2
Customizing forms and adding events
206
1
Adding child controls
207
16
Working with button controls
208
3
Working with text controls
211
3
Selection controls
214
5
More child controls
219
4
Multiple document interface forms and meus
223
6
Modal and modeless forms
228
1
Advanced controls in Windows Forms
229
13
Developing Windows Explorer
229
8
Implementing drag-and-drop in Windows Forms
237
5
Summary
242
3
Managed and unmanaged code
245
36
Mixing managed and unmanaged code
246
7
The / clr flag and It Just Works (IJW)
247
1
Limitations of IJW
247
1
The managed and unmanaged pragmas
248
1
The___pin keyword
249
1
Using managed types from unmanaged code
250
3
Writing managed proxy classes
253
12
The proxy design pattern
253
1
Basic wrapping steps
254
1
An unmanaged linked list
255
2
Wrapper construction
257
1
Create a member pointer to the unmanaged class
257
1
Wrapping constructors
257
2
Wrapping destructors
259
1
Dealing with overloaded operators
259
1
Wrapping member functions
259
3
Testing the managed wrapper with a C# client
262
2
Other wrapping issues
264
1
Variable numbers of parameters
264
1
Handling default arguments
264
1
Marshaling between managed and unmanaged code
265
14
The managed-to-unmanaged transition
265
1
Internal call transitions
266
1
IJW transitions
266
1
Platform Invoke (Plnvoke) transitions
266
1
When do we need to marshal?
266
1
The InteropServices::Marshal class
267
1
Marshaling strings
267
2
PInvoke: calling unmanaged functions from managed code
269
1
Using PInvoke to call exported functions in unmanaged DLLs
270
2
Receiving callback notifications in a Managed C++ application using PInvoke
272
2
Using PInvoke to pass structures to functions in unmanaged DLLs
274
3
Explicit marshaling for non-blittable data types
277
2
Performance considerations
279
1
Summary
279
2
COM interoperability
281
66
From COM to .NET
282
1
The need for interoperation
282
1
Using COM components from Managed C++
283
35
Calling into a COM component from .NET
284
1
Building a COM component
284
4
The type library importer (TLBIMP) utility
288
2
Early binding to a COM component from a Managed C++ application
290
2
Late binding to a COM component from a Managed C++ application
292
2
Sinking COM component events in a .NET application
294
1
Building a COM component that sources events using ATL 3.0
294
3
Using a Managed C++ application to sink events from a COM component
297
4
Exposing a COM-based collection class to a .NET application
301
1
Building a COM component that exposes a collection using ATL 3.0
301
3
Using a Managed C++ application to consume a COM-based collection
304
2
Using ActiveX controls from .NET applications
306
2
Design-time properties
308
1
Run-time properties and methods
309
1
Event handling
310
2
Reuse models for COM components from managed code
312
4
Managed threads and COM apartments
316
2
Using Managed C++ components from COM-aware C++
318
26
Building a .NET component using Managed C++
319
3
Exposing .NET components to unmanaged applications
322
1
The type library exporter and the assembly registration utility
323
1
Consuming a Managed C++ component
324
4
Sinking the events fired by a Managed C++ component
328
1
Adding events to the managed component
328
2
Firing events from the managed component
330
2
Sinking Managed C++ events in an unmanaged C++ application
332
4
Hosting Windows Forms controls in unmanaged containers
336
1
Controlling how a Managed C++ class is exported to a COM type library
337
1
The ClassInterface attribute
337
4
The Progld and Guid attributes
341
1
Controlling how a Managed C++ interface gets exported to a COM type library
342
2
Summary
344
3
ATL COM programming
347
32
What's new in ATL?
348
1
A simple ATL 7.0 project
349
14
Adding a component to the project
354
4
Adding methods
358
5
Creating an attributed project
363
7
Converting to an executable
368
2
New ATL classes
370
3
New string classes
371
1
String conversion classes
371
2
Example utilities project
373
4
Summary
377
2
An introduction to ATL Server
379
24
Architecture
379
2
Developing a simple ATL Server application
381
11
Creating the project
381
5
Generated code
386
1
FirstATLServerApplication.h
386
1
FirstATLServerApplication.srf
387
2
Building, deploying, and running the application
389
1
Modifying the code
390
2
ATL Server guest book application
392
6
Modifying the SRF
393
1
Implementing the handlers
394
1
The GetControls tag
394
1
The StoreData tag
395
1
The SendMail tag
396
1
The NotValidating tag
397
1
The ValidateAndExchange method
398
1
Building and running the project
398
1
Other features of ATL Server
398
2
Thread pooling
398
1
Caching
399
1
Performance monitoring
399
1
Summary
400
3
ATL Server web services
403
Benefits of web services
404
Locating services
404
Web services and ATL Server
405
Creating a web service
406
Creating the project
406
Hello.h
407
The request_handler attribute
408
The soap_handler attribute
408
The soap_method attribute
409
Building the project
410
Running the project
410
A simple service consumer
412
Creating the project
412
Examining the generated header
413
Developing client code
413
Understanding the client code
414
Stock quote service project
415
Creating the database
415
Stock table
415
OrderDetails table
416
Login table
416
Relationships
417
Creating the project
417
Writing code
417
Adding method declarations
417
Implementing the methods
419
Defining database mappings
422
Building and testing the web service
424
Developing the client
424
Creating the user interface
424
Adding a reference to the web service DLL
428
Modifying form code
429
Running the client
432
Summary
435
<