Illustrated C#2012 by Solis, Daniel M. -- Read -- Imperial Library of Trantor

Index

Cover Title Copyright Dedication Contents at a Glance Contents About the Author About the Technical Reviewer Acknowledgments Introduction CHAPTER 1: C# and the .NET Framework

Before .NET

Windows Programming in the Late 1990s Goals for the Next-Generation Platform Services

Enter Microsoft .NET

Components of the .NET Framework An Improved Programming Environment

Compiling to the Common Intermediate Language Compiling to Native Code and Execution

Overview of Compilation and Execution

The Common Language Runtime The Common Language Infrastructure

Important Parts of the CLI

Review of the Acronyms The Evolution of C#

CHAPTER 2: Overview of C# Programming

A Simple C# Program

More About SimpleProgram

Identifiers Keywords Main: The Starting Point of a Program Whitespace Statements

Blocks

Text Output from a Program

Write WriteLine The Format String Multiple Markers and Values Formatting Numeric Strings

Comments: Annotating the Code

More About Comments Documentation Comments Summary of Comment Types

CHAPTER 3: Types, Storage, and Variables

A C# Program Is a Set of Type Declarations A Type Is a Template Instantiating a Type Data Members and Function Members

Types of Members

Predefined Types

More About the Predefined Types

User-Defined Types The Stack and the Heap

The Stack The Heap

Value Types and Reference Types

Storing Members of a Reference Type Object Categorizing the C# Types

Variables

Variable Declarations Multiple-Variable Declarations Using the Value of a Variable

Static Typing and the dynamic Keyword Nullable Types

CHAPTER 4: Classes: The Basics

Overview of Classes

A Class Is an Active Data Structure

Programs and Classes: A Quick Example Declaring a Class Class Members

Fields Methods

Creating Variables and Instances of a Class Allocating Memory for the Data

Combining the Steps

Instance Members Access Modifiers

Private and Public Access

Accessing Members from Inside the Class Accessing Members from Outside the Class Putting It All Together

CHAPTER 5: Methods

The Structure of a Method Code Execution in the Method Body Local Variables

Type Inference and the var Keyword Local Variables Inside Nested Blocks

Local Constants Flow of Control Method Invocations Return Values The Return Statement and Void Methods Parameters

Formal Parameters Actual Parameters

Value Parameters Reference Parameters Reference Types As Value and Reference Parameters Output Parameters Parameter Arrays

Method Invocation Arrays As Actual Parameters

Summary of Parameter Types Method Overloading Named Parameters Optional Parameters Stack Frames Recursion

CHAPTER 6: More About Classes

Class Members Order of Member Modifiers Instance Class Members Static Fields Accessing Static Members from Outside the Class

Example of a Static Field Lifetimes of Static Members

Static Function Members Other Static Class Member Types Member Constants Constants Are Like Statics Properties

Property Declarations and Accessors A Property Example Using a Property Properties and Associated Fields Performing Other Calculations Read-Only and Write-Only Properties Properties vs. Public Fields An Example of a Computed, Read-Only Property Automatically Implemented Properties Static Properties

Instance Constructors

Constructors with Parameters Default Constructors

Static Constructors

Example of a Static Constructor

Object Initializers Destructors The readonly Modifier The this Keyword Indexers

What Is an Indexer? Indexers and Properties Declaring an Indexer The Indexer set Accessor The Indexer get Accessor More About Indexers Declaring the Indexer for the Employee Example Another Indexer Example Indexer Overloading

Access Modifiers on Accessors Partial Classes and Partial Types Partial Methods

CHAPTER 7: Classes and Inheritance

Class Inheritance Accessing the Inherited Members All Classes Are Derived from Class object Masking Members of a Base Class Base Access Using References to a Base Class

Virtual and Override Methods Overriding a Method Marked override Overriding Other Member Types

Constructor Execution

Constructor Initializers Class Access Modifiers

Inheritance Between Assemblies Member Access Modifiers

Regions Accessing a Member Public Member Accessibility Private Member Accessibility Protected Member Accessibility Internal Member Accessibility Protected Internal Member Accessibility Summary of Member Access Modifiers

Abstract Members Abstract Classes

Example of an Abstract Class and an Abstract Method Another Example of an Abstract Class

Sealed Classes Static Classes Extension Methods Naming Conventions

CHAPTER 8: Expressions and Operators

Expressions Literals

Integer Literals Real Literals Character Literals String Literals

Order of Evaluation

Precedence Associativity

Simple Arithmetic Operators The Remainder Operator Relational and Equality Comparison Operators

Comparison and Equality Operations

Increment and Decrement Operators Conditional Logical Operators Logical Operators Shift Operators Assignment Operators

Compound Assignment

