Home Page Icon
Home Page
Table of Contents for
Images
Close
Images
by Eric Lippert, Mark Michaelis
Essential C# 6.0
About This eBook
Title Page
Copyright Page
Dedication Page
Contents at a Glance
Contents
Figures
Tables
Foreword
Preface
Target Audience for This Book
Features of This Book
C# Coding Guidelines
Code Samples
Mind Maps
Helpful Notes
How This Book Is Organized
Acknowledgments
About the Authors
1. Introducing C#
Hello, World
Compiling and Running the Application
C# Syntax Fundamentals
C# Keywords
Identifiers
Type Definition
Main
Statements and Statement Delimiters
Whitespace
Working with Variables
Data Types
Declaring a Variable
Assigning a Variable
Using a Variable
Console Input and Output
Getting Input from the Console
Writing Output to the Console
Comments
Application Programming Interface
Managed Execution and the Common Language Infrastructure
C# and .NET Versioning
Common Intermediate Language and ILDASM
Summary
2. Data Types
Fundamental Numeric Types
Integer Types
Floating-Point Types (float, double)
Decimal Type
Literal Values
More Fundamental Types
Boolean Type (bool)
Character Type (char)
Strings
null and void
null
The void “Type”
Categories of Types
Value Types
Reference Types
Nullable Modifier
Conversions between Data Types
Explicit Cast
Implicit Conversion
Type Conversion without Casting
Arrays
Declaring an Array
Instantiating and Assigning Arrays
Using an Array
Strings As Arrays
Common Array Errors
Summary
3. Operators and Control Flow
Operators
Plus and Minus Unary Operators (+, -)
Arithmetic Binary Operators (+, -, *, /, %)
Compound Assignment Operators (+=, -=, *=, /=, %=)
Increment and Decrement Operators (++, --)
Constant Expressions and Constant Locals
Introducing Flow Control
if Statement
Nested if
Code Blocks ({})
Code Blocks, Scopes, and Declaration Spaces
Boolean Expressions
Relational and Equality Operators
Logical Boolean Operators
Logical Negation Operator (!)
Conditional Operator (?:)
Null-Coalescing Operator (??)
Null-Conditional Operator (?.)
Bitwise Operators (<<, >>, |, &, ^, ~)
Shift Operators (<<, >>, <<=, >>=)
Bitwise Operators (&, |, ^)
Bitwise Compound Assignment Operators (&=, |=, ^=)
Bitwise Complement Operator (~)
Control Flow Statements, Continued
The while and do/while Loops
The for Loop
The foreach Loop
The switch Statement
Jump Statements
The break Statement
The continue Statement
The goto Statement
C# Preprocessor Directives
Excluding and Including Code (#if, #elif, #else, #endif)
Defining Preprocessor Symbols (#define, #undef)
Emitting Errors and Warnings (#error, #warning)
Turning Off Warning Messages (#pragma)
nowarn:<warn list> Option
Specifying Line Numbers (#line)
Hints for Visual Editors (#region, #endregion)
Summary
4. Methods and Parameters
Calling a Method
Namespaces
Type Name
Scope
Method Name
Parameters and Arguments
Method Return Values
Statement versus Method Call
Declaring a Method
Formal Parameter Declaration
Method Return Type Declaration
Expression Bodied Methods
The using Directive
The using static Directive
Aliasing
Returns and Parameters on Main()
Advanced Method Parameters
Value Parameters
Reference Parameters (ref)
Output Parameters (out)
Parameter Arrays (params)
Recursion
Method Overloading
Optional Parameters
Basic Error Handling with Exceptions
Trapping Errors
Reporting Errors Using a throw Statement
Summary
5. Classes
Declaring and Instantiating a Class
Instance Fields
Declaring an Instance Field
Accessing an Instance Field
Instance Methods
Using the this Keyword
Access Modifiers
Properties
Declaring a Property
Automatically Implemented Properties
Property and Field Guidelines
Using Properties with Validation
Read-Only and Write-Only Properties
Properties As Virtual Fields
Access Modifiers on Getters and Setters
Properties and Method Calls Not Allowed As ref or out Parameter Values
Constructors
Declaring a Constructor
Default Constructors
Object Initializers
Overloading Constructors
Constructor Chaining: Calling Another Constructor Using this
Static Members
Static Fields
Static Methods
Static Constructors
Static Properties
Static Classes
Extension Methods
Encapsulating the Data
const
readonly
Nested Classes
Partial Classes
Defining a Partial Class
Partial Methods
Summary
6. Inheritance
Derivation
Casting between Base and Derived Types
private Access Modifier
protected Access Modifier
Extension Methods
Single Inheritance
Sealed Classes
Overriding the Base Class
virtual Modifier
new Modifier
sealed Modifier
base Member
Constructors
Abstract Classes
All Classes Derive from System.Object
Verifying the Underlying Type with the is Operator
Conversion Using the as Operator
Summary
7. Interfaces
Introducing Interfaces
Polymorphism through Interfaces
Interface Implementation
Explicit Member Implementation
Implicit Member Implementation
Explicit versus Implicit Interface Implementation
Converting between the Implementing Class and Its Interfaces
Interface Inheritance
Multiple Interface Inheritance
Extension Methods on Interfaces
Implementing Multiple Inheritance via Interfaces
Versioning
Interfaces Compared with Classes
Interfaces Compared with Attributes
Summary
8. Value Types
Structs
Initializing Structs
Using the default Operator
Inheritance and Interfaces with Value Types
Boxing
Enums
Type Compatibility between Enums
Converting between Enums and Strings
Enums As Flags
Summary
9. Well-Formed Types
Overriding object Members
Overriding ToString()
Overriding GetHashCode()
Overriding Equals()
Operator Overloading
Comparison Operators (==, !=, <, >, <=, >=)
Binary Operators (+, -, *, /, %, &, |, ^, <<, >>)
Combining Assignment with Binary Operators (+=, -=, *=, /=, %=, &=, ...)
Conditional Logical Operators (&&, ||)
Unary Operators (+, -, !, ~, ++, --, true, false)
Conversion Operators
Guidelines for Conversion Operators
Referencing Other Assemblies
Changing the Assembly Target
Referencing an Assembly
Defining Namespaces
Namespace Alias Qualifier
XML Comments
Associating XML Comments with Programming Constructs
Generating an XML Documentation File
Garbage Collection
Weak References
Resource Cleanup
Finalizers
Deterministic Finalization with the using Statement
Garbage Collection, Finalization, and IDisposable
Lazy Initialization
Summary
10. Exception Handling
Multiple Exception Types
Catching Exceptions
Rethrowing an Existing Exception
General Catch Block
Guidelines for Exception Handling
Defining Custom Exceptions
Rethrowing a Wrapped Exception
Summary
11. Generics
C# without Generics
Introducing Generic Types
Using a Generic Class
Defining a Simple Generic Class
Benefits of Generics
Type Parameter Naming Guidelines
Generic Interfaces and Structs
Defining a Constructor and a Finalizer
Specifying a Default Value
Multiple Type Parameters
Arity in Abundance
Nested Generic Types
Constraints
Interface Constraints
Class Type Constraints
struct/class Constraints
Multiple Constraints
Constructor Constraints
Constraint Inheritance
Generic Methods
Generic Method Type Inference
Specifying Constraints
Covariance and Contravariance
Enabling Covariance with the out Type Parameter Modifier in C# 4.0
Enabling Contravariance with the in Type Parameter Modifier in C# 4.0
Support for Unsafe Covariance in Arrays
Generic Internals
Summary
12. Delegates and Lambda Expressions
Introducing Delegates
Defining the Scenario
Delegate Data Types
Declaring a Delegate Type
Instantiating a Delegate
Lambda Expressions
Statement Lambdas
Expression Lambdas
Anonymous Methods
General-Purpose Delegates: System.Func and System.Action
Delegates Do Not Have Structural Equality
Outer Variables
Expression Trees
Summary
13. Events
Coding the Observer Pattern with Multicast Delegates
Defining Subscriber Methods
Defining the Publisher
Hooking up the Publisher and Subscribers
Invoking a Delegate
Check for null
Delegate Operators
Sequential Invocation
Error Handling
Method Returns and Pass-by-Reference
Events
Why Events?
Declaring an Event
Coding Conventions
Generics and Delegates
Customizing the Event Implementation
Summary
14. Collection Interfaces with Standard Query Operators
Anonymous Types and Implicitly Typed Local Variables
Anonymous Types
Implicitly Typed Local Variables (var)
More about Anonymous Types and Implicit Local Variables
Collection Initializers
What Makes a Class a Collection: IEnumerable<T>
foreach with Arrays
foreach with IEnumerable<T>
Do Not Modify Collections during foreach Iteration
Standard Query Operators
Filtering with Where()
Projecting with Select()
Counting Elements with Count()
Deferred Execution
Sorting with OrderBy() and ThenBy()
Performing an Inner Join with Join()
Grouping Results with GroupBy()
Implementing a One-to-Many Relationship with GroupJoin()
Calling SelectMany()
More Standard Query Operators
Summary
15. LINQ with Query Expressions
Introducing Query Expressions
Projection
Filtering
Sorting
The let Clause
Grouping
Query Continuation with into
“Flattening” Sequences of Sequences with Multiple from Clauses
Query Expressions Are Just Method Invocations
Summary
16. Building Custom Collections
More Collection Interfaces
IList<T> versus IDictionary<TKey, TValue>
ICollection<T>
Primary Collection Classes
List Collections: List<T>
Total Ordering
Searching a List<T>
Dictionary Collections: Dictionary<TKey, TValue>
Sorted Collections: SortedDictionary<TKey, TValue> and SortedList<T>
Stack Collections: Stack<T>
Queue Collections: Queue<T>
Linked Lists: LinkedList<T>
Providing an Indexer
Returning Null or an Empty Collection
Iterators
Defining an Iterator
Iterator Syntax
Yielding Values from an Iterator
Iterators and State
More Iterator Examples
Placing a yield return within a Loop
Canceling Further Iteration: yield break
Creating Multiple Iterators in a Single Class
yield Statement Requirements
Summary
17. Reflection, Attributes, and Dynamic Programming
Reflection
Accessing Metadata Using System.Type
Member Invocation
Reflection on Generic Types
nameof Operator
Attributes
Custom Attributes
Looking for Attributes
Initializing an Attribute through a Constructor
System.AttributeUsageAttribute
Named Parameters
Programming with Dynamic Objects
Invoking Reflection Using dynamic
dynamic Principles and Behaviors
Why Dynamic Binding?
Static Compilation versus Dynamic Programming
Implementing a Custom Dynamic Object
Summary
18. Multithreading
Multithreading Basics
Working with System.Threading
Asynchronous Operations with System.Threading.Thread
Thread Management
Do Not Put Threads to Sleep in Production Code
Do Not Abort Threads in Production Code
Thread Pooling
Asynchronous Tasks
From Thread to Task
Introducing Asynchronous Tasks
Task Continuation
Unhandled Exception Handling on Task with AggregateException
Canceling a Task
Task.Run(): A Shortcut and Simplification to Task.Factory.StartNew()
Long-Running Tasks
Tasks Are Disposable
The Task-Based Asynchronous Pattern
Synchronously Invoking a High-Latency Operation
Asynchronously Invoking a High-Latency Operation Using the TPL
The Task-Based Asynchronous Pattern with async and await
Asynchronous Lambdas
Task Schedulers and the Synchronization Context
async/await with the Windows UI
await Operators
Executing Loop Iterations in Parallel
Canceling a Parallel Loop
Running LINQ Queries in Parallel
Canceling a PLINQ Query
Summary
19. Thread Synchronization
Why Synchronization?
Synchronization Using Monitor
Using the lock Keyword
Choosing a lock Object
Why to Avoid Locking on this, typeof(type), and string
Declaring Fields As volatile
Using the System.Threading.Interlocked Class
Event Notification with Multiple Threads
Synchronization Design Best Practices
More Synchronization Types
Thread Local Storage
Timers
Summary
20. Platform Interoperability and Unsafe Code
Platform Invoke
Declaring External Functions
Parameter Data Types
Using ref Rather Than Pointers
Using StructLayoutAttribute for Sequential Layout
Error Handling
Using SafeHandle
Calling External Functions
Simplifying API Calls with Wrappers
Function Pointers Map to Delegates
Guidelines
Pointers and Addresses
Unsafe Code
Pointer Declaration
Assigning a Pointer
Dereferencing a Pointer
Accessing the Member of a Referent Type
Executing Unsafe Code via a Delegate
Using the Windows Runtime Libraries from C#
WinRT Events with Custom Add and Remove Handlers
Automatically Shimmed Interfaces
Task-Based Asynchrony
Summary
21. The Common Language Infrastructure
Defining the Common Language Infrastructure
CLI Implementations
C# Compilation to Machine Code
Runtime
Garbage Collection
Garbage Collection on .NET
Type Safety
Code Access Security
Platform Portability
Performance
Application Domains
Assemblies, Manifests, and Modules
Common Intermediate Language
Common Type System
Common Language Specification
Base Class Library
Metadata
Summary
A. Downloading and Installing the C# Compiler and CLI Platform
Microsoft .NET for Windows
Visual Studio Compilation
Setting up the Compiler Path for Command-Line Compilation
.NET on OS X and Linux
.NET Core
Mono
B. Tic-Tac-Toe Source Code Listing
Index
Index of 6.0 Topics
Index of 5.0 Topics
Index of 4.0 Topics
Index of 3.0 Topics
C. Interfacing with Multithreading Patterns prior to the TPL and C# 6.0
Asynchronous Programming Model
Using the APM Pattern
Calling APM Methods Using the TPL
Asynchronous Delegate Invocation
The Event-Based Asynchronous Pattern
Background Worker Pattern
Establishing the Pattern
Exception Handling
Dispatching to the Windows UI
Windows Forms
Windows Presentation Foundation
D. Timers Prior to the Async/Await Pattern of C# 5.0
Search in book...
Toggle Font Controls
Playlists
Add To
Create new playlist
Name your new playlist
Playlist description (optional)
Cancel
Create playlist
Sign In
Email address
Password
Forgot Password?
Create account
Login
or
Continue with Facebook
Continue with Google
Sign Up
Full Name
Email address
Confirm Email Address
Password
Login
Create account
or
Continue with Facebook
Continue with Google
Prev
Previous Chapter
Images
Next
Next Chapter
Images
Add Highlight
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click
here
login for view all page.
Day Mode
Cloud Mode
Night Mode
Reset