C# 6.0 and the .NET 4.6 Framework 7th ed. 2015 Edition.pdf

发布时间：2022-06-15 发布人：admin 分类：说明书资料大小：36.42M 资料格式：pdf 举报版权申诉

a3fb6ddf-d6b0-4988-8694-5fb80ebab007.pdf-第1页.png

第1页 / 共1660页

a3fb6ddf-d6b0-4988-8694-5fb80ebab007.pdf-第2页.png

第2页 / 共1660页

a3fb6ddf-d6b0-4988-8694-5fb80ebab007.pdf-第3页.png

第3页 / 共1660页

a3fb6ddf-d6b0-4988-8694-5fb80ebab007.pdf-第4页.png

第4页 / 共1660页

a3fb6ddf-d6b0-4988-8694-5fb80ebab007.pdf-第5页.png

第5页 / 共1660页

a3fb6ddf-d6b0-4988-8694-5fb80ebab007.pdf-第6页.png

第6页 / 共1660页

a3fb6ddf-d6b0-4988-8694-5fb80ebab007.pdf-第7页.png

第7页 / 共1660页

a3fb6ddf-d6b0-4988-8694-5fb80ebab007.pdf-第8页.png

第8页 / 共1660页

Contents at a Glance

Contents

About the Authors

About the Technical Reviewer

Acknowledgments

Introduction

Part I: Introducing C# and the .NET Platform

Chapter 1: The Philosophy of .NET

An Initial Look at the .NET Platform

Some Key Benefits of the .NET Platform

Introducing the Building Blocks of the .NET Platform (the CLR, CTS, and CLS)

The Role of the Base Class Libraries

What C# Brings to the Table

Managed vs. Unmanaged Code

Additional .NET-Aware Programming Languages

Life in a Multilanguage World

An Overview of .NET Assemblies

The Role of the Common Intermediate Language

Benefits of CIL

Compiling CIL to Platform-Specific Instructions

The Role of .NET Type Metadata

The Role of the Assembly Manifest

Understanding the Common Type System

CTS Class Types

CTS Interface Types

CTS Structure Types

CTS Enumeration Types

CTS Delegate Types

CTS Type Members

Intrinsic CTS Data Types

Understanding the Common Language Specification

Ensuring CLS Compliance

Understanding the Common Language Runtime

The Assembly/Namespace/Type Distinction

The Role of the Microsoft Root Namespace

Accessing a Namespace Programmatically

Referencing External Assemblies

Exploring an Assembly Using ildasm.exe

Viewing CIL Code

Viewing Type Metadata

Viewing Assembly Metadata (aka the Manifest)

The Platform-Independent Nature of .NET

The Mono Project

Microsoft .NET Core

Summary

Chapter 2: Building C# Applications

Building C# Applications on the Windows OS

The Visual Studio Express Family of IDEs

A Brief Overview of Express for Windows Desktop

The New Project Dialog Box and C# Code Editor

Running and Debugging your Project

The Solution Explorer

The Object Browser

Referencing Additional Assemblies

Viewing Project Properties

A Brief Overview of Express for Web

The Visual Studio Community Edition IDE

The Visual Class Designer

The Visual Studio 2015 Professional IDE

The .NET Framework Documentation System

Building .NET Applications Beyond the Windows OS

The Role of Xamarin Studio

Summary

Part II: Core C# Programming

Chapter 3: Core C# Programming Constructs, Part I

The Anatomy of a Simple C# Program

Variations on the Main() Method

Specifying an Application Error Code

Processing Command-Line Arguments

Specifying Command-Line Arguments with Visual Studio

An Interesting Aside: Some Additional Members of the System.Environment Class

The System.Console Class

Basic Input and Output with the Console Class

Formatting Console Output

Formatting Numerical Data

Formatting Numerical Data Beyond Console Applications

System Data Types and Corresponding C# Keywords

Variable Declaration and Initialization

Intrinsic Data Types and the new Operator

The Data Type Class Hierarchy

Members of Numerical Data Types

Members of System.Boolean

Members of System.Char

Parsing Values from String Data

System.DateTime and System.TimeSpan

The System.Numerics.dll Assembly

Working with String Data

Basic String Manipulation

String Concatenation

Escape Characters

Defining Verbatim Strings

Strings and Equality

Strings Are Immutable

The System.Text.StringBuilder Type

String Interpolation

Narrowing and Widening Data Type Conversions

The checked Keyword

Setting Project-wide Overflow Checking

The unchecked Keyword

Understanding Implicitly Typed Local Variables

Restrictions on Implicitly Typed Variables

Implicit Typed Data Is Strongly Typed Data

Usefulness of Implicitly Typed Local Variables

C# Iteration Constructs

The for Loop

The foreach Loop

Use of Implicit Typing Within foreach Constructs

The while and do/while Looping Constructs

Decision Constructs and the Relational/Equality Operators

The if/else Statement

Equality and Relational Operators

Conditional Operators

The switch Statement

Summary

Chapter 4: Core C# Programming Constructs, Part II

Methods and Parameter Modifiers

The Default by Value Parameter-Passing Behavior

The out Modifier

The ref Modifier

The params Modifier

Defining Optional Parameters

Invoking Methods Using Named Parameters

Understanding Method Overloading

Understanding C# Arrays

C# Array Initialization Syntax

Implicitly Typed Local Arrays

Defining an Array of Objects

Working with Multidimensional Arrays

Arrays As Arguments or Return Values

The System.Array Base Class

Understanding the enum Type

Controlling the Underlying Storage for an enum

Declaring enum Variables

The System.Enum Type

Dynamically Discovering an enum’s Name/Value Pairs

Understanding the Structure (aka Value Type)

Creating Structure Variables

Understanding Value Types and Reference Types

Value Types, References Types, and the Assignment Operator

Value Types Containing Reference Types

Passing Reference Types by Value

Passing Reference Types by Reference

Final Details Regarding Value Types and Reference Types

Understanding C# Nullable Types

Working with Nullable Types

The Null Coalescing Operator

The Null Conditional Operator

Summary

Part III: Object-Oriented Programming with C#

Chapter 5: Understanding Encapsulation

Introducing the C# Class Type

Allocating Objects with the new Keyword

Understanding Constructors

The Role of the Default Constructor

Defining Custom Constructors

The Default Constructor Revisited

The Role of the this Keyword

Chaining Constructor Calls Using this

Observing Constructor Flow

Revisiting Optional Arguments

