Tải bản đầy đủ - 0 (trang)
A Programmer’s Guide to C# 5.0

A Programmer’s Guide to C# 5.0

Tải bản đầy đủ - 0trang

A Programmer’s Guide to C# 5.0

Copyright © 2012 by Eric Gunnerson and Nick Wienholt

This work is subject to copyright. All rights are reserved by the Publisher, whether the whole or part of the material

is concerned, specifically the rights of translation, reprinting, reuse of illustrations, recitation, broadcasting,

reproduction on microfilms or in any other physical way, and transmission or information storage and retrieval,

electronic adaptation, computer software, or by similar or dissimilar methodology now known or hereafter

developed. Exempted from this legal reservation are brief excerpts in connection with reviews or scholarly

analysis or material supplied specifically for the purpose of being entered and executed on a computer system,

for exclusive use by the purchaser of the work. Duplication of this publication or parts thereof is permitted only

under the provisions of the Copyright Law of the Publisher’s location, in its current version, and permission

for use must always be obtained from Springer. Permissions for use may be obtained through RightsLink at the

Copyright Clearance Center. Violations are liable to prosecution under the respective Copyright Law.

ISBN-13 (pbk): 978-1-4302-4593-3

ISBN-13 (electronic): 978-1-4302-4594-0

Trademarked names, logos, and images may appear in this book. Rather than use a trademark symbol with every

occurrence of a trademarked name, logo, or image we use the names, logos, and images only in an editorial

fashion and to the benefit of the trademark owner, with no intention of infringement of the trademark.

The use in this publication of trade names, trademarks, service marks, and similar terms, even if they are

not identified as such, is not to be taken as an expression of opinion as to whether or not they are subject to

proprietary rights.

While the advice and information in this book are believed to be true and accurate at the date of publication, neither

the authors nor the editors nor the publisher can accept any legal responsibility for any errors or omissions that may

be made. The publisher makes no warranty, express or implied, with respect to the material contained herein.

President and Publisher: Paul Manning

Lead Editor: Gwenan Spearing

Technical Reviewer: Jonathan Allen

Editorial Board: Steve Anglin, Ewan Buckingham, Gary Cornell, Louise Corrigan, Morgan Ertel, Jonathan

Gennick, Jonathan Hassell, Robert Hutchinson, Michelle Lowman, James Markham, Matthew Moodie,

Jeff Olson, Jeffrey Pepper, Douglas Pundick, Ben Renow-Clarke, Dominic Shakeshaft, Gwenan Spearing,

Matt Wade, Tom Welsh

Coordinating Editor: Kevin Shea

Copy Editor: Kim Wimpsett

Compositor: SPi Global

Indexer: SPi Global

Artist: SPi Global

Cover Designer: Anna Ishchenko

Distributed to the book trade worldwide by Springer Science+Business Media New York, 233 Spring Street, 6th

Floor, New York, NY 10013. Phone 1-800-SPRINGER, fax (201) 348-4505, e-mail orders-ny@springer-sbm.com,

or visit www.springeronline.com.

For information on translations, please e-mail rights@apress.com, or visit www.apress.com.

Apress and friends of ED books may be purchased in bulk for academic, corporate, or promotional use.

eBook versions and licenses are also available for most titles. For more information, reference our Special Bulk

Sales–eBook Licensing web page at www.apress.com/bulk-sales.

Any source code or other supplementary materials referenced by the author in this text is available to

readers at www.apress.com. For detailed information about how to locate your book’s source code, go to

www.apress.com/source-code.



www.it-ebooks.info



To Tony Jongejan, for being ahead of his time and introducing me to programming.

—Eric Gunnerson



www.it-ebooks.info



Contents

Preface����������������������������������������������������������������������������������������������������������������������� xxv

About the Author����������������������������������������������������������������������������������������������������� xxvii

About the Technical Reviewer����������������������������������������������������������������������������������� xxix

