Microsoft Visual C# 2008 Step by Step

673 Pages·2008·5.074 MB·English

by  John Sharp

PUBLISHED BY
Microsoft Press
A Division of Microsoft Corporation
One Microsoft Way
Redmond, Washington 98052-6399
Copyright © 2008by John Sharp
All rights reserved. No part of the contents of this book may be reproduced or transmitted in any form
or by any means without the written permission of the publisher.
Library of Congress Control Number:2007939305
Printed and bound in the United States of America.
1 2 3 4 5 6 7 8 9 QWT 2 1 0 9 8 7
Distributed in Canada by H.B. Fenn and Company Ltd.
A CIP catalogue record for this book is available from the British Library.
Microsoft Press books are available through booksellers and distributors worldwide. For further infor-
mation about international editions, contact your local Microsoft Corporation officeor contact Microsoft
Press International directly at fax [phone]. Visit our Web site at www.microsoft.com/mspress.
Send comments to [email protected].
Microsoft, Microsoft Press, MSDN, SQL Server, Excel, Intellisense, Internet Explorer, Jscript,
Silverlight, Visual Basic, Visual C#, Visual Studio, Win32, Windows, Windows Server, and Windows
Vistaare either registered trademarks or trademarks of Microsoft Corporation in the United States and/or
other countries. Other product and company names mentioned herein may be the trademarks of their
respective owners.
The example companies, organizations, products, domain names, e-mail addresses, logos, people, places,
and events depicted herein are fictitious. No association with any real company, organization, product,
domain name, e-mail address, logo, person, place, or event is intended or should be inferred.
(cid:55)(cid:75)(cid:76)(cid:86)(cid:3)(cid:69)(cid:82)(cid:82)(cid:78)(cid:3)(cid:72)(cid:91)(cid:83)(cid:85)(cid:72)(cid:86)(cid:86)(cid:72)(cid:86)(cid:3)(cid:87)(cid:75)(cid:72)(cid:3)(cid:68)(cid:88)(cid:87)(cid:75)(cid:82)(cid:85)(cid:182)(cid:86)(cid:3)(cid:89)(cid:76)(cid:72)(cid:90)(cid:86)(cid:3)(cid:68)(cid:81)(cid:71)(cid:3)(cid:82)(cid:83)(cid:76)(cid:81)(cid:76)(cid:82)(cid:81)(cid:86)(cid:17)(cid:3)(cid:55)(cid:75)(cid:72)(cid:3)(cid:76)(cid:81)(cid:73)(cid:82)(cid:85)(cid:80)(cid:68)(cid:87)(cid:76)(cid:82)(cid:81)(cid:3)(cid:70)(cid:82)(cid:81)(cid:87)(cid:68)(cid:76)(cid:81)(cid:72)(cid:71)(cid:3)(cid:76)(cid:81)(cid:3)(cid:87)(cid:75)(cid:76)(cid:86)(cid:3)(cid:69)(cid:82)(cid:82)(cid:78)(cid:3)(cid:76)(cid:86)(cid:3)(cid:83)(cid:85)(cid:82)(cid:89)(cid:76)(cid:71)(cid:72)(cid:71)(cid:3)
without any express, statutory, or implied warranties. Neither the authors, Microsoft Corporation, nor its
resellers, or distributors will be held liable for any damages caused or alleged to be caused either directly
or indirectly by this book.
Acquisitions Editor:Ben Ryan
Developmental and Project Editor:Lynn Finnel
Editorial Production:Waypoint Press
Technical Reviewer:Kurt Meyer;Technical Review services provided by Content Master, a member
of CM Group, Ltd.
Body Part No. X14-22686
(cid:3)
Contents at a Glance
Part I Introducing Microsoft Visual C# and
Microsoft Visual Studio 2008
1 Welcome to C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2 Working with Variables, Operators, and Expressions . . . . . . . . . 29
3 Writing Methods and Applying Scope . . . . . . . . . . . . . . . . . . . . . 49
4 Using Decision Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
5 Using Compound Assignment and Iteration Statements. . . . . . 85
6 Managing Errors and Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . 103
Part II Understanding the C# Language
7 Creating and Managing Classes and Objects . . . . . . . . . . . . . . . 123
8 Understanding Values and References . . . . . . . . . . . . . . . . . . . . 145
9 Creating Value Types with Enumerations and Structures. . . . . 167
10 Using Arrays and Collections. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
11 Understanding Parameter Arrays. . . . . . . . . . . . . . . . . . . . . . . . . 207
12 Working with Inheritance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
13 Creating Interfaces and Defi ning Abstract Classes . . . . . . . . . . 239
14 Using Garbage Collection and Resource Management. . . . . . . 257
Part III Creating Components
15 Implementing Properties to Access Fields . . . . . . . . . . . . . . . . . 275
16 Using Indexers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
17 Interrupting Program Flow and Handling Events . . . . . . . . . . . 311
18 Introducing Generics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333
19 Enumerating Collections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355
20 Querying In-Memory Data by Using Query Expressions . . . . . 371
21 Operator Overloading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395
iii
iv Contents at a Glance
Part IV Working with Windows Applications
22 Introducing Windows Presentation Foundation . . . . . . . . . . . . 415
23 Working with Menus and Dialog Boxes . . . . . . . . . . . . . . . . . . . 451
24 Performing Validation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 473
Part V Managing Data
25 Querying Information in a Database. . . . . . . . . . . . . . . . . . . . . . 499
26 Displaying and Editing Data by Using Data Binding. . . . . . . . . 529
Part VI Building Web Applications
27 Introducing ASP.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 559
28 Understanding Web Forms Validation Controls. . . . . . . . . . . . . 587
29 Protecting a Web Site and Accessing Data with
Web Forms. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 597
30 Creating and Using a Web Service. . . . . . . . . . . . . . . . . . . . . . . . 623
Index. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 645
Table of Contents
Acknowledgments. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xvii
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .xix
Part I Introducing Microsoft Visual C# and
Microsoft Visual Studio 2008
1 Welcome to C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
Beginning Programming with the Visual Studio 2008 Environment. . . . . . . . . . 3
Writing Your First Program. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Using Namespaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .14
Creating a Graphical Application. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .17
Chapter 1 Quick Reference. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .28
2 Working with Variables, Operators, and Expressions . . . . . . . . . 29
Understanding Statements. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .29
Using Identifi ers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .30
Identifying Keywords. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .30
Using Variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .31
Naming Variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .32
Declaring Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .32
Working with Primitive Data Types. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .33
Displaying Primitive Data Type Values. . . . . . . . . . . . . . . . . . . . . . . . . . . . .34
Using Arithmetic Operators. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .38
Operators and Types. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .39
Examining Arithmetic Operators. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .40
Controlling Precedence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .43
Using Associativity to Evaluate Expressions . . . . . . . . . . . . . . . . . . . . . . . .44
Associativity and the Assignment Operator . . . . . . . . . . . . . . . . . . . . . . . .45
What do you think of this book? We want to hear from you!
Microsoft is interested in hearing your feedback so we can continually improve our books and
learning resources for you. To participate in a brief online survey, please visit:
www.microsoft.com/learning/booksurvey
v
vi Table of Contents
Incrementing and Decrementing Variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .45
Prefi x and Postfi x. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .46
Declaring Implicitly Typed Local Variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .47
Chapter 2 Quick Reference. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .48
3 Writing Methods and Applying Scope . . . . . . . . . . . . . . . . . . . . . 49
Declaring Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .49
Specifying the Method Declaration Syntax. . . . . . . . . . . . . . . . . . . . . . . . .50
Writing return Statements. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .51
Calling Methods. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .53
Specifying the Method Call Syntax. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .53
Applying Scope . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .56
Defi ning Local Scope. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .56
Defi ning Class Scope. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .56
Overloading Methods. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .57
Writing Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .58
Chapter 3 Quick Reference. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .66
4 Using Decision Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
Declaring Boolean Variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .67
Using Boolean Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .68
Understanding Equality and Relational Operators . . . . . . . . . . . . . . . . . .68
Understanding Conditional Logical Operators. . . . . . . . . . . . . . . . . . . . . .69
Summarizing Operator Precedence and Associativity . . . . . . . . . . . . . . .70
Using if Statements to Make Decisions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .71
Understanding if Statement Syntax. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .71
Using Blocks to Group Statements. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .73
Cascading if Statements. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .73
Using switch Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .78
Understanding switch Statement Syntax . . . . . . . . . . . . . . . . . . . . . . . . . .79
Following the switch Statement Rules. . . . . . . . . . . . . . . . . . . . . . . . . . . . .80
Chapter 4 Quick Reference. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .84
5 Using Compound Assignment and Iteration Statements. . . . . . 85
Using Compound Assignment Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .85
Writing while Statements. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .87
Writing for Statements. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .91
Understanding for Statement Scope. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .92
Table of Contents vii
Writing do Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .93
Chapter 5 Quick Reference. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .102
6 Managing Errors and Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . 103
Coping with Errors. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .103
Trying Code and Catching Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .104
Handling an Exception . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .105
Using Multiple catch Handlers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .106
Catching Multiple Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .106
Using Checked and Unchecked Integer Arithmetic. . . . . . . . . . . . . . . . . . . . . .111
Writing Checked Statements. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .112
Writing Checked Expressions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .113
Throwing Exceptions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .114
Using a fi nally Block. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .118
Chapter 6 Quick Reference. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .120
Part II Understanding the C# Language
7 Creating and Managing Classes and Objects . . . . . . . . . . . . . . . 123
Understanding Classifi cation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .123
The Purpose of Encapsulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .124
Defi ning and Using a Class. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .124
Controlling Accessibility . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
Working with Constructors. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .127
Overloading Constructors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .128
Understanding static Methods and Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .136
Creating a Shared Field. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .137
Creating a static Field by Using the const Keyword. . . . . . . . . . . . . . . .137
Chapter 7 Quick Reference. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .142
8 Understanding Values and References . . . . . . . . . . . . . . . . . . . . 145
Copying Value Type Variables and Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . .145
Understanding Null Values and Nullable Types . . . . . . . . . . . . . . . . . . . . . . . . .150
Using Nullable Types. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .151
Understanding the Properties of Nullable Types. . . . . . . . . . . . . . . . . . .152
Using ref and out Parameters. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .152
Creating ref Parameters. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .153
Creating out Parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .154
viii Table of Contents
How Computer Memory Is Organized. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .156
Using the Stack and the Heap. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .157
The System.Object Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .158
Boxing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .159
Unboxing. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .159
Casting Data Safely . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .161
The is Operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .161
The as Operator. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .162
Chapter 8 Quick Reference. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .164
9 Creating Value Types with Enumerations and Structures. . . . . 167
Working with Enumerations. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .167
Declaring an Enumeration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .167
Using an Enumeration. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .168
Choosing Enumeration Literal Values. . . . . . . . . . . . . . . . . . . . . . . . . . . . .169
Choosing an Enumeration’s Underlying Type. . . . . . . . . . . . . . . . . . . . . .170
Working with Structures. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .172
Declaring a Structure. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
Understanding Structure and Class Differences. . . . . . . . . . . . . . . . . . . .175
Declaring Structure Variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .176
Understanding Structure Initialization. . . . . . . . . . . . . . . . . . . . . . . . . . . .177
Copying Structure Variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .179
Chapter 9 Quick Reference. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .183
10 Using Arrays and Collections. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
What Is an Array?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .185
Declaring Array Variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .185
Creating an Array Instance. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .186
Initializing Array Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .187
Creating an Implicitly Typed Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .188
Accessing an Individual Array Element . . . . . . . . . . . . . . . . . . . . . . . . . . .189
Iterating Through an Array. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .190
Copying Arrays. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .191
What Are Collection Classes?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .192
The ArrayList Collection Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .194
The Queue Collection Class. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .196
The Stack Collection Class. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .197
The Hashtable Collection Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .198
The SortedList Collection Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .199
Table of Contents ix
Using Collection Initializers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .200
Comparing Arrays and Collections. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .200
Using Collection Classes to Play Cards. . . . . . . . . . . . . . . . . . . . . . . . . . . .201
Chapter 10 Quick Reference. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .206
11 Understanding Parameter Arrays. . . . . . . . . . . . . . . . . . . . . . . . . 207
Using Array Arguments. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .208
Declaring a params Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .209
Using params object[ ] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .211
Using a params Array. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .212
Chapter 11 Quick Reference. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .215
12 Working with Inheritance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
What Is Inheritance? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .217
Using Inheritance. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .218
Base Classes and Derived Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .218
Calling Base Class Constructors. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .220
Assigning Classes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .221
Declaring new Methods. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .222
Declaring Virtual Methods. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .224
Declaring override Methods. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .225
Understanding protected Access. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .227
Understanding Extension Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .233
Chapter 12 Quick Reference. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .237
13 Creating Interfaces and Defi ning Abstract Classes . . . . . . . . . . 239
Understanding Interfaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .239
Interface Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .240
Interface Restrictions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .241
Implementing an Interface. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .241
Referencing a Class Through Its Interface. . . . . . . . . . . . . . . . . . . . . . . . .243
Working with Multiple Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .244
Abstract Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .244
Abstract Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .245
Sealed Classes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .246
Sealed Methods. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .246
Implementing an Extensible Framework . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .247
Summarizing Keyword Combinations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .255
Chapter 13 Quick Reference. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .256
x Table of Contents
14 Using Garbage Collection and Resource Management. . . . . . . 257
The Life and Times of an Object . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .257
Writing Destructors. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .258
Why Use the Garbage Collector? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .260
How Does the Garbage Collector Work?. . . . . . . . . . . . . . . . . . . . . . . . . .261
Recommendations. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .262
Resource Management. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .262
Disposal Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .263
Exception-Safe Disposal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .263
The using Statement. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .264
Calling the Dispose Method from a Destructor. . . . . . . . . . . . . . . . . . . .266
Making Code Exception-Safe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .267
Chapter 14 Quick Reference. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .270
Part III Creating Components
15 Implementing Properties to Access Fields . . . . . . . . . . . . . . . . . 275
Implementing Encapsulation by Using Methods . . . . . . . . . . . . . . . . . . . . . . . .276
What Are Properties?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .278
Using Properties. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .279
Read-Only Properties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .280
Write-Only Properties. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .280
Property Accessibility . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .281
Understanding the Property Restrictions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .282
Declaring Interface Properties. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .284
Using Properties in a Windows Application . . . . . . . . . . . . . . . . . . . . . . .285
Generating Automatic Properties. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .287
Initializing Objects by Using Properties. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .288
Chapter 15 Quick Reference. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .292
16 Using Indexers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
What Is an Indexer?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .295
An Example That Doesn’t Use Indexers. . . . . . . . . . . . . . . . . . . . . . . . . . .295
The Same Example Using Indexers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .297
Understanding Indexer Accessors. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .299
Comparing Indexers and Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .300
Indexers in Interfaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .302
Using Indexers in a Windows Application. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .303
Chapter 16 Quick Reference. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .308