C# 8.0 in a Nutshell

Copyright
Table of Contents
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 Online Learning
	We’d Like to Hear from You
	Acknowledgments
		Joseph Albahari
		Eric Johannsen
Chapter 1. Introducing C# and .NET Core
	Object Orientation
	Type Safety
	Memory Management
	Platform Support
	C# and the Common Language Runtime
	Frameworks and Base Class Libraries
	Legacy and Niche Frameworks
	Windows Runtime
	A Brief History of C#
		What’s New in C# 8.0
		What’s New in C# 7.x
		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
Chapter 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
		Indices and Ranges (C# 8)
		Multidimensional Arrays
		Simplified Array Initialization Expressions
		Bounds Checking
	Variables and Parameters
		The Stack and the Heap
		Definite Assignment
		Default Values
		Parameters
		Ref Locals
		Ref Returns
		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-Coalescing Assignment Operator (C# 8)
		Null-Conditional Operator
	Statements
		Declaration Statements
		Expression Statements
		Selection Statements
		Iteration Statements
		Jump Statements
		Miscellaneous Statements
	Namespaces
		The using Directive
		using static
		Rules Within a Namespace
		Aliasing Types and Namespaces
		Advanced Namespace Features
Chapter 3. Creating Types in C#
	Classes
		Fields
		Constants
		Methods
		Instance Constructors
		Deconstructors
		Object Initializers
		The this Reference
		Properties
		Indexers
		Static Constructors
		Static Classes
		Finalizers
		Partial Types and Methods
		The nameof operator
	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
		Read-only Structs and Functions
		Ref Structs
	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
		Default Interface Members (C# 8)
	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
Chapter 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 Try XXX Method Pattern
		Alternatives to Exceptions
	Enumeration and Iterators
		Enumeration
		Collection Initializers
		Iterators
		Iterator Semantics
		Composing Sequences
	Nullable Value Types
		Nullable Struct
		Implicit and Explicit Nullable Conversions
		Boxing and Unboxing Nullable Values
		Operator Lifting
		bool? with & and | Operators
		Nullable Value Types & Null Operators
		Scenarios for Nullable Value Types
		Alternatives to Nullable Value Types
	Nullable Reference Types (C# 8)
		The Null-Forgiving Operator
		Separating the Annotation and Warning Contexts
		Treating Nullable Warnings as Errors
	Extension Methods
		Extension Method Chaining
		Ambiguity and Resolution
	Anonymous Types
	Tuples
		Naming Tuple Elements
		ValueTuple.Create
		Deconstructing Tuples
		Equality Comparison
		The System.Tuple classes
	Patterns
		Property Patterns (C# 8)
		Tuple Patterns (C# 8)
		Positional Patterns (C# 8)
		var Pattern
		Constant Pattern
	Attributes
		Attribute Classes
		Named and Positional Attribute Parameters
		Applying Attributes to Assemblies and Backing Fields
		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
		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
Chapter 5. Framework Overview
	.NET Standard
		.NET Standard 2.0
		.NET Standard 2.1
		Older .NET Standards
		.NET Framework and .NET Core Compatibility
	Framework and C# Language Versions
	Reference Assemblies
	The CLR and BCL
		System Types
		Text Processing
		Collections
		Querying
		XML and JSON
		Diagnostics
		Concurrency and Asynchrony
		Streams and I/O
		Networking
		Serialization
		Assemblies, Reflection, and Attributes
		Dynamic Programming
		Cryptography
		Advanced Threading
		Parallel Programming
		Span and Memory
		Native and COM Interoperability
		Regular Expressions
		The Roslyn Compiler
	Application Frameworks
		ASP.NET Core
		Windows Desktop
		UWP
		Xamarin
Chapter 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
Chapter 7. Collections
	Enumeration
		IEnumerable and IEnumerator
		IEnumerable and IEnumerator
		Implementing the Enumeration Interfaces
	The ICollection and IList Interfaces
		ICollection and ICollection
		IList and IList
		IReadOnlyCollection and 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
	Immutable Collections
		Creating Immutable Collections
		Manipulating Immutable Collections
		Builders
		Immutable Collections and Performance
	Plugging in Equality and Order
		IEqualityComparer and EqualityComparer
		IComparer and Comparer
		StringComparer
		IStructuralEquatable and IStructuralComparable
Chapter 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
	EF Core
		EF Core Entity Classes
		DbContext
		Object Tracking
		Change Tracking
		Navigation Properties
		Deferred Execution
	Building Query Expressions
		Delegates Versus Expression Trees
		Expression Trees
Chapter 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, ToHashSet, 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
Chapter 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
Chapter 11. Other XML and JSON 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
	Working with JSON
		Utf8JsonReader
		Utf8JsonWriter
		JsonDocument
Chapter 12. Disposal and Garbage Collection
	IDisposable, Dispose, and Close
		Standard Disposal Semantics
		When to Dispose
		Clearing Fields in Disposal
		Anonymous Disposal
	Automatic Garbage Collection
		Roots
		Garbage Collection and WinRT
	Finalizers
		Calling Dispose from a Finalizer
		Resurrection
	How the GC Works
		Optimization Techniques
		Forcing Garbage Collection
		Tuning Garbage Collection at Runtime
		Memory Pressure
		Array Pooling
	Managed Memory Leaks
		Timers
		Diagnosing Memory Leaks
	Weak References
		Weak References and Caching
		Weak References and Events
Chapter 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
	Cross-Platform Diagnostics Tools
		dotnet-counters
		dotnet-trace
		dotnet-dump
Chapter 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 Streams (C# 8)
		Asynchronous Methods in WinRT
		Asynchrony and Synchronization Contexts
		Optimizations
	Asynchronous Patterns
		Cancellation
		Progress Reporting
		The Task-Based Asynchronous Pattern
		Task Combinators
		Asynchronous Locking
	Obsolete Patterns
		Asynchronous Programming Model
		Event-Based Asynchronous Pattern
		BackgroundWorker
Chapter 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
		Unix gzip File Compression
	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
		Obtaining Directories and Files
	OS Security
		Running in a Standard User Account
		Administrative Elevation and Virtualization
	Memory-Mapped Files
		Memory-Mapped Files and Random File I/O
		Memory-Mapped Files and Shared Memory (Windows)
		Cross-Platform Interprocess Shared Memory
		Working with View Accessors
Chapter 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
	Writing an HTTP Server
	Using FTP
	Using DNS
	Sending Mail with SmtpClient
	Using TCP
		Concurrency with TCP
	Receiving POP3 Mail with TCP
	TCP in UWP
Chapter 17. Serialization
	Serialization Concepts
		Serialization Engines
		Formatters
		Explicit Versus Implicit Serialization
	The XML Serializer
		Getting Started with Attribute-Based Serialization
		Subclasses and Child Objects
		Serializing Collections
		IXmlSerializable
	The JSON Serializer
		Getting Started
		Serializing Child Objects
		Serializing Collections
		Controlling Serialization with Attributes
		Customizing Data Conversion
		JSON Serialization Options
	The Binary Serializer
		Getting Started
	Binary Serialization Attributes
		[NonSerialized]
		[OnDeserializing]
		[OnDeserialized]
		[OnSerializing] and [OnSerialized]
		[OptionalField] and Versioning
	Binary Serialization with ISerializable
		Subclassing Serializable Classes
Chapter 18. Assemblies
	What’s in an Assembly
		The Assembly Manifest
		The Application Manifest (Windows)
		Modules
		The Assembly Class
	Strong Names and Assembly Signing
		How to Strongly Name an Assembly
	Assembly Names
		Fully Qualified Names
		The AssemblyName Class
		Assembly Informational and File Versions
	Authenticode Signing
		How to Sign with Authenticode
	Resources and Satellite Assemblies
		Directly Embedding Resources
		.resources Files
		.resx Files
		Satellite Assemblies
		Cultures and Subcultures
	Loading, Resolving, and Isolating Assemblies
		Assembly Load Contexts
		The Default ALC
		The Current ALC
		Assembly.Load and Contextual ALCs
		Loading and Resolving Unmanaged Libraries
		AssemblyDependencyResolver
		Unloading ALCs
		The Legacy Loading Methods
		Writing a Plug-In System
Chapter 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
		Modules
	Working with Attributes
		Attribute Basics
		The AttributeUsage Attribute
		Defining Your Own Attribute
		Retrieving Attributes at Runtime
	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
		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
Chapter 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
Chapter 21. Cryptography
	Overview
	Windows Data Protection
	Hashing
		Hash Algorithms in .NET Core
		Hashing Passwords
	Symmetric Encryption
		Encrypting in Memory
		Chaining Encryption Streams
		Disposing Encryption Objects
		Key Management
	Public-Key Encryption and Signing
		The RSA Class
		Digital Signing
Chapter 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 Core 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
		WaitAny, WaitAll, and SignalAndWait
	The Barrier Class
	Lazy Initialization
		Lazy
		LazyInitializer
	Thread-Local Storage
		[ThreadStatic]
		ThreadLocal
		GetData and SetData
		AsyncLocal
	Timers
		Multithreaded Timers
		Single-Threaded Timers
Chapter 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
Chapter 24. Span and Memory
	Spans and Slicing
		CopyTo and TryCopyTo
		Working with Text
	Memory
	Forward-Only Enumerators
	Working with Stack-Allocated and Unmanaged Memory
Chapter 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
	Exposing C# Objects to COM
		Enabling Registry-Free COM
Chapter 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
Chapter 27. The Roslyn Compiler
	Roslyn Architecture
		Workspaces
		Scripting
	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
About the Authors