Nash Accelerated C# 2008

1. ed
ISBN: 978-1-4302-0338-4
Verlag: Apress
Format: PDF
Kopierschutz: 1 - PDF Watermark

E-Book, Englisch, 510 Seiten

Accelerated C# 3.0 is the fastest path to C# mastery. All C# programmers need to know and understand how C# really works but very few books address this. No other book covers the subject in the depth that this one does. It teaches both core C# language concepts and how to use them in high-performance code. All programmers moving to C# from any language or moving up to C# 3.0 from C# 2005 will find this book well worth buying, reading, and using as a reference.

Trey Nash is an escalation engineer at Microsoft working on the Windows operating systems as well as various other products. When he is not working feverishly within the bowels of the operating system, he is delivering training on .NET Platform debugging as well as user mode and kernel mode debugging on the Windows platform. Prior to working at Microsoft, he was a principal software engineer working on security solutions at Credant Technologies, a market-leading security software company. He also enjoined a stint at a large Bluetooth company developing Bluetooth solutions for the release of Microsoft Vista. Before that, he called Macromedia, Inc. home for five years. At Macromedia, he worked on a cross-product engineering team for several years, designing solutions for a wide range of products throughout the company, including Flash, Fireworks, and Dreamweaver. He specialized in COM/DCOM using C/C++/ATL until the .NET revolution. He's been glued to computers ever since he scored his first, a TI-99/4A, when he was a mere 13 years old. He astounded his parents by turning a childhood obsession into a decent-paying career, much to their dismay. Trey received his bachelor of science and his master of engineering degrees in electrical engineering from Texas A&M University. When he's not sitting in front of a computer, you can find him working in his garage, playing his piano, brushing up on a foreign language (Russian and Icelandic are the current favorites), or playing ice hockey.

Autoren/Hrsg.

Nash, Trey

Inhaltsverzeichnis

1;Contents at a Glance;5
2;Contents;6
3;Foreword;15
4;About the Author;16
5;About the Technical Reviewer;17
6;Acknowledgments;18
7;Introduction;19
7.1;About This Book;20
8;C# Preview;23
8.1;Differences Between C# and C++;23
8.2;Example of a C# Program;25
8.3;Overview of Features Added in C# 2.0;27
8.4;Overview of What’s New in C# 3.0;28
8.5;Summary;29
9;C# and the CLR;30
9.1;The JIT Compiler in the CLR;31
9.2;Assemblies and the Assembly Loader;32
9.3;Metadata;34
9.4;Cross- Language Compatibility;35
9.5;Summary;36
10;C# Syntax Overview;37
10.1;C# Is a Strongly Typed Language;37
10.2;Expressions;38
10.3;Statements and Expressions;39
10.4;Types and Variables;39
10.5;Namespaces;52
10.6;Control Flow;55
10.7;Summary;57
11;Classes, Structs, and Objects;58
11.1;Class Definitions;60
11.2;Value Type Definitions;94
11.3;Anonymous Types;100
11.4;Object Initializers;103
11.5;Boxing and Unboxing;106
11.6;System. Object;113
11.7;Creating Objects;114
11.8;Destroying Objects;123
11.9;Disposable Objects;126
11.10;Method Parameter Types;130
11.11;Method Overloading;133
11.12;Inheritance and Virtual Methods;134
11.13;Inheritance, Containment, and Delegation;137
11.14;Summary;141
12;Interfaces and Contracts;142
12.1;Interfaces Define Types;143
12.2;Defining Interfaces;144
12.3;Implementing Interfaces;147
12.4;Interface Member Matching Rules;154
12.5;Explicit Interface Implementation with Value Types;158
12.6;Versioning Considerations;160
12.7;Contracts;161
12.8;Choosing Between Interfaces and Classes;163
12.9;Summary;167
13;Overloading Operators;168
13.1;Just Because You Can Doesn’t Mean You Should;168
13.2;Types and Formats of Overloaded Operators;168
13.3;Operators Shouldn’t Mutate Their Operands;169
13.4;Does Parameter Order Matter?;170
13.5;Overloading the Addition Operator;170
13.6;Operators That Can Be Overloaded;172
13.7;Summary;180
14;Exception Handling and Exception Safety;181
14.1;How the CLR Treats Exceptions;181
14.2;Mechanics of Handling Exceptions in C#;182
14.3;Who Should Handle Exceptions?;190
14.4;Avoid Using Exceptions to Control Flow;191
14.5;Achieving Exception Neutrality;191
14.6;Creating Custom Exception Classes;203
14.7;Working with Allocated Resources and Exceptions;204
14.8;Providing Rollback Behavior;208
14.9;Summary;211
15;Working with Strings;212
15.1;String Overview;212
15.2;String Literals;213
15.3;Format Specifiers and Globalization;214
15.4;Working with Strings from Outside Sources;225
15.5;StringBuilder;226
15.6;Searching Strings with Regular Expressions;228
15.7;Summary;237
16;Arrays, Collection Types, and Iterators;238
16.1;Introduction to Arrays;238
16.2;Multidimensional Rectangular Arrays;245
16.3;Multidimensional Jagged Arrays;246
16.4;Collection Types;248
16.5;IEnumerable< T>, IEnumerator< T>, IEnumerable, and IEnumerator;256
16.6;Iterators;259
16.7;Collection Initializers;268
16.8;Summary;269
17;Delegates, Anonymous Functions, and Events;270
17.1;Overview of Delegates;270
17.2;Delegate Creation and Use;271
17.3;Events;279
17.4;Anonymous Methods;283
17.5;The Strategy Pattern;293
17.6;Summary;295
18;Generics;296
18.1;Difference Between Generics and C++ Templates;297
18.2;Efficiency and Type Safety of Generics;298
18.3;Generic Type Definitions and Constructed Types;299
18.4;Constraints;314
18.5;Generic System Collections;319
18.6;Generic System Interfaces;320
18.7;Select Problems and Solutions;322
18.8;Summary;333
19;Threading in C#;334
19.1;Threading in C# and . NET;334
19.2;Synchronizing Work Between Threads;348
19.3;Using ThreadPool;370
19.4;Summary;379
20;In Search of C# Canonical Forms;380
20.1;Reference Type Canonical Forms;380
20.2;Value Type Canonical Forms;422
20.3;Summary;431
21;Extension Methods;434
21.1;Introduction to Extension Methods;434
21.2;Recommendations for Use;440
21.3;Transforms;442
21.4;Operation Chaining;446
21.5;Custom Iterators;447
21.6;The Visitor Pattern;454
21.7;Summary;458
22;Lambda Expressions;459
22.1;Introduction to Lambda Expressions;459
22.2;Expression Trees;465
22.3;Useful Applications of Lambda Expressions;469
22.4;Summary;480
23;LINQ: Language Integrated Query;481
23.1;A Bridge to Data;481
23.2;Standard Query Operators;485
23.3;C# Query Keywords;486
23.4;The Virtues of Being Lazy;498
23.5;Techniques from Functional Programming;502
23.6;Summary;510
24;References;511
24.1;Blogs;512
25;Index;513