Understanding the static Keyword

Defining Static Field Data

Defining Static Methods

Defining Static Constructors

Defining Static Classes

Importing Static Members via the C# using Keyword

Defining the Pillars of OOP

The Role of Encapsulation

The Role of Inheritance

The Role of Polymorphism

C# Access Modifiers

The Default Access Modifiers

Access Modifiers and Nested Types

The First Pillar: C#’s Encapsulation Services

Encapsulation Using Traditional Accessors and Mutators

Encapsulation Using .NET Properties

Using Properties Within a Class Definition

Read-Only and Write-Only Properties

Revisiting the static Keyword: Defining Static Properties

Understanding Automatic Properties

Interacting with Automatic Properties

Automatic Properties and Default Values

Initialization of Automatic Properties

Understanding Object Initialization Syntax

Calling Custom Constructors with Initialization Syntax

Initializing Data with Initialization Syntax

Working with Constant Field Data

Understanding Read-Only Fields

Static Read-Only Fields

Understanding Partial Classes

Use Cases for Partial Classes?

Summary

Chapter 6: Understanding Inheritance and Polymorphism

The Basic Mechanics of Inheritance

Specifying the Parent Class of an Existing Class

Regarding Multiple Base Classes

The sealed Keyword

Revising Visual Studio Class Diagrams

The Second Pillar of OOP: The Details of Inheritance

Controlling Base Class Creation with the base Keyword

Keeping Family Secrets: The protected Keyword

Adding a Sealed Class

Programming for Containment/Delegation

Understanding Nested Type Definitions

The Third Pillar of OOP: C#’s Polymorphic Support

The virtual and override Keywords

Overriding Virtual Members Using the Visual Studio IDE

Sealing Virtual Members

Understanding Abstract Classes

Understanding the Polymorphic Interface

Understanding Member Shadowing

Understanding Base Class/Derived Class Casting Rules

The C# as Keyword

The C# is Keyword

The Master Parent Class: System.Object

Overriding System.Object.ToString()

Overriding System.Object.Equals()

Overriding System.Object.GetHashCode()

Testing Your Modified Person Class

The Static Members of System.Object

Summary

Chapter 7: Understanding Structured Exception Handling

Ode to Errors, Bugs, and Exceptions

The Role of .NET Exception Handling

The Building Blocks of .NET Exception Handling

The System.Exception Base Class

The Simplest Possible Example

Throwing a General Exception

Catching Exceptions

Configuring the State of an Exception

The TargetSite Property

The StackTrace Property

The HelpLink Property

The Data Property

System-Level Exceptions (System.SystemException)

Application-Level Exceptions (System.ApplicationException)

Building Custom Exceptions, Take 1

Building Custom Exceptions, Take 2

Building Custom Exceptions, Take 3

Processing Multiple Exceptions

General catch Statements

Rethrowing Exceptions

Inner Exceptions

The finally Block

Exception Filters

Debugging Unhandled Exceptions Using Visual Studio

Summary

Chapter 8: Working with Interfaces

Understanding Interface Types

Interface Types vs. Abstract Base Classes

Defining Custom Interfaces

Implementing an Interface

Invoking Interface Members at the Object Level

Obtaining Interface References: The as Keyword

Obtaining Interface References: The is Keyword

Interfaces As Parameters

Interfaces As Return Values

Arrays of Interface Types

Implementing Interfaces Using Visual Studio

Explicit Interface Implementation

Designing Interface Hierarchies

Multiple Inheritance with Interface Types

The IEnumerable and IEnumerator Interfaces

Building Iterator Methods with the yield Keyword

Building a Named Iterator

The ICloneable Interface

A More Elaborate Cloning Example

The IComparable Interface

Specifying Multiple Sort Orders with IComparer

Custom Properties and Custom Sort Types

Summary

Part IV: Advanced C# Programming

Chapter 9: Collections and Generics

The Motivation for Collection Classes

The System.Collections Namespace

An Illustrative Example: Working with the ArrayList

A Survey of System.Collections.Specialized Namespace

The Problems of Nongeneric Collections

The Issue of Performance

The Issue of Type Safety

A First Look at Generic Collections

The Role of Generic Type Parameters

Specifying Type Parameters for Generic Classes/Structures

Specifying Type Parameters for Generic Members

Specifying Type Parameters for Generic Interfaces

The System.Collections.Generic Namespace

Understanding Collection Initialization Syntax

Working with the List Class

Working with the Stack Class

Working with the Queue Class

Working with the SortedSet Class

Working with the Dictionary Class

The System.Collections.ObjectModel Namespace

Working with ObservableCollection

Creating Custom Generic Methods

Inference of Type Parameters

Creating Custom Generic Structures and Classes

The default Keyword in Generic Code

Constraining Type Parameters

Examples Using the where Keyword

The Lack of Operator Constraints

Summary

Chapter 10: Delegates, Events, and Lambda Expressions

Understanding the .NET Delegate Type

Defining a Delegate Type in C#

The System.MulticastDelegate and System.Delegate Base Classes

The Simplest Possible Delegate Example

Investigating a Delegate Object

Sending Object State Notifications Using Delegates

Enabling Multicasting

Removing Targets from a Delegate’s Invocation List

Method Group Conversion Syntax

Understanding Generic Delegates

The Generic Action<> and Func<> Delegates

Understanding C# Events

The C# event Keyword

Events Under the Hood

Listening to Incoming Events

Simplifying Event Registration Using Visual Studio

Cleaning Up Event Invocation Using the C# 6.0 Null-Conditional Operator

Creating Custom Event Arguments

The Generic EventHandler Delegate

Understanding C# Anonymous Methods

Accessing Local Variables

Understanding Lambda Expressions

Dissecting a Lambda Expression

Processing Arguments Within Multiple Statements

Lambda Expressions with Multiple (or Zero) Parameters

Retrofitting the CarEvents Example Using Lambda Expressions

Lambdas and Single Statement Member Implementations

Summary

Chapter 11: Advanced C# Language Features

Understanding Indexer Methods

Indexing Data Using String Values

Overloading Indexer Methods

Indexers with Multiple Dimensions

Indexer Definitions on Interface Types

Understanding Operator Overloading

Overloading Binary Operators

And What of the += and –+ Operators?

Overloading Unary Operators

Overloading Equality Operators

Overloading Comparison Operators

Final Thoughts Regarding Operator Overloading

Understanding Custom Type Conversions

Recall: Numerical Conversions

Recall: Conversions Among Related Class Types

Creating Custom Conversion Routines

Additional Explicit Conversions for the Square Type

Defining Implicit Conversion Routines

Understanding Extension Methods

Defining Extension Methods

Invoking Extension Methods

Importing Extension Methods

The IntelliSense of Extension Methods

Extending Types Implementing Specific Interfaces

Understanding Anonymous Types

Defining an Anonymous Type

The Internal Representation of Anonymous Types

The Implementation of ToString() and GetHashCode()

The Semantics of Equality for Anonymous Types

Anonymous Types Containing Anonymous Types

Working with Pointer Types

The unsafe Keyword

Working with the * and & Operators

An Unsafe (and Safe) Swap Function

Field Access via Pointers (the -> Operator)

The stackalloc Keyword

Pinning a Type via the fixed Keyword

The sizeof Keyword

Summary

Chapter 12: LINQ to Objects

LINQ-Specific Programming Constructs

Implicit Typing of Local Variables

Object and Collection Initialization Syntax

Lambda Expressions

Extension Methods

Anonymous Types

Understanding the Role of LINQ

LINQ Expressions Are Strongly Typed

The Core LINQ Assemblies

Applying LINQ Queries to Primitive Arrays

Once Again, Without LINQ

Reflecting over a LINQ Result Set

LINQ and Implicitly Typed Local Variables

LINQ and Extension Methods

The Role of Deferred Execution

The Role of Immediate Execution

Returning the Result of a LINQ Query

Returning LINQ Results via Immediate Execution

Applying LINQ Queries to Collection Objects

Accessing Contained Subobjects

Applying LINQ Queries to Nongeneric Collections

Filtering Data Using OfType()

Investigating the C# LINQ Query Operators

Basic Selection Syntax

Obtaining Subsets of Data

Projecting New Data Types

Obtaining Counts Using Enumerable

Reversing Result Sets

Sorting Expressions

LINQ As a Better Venn Diagramming Tool

Removing Duplicates

LINQ Aggregation Operations

The Internal Representation of LINQ Query Statements

Building Query Expressions with Query Operators (Revisited)

Building Query Expressions Using the Enumerable Type and Lambda Expressions

Building Query Expressions Using the Enumerable Type and Anonymous Methods

Building Query Expressions Using the Enumerable Type and Raw Delegates

Summary

Chapter 13: Understanding Object Lifetime

Classes, Objects, and References

The Basics of Object Lifetime

The CIL of new

Setting Object References to null

The Role of Application Roots

Understanding Object Generations

Concurrent Garbage Collection Prior to .NET 4.0

Background Garbage Collection Under .NET 4.0 and Beyond

The System.GC Type

Forcing a Garbage Collection

Building Finalizable Objects

Overriding System.Object.Finalize()

Detailing the Finalization Process

Building Disposable Objects

Reusing the C# using Keyword

Building Finalizable and Disposable Types

A Formalized Disposal Pattern

Understanding Lazy Object Instantiation

Customizing the Creation of the Lazy Data

Summary

Part V: Programming with .NET Assemblies

Chapter 14: Building and Configuring Class Libraries

Defining Custom Namespaces

Resolving Name Clashes with Fully Qualified Names

Resolving Name Clashes with Aliases

Creating Nested Namespaces

The Default Namespace of Visual Studio

The Role of .NET Assemblies

Assemblies Promote Code Reuse

Assemblies Establish a Type Boundary

Assemblies are Versionable Units

Assemblies are Self-Describing

Assemblies are Configurable

Understanding the Format of a .NET Assembly

The Windows File Header

The CLR File Header

CIL Code, Type Metadata, and the Assembly Manifest

Optional Assembly Resources

Building and Consuming Custom Class Library

Exploring the Manifest

Exploring the CIL

Exploring the Type Metadata

Building a C# Client Application

Building a Visual Basic Client Application

Cross-Language Inheritance in Action

Understanding Private Assemblies

The Identity of a Private Assembly

Understanding the Probing Process

Configuring Private Assemblies

The Role of the App.Config File

Understanding Shared Assemblies

The Global Assembly Cache

Understanding Strong Names

Generating Strong Names at the Command Line

Generating Strong Names Using Visual Studio

Installing Strongly Named Assemblies to the GAC

Consuming a Shared Assembly

Exploring the Manifest of SharedCarLibClient

Configuring Shared Assemblies

Freezing the Current Shared Assembly

Building a Shared Assembly Version 2.0.0.0

Dynamically Redirecting to Specific Versions of a Shared Assembly

Understanding Publisher Policy Assemblies

Disabling Publisher Policy

Understanding the Element

The System.Configuration Namespace

The Configuration File Schema Documentation

Summary

Chapter 15: Type Reflection, Late Binding, and Attribute-Based Programming

The Necessity of Type Metadata

Viewing (Partial) Metadata for the EngineState Enumeration

Viewing (Partial) Metadata for the Car Type

Examining a TypeRef

Documenting the Defining Assembly

Documenting Referenced Assemblies

Documenting String Literals

Understanding Reflection

The System.Type Class

Obtaining a Type Reference Using System.Object.GetType()

Obtaining a Type Reference Using typeof()

Obtaining a Type Reference Using System.Type.GetType()

Building a Custom Metadata Viewer

Reflecting on Methods

Reflecting on Fields and Properties

Reflecting on Implemented Interfaces

Displaying Various Odds and Ends

Implementing Main()

Reflecting on Generic Types

Reflecting on Method Parameters and Return Values

Dynamically Loading Assemblies

Reflecting on Shared Assemblies

Understanding Late Binding

The System.Activator Class

Invoking Methods with No Parameters

Invoking Methods with Parameters

Understanding the Role of .NET Attributes

Attribute Consumers

Applying Attributes in C#

C# Attribute Shorthand Notation

Specifying Constructor Parameters for Attributes

The Obsolete Attribute in Action

Building Custom Attributes

Applying Custom Attributes

Named Property Syntax

Restricting Attribute Usage

Assembly-Level Attributes

The Visual Studio AssemblyInfo.cs File

Reflecting on Attributes Using Early Binding

Reflecting on Attributes Using Late Binding

Putting Reflection, Late Binding, and Custom Attributes in Perspective

Building an Extendable Application

Building CommonSnappableTypes.dll

Building the C# Snap- In

Building the Visual Basic Snap-In

Building an Extendable Windows Forms Application

Summary

Chapter 16: Dynamic Types and the Dynamic Language Runtime

The Role of the C# dynamic Keyword

Calling Members on Dynamically Declared Data

The Role of the Microsoft.CSharp.dll Assembly

The Scope of the dynamic Keyword

Limitations of the dynamic Keyword

Practical Uses of the dynamic Keyword

The Role of the Dynamic Language Runtime

The Role of Expression Trees

The Role of the System.Dynamic Namespace

Dynamic Runtime Lookup of Expression Trees

Simplifying Late-Bound Calls Using Dynamic Types

Leveraging the dynamic Keyword to Pass Arguments

Simplifying COM Interoperability Using Dynamic Data

The Role of Primary Interop Assemblies

Embedding Interop Metadata

Common COM Interop Pain Points

COM Interop Using C# Dynamic Data

COM interop Without C# Dynamic Data

Summary

Chapter 17: Processes, AppDomains, and Object Contexts

The Role of a Windows Process

The Role of Threads

Interacting with Processes Under the .NET Platform

Enumerating Running Processes

Investigating a Specific Process

Investigating a Process’s Thread Set

Investigating a Process’s Module Set

Starting and Stopping Processes Programmatically

Controlling Process Startup Using the ProcessStartInfo Class

Understanding .NET Application Domains

The System.AppDomain Class

Interacting with the Default Application Domain

Enumerating Loaded Assemblies

Receiving Assembly Load Notifications

Creating New Application Domains

Loading Assemblies into Custom Application Domains

Programmatically Unloading AppDomains

Understanding Object Context Boundaries

Context-Agile and Context-Bound Types

Defining a Context-Bound Object

Inspecting an Object’s Context

Summarizing Processes, AppDomains, and Context

Summary

Chapter 18: Understanding CIL and the Role of Dynamic Assemblies

Motivations for Learning the Grammar of CIL

Examining CIL Directives, Attributes, and Opcodes

The Role of CIL Directives

The Role of CIL Attributes

The Role of CIL Opcodes

The CIL Opcode/CIL Mnemonic Distinction

Pushing and Popping: The Stack-Based Nature of CIL

Understanding Round-Trip Engineering

The Role of CIL Code Labels

Interacting with CIL: Modifying an *.il File

Compiling CIL Code Using ilasm.exe

The Role of peverify.exe

Understanding CIL Directives and Attributes

Specifying Externally Referenced Assemblies in CIL

Defining the Current Assembly in CIL

Defining Namespaces in CIL

Defining Class Types in CIL

Defining and Implementing Interfaces in CIL

Defining Structures in CIL

Defining Enums in CIL

Defining Generics in CIL

Compiling the CILTypes.il file

.NET Base Class Library, C#, and CIL Data Type Mappings

Defining Type Members in CIL

Defining Field Data in CIL

Defining Type Constructors in CIL

Defining Properties in CIL

Defining Member Parameters

Examining CIL Opcodes

The .maxstack Directive

Declaring Local Variables in CIL

Mapping Parameters to Local Variables in CIL

The Hidden this Reference

Representing Iteration Constructs in CIL

Building a .NET Assembly with CIL

Building CILCars.dll

Building CILCarClient.exe

Understanding Dynamic Assemblies

Exploring the System.Reflection.Emit Namespace

The Role of the System.Reflection.Emit.ILGenerator

Emitting a Dynamic Assembly

Emitting the Assembly and Module Set

The Role of the ModuleBuilder Type

Emitting the HelloClass Type and the String Member Variable

Emitting the Constructors

Emitting the SayHello() Method

Using the Dynamically Generated Assembly

Summary

Part VI: Introducing the .NET Base Class Libraries

Chapter 19: Multithreaded, Parallel, and Async Programming

The Process/AppDomain/Context/Thread Relationship

The Problem of Concurrency

The Role of Thread Synchronization

A Brief Review of the .NET Delegate

The Asynchronous Nature of Delegates

The BeginInvoke() and EndInvoke() Methods

The System.IAsyncResult Interface

Invoking a Method Asynchronously

Synchronizing the Calling Thread

The Role of the AsyncCallback Delegate

The Role of the AsyncResult Class

Passing and Receiving Custom State Data

The System.Threading Namespace

The System.Threading.Thread Class

Obtaining Statistics About the Current Thread of Execution

The Name Property

The Priority Property

Manually Creating Secondary Threads

Working with the ThreadStart Delegate

Working with the ParameterizedThreadStart Delegate

The AutoResetEvent Class

Foreground Threads and Background Threads

The Issue of Concurrency

Synchronization Using the C# lock Keyword

Synchronization Using the System.Threading.Monitor Type

Synchronization Using the System.Threading.Interlocked Type

Synchronization Using the [Synchronization] Attribute

Programming with Timer Callbacks

Understanding the CLR ThreadPool

Parallel Programming Using the Task Parallel Library

The System.Threading.Tasks Namespace

The Role of the Parallel Class

Data Parallelism with the Parallel Class

Accessing UI Elements on Secondary Threads

The Task Class

Handling Cancellation Request

Task Parallelism Using the Parallel Class

Parallel LINQ Queries (PLINQ)

Opting in to a PLINQ Query

Cancelling a PLINQ Query

Asynchronous Calls with the async Keyword

A First Look at the C# async and await Keywords

Naming Conventions for Async Methods

Async Methods Returning Void

Async Methods with Multiple Awaits

Retrofitting the AddWithThreads Example Using Asycn/Await

Summary

Chapter 20: File I/O and Object Serialization

Exploring the System.IO Namespace

The Directory(Info) and File(Info) Types

The Abstract FileSystemInfo Base Class

Working with the DirectoryInfo Type

Enumerating Files with the DirectoryInfo Type

Creating Subdirectories with the DirectoryInfo Type

Working with the Directory Type

Working with the DriveInfo Class Type

Working with the FileInfo Class

The FileInfo.Create() Method

The FileInfo.Open() Method

The FileInfo.OpenRead() and FileInfo.OpenWrite() Methods

The FileInfo.OpenText() Method

The FileInfo.CreateText() and FileInfo.AppendText() Methods

Working with the File Type

Additional File-Centric Members

The Abstract Stream Class

Working with FileStreams

Working with StreamWriters and StreamReaders

Writing to a Text File

Reading from a Text File

Directly Creating StreamWriter/StreamReader Types

Working with StringWriters and StringReaders

Working with BinaryWriters and BinaryReaders

Watching Files Programmatically

Understanding Object Serialization

The Role of Object Graphs

Configuring Objects for Serialization

Defining Serializable Types

Public Fields, Private Fields, and Public Properties

Choosing a Serialization Formatter

The IFormatter and IRemotingFormatter Interfaces

Type Fidelity Among the Formatters

Serializing Objects Using the BinaryFormatter

Deserializing Objects Using the BinaryFormatter

Serializing Objects Using the SoapFormatter

Serializing Objects Using the XmlSerializer

Controlling the Generated XML Data

Serializing Collections of Objects

Customizing the Soap/Binary Serialization Process

A Deeper Look at Object Serialization

Customizing Serialization Using ISerializable

Customizing Serialization Using Attributes

Summary

Chapter 21: ADO.NET Part I: The Connected Layer

A High-Level Definition of ADO.NET

The Three Faces of ADO.NET

Understanding ADO.NET Data Providers

The Microsoft-Supplied ADO.NET Data Providers

A Word Regarding System.Data.OracleClient.dll

Obtaining Third-Party ADO.NET Data Providers

Additional ADO.NET Namespaces

The Types of the System.Data Namespace

The Role of the IDbConnection Interface

The Role of the IDbTransaction Interface

The Role of the IDbCommand Interface

The Role of the IDbDataParameter and IDataParameter Interfaces

The Role of the IDbDataAdapter and IDataAdapter Interfaces

The Role of the IDataReader and IDataRecord Interfaces

Abstracting Data Providers Using Interfaces

Increasing Flexibility Using Application Configuration Files

Creating the AutoLot Database

Creating the Inventory Table

Adding Test Records to the Inventory Table

Authoring the GetPetName() Stored Procedure

Creating the Customers and Orders Tables

Creating Table Relationships in Visual Studio

The ADO.NET Data Provider Factory Model

A Complete Data Provider Factory Example

A Potential Drawback with the Data Provider Factory Model

The Element

Understanding the Connected Layer of ADO.NET

Working with Connection Objects

Working with ConnectionStringBuilder Objects

Working with Command Objects

Working with Data Readers

Obtaining Multiple Result Sets Using a Data Reader

Building a Reusable Data Access Library

Adding the Connection Logic

Adding the Insertion Logic

Adding the Deletion Logic

Adding the Update Logic

Adding the Selection Logic

Working with Parameterized Command Objects

Specifying Parameters Using the DbParameter Type

Executing a Stored Procedure

Creating a Console UI–Based Front End

Implementing the Main() Method

Implementing the ShowInstructions() Method

Implementing the ListInventory() Method

Implementing the DeleteCar() Method

Implementing the InsertNewCar() Method

Implementing the UpdateCarPetName() Method

Implementing LookUpPetName()

Understanding Database Transactions

Key Members of an ADO.NET Transaction Object

Adding a CreditRisks Table to the AutoLot Database

Adding a Transaction Method to InventoryDAL

Testing Your Database Transaction

Summary

Chapter 22: ADO.NET Part II: The Disconnected Layer

Understanding the Disconnected Layer of ADO.NET

Understanding the Role of the DataSet

Key Properties of the DataSet

Key Methods of the DataSet

Building a DataSet

Working with DataColumns

Building a DataColumn

Enabling Autoincrementing Fields

Adding DataColumn Objects to a DataTable

Working with DataRows

Understanding the RowState Property

Understanding the DataRowVersion Property

Working with DataTables

Inserting DataTables into DataSets

Obtaining Data in a DataSet

Processing DataTable Data Using DataTableReader Objects

Serializing DataTable/DataSet Objects As XML

Serializing DataTable/DataSet Objects in a Binary Format

Binding DataTable Objects to Windows Forms GUIs

Hydrating a DataTable from a Generic List

Deleting Rows from a DataTable

Selecting Rows Based on Filter Criteria

Updating Rows Within a DataTable

Working with the DataView Type

Working with Data Adapters

A Simple Data Adapter Example

Mapping Database Names to Friendly Names

Adding Disconnected Functionality to AutoLotDAL.dll

Defining the Initial Class Type

Configuring the Data Adapter Using the SqlCommandBuilder

Implementing GetAllInventory()

Implementing UpdateInventory()

Setting Your Version Number

Testing the Disconnected Functionality

Multitabled DataSet Objects and Data Relationships

Prepping the Data Adapters

Building the Table Relationships

Updating the Database Tables

Navigating Between Related Tables

The Windows Forms Database Designer Tools

Visually Designing the DataGridView

The Generated App.config File

Examining the Strongly Typed DataSet

Examining the Strongly Typed DataTable

Examining the Strongly Typed DataRow

Examining the Strongly Typed Data Adapter

Completing the Windows Forms Application

Isolating Strongly Typed Database Code into a Class Library

Viewing the Generated Code

Selecting Data with the Generated Code

Inserting Data with the Generated Code

Deleting Data with the Generated Code

Invoking a Stored Procedure Using the Generated Code

Programming with LINQ to DataSet

The Role of the DataSet Extensions Library

Obtaining a LINQ-Compatible DataTable

The Role of the DataRowExtensions.Field() Extension Method

Hydrating New DataTables from LINQ Queries

Summary

Chapter 23: ADO.NET Part III: Entity Framework

Understanding the Role of the Entity Framework

The Role of Entities

The Building Blocks of the Entity Framework

The Role of the DbContext Class

The Role of the Derived Context Class

The Role of DbSet

Empty Code First Model or Code First from Database

Transaction Support

Entity State

Code First from an Existing Database

Generating the Model

What Did That Do?

Changing the Default Mappings

Adding to the Generated Model Classes

Using the Model Classes in Code

Inserting a Record

Selecting Records

Querying with SQL

Querying with LINQ

The Role of Navigation Properties

Lazy, Eager, and Explicit Loading

Lazy Loading

Eager Loading

Explicit Loading

Deleting a Record

Deleting a Record Using EntityState

Updating a Record

Handling Database Changes

AutoLotDAL Version 4

Entity Framework Data Annotations

Adding or Updating the Model Classes

Creating the Inventory Model Class

Configuring the Model with Data Annotations

Adding the Navigation Property to Inventory

Adding the InventoryPartial Class

Creating the Customer Model Class

Creating the Order Model Class

Creating the CreditRisk Class

Adding the DbContext

Updates to the *.config File and the EF Connection String

Update the Context

Adding the Repositories

Adding the IRepo Interface

Adding the BaseRepo

Implementing the SaveChanges() Helper Methods

Retrieving Records

Retrieving Records with SQL

Adding Records

Updating Records

Deleting Records

Adding the Inventory Repository

Deleting Records by Id

Adding the Remaining Repositories

Initializing the Database

Test-Driving AutoLotDAL

Printing All Inventory Records

Adding Inventory Records

Editing Records

Using Navigation Properties

Eager Loading

Multitable Actions/Implicit Transactions

Entity Framework Migrations

Updating the Model

Inventory Class

Customer Class

Order Class

Credit Risk Class

Testing the App

Entering EF Migrations

Creating the Baseline Migration

Seeding the Database

Revisiting the Transaction Test

Concurrency

Correcting the Repositories

Testing Concurrency

Interception

The IDbCommandInterceptor Interface

Adding Interception to AutoLotDAL

Registering the Interceptor

Adding the DatabaseLogger Interceptor

ObjectMaterialized and SavingChanges Events

Accessing the Object Context

ObjectMaterialized

SavingChanges

Deploying to SQL Server

Summary

Chapter 24: Introducing LINQ to XML

A Tale of Two XML APIs

LINQ to XML As a Better DOM

VB Literal Syntax As a Better LINQ to XML

Members of the System.Xml.Linq Namespace

The LINQ to XML Axis Methods

The Oddness of XName (and XNamespace)

Working with XElement and XDocument

Generating Documents from Arrays and Containers

Loading and Parsing XML Content

Manipulating an In-Memory XML Document

Building the UI of the LINQ to XML App

Import the Inventory.xml File

Defining a LINQ to XML Helper Class

Attaching the UI to Your Helper Class

Summary

Chapter 25: Introducing Windows Communication Foundation

A Potpourri of Distributed Computing APIs

The Role of DCOM

The Role of COM+/Enterprise Services

The Role of MSMQ

The Role of .NET Remoting

The Role of XML Web Services

Web Service Standards

The Role of WCF

An Overview of WCF Features

An Overview of Service-Oriented Architecture

Tenet 1: Boundaries are Explicit

Tenet 2: Services are Autonomous

Tenet 3: Services Communicate via Contract, Not Implementation

Tenet 4: Service Compatibility is Based on Policy

WCF: The Bottom Line

Investigating the Core WCF Assemblies

The Visual Studio WCF Project Templates

The WCF Service Web Site Project Template

The Basic Composition of a WCF Application

The ABCs of WCF

Understanding WCF Contracts

Understanding WCF Bindings

HTTP-Based Bindings

TCP-Based Bindings

MSMQ-Based Bindings

Understanding WCF Addresses

Building a WCF Service

The [ServiceContract] Attribute

The [OperationContract] Attribute

Service Types As Operational Contracts

Hosting the WCF Service

Establishing the ABCs Within an App.config File

Coding Against the ServiceHost Type

Specifying Base Addresses

Details of the ServiceHost Type

Details of the Element

Enabling Metadata Exchange

Building the WCF Client Application

Generating Proxy Code Using svcutil.exe

Generating Proxy Code Using Visual Studio

Configuring a TCP-Based Binding

Simplifying Configuration Settings

Leveraging Default Endpoints

Exposing a Single WCF Service Using Multiple Bindings

Changing Settings for a WCF Binding

Leveraging the Default MEX Behavior Configuration

Refreshing the Client Proxy and Selecting the Binding

Using the WCF Service Library Project Template

Building a Simple Math Service

Testing the WCF Service with WcfTestClient.exe

Altering Configuration Files Using SvcConfigEditor.exe

Hosting the WCF Service Within a Windows Service

Specifying the ABCs in Code

Enabling MEX

Creating a Windows Service Installer

Installing the Windows Service

Invoking a Service Asynchronously from the Client

Designing WCF Data Contracts

Using the Web-centric WCF Service Project Template

Implementing the Service Contract

The Role of the *.svc File

Examining the Web.config File

Testing the Service

Summary

Part VII: Windows Presentation Foundation

Chapter 26: Introducing Windows Presentation Foundation and XAML

The Motivation Behind WPF

Unifying Diverse APIs

Providing a Separation of Concerns via XAML

Providing an Optimized Rendering Model

Simplifying Complex UI Programming

The Various Flavors of WPF

Traditional Desktop Applications

Navigation -Based WPF Applications

XBAP Applications

The WPF/Silverlight Relationship

Investigating the WPF Assemblies

The Role of the Application Class

Constructing an Application Class

Enumerating the Windows Collection

The Role of the Window Class

The Role of System.Windows.Controls.ContentControl

The Role of System.Windows.Controls.Control

The Role of System.Windows.FrameworkElement

The Role of System.Windows.UIElement

The Role of System.Windows.Media.Visual

The Role of System.Windows.DependencyObject

The Role of System.Windows.Threading.DispatcherObject

Building a WPF Application Without XAML

Creating a Strongly Typed Window

Creating a Simple User Interface

Interacting with Application-Level Data

Handling the Closing of a Window Object

Intercepting Mouse Events

Intercepting Keyboard Events

Building a WPF Application Using Only XAML

Defining a Window Object in XAML

Defining the Application Object in XAML

Processing the XAML Files Using msbuild.exe

Transforming Markup into a .NET Assembly

Mapping the Window XAML Markup to C# Code

The Role of BAML

Mapping the Application XAML Markup to C# Code

XAML-to-Assembly Process Summary

Understanding the Syntax of WPF XAML

Introducing Kaxaml

XAML XML Namespaces and XAML “Keywords”

Controlling Class and Member Variable Visibility

XAML Elements, XAML Attributes, and Type Converters

Understanding XAML Property-Element Syntax

Understanding XAML Attached Properties

Understanding XAML Markup Extensions

Building a WPF Application Using Code-Behind Files

Adding a Code File for the MainWindow Class

Adding a Code File for the MyApp Class

Processing the Code Files with msbuild.exe

Building WPF Applications Using Visual Studio

The WPF Project Templates

The Toolbox and XAML Designer/Editor

Setting Properties Using the Properties Window

Handling Events Using the Properties Window

Handling Events in the XAML Editor

The Document Outline Window

Viewing the Autogenerated Code Files

Building a Custom XAML Editor with Visual Studio

Designing the GUI of Your Window

Implementing the Loaded Event

Implementing the Button’s Click Event

Implementing the Closed Event

Testing Your Application

Exploring the WPF Documentation

Summary

Chapter 27: Programming with WPF Controls

A Survey of the Core WPF Controls

The WPF Ink Controls

The WPF Document Controls

WPF Common Dialog Boxes

The Details Are in the Documentation

A Brief Review of the Visual Studio WPF Designer

Working with WPF Controls Using Visual Studio

Working with the Document Outline Editor

Controlling Content Layout Using Panels

Positioning Content Within Canvas Panels

Positioning Content Within WrapPanel Panels

Positioning Content Within StackPanel Panels

Positioning Content Within Grid Panels

Grids with GridSplitter Types

Positioning Content Within DockPanel Panels

Enabling Scrolling for Panel Types

Configuring Panels Using the Visual Studio Designers

Building a Window’s Frame Using Nested Panels

Building the Menu System

Building Menus Visually

Building the ToolBar

Building the StatusBar

Finalizing the UI Design

Implementing the MouseEnter/MouseLeave Event Handlers

Implementing the Spell Checking Logic

Understanding WPF Commands

The Intrinsic Command Objects

Connecting Commands to the Command Property

Connecting Commands to Arbitrary Actions

Working with the Open and Save Commands

Understanding Routed Events

The Role of Routed Bubbling Events

Continuing or Halting Bubbling

The Role of Routed Tunneling Events

A Deeper Look at WPF APIs and Controls

Working with the TabControl

Building the Ink API Tab

Designing the ToolBar

The RadioButton Control

Handling Events for the Ink API Tab

The InkCanvas Control

The ComboBox Control

Saving, Loading, and Clearing InkCanvas Data

Introducing the Documents API

Block Elements and Inline Elements

Document Layout Managers

Building the Documents Tab

Populating a FlowDocument Using Code

Enabling Annotations and Sticky Notes

Saving and Loading a Flow Document

Introducing the WPF Data-Binding Model

Building the Data Binding Tab

Establishing Data Bindings Using Visual Studio

The DataContext Property

Data Conversion Using IValueConverter

Establishing Data Bindings in Code

Building the DataGrid Tab

Understanding the Role of Dependency Properties

Examining an Existing Dependency Property

Important Notes Regarding CLR Property Wrappers

Building a Custom Dependency Property

Adding a Data Validation Routine

Responding to the Property Change

Summary

Chapter 28: WPF Graphics Rendering Services

Understanding WPF’s Graphical Rendering Services

WPF Graphical Rendering Options

Rendering Graphical Data Using Shapes

Adding Rectangles, Ellipses, and Lines to a Canvas

Removing Rectangles, Ellipses, and Lines from a Canvas

Working with Polylines and Polygons

Working with Paths

The Path Modeling “Mini-Language”

WPF Brushes and Pens

Configuring Brushes Using Visual Studio

Configuring Brushes in Code

Configuring Pens

Applying Graphical Transformations

A First Look at Transformations

Transforming Your Canvas Data

Working with the Visual Studio Transform Editor

Building the Initial Layout

Applying Transformations at Design Time

Transforming the Canvas in Code

Rendering Graphical Data Using Drawings and Geometries

Building a DrawingBrush Using Geometries

Painting with the DrawingBrush

Containing Drawing Types in a DrawingImage

Working with Vector Images

Converting a Sample Vector Graphic File into XAML

Importing the Graphical Data into a WPF Project

Interacting with the Sign

Rendering Graphical Data Using the Visual Layer

The Visual Base Class and Derived Child Classes

A First Look at Using the DrawingVisual Class

Rendering Visual Data to a Custom Layout Manager

Responding to Hit-Test Operations

Summary

Chapter 29: WPF Resources, Animations, Styles, and Templates

Understanding the WPF Resource System

Working with Binary Resources

Including Loose Resource Files in a Project

Configuring the Loose Resources

Programmatically Loading an Image

Embedding Application Resources

Working with Object (Logical) Resources

The Role of the Resources Property

Defining Window-Wide Resources

The {StaticResource} Markup Extension

The {DynamicResource} Markup Extension

Application-Level Resources

Defining Merged Resource Dictionaries

Defining a Resource-Only Assembly

Understanding WPF’s Animation Services

The Role of the Animation Class Types

The To, From, and By Properties

The Role of the Timeline Base Class

Authoring an Animation in C# Code

Controlling the Pace of an Animation

Reversing and Looping an Animation

Authoring Animations in XAML

The Role of Storyboards

The Role of Event Triggers

Animation Using Discrete Key Frames

Understanding the Role of WPF Styles

Defining and Applying a Style

Overriding Style Settings

Limiting Application of a Style with TargetType

Automatically Applying a Style with TargetType

Subclassing Existing Styles

Defining Styles with Triggers

Defining Styles with Multiple Triggers

Animated Styles

Assigning Styles Programmatically

Logical Trees, Visual Trees, and Default Templates

Programmatically Inspecting a Logical Tree

Programmatically Inspecting a Visual Tree

Programmatically Inspecting a Control’s Default Template

Building a Control Template with the Trigger Framework

Templates as Resources

Incorporating Visual Cues Using Triggers

The Role of the {TemplateBinding} Markup Extension

The Role of ContentPresenter

Incorporating Templates into Styles

Summary

Chapter 30: Notifications, Commands, Validation, and MVVM

Introducing Model-View-ViewModel

Model

View

ViewModel

Anemic Models or ViewModels

The WPF Binding Notification System

Observable Models and Collections

Adding Bindings and Data

Programmatically Changing the Vehicle Data

Observable Models

Using nameof

Observable Collections

Building Custom IList

Using ObservableCollections

Implementing a Dirty Flag

Updating the Source Through UI Interaction

The Final Word

Validation

Updating the Sample for the Validation Examples

The Validation Class

Validation Options

Notify on Exceptions

IDataErrorInfo

INotifyDataErrorInfo

Implementing the Supporting Code

Using INotifyDataErrorInfo for Validations

Showing All Errors

Move the Support Code to a Base Class

Using Data Annotations

Adding Data Annotations

Checking for Data Annotation-Based Validation Errors

Customizing the ErrorTemplate

Creating Custom Commands

Implementing the ICommand Interface

Updating MainWindow.xaml.cs

Updating MainWindow.xaml

Attaching Command to the CommandManager

Creating the CommandBase Class

Updating the ChangeColorCommand Class

Testing the Application

Adding the Remaining Commands

Adding the RemoveCarCommand

Adding the Command Class

Updating the XAML

Adding the AddCarCommand

Adding the Command Class

Updating the XAML