The Conditional Operator Unary Arithmetic Operators User-Defined Type Conversions

Explicit Conversion and the Cast Operator

Operator Overloading

Restrictions on Operator Overloading Example of Operator Overloading

The typeof Operator Other Operators

CHAPTER 9: Statements

What Are Statements? Expression Statements Flow-of-Control Statements The if Statement The if...else Statement The while Loop The do Loop The for Loop

The Scope of Variables in a for Statement Multiple Expressions in the Initializer and Iteration Expression

The switch Statement

A Switch Example More on the switch Statement Switch Labels

Jump Statements The break Statement The continue Statement Labeled Statements

Labels The Scope of Labeled Statements

The goto Statement

The goto Statement Inside a switch Statement

The using Statement

Packaging the Use of a Resource Example of the using Statement Multiple Resources and Nesting Another Form of the using Statement

Other Statements

CHAPTER 10: Structs

What Are Structs? Structs Are Value Types Assigning to a Struct Constructors and Destructors

Instance Constructors Static Constructors Summary of Constructors and Destructors

Field Initializers Are Not Allowed Structs Are Sealed Boxing and Unboxing Structs As Return Values and Parameters Additional Information About Structs

CHAPTER 11: Enumerations

Enumerations

Setting the Underlying Type and Explicit Values Implicit Member Numbering

Bit Flags

The Flags Attribute Example Using Bit Flags

More About Enums

CHAPTER 12: Arrays

Arrays

Definitions Important Details

Types of Arrays An Array As an Object One-Dimensional and Rectangular Arrays

Declaring a One-Dimensional or Rectangular Array

Instantiating a One-Dimensional or Rectangular Array Accessing Array Elements Initializing an Array

Explicit Initialization of One-Dimensional Arrays Explicit Initialization of Rectangular Arrays Syntax Points for Initializing Rectangular Arrays Shortcut Syntax Implicitly Typed Arrays Putting It All Together

Jagged Arrays

Declaring a Jagged Array Shortcut Instantiation Instantiating a Jagged Array Subarrays in Jagged Arrays

Comparing Rectangular and Jagged Arrays The foreach Statement

The Iteration Variable Is Read-Only The foreach Statement with Multidimensional Arrays

Array Covariance Useful Inherited Array Members

The Clone Method

Comparing Array Types

CHAPTER 13: Delegates

What Is a Delegate? An Overview of Delegates Declaring the Delegate Type Creating the Delegate Object Assigning Delegates Combining Delegates Adding Methods to Delegates Removing Methods from a Delegate Invoking a Delegate Delegate Example Invoking Delegates with Return Values Invoking Delegates with Reference Parameters Anonymous Methods

Using Anonymous Methods Syntax of Anonymous Methods Scope of Variables and Parameters

Lambda Expressions

CHAPTER 14: Events

Publishers and Subscribers Overview of Source Code Components Declaring an Event

An Event Is a Member

Subscribing to an Event Raising an Event Standard Event Usage

Passing Data by Extending EventArgs Removing Event Handlers

Event Accessors

CHAPTER 15: Interfaces

What Is an Interface?

Example Using the IComparable Interface

Declaring an Interface Implementing an Interface

Example with a Simple Interface

An Interface Is a Reference Type Using the as Operator with Interfaces Implementing Multiple Interfaces Implementing Interfaces with Duplicate Members References to Multiple Interfaces An Inherited Member As an Implementation Explicit Interface Member Implementations

Accessing Explicit Interface Member Implementations

Interfaces Can Inherit Interfaces Example of Different Classes Implementing an Interface

CHAPTER 16: Conversions

What Are Conversions? Implicit Conversions Explicit Conversions and Casting

Casting

Types of Conversions Numeric Conversions

Implicit Numeric Conversions Overflow Checking Context Explicit Numeric Conversions

Reference Conversions

Implicit Reference Conversions Explicit Reference Conversions Valid Explicit Reference Conversions

Boxing Conversions

Boxing Creates a Copy The Boxing Conversions

Unboxing Conversions

The Unboxing Conversions

User-Defined Conversions

Constraints on User-Defined Conversions Example of a User-Defined Conversion Evaluating User-Defined Conversions Example of a Multistep User-Defined Conversion

The is Operator The as Operator

CHAPTER 17: Generics

What Are Generics?

A Stack Example

Generics in C#

Continuing with the Stack Example

Generic Classes Declaring a Generic Class Creating a Constructed Type Creating Variables and Instances

The Stack Example Using Generics Comparing the Generic and Nongeneric Stack

Constraints on Type Parameters

Where Clauses Constraint Types and Order

Generic Methods

Declaring a Generic Method Invoking a Generic Method Example of a Generic Method