Acknowledgments����������������������������������������������������������������������������������������������������� xxxi

Introduction������������������������������������������������������������������������������������������������������������� xxxiii

■■Chapter 1: C# and the .NET Runtime and Libraries����������������������������������������������������� 1

■■Chapter 2: C# QuickStart and Developing in C#���������������������������������������������������������� 3

Hello, Universe�������������������������������������������������������������������������������������������������������������������������3

Namespace and Using Statements�����������������������������������������������������������������������������������������4

Namespaces and Assemblies��������������������������������������������������������������������������������������������������5

Basic Data Types���������������������������������������������������������������������������������������������������������������������5

Classes, Structs, and Interfaces����������������������������������������������������������������������������������������������7

Statements������������������������������������������������������������������������������������������������������������������������������7

Enums�������������������������������������������������������������������������������������������������������������������������������������7

Delegates and Events��������������������������������������������������������������������������������������������������������������8

Properties and Indexers����������������������������������������������������������������������������������������������������������8

Attributes���������������������������������������������������������������������������������������������������������������������������������8

Developing in C#���������������������������������������������������������������������������������������������������������������������9

Tools of Note���������������������������������������������������������������������������������������������������������������������������������������������������9



■■Chapter 3: Classes 101���������������������������������������������������������������������������������������������� 11

A Simple Class����������������������������������������������������������������������������������������������������������������������11

Member Functions����������������������������������������������������������������������������������������������������������������13

vii

www.it-ebooks.info



■ Contents



ref and out Parameters���������������������������������������������������������������������������������������������������������14

Overloading���������������������������������������������������������������������������������������������������������������������������16

■■Chapter 4: Base Classes and Inheritance������������������������������������������������������������������ 19

The Engineer Class����������������������������������������������������������������������������������������������������������������19

Simple Inheritance����������������������������������������������������������������������������������������������������������������20

Arrays of Engineers���������������������������������������������������������������������������������������������������������������21

Virtual Functions�������������������������������������������������������������������������������������������������������������������25

Abstract Classes��������������������������������������������������������������������������������������������������������������������27

Sealed Classes and Methods������������������������������������������������������������������������������������������������31

■■Chapter 5: Exception Handling���������������������������������������������������������������������������������� 33

What’s Wrong with Return Codes?����������������������������������������������������������������������������������������33

Trying and Catching���������������������������������������������������������������������������������������������������������������34

Choosing the Catch Block�����������������������������������������������������������������������������������������������������34

Passing Exceptions on to the Caller��������������������������������������������������������������������������������������36

Caller Beware�����������������������������������������������������������������������������������������������������������������������������������������������37

Caller Confuse����������������������������������������������������������������������������������������������������������������������������������������������37

Caller Inform�������������������������������������������������������������������������������������������������������������������������������������������������38



User-Defined Exception Classes��������������������������������������������������������������������������������������������39

Finally������������������������������������������������������������������������������������������������������������������������������������40

Top-Level Exception Handlers�����������������������������������������������������������������������������������������������42

Efficiency and Overhead��������������������������������������������������������������������������������������������������������43

Design Guidelines������������������������������������������������������������������������������������������������������������������43

Exceptions Are Exceptional��������������������������������������������������������������������������������������������������������������������������43

Choosing the Right Exception for Wrapping�������������������������������������������������������������������������������������������������43

Exceptions Should be as Specific as Possible����������������������������������������������������������������������������������������������45

Retry Logic���������������������������������������������������������������������������������������������������������������������������������������������������45

Rethrowing���������������������������������������������������������������������������������������������������������������������������������������������������45

Catch Only if You Have Something Useful to Do�������������������������������������������������������������������������������������������45



viii

www.it-ebooks.info



■ Contents



■■Chapter 6: Member Accessibility and Overloading��������������������������������������������������� 47

Class Accessibility�����������������������������������������������������������������������������������������������������������������47

Using Internal on Members���������������������������������������������������������������������������������������������������47

Expanding Internal Accessibility�������������������������������������������������������������������������������������������������������������������48



Protected�������������������������������������������������������������������������������������������������������������������������������49

Internal Protected�����������������������������������������������������������������������������������������������������������������������������������������49



The Interaction of Class and Member Accessibility���������������������������������������������������������������49

Accessability Summary���������������������������������������������������������������������������������������������������������49

Method Overloading��������������������������������������������������������������������������������������������������������������50

Method Hiding����������������������������������������������������������������������������������������������������������������������������������������������50

Better Conversions���������������������������������������������������������������������������������������������������������������������������������������52



Variable-Length Parameter Lists�������������������������������������������������������������������������������������������53

Default Arguments�����������������������������������������������������������������������������������������������������������������54

Named Arguments�����������������������������������������������������������������������������������������������������������������56

■■Chapter 7: Other Class Details����������������������������������������������������������������������������������� 57

Nested Classes����������������������������������������������������������������������������������������������������������������������57

Other Nesting������������������������������������������������������������������������������������������������������������������������������������������������58



Anonymous Types������������������������������������������������������������������������������������������������������������������58

Creation, Initialization, Destruction���������������������������������������������������������������������������������������58

Constructors�������������������������������������������������������������������������������������������������������������������������������������������������58

Initialization��������������������������������������������������������������������������������������������������������������������������������������������������61

Destructors���������������������������������������������������������������������������������������������������������������������������������������������������61

Managing Nonmemory Resources���������������������������������������������������������������������������������������������������������������62

IDisposable and the Using Statement�����������������������������������������������������������������������������������������������������������64

IDisposable and Longer-Lived Objects���������������������������������������������������������������������������������������������������������64



Static Fields���������������������������������������������������������������������������������������������������������������������������65

Static Member Functions������������������������������������������������������������������������������������������������������66

Static Constructors����������������������������������������������������������������������������������������������������������������67

Constants������������������������������������������������������������������������������������������������������������������������������67

Read-Only Fields�������������������������������������������������������������������������������������������������������������������68

ix

www.it-ebooks.info



■ Contents



Extension Methods����������������������������������������������������������������������������������������������������������������71

Usage Guidelines������������������������������������������������������������������������������������������������������������������������������������������72



Object Initializers�������������������������������������������������������������������������������������������������������������������72

Static Classes������������������������������������������������������������������������������������������������������������������������73

Partial Classes and Methods�������������������������������������������������������������������������������������������������74

■■Chapter 8: Structs (Value Types)������������������������������������������������������������������������������� 77

A Point Struct������������������������������������������������������������������������������������������������������������������������77

Boxing and Unboxing�������������������������������������������������������������������������������������������������������������78

Structs and Constructors������������������������������������������������������������������������������������������������������79

Mutable Structs���������������������������������������������������������������������������������������������������������������������80

Design Guidelines������������������������������������������������������������������������������������������������������������������81

Immutable Classes����������������������������������������������������������������������������������������������������������������81

■■Chapter 9: Interfaces������������������������������������������������������������������������������������������������� 83

A Simple Example�����������������������������������������������������������������������������������������������������������������83

Working with Interfaces��������������������������������������������������������������������������������������������������������84

The as Operator���������������������������������������������������������������������������������������������������������������������86

Interfaces and Inheritance����������������������������������������������������������������������������������������������������86

Design Guidelines������������������������������������������������������������������������������������������������������������������87

Multiple Implementation�������������������������������������������������������������������������������������������������������88

Explicit Interface Implementation�����������������������������������������������������������������������������������������������������������������89

Implementation Hiding���������������������������������������������������������������������������������������������������������������������������������91



Interfaces Based on Interfaces���������������������������������������������������������������������������������������������92

Interfaces and Structs�����������������������������������������������������������������������������������������������������������92

■■Chapter 10: Versioning and Aliases��������������������������������������������������������������������������� 95

A Versioning Example������������������������������������������������������������������������������������������������������������95

Coding for Versioning������������������������������������������������������������������������������������������������������������97

Type Aliases���������������������������������������������������������������������������������������������������������������������������97

External Assembly Aliases�����������������������������������������������������������������������������������������������������98

x

www.it-ebooks.info



■ Contents



■■Chapter 11: Statements and Flow of Execution������������������������������������������������������� 101

Selection Statements����������������������������������������������������������������������������������������������������������101

If�����������������������������������������������������������������������������������������������������������������������������������������������������������������101

Switch���������������������������������������������������������������������������������������������������������������������������������������������������������102



Iteration Statements������������������������������������������������������������������������������������������������������������103

While�����������������������������������������������������������������������������������������������������������������������������������������������������������103

Do���������������������������������������������������������������������������������������������������������������������������������������������������������������104

For��������������������������������������������������������������������������������������������������������������������������������������������������������������105

Foreach�������������������������������������������������������������������������������������������������������������������������������������������������������105



Jump Statements����������������������������������������������������������������������������������������������������������������107

Break����������������������������������������������������������������������������������������������������������������������������������������������������������107

Continue�����������������������������������������������������������������������������������������������������������������������������������������������������107

Goto������������������������������������������������������������������������������������������������������������������������������������������������������������107

Return���������������������������������������������������������������������������������������������������������������������������������������������������������108



Other Statements����������������������������������������������������������������������������������������������������������������108

lock�������������������������������������������������������������������������������������������������������������������������������������������������������������108

using�����������������������������������������������������������������������������������������������������������������������������������������������������������108

try, catch, and finally����������������������������������������������������������������������������������������������������������������������������������108

checked and unchecked�����������������������������������������������������������������������������������������������������������������������������108

yield������������������������������������������������������������������������������������������������������������������������������������������������������������108



■■Chapter 12: Variable Scoping and Definite Assignment������������������������������������������ 109

Definite Assignment������������������������������������������������������������������������������������������������������������110

Definite Assignment and Class Members���������������������������������������������������������������������������������������������������112

Definite Assignment and Arrays�����������������������������������������������������������������������������������������������������������������113



■■Chapter 13: Operators and Expressions������������������������������������������������������������������ 115

Operator Precedence�����������������������������������������������������������������������������������������������������������115

Built-in Operators����������������������������������������������������������������������������������������������������������������116

User-Defined Operators�������������������������������������������������������������������������������������������������������117

Numeric Promotions������������������������������������������������������������������������������������������������������������117



xi

www.it-ebooks.info



■ Contents



Arithmetic Operators�����������������������������������������������������������������������������������������������������������117

Unary Plus (+) ��������������������������������������������������������������������������������������������������������������������������������������������117

Unary Minus (−) �����������������������������������������������������������������������������������������������������������������������������������������117

Bitwise Complement (~) ����������������������������������������������������������������������������������������������������������������������������117

Addition (+) ������������������������������������������������������������������������������������������������������������������������������������������������117

Subtraction (−) ������������������������������������������������������������������������������������������������������������������������������������������118

Multiplication (*) ����������������������������������������������������������������������������������������������������������������������������������������118

Division (/) ��������������������������������������������������������������������������������������������������������������������������������������������������118

Remainder (%) �������������������������������������������������������������������������������������������������������������������������������������������118

Shift (<< and >>) ��������������������������������������������������������������������������������������������������������������������������������������118

Increment and Decrement (++ and --) ������������������������������������������������������������������������������������������������������118



Relational and Logical Operators����������������������������������������������������������������������������������������119

Logical Negation (!) �����������������������������������������������������������������������������������������������������������������������������������119

Relational Operators over���������������������������������������������������������������������������������������������������������������������������119

Logical Operators ��������������������������������������������������������������������������������������������������������������������������������������120

Conditional Operator (?:)�����������������������������������������������������������������������������������������������������������������������������121

Null Coalescing Operator (??)���������������������������������������������������������������������������������������������������������������������121



Assignment Operators���������������������������������������������������������������������������������������������������������121

Simple Assignment�������������������������������������������������������������������������������������������������������������������������������������122

Compound Assignment�������������������������������������������������������������������������������������������������������������������������������122



Type Operators��������������������������������������������������������������������������������������������������������������������122

typeof����������������������������������������������������������������������������������������������������������������������������������������������������������122

is�����������������������������������������������������������������������������������������������������������������������������������������������������������������123

as����������������������������������������������������������������������������������������������������������������������������������������������������������������123



Checked and Unchecked Expressions���������������������������������������������������������������������������������124

Type Inference (var)�������������������������������������������������������������������������������������������������������������125

Best Practices���������������������������������������������������������������������������������������������������������������������������������������������125



xii

www.it-ebooks.info



■ Contents



■■Chapter 14: Conversions����������������������������������������������������������������������������������������� 127

Numeric Types���������������������������������������������������������������������������������������������������������������������127

Conversions and Member Lookup��������������������������������������������������������������������������������������������������������������128

Explicit Numeric Conversions���������������������������������������������������������������������������������������������������������������������129

Checked Conversions���������������������������������������������������������������������������������������������������������������������������������130



Conversions of Classes (Reference Types)��������������������������������������������������������������������������131

From an Object to the Base Class of an Object������������������������������������������������������������������������������������������131

From an Object to an Interface the Object Implements������������������������������������������������������������������������������133

From an Object to an Interface the Object Might Implement���������������������������������������������������������������������133

From One Interface Type to Another�����������������������������������������������������������������������������������������������������������134



Conversions of Structs (Value Types)����������������������������������������������������������������������������������135

■■Chapter 15: Arrays�������������������������������������������������������������������������������������������������� 137

Array Initialization���������������������������������������������������������������������������������������������������������������137

Multidimensional and Jagged Arrays����������������������������������������������������������������������������������137

Multidimensional Arrays�����������������������������������������������������������������������������������������������������������������������������138

Jagged Arrays���������������������������������������������������������������������������������������������������������������������������������������������139



Arrays of Reference Types���������������������������������������������������������������������������������������������������140

Array Conversions���������������������������������������������������������������������������������������������������������������141

The System.Array Type��������������������������������������������������������������������������������������������������������142

Sorting and Searching��������������������������������������������������������������������������������������������������������������������������������142

Reverse�������������������������������������������������������������������������������������������������������������������������������������������������������142



■■Chapter 16: Properties�������������������������������������������������������������������������������������������� 143

Accessors����������������������������������������������������������������������������������������������������������������������������143

Properties and Inheritance��������������������������������������������������������������������������������������������������144

Using Properties������������������������������������������������������������������������������������������������������������������144

Side Effects When Setting Values����������������������������������������������������������������������������������������145

Static Properties������������������������������������������������������������������������������������������������������������������146

Property Efficiency��������������������������������������������������������������������������������������������������������������147

Property Accessibility����������������������������������������������������������������������������������������������������������148

Virtual Properties�����������������������������������������������������������������������������������������������������������������149

xiii

www.it-ebooks.info



■ Contents



Automatic Properties�����������������������������������������������������������������������������������������������������������150

Properties vs. Fields������������������������������������������������������������������������������������������������������������150

■■Chapter 17: Generic Types��������������������������������������������������������������������������������������� 153

A List of Integers�����������������������������������������������������������������������������������������������������������������153

Constraints��������������������������������������������������������������������������������������������������������������������������156

Interface Constraints����������������������������������������������������������������������������������������������������������������������������������156

Base Class Constraints�������������������������������������������������������������������������������������������������������������������������������156

Class and Struct Constraints����������������������������������������������������������������������������������������������������������������������157

Multiple Constraints������������������������������������������������������������������������������������������������������������������������������������157



