C# 5.0 in a Nutshell · 5th Edition by Albahari, Joseph -- Read -- Imperial Library of Trantor

Index

C# 5.0 in a Nutshell Preface

Intended Audience How This Book Is Organized What You Need to Use This Book Conventions Used in This Book Using Code Examples Safari® Books Online How to Contact Us Acknowledgments

Joseph Albahari Ben Albahari

1. Introducing C# and the .NET Framework

Object Orientation Type Safety Memory Management Platform Support C#’s Relationship with the CLR The CLR and .NET Framework C# and Windows Runtime What’s New in C# 5.0 What’s New in C# 4.0 What’s New in C# 3.0

2. C# Language Basics

A First C# Program

Compilation

Syntax

Identifiers and Keywords

Avoiding conflicts Contextual keywords

Literals, Punctuators, and Operators Comments

Type Basics

Predefined Type Examples Custom Type Examples

Members of a type Symmetry of predefined types and custom types Constructors and instantiation Instance versus static members The public keyword

Conversions Value Types Versus Reference Types

Value types Reference types Null Storage overhead

Predefined Type Taxonomy

Numeric Types

Numeric Literals

Numeric literal type inference Numeric suffixes

Numeric Conversions

Integral to integral conversions Floating-point to floating-point conversions Floating-point to integral conversions Decimal conversions

Arithmetic Operators Increment and Decrement Operators Specialized Integral Operations

Integral division Integral overflow Integral arithmetic overflow check operators Overflow checking for constant expressions Bitwise operators

8- and 16-Bit Integrals Special Float and Double Values double Versus decimal Real Number Rounding Errors

Boolean Type and Operators

Bool Conversions Equality and Comparison Operators Conditional Operators

Strings and Characters

Char Conversions String Type

String concatenation String comparisons

Arrays

Default Element Initialization

Value types versus reference types

Multidimensional Arrays

Rectangular arrays Jagged arrays

Simplified Array Initialization Expressions Bounds Checking

Variables and Parameters

The Stack and the Heap

Stack Heap

Definite Assignment Default Values Parameters

Passing arguments by value The ref modifier The out modifier Implications of passing by reference The params modifier Optional parameters Named arguments

var—Implicitly Typed Local Variables

Expressions and Operators

Primary Expressions Void Expressions Assignment Expressions Operator Precedence and Associativity

Precedence Left-associative operators Right-associative operators

Operator Table

Statements

Declaration Statements

Local variables

Expression Statements Selection Statements

The if statement The else clause Changing the flow of execution with braces The switch statement

Iteration Statements

while and do-while loops for loops foreach loops

Jump Statements

The break statement The continue statement The goto statement The return statement The throw statement

Miscellaneous Statements

Namespaces

The using Directive Rules Within a Namespace

Name scoping Name hiding Repeated namespaces Nested using directive

Aliasing Types and Namespaces Advanced Namespace Features

Extern Namespace alias qualifiers

3. Creating Types in C#

Classes

Fields

The readonly modifier Field initialization Declaring multiple fields together

Methods

Overloading methods Pass-by-value versus pass-by-reference

Instance Constructors

Overloading constructors Implicit parameterless constructors Constructor and field initialization order Nonpublic constructors

Object Initializers The this Reference Properties

Read-only and calculated properties Automatic properties get and set accessibility CLR property implementation

Indexers

Implementing an indexer CLR indexer implementation

Constants Static Constructors

Static constructors and field initialization order

Static Classes Finalizers Partial Types and Methods

Partial methods

Inheritance

Polymorphism Casting and Reference Conversions

Upcasting Downcasting The as operator The is operator

Virtual Function Members Abstract Classes and Abstract Members Hiding Inherited Members

new versus override

Sealing Functions and Classes The base Keyword Constructors and Inheritance

Implicit calling of the parameterless base-class constructor Constructor and field initialization order

Overloading and Resolution

The object Type

Boxing and Unboxing

Copying semantics of boxing and unboxing

Static and Runtime Type Checking The GetType Method and typeof Operator The ToString Method Object Member Listing

Structs