Fully Implementing MVVM

Moving the Data Source Out of the View

Moving the Commands to the ViewModel

Updating AutoLotDAL for MVVM

Updating the AutoLotDAL Models

Updating the Base Class

Updating the Inventory Partial

Implementing INotifyPropertyChanged

Full MVVM Example

Using ObjectMaterialized with Entity Framework

Summary

Part VIII: ASP.NET

Chapter 31: Introducing ASP.NET Web Forms

The Role of HTTP

The HTTP Request/Response Cycle

HTTP Is a Stateless Protocol

Understanding Web Applications and Web Servers

The Role of IIS Virtual Directories

IIS Express

The Role of HTML

HTML Document Structure

The Role of an HTML Form

T he Visual Studio HTML Designer Tools

Building an HTML Form

The Role of Client-Side Scripting

A Client-Side Scripting Example

Posting Back to the Web Server

Postbacks Under Web Forms

An Overview of the Web Forms API

Major Features of Web Forms 2.0 and Higher

Major Features of Web Forms 3.5 (and .NET 3.5 SP1) and Higher

Major Features of Web Forms 4.0

Major Features of Web Forms 4.5 and 4.6

Features Added in Web Forms 4.5

Features Added in Web Forms 4.6

Building a Single-File Web Forms Web App

Referencing AutoLotDAL.dll

Designing the UI

Adding the Data Access Logic

The Role of ASP.NET Directives

Analyzing the “Script” Block

Analyzing the ASP.NET Control Declarations

Building an ASP.NET Web Page Using Code Files

Reference the AutoLotDAL Project

Updating the Code File

Debugging and Tracing ASP.NET Pages

ASP.NET Web Sites vs. ASP.NET Web Applications

Enabling C# 6 For ASP.NET Web Sites

The ASP.NET Web Site Directory Structure

Referencing Assemblies

The Role of the App_Code Folder

The Inheritance Chain of the Page Type

Interacting with the Incoming HTTP Request

Obtaining Browser Statistics

Access to Incoming Form Data

The IsPostBack Property

Interacting with the Outgoing HTTP Response

Emitting HTML Content

Redirecting Users

The Life Cycle of an ASP.NET Web Page

The Role of the AutoEventWireup Attribute

The Error Event

The Role of the Web.config File

The ASP.NET Web Site Administration Utility

Summary

Chapter 32: ASP.NET Web Controls, Master Pages, and Themes

Understanding the Nature of Web Controls

Understanding Server-Side Event Handling

The AutoPostBack Property

The Control and WebControl Base Classes

Enumerating Contained Controls

Dynamically Adding and Removing Controls

Interacting with Dynamically Created Controls

Functionality of the WebControl Base Class

Major Categories of Web Forms Controls

A Brief Word Regarding System.Web.UI.HtmlControls

Web Control Documentation

Building the Web Forms Cars Web Site

Working with Web Forms Master Pages

Configuring the TreeView Control Site Navigation Logic

Establishing Breadcrumbs with the SiteMapPath Type

Configuring the AdRotator Control

Defining the Default Content Page

Designing the Inventory Content Page

Adding AutoLotDAL and Entity Framework to AspNetCarsSite

Filling the GridView with Data

Enabling In-Place Editing

Enabling Sorting and Paging

Enabling Filtering

Designing the Build-a-Car Content Page

The Role of the Validation Controls

Enabling Client-Side JavaScript Validation Support

The RequiredFieldValidator

The RegularExpressionValidator

The RangeValidator

The CompareValidator

Creating Validation Summaries

Defining Validation Groups

Validation with Data Annotations

Creating the Model

Building the User Interface

Adding the Code

Test the App

Working with Themes

Understanding *.skin Files

Applying Site-Wide Themes

Applying Themes at the Page Level

The SkinID Property

Assigning Themes Programmatically

Summary

Chapter 33: ASP.NET State Management Techniques

The Issue of State

ASP.NET State Management Techniques

Understanding the Role of ASP.NET View State

Demonstrating View State

Adding Custom View State Data

The Role of the Global.asax File

The Global Last-Chance Exception Event Handler

The HttpApplication Base Class

Understanding the Application/Session Distinction

Maintaining Application-Level State Data

Modifying Application Data

Handling Web Application Shutdown

Working with the Application Cache

Fun with Data Caching

Modifying the *.aspx File

Maintaining Session Data

Additional Members of HttpSessionState

Understanding Cookies

Creating Cookies

Reading Incoming Cookie Data

The Role of the Element

Storing Session Data in the ASP.NET Session State Server

Storing Session Data in a Dedicated Database

Introducing the ASP.NET Profile API

The ASPNETDB.mdf Database

Defining a User Profile Within web.config

Accessing Profile Data Programmatically

Grouping Profile Data and Persisting Custom Objects

Summary

Chapter 34: ASP.NET MVC and Web API

Introducing the MVC Pattern

The Model

The View

The Controller

Why MVC?

Enter ASP.NET MVC

Convention over Configuration

Building Your First ASP.NET MVC Application

The New Project Wizard

The Components of a Base MVC Project

Project Root Files

Global.asax.cs

The Models Folder

The Controllers Folder

The Views Folder

The Shared Folder

The ASP.NET Folders

The App_Start Folder

BundleConfig

Bundling

Minification

FilterConfig

Identity

RouteConfig

The Content Folder

Bootstrap

The Fonts Folder

The Scripts Folder

Updating NuGet Packages to Current Versions

Test-Drive Your Site

Routing

URL Patterns

Creating Routes for the Contact and About Pages

Redirecting Users Using Routing

Adding AutoLotDAL

Controllers and Actions

Adding the Inventory Controller

Examine the Scaffolded Views

MVC Controllers

Action Results

Using the Inventory Repository

The Index Action

The Details Action

The Create Action

HttpGet

HttpPost

Model Binding

HttpPost vs. HttpGet

AntiForgery Tokens

The Bind Attribute

And Now the Code…

The Edit Action

HttpGet

HttpPost

The Delete Action

HttpGet

HttpPost

The Dispose Method

The Final Word on Controllers

MVC Views

The Razor View Engine

Razor Syntax

Helpers, Functions, and Delegates

HTML Helpers

Razor Functions

Razor Delegates

The Final Word on Razor

Layouts

Using a Specific Layout Page

Partial Views

Sending Data to the View

ViewBag, ViewData, and TempData

Strongly Type Views and View Models

The Index View

MVC Display Data Annotations