Extension Methods with Generic Classes Generic Structs Generic Delegates

Another Generic Delegate Example

Generic Interfaces

An Example Using Generic Interfaces Generic Interface Implementations Must Be Unique

Covariance Contravariance

Covariance and Contravariance in Interfaces More About Variance

CHAPTER 18: Enumerators and Iterators

Enumerators and Enumerable Types

Using the foreach Statement

The IEnumerator Interface

Example Using IEnumerable and IEnumerator

The Generic Enumeration Interfaces Iterators

Iterator Blocks Using an Iterator to Create an Enumerator Using an Iterator to Create an Enumerable

Common Iterator Patterns Producing Multiple Enumerables Iterators As Properties Behind the Scenes with Iterators

CHAPTER 19: Introduction to LINQ

What Is LINQ? LINQ Providers

Anonymous Types

Method Syntax and Query Syntax Query Variables The Structure of Query Expressions

The from Clause The join Clause What Is a Join? The from . . . let . . . where Section in the Query Body The orderby Clause The select . . . group Clause Anonymous Types in Queries The group Clause Query Continuation: The into Clause

The Standard Query Operators

Signatures of the Standard Query Operators Query Expressions and the Standard Query Operators Delegates As Parameters The LINQ Predefined Delegate Types Example Using a Delegate Parameter Example Using a Lambda Expression Parameter

LINQ to XML

Markup Languages XML Basics The XML Classes Working with XML Attributes Other Types of Nodes Using LINQ Queries with LINQ to XML

CHAPTER 20: Introduction to Asynchronous Programming

What Is Asynchrony?

A Starting Example

The Structure of the async/await Feature What Is An async Method?

The Flow of Control in an Async Method The await Expression Cancelling an async Operation Exception Handling and the await Expression Waiting Synchronously for Tasks in the Calling Method Waiting Asynchronously for Tasks in the async Method The Task.Delay Method

Async Operations in GUI Programs

Task.Yield

Using an async Lambda Expression A Full GUI Example The BackgroundWorker Class

Example of the BackgroundWorker Class in a WPF Program

Parallel Loops Other Asynchronous Programming Patterns BeginInvoke and EndInvoke

The Wait-Until-Done Pattern The AsyncResult Class The Polling Pattern The Callback Pattern

Timers

CHAPTER 21: Namespaces and Assemblies

Referencing Other Assemblies

The mscorlib Library

Namespaces

Namespace Names More About Namespaces Namespaces Spread Across Files Nesting Namespaces

The using Directives

The using Namespace Directive The using Alias Directive

The Structure of an Assembly The Identity of an Assembly Strongly Named Assemblies

Creating a Strongly Named Assembly

Private Deployment of an Assembly Shared Assemblies and the GAC

Installing Assemblies into the GAC Side-by-Side Execution in the GAC

Configuration Files Delayed Signing

CHAPTER 22: Exceptions

What Are Exceptions? The try Statement

Handling the Exception

The Exception Classes The catch Clause Examples Using Specific catch Clauses The catch Clauses Section The finally Block Finding a Handler for an Exception Searching Further

General Algorithm Example of Searching Down the Call Stack

Throwing Exceptions Throwing Without an Exception Object

CHAPTER 23: Preprocessor Directives

What Are Preprocessor Directives? General Rules The #define and #undef Directives Conditional Compilation The Conditional Compilation Constructs Diagnostic Directives Line Number Directives Region Directives The #pragma warning Directive

CHAPTER 24: Reflection and Attributes

Metadata and Reflection The Type Class Getting a Type Object What Is an Attribute? Applying an Attribute Predefined, Reserved Attributes

The Obsolete Attribute The Conditional Attribute The Caller Information Attributes The DebuggerStepThrough Attribute Other Predefined Attributes

More About Applying Attributes

Multiple Attributes Other Types of Targets Global Attributes

Custom Attributes

Declaring a Custom Attribute Using Attribute Constructors Specifying the Constructor Using the Constructor Positional and Named Parameters in Constructors Restricting the Usage of an Attribute Suggested Practices for Custom Attributes

Accessing an Attribute

Using the IsDefined Method Using the GetCustomAttributes Method

CHAPTER 25: Other Topics

Overview Strings The StringBuilder Class Parsing Strings to Data Values More About the Nullable Types

Assigning to a Nullable Type The Null Coalescing Operator Using Nullable User-Defined Types

Method Main

Accessibility of Main

Documentation Comments

Inserting Documentation Comments Using Other XML Tags

Nested Types

Example of a Nested Class Visibility and Nested Types

Destructors and the Dispose Pattern

The Standard Dispose Pattern Comparing Constructors and Destructors

Interoperating with COM

Index

← Prev
Back
Next →

← Prev
Back
Next →