Solis Illustrated C# 2008

1. ed
ISBN: 978-1-4302-0574-6
Verlag: Apress
Format: PDF
Kopierschutz: 1 - PDF Watermark

E-Book, Englisch, 728 Seiten

The unique, visual format of Illustrated C# 2008 has been specially created by author, and teacher of development methods, Daniel Solis. The concise text, use of tables to clarify language features, frequent figures and diagrams, as well as focused code samples all combine to create a unique approach that will help you understand and get to work with C# fast. Following an overview of the .NET platform and the role played by C#, you'll soon move into exploring the C# language in its entirety, including all the new C# 2008 features right down to the most complex topics involved in C#.

Daniel Solis is a contract software engineer who has worked for a number of high-profile clients, including Microsoft Consulting Services, IBM, Lockheed Martin, and PeopleSoft. He has been programming and teaching object-oriented languages and development methods throughout the U.S. and Europe since the early days of C++. It was while teaching numerous seminars on various programming languages that he realized the immense power of diagrams in explaining programming language concepts.

Autoren/Hrsg.

Solis, Daniel

Inhaltsverzeichnis

1;Contents at a Glance;5
2;Contents;7
3;About the Author;23
4;About the Technical Reviewer;24
5;Acknowledgments;25
6;Introduction;26
7;C# and the .NET Framework;27
7.1;Before . NET;28
7.2;Enter Microsoft . NET;28
7.3;Compiling to the Common Intermediate Language ( CIL);33
7.4;Compiling to Native Code and Execution;34
7.5;The Common Language Runtime ( CLR);36
7.6;The Common Language Infrastructure ( CLI);37
7.7;Review of the Acronyms;39
8;Overview of C# Programming;40
8.1;A Simple C# Program;41
8.2;More About SimpleProgram;42
8.3;Identifiers and Keywords;43
8.4;Naming Conventions;44
8.5;Keywords;45
8.6;Main: The Starting Point of a Program;46
8.7;Whitespace;46
8.8;Statements;47
8.9;Simple Statements;47
8.10;Blocks;47
8.11;Text Output from a Program;49
8.12;Write;49
8.13;WriteLine;50
8.14;The Format String;51
8.15;Multiple Markers and Values;52
8.16;Comments: Annotating the Code;53
8.17;More About Comments;54
8.18;Documentation Comments;54
8.19;Summary of Comment Types;55
9;Types, Storage, and Variables;56
9.1;A C# Program Is a Set of Type Declarations;57
9.2;A Type Is a Template;58
9.3;Instantiating a Type;58
9.4;Data Members and Function Members;59
9.5;Predefined Types;60
9.6;User- Defined Types;62
9.7;The Stack and the Heap;63
9.8;Value Types and Reference Types;65
9.9;Variables;67
10;Classes: The Basics;70
10.1;Overview of Classes;71
10.2;Programs and Classes: A Quick Example;72
10.3;Declaring a Class;73
10.4;Class Members;74
10.5;Creating Variables and Instances of a Class;77
10.6;Allocating Memory for the Data;78
10.7;Instance Members;80
10.8;Access Modifiers;81
10.9;Accessing Members from Inside the Class;84
10.10;Accessing Members from Outside the Class;85
10.11;Putting It All Together;87
11;Methods;89
11.1;The Structure of a Method;90
11.2;Local Variables;92
11.3;Local Constants;95
11.4;Method Invocations;97
11.5;Return Values;98
11.6;Parameters;102
11.7;Value Parameters;105
11.8;Reference Parameters;108
11.9;Output Parameters;111
11.10;Parameter Arrays;114
11.11;Summary of Parameter Types;118
11.12;Stack Frames;119
11.13;Recursion;121
11.14;Method Overloading;123
12;More About Classes;124
12.1;Class Members;125
12.2;Instance Class Members;127
12.3;Static Fields;128
12.4;Accessing Static Members from Outside the Class;129
12.5;Static Function Members;131
12.6;Other Static Class Member Types;132
12.7;Member Constants;133
12.8;Properties;136
12.9;Instance Constructors;149
12.10;Static Constructors;152
12.11;Object Initializers;154
12.12;Destructors;156
12.13;Comparing Constructors and Destructors;160
12.14;The readonly Modifier;161
12.15;The this Keyword;163
12.16;Indexers;164
12.17;Access Modifiers on Accessors;173
12.18;Partial Classes and Partial Types;174
13;Classes and Inheritance;178
13.1;Class Inheritance;179
13.2;Accessing the Inherited Members;180
13.3;Hiding Members of a Base Class;182
13.4;Base Access;184
13.5;Using References to a Base Class;185
13.6;Constructor Execution;192
13.7;Inheritance Between Assemblies;197
13.8;Member Access Modifiers;199
13.9;Abstract Members;205
13.10;Abstract Classes;206
13.11;Sealed Classes;208
13.12;Static Classes;209
13.13;Extension Methods;210
13.14;External Methods;214
14;Expressions and Operators;216
14.1;Expressions;217
14.2;Literals;218
14.3;Integer Literals;219
14.4;Character Literals;221
14.5;String Literals;222
14.6;Order of Evaluation;224
14.7;Simple Arithmetic Operators;226
14.8;The Remainder Operator;227
14.9;Relational and Equality Comparison Operators;228
14.10;Increment and Decrement Operators;230
14.11;Conditional Logical Operators;232
14.12;Logical Operators;234
14.13;Shift Operators;236
14.14;Assignment Operators;238
14.15;The Conditional Operator;240
14.16;Unary Arithmetic Operators;242
14.17;User- Defined Type Conversions;243
14.18;Operator Overloading;246
14.19;The typeof Operator;249
15;Statements;252
15.1;What Are Statements?;253
15.2;Expression Statements;254
15.3;Flow- of- Control Statements;255
15.4;The if Statement;256
15.5;The if . . . else Statement;257
15.6;The switch Statement;258
15.7;The while Loop;263
15.8;The do Loop;264
15.9;The for Loop;266
15.10;Jump Statements;270
15.11;The break Statement;270
15.12;The continue Statement;271
15.13;Labeled Statements;272
15.14;The goto Statement;274
15.15;The using Statement;275
15.16;Other Statements;280
16;Namespaces and Assemblies;281
16.1;Referencing Other Assemblies;282
16.2;Namespaces;287
16.3;The using Directives;293
16.4;The Structure of an Assembly;295
16.5;The Identity of an Assembly;297
16.6;Strongly Named Assemblies;299
16.7;Private Deployment of an Assembly;301
16.8;Shared Assemblies and the GAC;302
16.9;Configuration Files;304
16.10;Delayed Signing;305
17;Exceptions;307
17.1;What Are Exceptions?;308
17.2;The try Statement;309
17.3;The Exception Classes;311
17.4;The catch Clause;312
17.5;Examples Using Specific catch Clauses;313
17.6;The catch Clauses Section;314
17.7;The finally Block;315
17.8;Finding a Handler for an Exception;316
17.9;Searching Further;317
17.10;Throwing Exceptions;321
17.11;Throwing Without an Exception Object;322
18;Structs;324
18.1;What Are Structs?;325
18.2;Structs Are Value Types;326
18.3;Assigning to a Struct;327
18.4;Constructors and Destructors;328
18.5;Field Initializers Are Not Allowed;331
18.6;Structs Are Sealed;331
18.7;Boxing and Unboxing;331
18.8;Structs As Return Values and Parameters;332
18.9;Additional Information About Structs;332
19;Enumerations;333
19.1;Enumerations;334
19.2;Bit Flags;338
19.3;More About Enums;344
20;Arrays;346
20.1;Arrays;347
20.2;Types of Arrays;348
20.3;An Array As an Object;349
20.4;One- Dimensional and Rectangular Arrays;350
20.5;Instantiating a One- Dimensional or Rectangular Array;351
20.6;Accessing Array Elements;352
20.7;Initializing an Array;353
20.8;Jagged Arrays;358
20.9;Comparing Rectangular and Jagged Arrays;362
20.10;The foreach Statement;363
20.11;Array Covariance;368
20.12;Useful Inherited Array Members;369
20.13;Comparing Array Types;373
21;Delegates;374
21.1;What Is a Delegate?;375
21.2;Declaring the Delegate Type;376
21.3;Creating the Delegate Object;377
21.4;Assigning Delegates;379
21.5;Combining Delegates;380
21.6;Adding Methods to Delegates;381
21.7;Removing Methods from a Delegate;382
21.8;Invoking a Delegate;383
21.9;Delegate Example;383
21.10;Invoking Delegates with Return Values;385
21.11;Invoking Delegates with Reference Parameters;387
21.12;Anonymous Methods;389
21.13;Lambda Expressions;394
22;Events;397
22.1;Events Are Like Delegates;398
22.2;Overview of Source Code Components;400
22.3;Declaring an Event;401
22.4;Raising an Event;403
22.5;Subscribing to an Event;404
22.6;Standard Event Usage;407
22.7;The MyTimerClass Code;412
22.8;Event Accessors;414
23;Interfaces;415
23.1;What Is an Interface?;416
23.2;Declaring an Interface;420
23.3;Implementing an Interface;422
23.4;An Interface Is a Reference Type;424
23.5;Using the as Operator with Interfaces;426
23.6;Implementing Multiple Interfaces;427
23.7;Implementing Interfaces with Duplicate Members;428
23.8;References to Multiple Interfaces;430
23.9;An Inherited Member As an Implementation;432
23.10;Explicit Interface Member Implementations;433
23.11;Interfaces Can Inherit Interfaces;437
24;Conversions;440
24.1;What Are Conversions?;441
24.2;Implicit Conversions;442
24.3;Explicit Conversions and Casting;443
24.4;Types of Conversions;445
24.5;Numeric Conversions;445
24.6;Reference Conversions;453
24.7;Boxing Conversions;459
24.8;Unboxing Conversions;461
24.9;User- Defined Conversions;463
24.10;The is Operator;468
24.11;The as Operator;469
25;Generics;470
25.1;What Are Generics?;471
25.2;Generics in C#;473
25.3;Generic Classes;475
25.4;Declaring a Generic Class;476
25.5;Creating a Constructed Type;477
25.6;Creating Variables and Instances;478
25.7;Constraints on Type Parameters;483
25.8;Generic Structs;486
25.9;Generic Interfaces;487
25.10;Generic Delegates;490
25.11;Generic Methods;493
25.12;Extension Methods with Generic Classes;498
26;Enumerators and Iterators;500
26.1;Enumerators and Enumerable Types;501
26.2;Using the IEnumerator Interface;503
26.3;The IEnumerable Interface;508
26.4;The Non- Interface Enumerator;511
26.5;The Generic Enumeration Interfaces;513
26.6;The IEnumerator< T> Interface;514
26.7;The IEnumerable< T> Interface;517
26.8;Iterators;519
26.9;Common Iterator Patterns;524
26.10;Producing Enumerables and Enumerators;525
26.11;Producing Multiple Enumerables;526
26.12;Producing Multiple Enumerators;528
26.13;Behind the Scenes with Iterators;530
27;Introduction to LINQ;531
27.1;What Is LINQ?;532
27.2;LINQ Providers;533
27.3;Query Syntax and Method Syntax;536
27.4;Query Variables;538
27.5;The Structure of Query Expressions;540
27.6;The Standard Query Operators;558
27.7;LINQ to XML;569
28;Introduction to Asynchronous Programming;589
28.1;Processes, Threads, and Asynchronous Programming;590
28.2;Asynchronous Programming Patterns;593
28.3;BeginInvoke and EndInvoke;594
28.4;Timers;605
29;Preprocessor Directives;608
29.1;What Are Preprocessor Directives?;609
29.2;General Rules;609
29.3;The # define and # undef Directives;611
29.4;Conditional Compilation;612
29.5;The Conditional Compilation Constructs;613
29.6;Diagnostic Directives;616
29.7;Line Number Directives;617
29.8;Region Directives;618
29.9;The # pragma warning Directive;619
30;Reflection and Attributes;620
30.1;Metadata and Reflection;621
30.2;The Type Class;621
30.3;Getting a Type Object;623
30.4;What Is an Attribute?;626
30.5;Applying an Attribute;627
30.6;Predefined, Reserved Attributes;628
30.7;More About Applying Attributes;632
30.8;Custom Attributes;635
30.9;Accessing an Attribute;643
31;Other Topics;645
31.1;Overview;646
31.2;Strings;646
31.3;Parsing Strings to Data Values;653
31.4;Nullable Types;654
31.5;Method Main;661
31.6;Documentation Comments;663
31.7;Nested Types;666
32;Index;671