Struct Construction Semantics

Access Modifiers

Examples Friend Assemblies Accessibility Capping Restrictions on Access Modifiers

Interfaces

Extending an Interface Explicit Interface Implementation Implementing Interface Members Virtually Reimplementing an Interface in a Subclass

Alternatives to interface reimplementation

Interfaces and Boxing

Enums

Enum Conversions Flags Enums Enum Operators Type-Safety Issues

Nested Types Generics

Generic Types Why Generics Exist Generic Methods Declaring Type Parameters typeof and Unbound Generic Types The default Generic Value Generic Constraints Subclassing Generic Types Self-Referencing Generic Declarations Static Data Type Parameters and Conversions Covariance

Classes Arrays Interfaces

Contravariance C# Generics Versus C++ Templates

4. Advanced C#

Delegates

Writing Plug-in Methods with Delegates Multicast Delegates

Multicast delegate example

Instance Versus Static Method Targets Generic Delegate Types The Func and Action Delegates Delegates Versus Interfaces Delegate Compatibility

Type compatibility Parameter compatibility Return type compatibility Generic delegate type parameter variance

Events

Standard Event Pattern Event Accessors Event Modifiers

Lambda Expressions

Explicitly Specifying Lambda Parameter Types Capturing Outer Variables

Capturing iteration variables

Anonymous Methods try Statements and Exceptions

The catch Clause The finally Block

The using statement

Throwing Exceptions

Rethrowing an exception

Key Properties of System.Exception Common Exception Types The TryXXX Method Pattern Alternatives to Exceptions

Enumeration and Iterators

Enumeration Collection Initializers Iterators Iterator Semantics

yield break Iterators and try/catch/finally blocks

Composing Sequences

Nullable Types

Nullable <T> Struct

Implicit and explicit nullable conversions Boxing and unboxing nullable values

Operator Lifting

Equality operators (== and !=) Relational operators (<, <=, >=, >) All other operators (+, −, *, /, %, &, |, ^, <<, >>, +, ++, --, !, ~) Mixing nullable and non-nullable operators

bool? with & and | Operators Null Coalescing Operator Scenarios for Nullable Types Alternatives to Nullable Types

Operator Overloading

Operator Functions Overloading Equality and Comparison Operators Custom Implicit and Explicit Conversions Overloading true and false

Extension Methods

Extension Method Chaining Ambiguity and Resolution

Namespaces Extension methods versus instance methods Extension methods versus extension methods

Anonymous Types Dynamic Binding

Static Binding Versus Dynamic Binding Custom Binding Language Binding RuntimeBinderException Runtime Representation of Dynamic Dynamic Conversions var Versus dynamic Dynamic Expressions Dynamic Calls without Dynamic Receivers Static Types in Dynamic Expressions Uncallable Functions

Attributes

Attribute Classes Named and Positional Attribute Parameters Attribute Targets Specifying Multiple Attributes

