Efnisyfirlit

• Preface
• Intended Audience
• How This Book Is Organized
• What You Need to Use This Book
• Conventions Used in This Book
• Using Code Examples
• O’Reilly Safari
• We’d Like to Hear from You
• Acknowledgments
• Joseph Albahari
• Ben Albahari
• 1. Introducing C# and the .NET Framework
• Object Orientation
• Type Safety
• Memory Management
• Platform Support
• C# and the CLR
• The CLR and .NET Framework
• Other Frameworks
• Legacy and Niche Frameworks
• Windows Runtime
• A Brief History of C#
• What’s New in C# 7.0
• What’s New in C# 6.0
• What’s New in C# 5.0
• What’s New in C# 4.0
• What’s New in C# 3.0
• What’s New in C# 2.0
• 2. C# Language Basics
• A First C# Program
• Compilation
• Syntax
• Identifiers and Keywords
• Literals, Punctuators, and Operators
• Comments
• Type Basics
• Predefined Type Examples
• Custom Type Examples
• Conversions
• Value Types Versus Reference Types
• Predefined Type Taxonomy
• Numeric Types
• Numeric Literals
• Numeric Conversions
• Arithmetic Operators
• Increment and Decrement Operators
• Specialized Operations on Integral Types
• 8- and 16-Bit Integral Types
• 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
• Arrays
• Default Element Initialization
• Multidimensional Arrays
• Simplified Array Initialization Expressions
• Bounds Checking
• Variables and Parameters
• The Stack and the Heap
• Definite Assignment
• Default Values
• Parameters
• Ref Locals (C# 7)
• Ref Returns (C# 7)
• var—Implicitly Typed Local Variables
• Expressions and Operators
• Primary Expressions
• Void Expressions
• Assignment Expressions
• Operator Precedence and Associativity
• Operator Table
• Null Operators
• Null Coalescing Operator
• Null-conditional Operator (C# 6)
• Statements
• Declaration Statements
• Expression Statements
• Selection Statements
• Iteration Statements
• Jump Statements
• Miscellaneous Statements
• Namespaces
• The using Directive
• using static (C# 6)
• Rules Within a Namespace
• Aliasing Types and Namespaces
• Advanced Namespace Features
• 3. Creating Types in C#
• Classes
• Fields
• Methods
• Instance Constructors
• Deconstructors (C# 7)
• Object Initializers
• The this Reference
• Properties
• Indexers
• Constants
• Static Constructors
• Static Classes
• Finalizers
• Partial Types and Methods
• The nameof Operator (C# 6)
• Inheritance
• Polymorphism
• Casting and Reference Conversions
• Virtual Function Members
• Abstract Classes and Abstract Members
• Hiding Inherited Members
• Sealing Functions and Classes
• The base Keyword
• Constructors and Inheritance
• Overloading and Resolution
• The object Type
• 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
• 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
• Contravariance
• C# Generics Versus C++ Templates
• 4. Advanced C#
• Delegates
• Writing Plug-in Methods with Delegates
• Multicast Delegates
• Instance Versus Static Method Targets
• Generic Delegate Types
• The Func and Action Delegates
• Delegates Versus Interfaces
• Delegate Compatibility
• Events
• Standard Event Pattern
• Event Accessors
• Event Modifiers
• Lambda Expressions
• Explicitly Specifying Lambda Parameter Types
• Capturing Outer Variables
• Lambda Expressions Versus Local Methods
• Anonymous Methods
• try Statements and Exceptions
• The catch Clause
• The finally Block
• Throwing Exceptions
• Key Properties of System.Exception
• Common Exception Types
• The TryXXX Method Pattern
• Alternatives to Exceptions
• Enumeration and Iterators
• Enumeration
• Collection Initializers
• Iterators
• Iterator Semantics
• Composing Sequences
• Nullable Types
• Nullable Struct
• Implicit and Explicit Nullable Conversions
• Boxing and Unboxing Nullable Values
• Operator Lifting
• bool? with & and | Operators
• Nullable Types and Null Operators
• Scenarios for Nullable Types
• Alternatives to Nullable Types
• Extension Methods
• Extension Method Chaining
• Ambiguity and Resolution
• Anonymous Types
• Tuples (C# 7)
• Naming Tuple Elements
• ValueTuple.Create
• Deconstructing Tuples
• Equality Comparison
• The System.Tuple Classes
• Attributes
• Attribute Classes
• Named and Positional Attribute Parameters
• Attribute Targets
• Specifying Multiple Attributes
• Caller Info Attributes
• 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
• Operator Overloading
• Operator Functions
• Overloading Equality and Comparison Operators
• Custom Implicit and Explicit Conversions
• Overloading true and false
• Unsafe Code and Pointers
• Pointer Basics
• Unsafe Code
• The fixed Statement
• The Pointer-to-Member Operator
• Arrays
• 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
• .NET Standard 2.0
• Older .NET Standards
• Reference Assemblies
• The CLR and Core Framework
• System Types
• Text Processing
• Collections
• Queries
• XML
• Diagnostics
• 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 APIs
• Backend Technologies
• Distributed System Technologies
• 6. Framework Fundamentals
• String and Text Handling
• Char
• String
• Comparing Strings
• StringBuilder
• Text Encodings and Unicode
• Dates and Times
• TimeSpan
• DateTime and DateTimeOffset
• Dates and Time Zones
• DateTime and Time Zones
• DateTimeOffset and Time Zones
• TimeZone and TimeZoneInfo
• Daylight Saving Time and DateTime
• Formatting and Parsing
• ToString and Parse
• Format Providers
• Standard Format Strings and Parsing Flags
• Numeric Format Strings
• NumberStyles
• Date/Time Format Strings
• DateTimeStyles
• Enum Format Strings
• Other Conversion Mechanisms
• Convert
• XmlConvert
• Type Converters
• BitConverter
• Globalization
• Globalization Checklist
• Testing
• Working with Numbers
• Conversions
• Math
• BigInteger
• Complex
• Random
• Enums
• Enum Conversions
• Enumerating Enum Values
• How Enums Work
• The Guid Struct
• Equality Comparison
• Value Versus Referential Equality
• Standard Equality Protocols
• Equality and Custom Types
• Order Comparison
• IComparable
• < and >
• Implementing the IComparable Interfaces
• Utility Classes
• Console
• Environment
• Process
• AppContext
• 7. Collections
• Enumeration
• IEnumerable and IEnumerator
• IEnumerable and IEnumerator
• Implementing the Enumeration Interfaces
• The ICollection and IList Interfaces
• ICollection and ICollection
• IList and IList
• IReadOnlyList
• The Array Class
• Construction and Indexing
• Enumeration
• Length and Rank
• Searching
• Sorting
• Reversing Elements
• Copying
• Converting and Resizing
• Lists, Queues, Stacks, and Sets
• List and ArrayList
• LinkedList
• Queue and Queue
• Stack and Stack
• BitArray
• HashSet and SortedSet
• Dictionaries
• IDictionary
• IDictionary
• Dictionary and Hashtable
• OrderedDictionary
• ListDictionary and HybridDictionary
• Sorted Dictionaries
• Customizable Collections and Proxies
• Collection and CollectionBase
• KeyedCollection and DictionaryBase
• ReadOnlyCollection
• Plugging in Equality and Order
• IEqualityComparer and EqualityComparer
• IComparer and Comparer
• StringComparer
• IStructuralEquatable and IStructuralComparable
• 8. LINQ Queries
• Getting Started
• Fluent Syntax
• Chaining Query Operators
• Composing Lambda Expressions
• 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
• Wrapping Queries
• Projection Strategies
• Object Initializers
• Anonymous Types
• The let Keyword
• Interpreted Queries
• How Interpreted Queries Work
• Combining Interpreted and Local Queries
• AsEnumerable
• LINQ to SQL and Entity Framework
• LINQ to SQL Entity Classes
• Entity Framework Entity Classes
• DataContext and ObjectContext
• Associations
• Deferred Execution with L2S and EF
• DataLoadOptions
• Eager Loading in Entity Framework
• Updates
• API Differences Between L2S and EF
• Building Query Expressions
• Delegates Versus Expression Trees
• Expression Trees
• 9. LINQ Operators
• Overview
• Sequence→Sequence
• Sequence→Element or Value
• Void→Sequence
• Filtering
• Where
• Take and Skip
• TakeWhile and SkipWhile
• Distinct
• Projecting
• Select
• SelectMany
• Joining
• Join and GroupJoin
• The Zip Operator
• Ordering
• OrderBy, OrderByDescending, ThenBy, and ThenByDescending
• Grouping
• GroupBy
• 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
• 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
• Parent Navigation
• Peer Node Navigation
• Attribute Navigation
• Updating an X-DOM
• Simple Value Updates
• Updating Child Nodes and Attributes
• Updating Through the Parent
• Working with Values
• Setting Values
• Getting Values
• Values and Mixed Content Nodes
• Automatic XText Concatenation
• Documents and Declarations
• XDocument
• XML Declarations
• Names and Namespaces
• Namespaces in XML
• 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
• 11. Other XML Technologies
• XmlReader
• Reading Nodes
• Reading Elements
• Reading Attributes
• 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
• XSD and Schema Validation
• Performing Schema Validation
• XSLT
• 12. Disposal and Garbage Collection
• IDisposable, Dispose, and Close
• Standard Disposal Semantics
• 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
• How the Garbage Collector Works
• Optimization Techniques
• Forcing Garbage Collection
• Tuning Garbage Collection
• Memory Pressure
• Managed Memory Leaks
• Timers
• Diagnosing Memory Leaks
• Weak References
• Weak References and Caching
• Weak References and Events
• 13. Diagnostics
• Conditional Compilation
• Conditional Compilation Versus Static Variable Flags
• The Conditional Attribute
• Debug and Trace Classes
• Fail and Assert
• TraceListener
• Flushing and Closing Listeners
• 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 and Asynchrony
• Introduction
• Threading
• Creating a Thread
• Join and Sleep
• Blocking
• Local Versus Shared State
• Locking and Thread Safety
• Passing Data to a Thread
• Exception Handling
• Foreground Versus Background Threads
• Thread Priority
• Signaling
• Threading in Rich-Client Applications
• Synchronization Contexts
• The Thread Pool
• Tasks
• Starting a Task
• Returning Values
• Exceptions
• 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#
• Awaiting
• Writing Asynchronous Functions
• Asynchronous Lambda Expressions
• Asynchronous Methods in WinRT
• Asynchrony and Synchronization Contexts
• Optimizations
• Asynchronous Patterns
• Cancellation
• Progress Reporting
• The Task-based Asynchronous Pattern (TAP)
• Task Combinators
• Obsolete Patterns
• Asynchronous Programming Model (APM)
• 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
• MemoryStream
• PipeStream
• BufferedStream
• Stream Adapters
• Text Adapters
• Binary Adapters
• Closing and Disposing Stream Adapters
• Compression Streams
• Compressing in Memory
• Working with ZIP Files
• File and Directory Operations
• The File Class
• The Directory Class
• FileInfo and DirectoryInfo
• Path
• Special Folders
• Querying Volume Information
• Catching Filesystem Events
• File I/O in UWP
• Working with Directories
• Working with Files
• Isolated Storage in UWP Apps
• Memory-Mapped Files
• Memory-Mapped Files and Random File I/O
• Memory-Mapped Files and Shared Memory
• Working with View Accessors
• Isolated Storage
• 16. Networking
• Network Architecture
• Addresses and Ports
• URIs
• Client-Side Classes
• WebClient
• WebRequest and WebResponse
• HttpClient
• Proxies
• Authentication
• 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
• Formatters
• Explicit Versus Implicit Serialization
• The Data Contract Serializer
• DataContractSerializer Versus NetDataContractSerializer
• Using the Serializers
• Serializing Subclasses
• Object References
• Version Tolerance
• 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
• Subclasses and Child Objects
• Serializing Collections
• IXmlSerializable
• 18. Assemblies
• What’s in an Assembly
• The Assembly Manifest
• The 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
• 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
• Satellite Assemblies
• Cultures and Subcultures
• Resolving and Loading Assemblies
• Assembly and Type Resolution Rules
• AssemblyResolve
• Loading Assemblies
• Deploying Assemblies Outside the Base Folder
• Packing a Single-File Executable
• Working with Unreferenced Assemblies
• 19. Reflection and Metadata
• Reflecting and Activating Types
• Obtaining a Type
• 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
• Using Delegates for Performance
• Accessing Nonpublic Members
• 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
• Emitting Fields and Properties
• Emitting 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
• 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
• Code Access Security
• Identity and Role Security
• Permissions
• Declarative Versus Imperative Security
• Implementing Identity and Role Security
• Assigning Users and Roles
• Operating System Security
• Running in a Standard User Account
• Administrative Elevation and Virtualization
• 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
• 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
• Thread Safety in Application Servers
• Immutable Objects
• Nonexclusive Locking
• Semaphore
• Reader/Writer Locks
• Signaling with Event Wait Handles
• AutoResetEvent
• ManualResetEvent
• CountdownEvent
• Creating a Cross-Process EventWaitHandle
• Wait Handles and Continuations
• Converting Wait Handles to Tasks
• WaitAny, WaitAll, and SignalAndWait
• The Barrier Class
• Lazy Initialization
• Lazy
• LazyInitializer
• Thread-Local Storage
• [ThreadStatic]
• ThreadLocal
• 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
• Functional Purity
• Setting the Degree of Parallelism
• Cancellation
• Optimizing PLINQ
• The Parallel Class
• Parallel.Invoke
• Parallel.For and Parallel.ForEach
• Task Parallelism
• Creating and Starting Tasks
• Waiting on Multiple Tasks
• Canceling Tasks
• Continuations
• Task Schedulers
• TaskFactory
• Working with AggregateException
• Flatten and Handle
• Concurrent Collections
• IProducerConsumerCollection
• ConcurrentBag
• BlockingCollection
• Writing a Producer/Consumer Queue
• 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
• 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
• 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
• Regular Expressions Language Reference
• 27. The Roslyn Compiler
• Roslyn Architecture
• Workspaces
• Syntax Trees
• SyntaxTree Structure
• Obtaining a Syntax Tree
• Traversing and Searching a Tree
• Trivia
• Transforming a Syntax Tree
• Compilations and Semantic Models
• Creating a Compilation
• Emitting an Assembly
• Querying the Semantic Model
• Example: Renaming a Symbol
• Index