The Default Value of a Type�������������������������������������������������������������������������������������������������157

Generic Interfaces and Inheritance�������������������������������������������������������������������������������������157

Generic Methods�����������������������������������������������������������������������������������������������������������������158

Generic Delegates���������������������������������������������������������������������������������������������������������������159

Covariance and Contravariance�������������������������������������������������������������������������������������������159

Contravariance�������������������������������������������������������������������������������������������������������������������������������������������161



Generics and Efficiency�������������������������������������������������������������������������������������������������������162

Generic Naming Guidelines�������������������������������������������������������������������������������������������������162

■■Chapter 18: Indexers, Enumerators, and Iterators�������������������������������������������������� 165

Indexing with an Integer Index��������������������������������������������������������������������������������������������165

Indexing with a String Index������������������������������������������������������������������������������������������������166

Indexing with Multiple Parameters�������������������������������������������������������������������������������������167

Design Guidelines for Indexers�������������������������������������������������������������������������������������������������������������������169



Object Enumeration�������������������������������������������������������������������������������������������������������������169

Enumerators and Foreach��������������������������������������������������������������������������������������������������������������������������169

Enabling Enumeration��������������������������������������������������������������������������������������������������������������������������������170

Iterators �����������������������������������������������������������������������������������������������������������������������������������������������������172

Named Iterators������������������������������������������������������������������������������������������������������������������������������������������173

Iterators and Generic Types������������������������������������������������������������������������������������������������������������������������174

Iterators and Resource Management���������������������������������������������������������������������������������������������������������175



xiv

www.it-ebooks.info



■ Contents



■■Chapter 19: Strings������������������������������������������������������������������������������������������������� 177

Operations���������������������������������������������������������������������������������������������������������������������������177

String Literals����������������������������������������������������������������������������������������������������������������������179

String Encodings and Conversions��������������������������������������������������������������������������������������179

Converting Objects to Strings����������������������������������������������������������������������������������������������179

An Example�������������������������������������������������������������������������������������������������������������������������179

StringBuilder�����������������������������������������������������������������������������������������������������������������������180

Regular Expressions������������������������������������������������������������������������������������������������������������181

Regular Expression Options������������������������������������������������������������������������������������������������������������������������182

More Complex Parsing��������������������������������������������������������������������������������������������������������������������������������182



■■Chapter 20: Enumerations��������������������������������������������������������������������������������������� 187

A Line-Style Enumeration����������������������������������������������������������������������������������������������������187

Enumeration Base Types�����������������������������������������������������������������������������������������������������188

Initialization�������������������������������������������������������������������������������������������������������������������������188

Bit Flag Enums��������������������������������������������������������������������������������������������������������������������190

Conversions�������������������������������������������������������������������������������������������������������������������������191

The System.Enum Type�������������������������������������������������������������������������������������������������������191

■■Chapter 21: Attributes��������������������������������������������������������������������������������������������� 195

Using Attributes�������������������������������������������������������������������������������������������������������������������195

A Few More Details�������������������������������������������������������������������������������������������������������������������������������������197



An Attribute of Your Own�����������������������������������������������������������������������������������������������������198

Attribute Usage�������������������������������������������������������������������������������������������������������������������������������������������199

Attribute Parameters����������������������������������������������������������������������������������������������������������������������������������199



Fetching Attribute Values����������������������������������������������������������������������������������������������������200

■■Chapter 22: Delegates, Anonymous Methods, and Lambdas����������������������������������� 203

Using Delegates������������������������������������������������������������������������������������������������������������������203

Delegates to Instance Members������������������������������������������������������������������������������������������205

Multicasting�������������������������������������������������������������������������������������������������������������������������206

Delegates As Static Members���������������������������������������������������������������������������������������������207

xv

www.it-ebooks.info



Tài liệu bạn tìm kiếm đã sẵn sàng tải về

A Programmer’s Guide to C# 5.0

Tải bản đầy đủ ngay(0 tr)

×