Caller Info Attributes (C# 5) Unsafe Code and Pointers

Pointer Basics Unsafe Code The fixed Statement The Pointer-to-Member Operator Arrays

The stackalloc keyword Fixed-size buffers

void* Pointers to Unmanaged Code

Preprocessor Directives

Conditional Attributes Pragma Warning

XML Documentation

Standard XML Documentation Tags User-Defined Tags Type or Member Cross-References

5. Framework Overview

The CLR and Core Framework

System Types Text Processing Collections Queries XML Diagnostics and Code Contracts Concurrency and Asynchrony Streams and I/O Networking Serialization Assemblies, Reflection, and Attributes Dynamic Programming Security Advanced Threading Parallel Programming Application Domains Native and COM Interoperability

Applied Technologies

User Interface Technologies

ASP.NET Silverlight Metro Windows Presentation Foundation (WPF) Windows Forms

Backend Technologies

ADO.NET Windows Workflow COM+ and MSMQ

Distributed System Technologies

Windows Communication Foundation (WCF) Remoting and .ASMX Web Services CardSpace

6. Framework Fundamentals

String and Text Handling

Char String

Constructing strings Null and empty strings Accessing characters within a string Searching within strings Manipulating strings Splitting and joining strings String.Format and composite format strings

Comparing Strings

Ordinal versus culture comparison String equality comparison String order comparison

StringBuilder Text Encodings and Unicode

Obtaining an Encoding object Encoding for file and stream I/O Encoding to byte arrays UTF-16 and surrogate pairs

Dates and Times

TimeSpan DateTime and DateTimeOffset

Choosing between DateTime and DateTimeOffset Constructing a DateTime Constructing a DateTimeOffset The current DateTime/DateTimeOffset Working with dates and times Formatting and parsing Null DateTime and DateTimeOffset values

Dates and Time Zones

DateTime and Time Zones DateTimeOffset and Time Zones TimeZone and TimeZoneInfo

TimeZone TimeZoneInfo

Daylight Saving Time and DateTime

Formatting and Parsing

ToString and Parse Format Providers

Format providers and CultureInfo Using NumberFormatInfo or DateTimeFormatInfo Composite formatting Parsing with format providers IFormatProvider and ICustomFormatter

Standard Format Strings and Parsing Flags

Numeric Format Strings NumberStyles Date/Time Format Strings

Parsing and misparsing DateTimes

DateTimeStyles Enum Format Strings

Other Conversion Mechanisms

Convert

Rounding real to integral conversions Parsing numbers in base 2, 8, and 16 Dynamic conversions Base 64 conversions

XmlConvert Type Converters BitConverter

Globalization

Globalization Checklist Testing

Working with Numbers

Conversions Math BigInteger Complex Random

Enums

Enum Conversions

Enum to integral conversions Integral to enum conversions String conversions

Enumerating Enum Values How Enums Work

Tuples

Comparing Tuples

The Guid Struct Equality Comparison

Value Versus Referential Equality Standard Equality Protocols

== and != The virtual Object.Equals method The static object.Equals method The static object.ReferenceEquals method The IEquatable<T> interface When Equals and == are not equal

Equality and Custom Types

Changing the meaning of equality Speeding up equality comparisons with structs How to override equality semantics Overriding GetHashCode Overriding Equals Overloading == and != Implementing IEquatable<T> An example: The Area struct Pluggable equality comparers

Order Comparison

IComparable

IComparable versus Equals

< and > Implementing the IComparable Interfaces

Utility Classes

Console Environment Process

7. Collections

Enumeration

IEnumerable and IEnumerator IEnumerable<T> and IEnumerator<T>

IEnumerable<T> and IDisposable

Implementing the Enumeration Interfaces

The ICollection and IList Interfaces

ICollection<T> and ICollection IList<T> and IList IReadOnlyList<T>

The Array Class

Construction and Indexing Enumeration Length and Rank Searching Sorting Reversing Elements Copying Converting and Resizing

Lists, Queues, Stacks, and Sets

List<T> and ArrayList LinkedList<T> Queue<T> and Queue Stack<T> and Stack BitArray HashSet<T> and SortedSet<T>

Dictionaries

IDictionary<TKey,TValue> IDictionary Dictionary<TKey,TValue> and Hashtable OrderedDictionary ListDictionary and HybridDictionary Sorted Dictionaries

Customizable Collections and Proxies

Collection<T> and CollectionBase

CollectionBase

KeyedCollection<TKey,TItem> and DictionaryBase

DictionaryBase

ReadOnlyCollection<T>

Plugging in Equality and Order

IEqualityComparer and EqualityComparer

EqualityComparer<T>.Default

IComparer and Comparer StringComparer IStructuralEquatable and IStructuralComparable

8. LINQ Queries

Getting Started Fluent Syntax

Chaining Query Operators

Why extension methods are important

Composing Lambda Expressions

Lambda expressions and Func signatures Lambda expressions and element typing

Natural Ordering Other Operators

Query Expressions

Range Variables Query Syntax Versus SQL Syntax Query Syntax Versus Fluent Syntax Mixed Syntax Queries

Deferred Execution

Reevaluation Captured Variables How Deferred Execution Works Chaining Decorators How Queries Are Executed

Subqueries

Subqueries and Deferred Execution

Composition Strategies

Progressive Query Building The into Keyword

Scoping rules

Wrapping Queries

Projection Strategies

Object Initializers Anonymous Types The let Keyword

Interpreted Queries

How Interpreted Queries Work

Execution

Combining Interpreted and Local Queries AsEnumerable

LINQ to SQL and Entity Framework

LINQ to SQL Entity Classes Entity Framework Entity Classes DataContext and ObjectContext

Typed contexts Object tracking

Associations Deferred Execution with L2S and EF DataLoadOptions

Specifying a filter in advance Eager loading

Eager Loading in Entity Framework Updates API Differences Between L2S and EF

Building Query Expressions

Delegates Versus Expression Trees

Compiling expression trees AsQueryable

Expression Trees

The Expression DOM

9. LINQ Operators

Overview

Sequence→Sequence

Filtering Projecting Joining Ordering Grouping Set operators Conversion methods: Import Conversion methods: Export

Sequence→Element or Value

Element operators Aggregation methods Quantifiers

Void→Sequence

Generation methods

Filtering

Where

Query syntax Enumerable.Where implementation Overview Indexed filtering SQL LIKE comparisons in LINQ to SQL and EF < and > string comparisons in LINQ to SQL and EF WHERE x IN (..., ..., ...) in LINQ to SQL and EF

Take and Skip TakeWhile and SkipWhile Distinct

Projecting

Select

Query syntax Enumerable implementation Overview Indexed projection Select subqueries and object hierarchies Subqueries and joins in LINQ to SQL and EF Projecting into concrete types

SelectMany

Query syntax Enumerable implementation Overview Multiple range variables Thinking in query syntax Joining with SelectMany SelectMany in LINQ to SQL and EF Outer joins with SelectMany

Joining

Join and GroupJoin

Join arguments GroupJoin arguments Query syntax Overview Join Joining on multiple keys Joining in fluent syntax GroupJoin Flat outer joins Joining with lookups Enumerable implementations

The Zip Operator

Ordering

OrderBy, OrderByDescending, ThenBy, and ThenByDescending

OrderBy and OrderByDescending arguments ThenBy and ThenByDescending arguments Query syntax Overview Comparers and collations IOrderedEnumerable and IOrderedQueryable

Grouping

GroupBy

Query syntax Overview GroupBy in LINQ to SQL and EF Grouping by multiple keys Custom equality comparers

Set Operators

Concat and Union Intersect and Except

Conversion Methods

OfType and Cast ToArray, ToList, ToDictionary, and ToLookup AsEnumerable and AsQueryable

Element Operators

First, Last, and Single ElementAt DefaultIfEmpty

Aggregation Methods

Count and LongCount Min and Max Sum and Average Aggregate

Unseeded aggregations Traps with unseeded aggregations

Quantifiers

Contains and Any All and SequenceEqual

Generation Methods

Empty Range and Repeat

10. LINQ to XML

Architectural Overview

What Is a DOM? The LINQ to XML DOM

X-DOM Overview

Loading and Parsing Saving and Serializing

Instantiating an X-DOM

Functional Construction Specifying Content Automatic Deep Cloning

Navigating and Querying

Child Node Navigation

FirstNode, LastNode, and Nodes Retrieving elements Retrieving a single element Retrieving descendants

Parent Navigation Peer Node Navigation Attribute Navigation

Updating an X-DOM

Simple Value Updates Updating Child Nodes and Attributes Updating through the Parent

Removing a sequence of nodes or attributes

Working with Values

Setting Values Getting Values Values and Mixed Content Nodes Automatic XText Concatenation

Documents and Declarations

XDocument XML Declarations

Writing a declaration to a string

Names and Namespaces

Namespaces in XML

Prefixes Attributes

Specifying Namespaces in the X-DOM The X-DOM and Default Namespaces Prefixes

Annotations Projecting into an X-DOM

Eliminating Empty Elements Streaming a Projection Transforming an X-DOM

Advanced transformations

11. Other XML Technologies

XmlReader

Reading Nodes Reading Elements

Optional elements Random element order Empty elements Other ReadXXX methods

Reading Attributes

Attribute nodes

Namespaces and Prefixes

XmlWriter

Writing Attributes Writing Other Node Types Namespaces and Prefixes

Patterns for Using XmlReader/XmlWriter

Working with Hierarchical Data Mixing XmlReader/XmlWriter with an X-DOM

Using XmlReader with XElement Using XmlWriter with XElement

XmlDocument

Loading and Saving an XmlDocument Traversing an XmlDocument InnerText and InnerXml Creating and Manipulating Nodes Namespaces

XPath

Common XPath Operators XPathNavigator Querying with Namespaces XPathDocument

XSD and Schema Validation

Performing Schema Validation

Validating with an XmlReader Validating an X-DOM or XmlDocument

XSLT

12. Disposal and Garbage Collection

IDisposable, Dispose, and Close

Standard Disposal Semantics

Close and Stop

When to Dispose Opt-in Disposal Clearing Fields in Disposal

Automatic Garbage Collection

Roots Garbage Collection and WinRT

Finalizers

Calling Dispose from a Finalizer Resurrection

GC.ReRegisterForFinalize

How the Garbage Collector Works

Optimization Techniques

Generational collection The large object heap Concurrent and background collection GC notifications (server CLR)

Forcing Garbage Collection Memory Pressure

Managed Memory Leaks

Timers Diagnosing Memory Leaks

Weak References

Weak References and Caching Weak References and Events

13. Diagnostics and Code Contracts

Conditional Compilation

Conditional Compilation Versus Static Variable Flags The Conditional Attribute

Alternatives to the Conditional attribute

Debug and Trace Classes

Fail and Assert TraceListener Flushing and Closing Listeners

Code Contracts Overview

Why Use Code Contracts? Contract Principles

Compilation The binary rewriter Asserting versus throwing on failure Purity

Preconditions

Contract.Requires Contract.Requires<TException> Contract.EndContractBlock Preconditions and Overridden Methods

Postconditions

Contract.Ensures Contract.EnsuresOnThrow<TException> Contract.Result<T> and Contract.ValueAtReturn<T> Contract.OldValue<T> Postconditions and Overridden Methods

Assertions and Object Invariants

Assertions

Contract.Assert Contract.Assume

Object Invariants

Contracts on Interfaces and Abstract Methods Dealing with Contract Failure

The ContractFailed Event Exceptions Within Contract Conditions

Selectively Enforcing Contracts

Contracts in Release Builds Call-Site Checking

Static Contract Checking

The ContractVerification Attribute Baselines The SuppressMessage Attribute

Debugger Integration

Attaching and Breaking Debugger Attributes

Processes and Process Threads

Examining Running Processes Examining Threads in a Process

StackTrace and StackFrame Windows Event Logs

Writing to the Event Log Reading the Event Log Monitoring the Event Log

Performance Counters

Enumerating the Available Counters Reading Performance Counter Data Creating Counters and Writing Performance Data

The Stopwatch Class

14. Concurrency & Asynchrony

Introduction Threading

Creating a Thread Join and Sleep Blocking

I/O-bound versus compute-bound Blocking versus spinning

Local Versus Shared State Locking and Thread Safety Passing Data to a Thread

Lambda expressions and captured variables

Exception Handling

Centralized exception handling

Foreground Versus Background Threads Thread Priority Signaling Threading in Rich Client Applications Synchronization Contexts The Thread Pool

Entering the thread pool Hygiene in the thread pool

Tasks

Starting a Task

Wait Long-running tasks

Returning values Exceptions

Exceptions and autonomous tasks

Continuations TaskCompletionSource Task.Delay

Principles of Asynchrony

Synchronous Versus Asynchronous Operations What is Asynchronous Programming? Asynchronous Programming and Continuations Why Language Support is Important

Asynchronous Functions in C# 5.0

Awaiting

Capturing local state Awaiting in a UI Comparison to course-grained concurrency

Writing Asynchronous Functions

Returning Task<TResult> Asynchronous call graph execution Parallelism

Asynchronous Lambda Expressions Asynchronous Methods in WinRT Asynchrony and Synchronization Contexts

Exception posting OperationStarted and OperationCompleted

Optimizations

Completing synchronously Avoiding excessive bouncing

Asynchronous Patterns

Cancellation Progress Reporting

IProgress<T> and Progress<T>

The Task-based Asynchronous Pattern (TAP) Task Combinators

WhenAny WhenAll Custom combinators

Obsolete Patterns

Asynchronous Programming Model (APM)

Asynchronous delegates

Event-Based Asynchronous Pattern (EAP) BackgroundWorker

15. Streams and I/O

Stream Architecture Using Streams

Reading and Writing Seeking Closing and Flushing Timeouts Thread Safety Backing Store Streams FileStream

Constructing a FileStream Specifying a filename Specifying a FileMode Advanced FileStream features

MemoryStream PipeStream

Named pipes Anonymous pipes

BufferedStream

Stream Adapters

Text Adapters

StreamReader and StreamWriter Character encodings StringReader and StringWriter

Binary Adapters Closing and Disposing Stream Adapters

Compression Streams

Compressing in Memory

Working with Zip Files File and Directory Operations

The File Class

Compression and encryption attributes File security

The Directory Class FileInfo and DirectoryInfo Path Special Folders Querying Volume Information Catching Filesystem Events

File I/O in Windows Runtime

Working with Directories Working with Files Isolated Storage in Metro Apps

Memory-Mapped Files

Memory-Mapped Files and Random File I/O Memory-Mapped Files and Shared Memory Working with View Accessors

Isolated Storage

Isolation Types Reading and Writing Isolated Storage Store Location Enumerating Isolated Storage

16. Networking

Network Architecture Addresses and Ports URIs Client-Side Classes

WebClient WebRequest and WebResponse HttpClient

GetAsync and response messages SendAsync and request messages Uploading data and HttpContent HttpMessageHandler Unit testing and mocking Chaining handlers with DelegatingHandler

Proxies Authentication

CredentialCache Authenticating via headers with HttpClient

Exception Handling

Working with HTTP

Headers Query Strings Uploading Form Data Cookies Forms Authentication SSL

Writing an HTTP Server Using FTP Using DNS Sending Mail with SmtpClient Using TCP

Concurrency with TCP

Receiving POP3 Mail with TCP TCP in Windows Runtime

17. Serialization

Serialization Concepts

Serialization Engines

Why three engines? The data contract serializer The binary serializer XmlSerializer IXmlSerializable

Formatters Explicit Versus Implicit Serialization

The Data Contract Serializer

DataContractSerializer Versus NetDataContractSerializer Using the Serializers

Specifying a binary formatter

Serializing Subclasses Object References

Preserving object references

Version Tolerance

Required members

Member Ordering Null and Empty Values

Data Contracts and Collections

Subclassed Collection Elements Customizing Collection and Element Names

Extending Data Contracts

Serialization and Deserialization Hooks Interoperating with [Serializable] Interoperating with IXmlSerializable

The Binary Serializer

Getting Started

Binary Serialization Attributes

[NonSerialized] [OnDeserializing] and [OnDeserialized] [OnSerializing] and [OnSerialized] [OptionalField] and Versioning

Binary Serialization with ISerializable

Subclassing Serializable Classes

XML Serialization

Getting Started with Attribute-Based Serialization

Attributes, names, and namespaces XML element order

Subclasses and Child Objects

Subclassing the root type Serializing child objects Subclassing child objects

Serializing Collections

Working with subclassed collection elements

IXmlSerializable

18. Assemblies

What’s in an Assembly

The Assembly Manifest

Specifying assembly attributes

The Application Manifest

Deploying an .NET application manifest

Modules The Assembly Class

Strong Names and Assembly Signing

How to Strongly Name an Assembly Delay Signing

Assembly Names

Fully Qualified Names The AssemblyName Class Assembly Informational and File Versions

Authenticode Signing

How to Sign with Authenticode

Obtaining and installing a certificate Signing with signtool.exe Time stamping Verifying that a program has been signed

Authenticode Validation

The Global Assembly Cache

How to Install Assemblies to the GAC GAC and Versioning

Resources and Satellite Assemblies

Directly Embedding Resources .resources Files .resx Files

Creating a .resx file at the command line Reading .resources files Creating a pack URI resource in Visual Studio

Satellite Assemblies

Building satellite assemblies Testing satellite assemblies Visual Studio designer support

Cultures and Subcultures

Resolving and Loading Assemblies

Assembly and Type Resolution Rules AssemblyResolve Loading Assemblies

Loading from a filename Statically referenced types and LoadFrom/LoadFile Location versus CodeBase

Deploying Assemblies Outside the Base Folder Packing a Single-File Executable

Selective Patching

Working with Unreferenced Assemblies

19. Reflection and Metadata

Reflecting and Activating Types

Obtaining a Type

TypeInfo and Metro applications Obtaining array types Obtaining nested types

Type Names

Nested type names Generic type names Array and pointer type names ref and out parameter type names

Base Types and Interfaces Instantiating Types Generic Types

Reflecting and Invoking Members

Member Types C# Members Versus CLR Members Generic Type Members Dynamically Invoking a Member Method Parameters

Dealing with ref and out parameters Retrieving and invoking generic methods

Using Delegates for Performance Accessing Nonpublic Members

The BindingFlags enum

Generic Methods Anonymously Calling Members of a Generic Interface

Reflecting Assemblies

Loading an Assembly into a Reflection-Only Context Modules

Working with Attributes

Attribute Basics The AttributeUsage Attribute Defining Your Own Attribute Retrieving Attributes at Runtime Retrieving Attributes in the Reflection-Only Context

Dynamic Code Generation

Generating IL with DynamicMethod The Evaluation Stack Passing Arguments to a Dynamic Method Generating Local Variables Branching Instantiating Objects and Calling Instance Methods Exception Handling

Emitting Assemblies and Types

Saving Emitted Assemblies The Reflection.Emit Object Model

Emitting Type Members

Emitting Methods

Generating instance methods HideBySig

Emitting Fields and Properties Emitting Constructors

Calling base constructors

Attaching Attributes

Emitting Generic Methods and Types

Defining Generic Methods Defining Generic Types

Awkward Emission Targets

Uncreated Closed Generics Circular Dependencies

Parsing IL

Writing a Disassembler

20. Dynamic Programming

The Dynamic Language Runtime Numeric Type Unification Dynamic Member Overload Resolution

Simplifying the Visitor Pattern

Variations

Anonymously Calling Members of a Generic Type

Implementing Dynamic Objects

DynamicObject ExpandoObject

Interoperating with Dynamic Languages

Passing State Between C# and a Script

21. Security

Permissions

CodeAccessPermission and PrincipalPermission

IPermission

PermissionSet Declarative Versus Imperative Security

Code Access Security (CAS)

How Code Access Security Is Applied Testing for Full Trust

Allowing Partially Trusted Callers

Elevation of Privilege APTCA and [SecurityTransparent]

The Transparency Model

How the Transparency Model Works

Transparent code Settings the transparency default for an assembly

How to Write APTCA Libraries with Transparency

Securing unsafe methods P/Invokes and [SuppressUnmanagedSecurity]

Transparency in Full-Trust Scenarios

Sandboxing Another Assembly

Asserting Permissions

Operating System Security

Running in a Standard User Account Administrative Elevation and Virtualization

Identity and Role Security

Assigning Users and Roles

Cryptography Overview Windows Data Protection Hashing Symmetric Encryption

Encrypting in Memory Chaining Encryption Streams Disposing Encryption Objects Key Management

Public Key Encryption and Signing

The RSA Class Digital Signing

22. Advanced Threading

Synchronization Overview Exclusive Locking

The lock Statement Monitor.Enter and Monitor.Exit

The lockTaken overloads TryEnter

Choosing the Synchronization Object When to Lock Locking and Atomicity Nested Locking Deadlocks Performance Mutex

Locking and Thread Safety

Thread Safety and .NET Framework Types

Locking around thread-safe objects Static members Read-only thread safety

Thread Safety in Application Servers Immutable Objects

Non-Exclusive Locking

Semaphore Reader/Writer Locks

Upgradeable locks Lock recursion

Signaling with Event Wait Handles

AutoResetEvent

Two-way signaling

ManualResetEvent CountdownEvent Creating a Cross-Process EventWaitHandle Wait Handles and Continuations Converting Wait Handles to Tasks WaitAny, WaitAll, and SignalAndWait

Alternatives to WaitAll and SignalAndWait

The Barrier Class Lazy Initialization

Lazy<T> LazyInitializer

Thread-Local Storage

[ThreadStatic] ThreadLocal<T>

ThreadLocal<T> and instance fields

GetData and SetData

Interrupt and Abort Suspend and Resume Timers

Multithreaded Timers Single-Threaded Timers

23. Parallel Programming

Why PFX?

PFX Concepts PFX Components When to Use PFX

PLINQ

Parallel Execution Ballistics PLINQ and Ordering PLINQ Limitations Example: Parallel Spellchecker

Using ThreadLocal<T>

Functional Purity Setting the Degree of Parallelism

Changing the degree of parallelism

Cancellation Optimizing PLINQ

Output-side optimization Input-side optimization Optimizing custom aggregations

The Parallel Class

Parallel.Invoke Parallel.For and Parallel.ForEach

Outer versus inner loops Indexed Parallel.ForEach ParallelLoopState: Breaking early out of loops Optimization with local values

Task Parallelism

Creating and Starting Tasks

Specifying a state object TaskCreationOptions Child tasks

Waiting on Multiple Tasks Canceling Tasks Continuations

Continuations and Task<TResult> Continuations and exceptions Continuations and child tasks Conditional continuations Continuations with multiple antecedents Multiple continuations on a single antecedent

Task Schedulers TaskFactory

Creating your own task factories

Working with AggregateException

Flatten and Handle

Flatten Handle

Concurrent Collections

IProducerConsumerCollection<T> ConcurrentBag<T>

BlockingCollection<T>

Writing a Producer/Consumer Queue

Leveraging Tasks

24. Application Domains

Application Domain Architecture Creating and Destroying Application Domains Using Multiple Application Domains Using DoCallBack Monitoring Application Domains Domains and Threads Sharing Data Between Domains

Sharing Data via Slots Intra-Process Remoting Isolating Types and Assemblies

Type discovery

25. Native and COM Interoperability

Calling into Native DLLs Type Marshaling

Marshaling Common Types Marshaling Classes and Structs In and Out Marshaling

Callbacks from Unmanaged Code Simulating a C Union Shared Memory Mapping a Struct to Unmanaged Memory

fixed and fixed {...}

COM Interoperability

The Purpose of COM The Basics of the COM Type System

IUnknown and IDispatch

Calling a COM Component from C#

Optional Parameters and Named Arguments Implicit ref Parameters Indexers Dynamic Binding

Embedding Interop Types

Type Equivalence

Primary Interop Assemblies Exposing C# Objects to COM

26. Regular Expressions

Regular Expression Basics

Compiled Regular Expressions RegexOptions Character Escapes Character Sets

Quantifiers

Greedy Versus Lazy Quantifiers

Zero-Width Assertions

Lookahead and Lookbehind Anchors Word Boundaries

Groups

Named Groups

Replacing and Splitting Text

MatchEvaluator Delegate Splitting Text

Cookbook Regular Expressions

Recipes

Matching U.S. Social Security number/phone number Extracting “name = value” pairs (one per line) Strong password validation Lines of at least 80 characters Parsing dates/times (N/N/N H:M:S AM/PM) Matching Roman numerals Removing repeated words Word count Matching a Guid Parsing an XML/HTML tag Splitting a camel-cased word Obtaining a legal filename Escaping Unicode characters for HTML Unescaping characters in an HTTP query string Parsing Google search terms from a web stats log

Regular Expressions Language Reference

Index About the Authors Colophon Copyright

← Prev
Back
Next →

← Prev
Back
Next →