Professional C# 7 and .Net Core 2.0

Cover
Title Page
Copyright
About the Author
About the Technical Editor
Credits
Acknowledgments
Contents
Introduction
The World of .NET Core
The World of C#
What’s New In C# 7
Digit Separators
Binary Literals
Expression-Bodied Members
Out Var
Non-Trailing Named Arguments
Readonly Struct
In Parameters
Private Protected
Target-Typed Default
Local Functions
Tuples
Inferred Tuple Names
Deconstructors
Pattern Matching
Throw Expressions
Async Main
Reference Semantics
What’s New in ASP.NET Core
What’s New With the Universal Windows Platform
What you Need to Write and Run C# Code
What This Book Covers
Part I: The C# Language
Part II: .NET Core and the Windows Runtime
Part III: Web Applications and Services
Part IV: Apps
Bonus Chapters
Conventions
Source Code
GitHub
Errata
Part I: The C# Language
Chapter 1: .NET Applications and Tools
Choosing Your Technologies
Reviewing .NET History
C# 1.0—A New Language
C# 2 and .NET 2 with Generics
.NET 3—Windows Presentation Foundation
C# 3 and .NET 3.5—LINQ
C# 4 and .NET 4—Dynamic and TPL
C# 5 and Asynchronous Programming
C# 6 and .NET Core 1.0
C# 7 and .NET Core 2.0
Choosing Technologies and Going Forward
.NET Terms
.NET Framework
.NET Core
.NET Standard
NuGet Packages
Namespaces
Common Language Runtime
Windows Runtime
Using the .NET Core CLI
Setting Up the Environment
Creating the Application
Building the Application
Running the Application
Creating a Web Application
Publishing the Application
Self-Contained Deployments
Using Visual Studio 2017
Installing Visual Studio 2017
Creating a Project
Working with Solution Explorer
Configuring Project Properties
Getting to Know the Editor
Building a Project
Running an Application
Debugging
Application Types and Technologies
Data Access
Windows Apps
Xamarin
Web Applications
Web API
WebHooks and SignalR
Microsoft Azure
Software as a Service
Infrastructure as a Service
Platform as a Service
Functions as a Service
Developer Tools
Visual Studio Community
Visual Studio Professional
Visual Studio Enterprise
Visual Studio for Mac
Visual Studio Code
Summary
Chapter 2: Core C#
Fundamentals of C#
Hello, World!
Working with Variables
Initializing Variables
Using Type Inference
Understanding Variable Scope
Scope Clashes for Local Variables
Scope Clashes for Fields and Local Variables
Working with Constants
Using Predefined Data Types
Value Types and Reference Types
.NET Types
Predefined Value Types
Integer Types
Digit Separators
Working with Binary Values
Floating-Point Types
The Decimal Type
The Boolean Type
The Character Type
Literals for Numbers
Predefined Reference Types
The object Type
The string Type
Controlling Program Flow
Conditional Statements
The if Statement
The switch Statement
Loops
The for Loop
The while Loop
The do. . .while Loop
The foreach Loop
Jump Statements
The goto Statement
The break Statement
The continue Statement
The return Statement
Getting Organized with Namespaces
The using Directive
Namespace Aliases
Understanding the Main Method
Using Comments
Internal Comments Within the Source Files
XML Documentation
Understanding C# Preprocessor Directives
#define and #undef
#if, #elif, #else, and #endif
#warning and #error
#region and #endregion
#line
#pragma
C# Programming Guidelines
Rules for Identifiers
Usage Conventions
Naming Conventions
Casing of Names
Name Styles
Namespace Names
Names and Keywords
Use of Properties and Methods
Use of Fields
Summary
Chapter 3: Objects and Types
Creating and Using Classes
Classes and Structs
Classes
Fields
Readonly Fields
Properties
Expression-Bodied Property Accessors
Auto-Implemented Properties
Access Modifiers for Properties
Read-Only Properties
Auto-Implemented Read-Only Properties
Expression-Bodied Properties
Immutable Types
Anonymous Types
Methods
Declaring Methods
Expression-Bodied Methods
Invoking Methods
Method Overloading
Named Arguments
Optional Arguments
Variable Number of Arguments
Constructors
Expression Bodies with Constructors
Calling Constructors from Other Constructors
Static Constructors
Structs
Structs Are Value Types
Readonly structs
Structs and Inheritance
Constructors for Structs
ref structs
Passing Parameters by Value and by Reference
ref Parameters
out Parameters
in Parameters
Nullable Types
Enum Types
Partial Classes
Extension Methods
The Object Class
Summary
Chapter 4: Object-Oriented Programming with C#
Object Orientation
Types of Inheritance
Multiple Inheritance
Structs and Classes
Implementation Inheritance
Virtual Methods
Polymorphism
Hiding Methods
Calling Base Versions of Methods
Abstract Classes and Methods
Sealed Classes and Methods
Constructors of Derived Classes
Modifiers
Access Modifiers
Other Modifiers
Interfaces
Defining and Implementing Interfaces
Interface Inheritance
Is and as Operators
Summary
Chapter 5: Generics
Generics Overview
Performance
Type Safety
Binary Code Reuse
Code Bloat
Naming Guidelines
Creating Generic Classes
Generics Features
Default Values
Constraints
Inheritance
Static Members
Generic Interfaces
Covariance and Contra-Variance
Covariance with Generic Interfaces
Contra-Variance with Generic Interfaces
Generic Structs
Generic Methods
Generic Methods Example
Generic Methods with Constraints
Generic Methods with Delegates
Generic Methods Specialization
Summary
Chapter 6: Operators and Casts
Operators and Casts
Operators
Operator Shortcuts
The Conditional-Expression Operator (?:)
The checked and unchecked Operators
The is Operator
The as Operator
The sizeof Operator
The typeof Operator
The nameof Operator
The index Operator
Nullable Types and Operators
The Null Coalescing Operator
The Null-Conditional Operator
Operator Precedence and Associativity
Using Binary Operators
Shifting Bits
Signed and Unsigned Numbers
Type Safety
Type Conversions
Implicit Conversions
Explicit Conversions
Boxing and Unboxing
Comparing Objects for Equality
Comparing Reference Types for Equality
The ReferenceEquals Method
The Virtual Equals Method
The Static Equals Method
Comparison Operator (==)
Comparing Value Types for Equality
Operator Overloading
How Operators Work
Operator Overloading Example: The struct Vector
Overloading the Comparison Operators
Which Operators Can You Overload?
Implementing Custom Index Operators
User-Defined Casts
Implementing User-Defined Casts
Casts Between Classes
Casts Between Base and Derived Classes
Boxing and Unboxing Casts
Multiple Casting
Summary
Chapter 7: Arrays
Multiple Objects of the Same Type
Simple Arrays
Array Declaration
Array Initialization
Accessing Array Elements
Using Reference Types
Multidimensional Arrays
Jagged Arrays
Array Class
Creating Arrays
Copying Arrays
Sorting
Arrays as Parameters
Array Covariance
Enumerators
IEnumerator Interface
foreach Statement
yield Statement
Different Ways to Iterate Through Collections
Returning Enumerators with Yield Return
Structural Comparison
Spans
Creating Slices
Changing Values Using Spans
ReadOnly Spans
Array Pools
Creating the Array Pool
Renting Memory from the Pool
Returning Memory to the Pool
Summary
Chapter 8: Delegates, Lambdas, and Events
Referencing Methods
Delegates
Declaring Delegates
Using Delegates
Simple Delegate Example
Action and Func Delegates
BubbleSorter Example
Multicast Delegates
Anonymous Methods
Lambda Expressions
Parameters
Multiple Code Lines
Closures
Events
Event Publisher
Event Listener
Summary
Chapter 9: Strings and Regular Expressions
Examining System.String
Building Strings
StringBuilder Members
String Formats
String Interpolation
FormattableString
Using Other Cultures with String Interpolation
Escaping Curly Brackets
DateTime and Number Formats
Custom String Formats
Regular Expressions
Introduction to Regular Expressions
The RegularExpressionsPlayground Example
Displaying Results
Matches, Groups, and Captures
Strings and Spans
Summary
Chapter 10: Collections
Overview
Collection Interfaces and Types
Lists
Creating Lists
Collection Initializers
Adding Elements
Inserting Elements
Accessing Elements
Removing Elements
Searching
Sorting
Read-Only Collections
Queues
Stacks
Linked Lists
Sorted List
Dictionaries
Dictionary Initializers
Key Type
Dictionary Example
Lookups
Sorted Dictionaries
Sets
Performance
Summary
Chapter 11: Special Collections
Overview
Working with Bits
BitArray
BitVector32
Observable Collections
Immutable Collections
Using Builders with Immutable Collections
Immutable Collection Types and Interfaces
Using LINQ with Immutable Arrays
Concurrent Collections
Creating Pipelines
Using a BlockingCollection
Using a ConcurrentDictionary
Completing the Pipeline
Summary
Chapter 12: Language Integrated Query
LINQ Overview
Lists and Entities
LINQ Query
Extension Methods
Deferred Query Execution
Standard Query Operators
Filtering
Filtering with Index
Type Filtering
Compound from
Sorting
Grouping
Variables Within the LINQ Query
Grouping with Nested Objects
Inner Join
Left Outer Join
Group Join
Set Operations
Zip
Partitioning
Aggregate Operators
Conversion Operators
Generation Operators
Parallel LINQ
Parallel Queries
Partitioners
Cancellation
Expression Trees
LINQ Providers
Summary
Chapter 13: Functional Programming with C#
What Is Functional Programming?
Avoiding State Mutation
Functions as First Class
Higher-Order Functions
Pure Functions
Expression-Bodied Members
Extension Methods
Using Static
Local Functions
Local Functions with the yield Statement
Recursive Local Functions
Tuples
Declaring and Initializing Tuples
Tuple Deconstruction
Returning Tuples
Behind the Scenes
Compatibility of ValueTuple with Tuple
Infer Tuple Names
Tuples with Linked Lists
Tuples with LINQ
Deconstruction
Deconstruction with Extension Methods
Pattern Matching
Pattern Matching with the is Operator
Pattern Matching with the switch Statement
Pattern Matching with Generics
Summary
Chapter 14: Errors and Exceptions
Introduction
Exception Classes
Catching Exceptions
Exceptions and Performance
Implementing Multiple Catch Blocks
Catching Exceptions from Other Code
System.Exception Properties
Exception Filters
Re-throwing Exceptions
Naïve Use to Rethrow the Exception
Changing the Exception
Rethrowing the Exception
Using Filters to Add Functionality
What Happens If an Exception Isn’t Handled?
User-Defined Exception Classes
Catching the User-Defined Exceptions
Throwing the User-Defined Exceptions
Defining the User-Defined Exception Classes
Caller Information
Summary
Chapter 15: Asynchronous Programming
Why Asynchronous Programming Is Important
.NET History of Asynchronous Programming
Synchronous Call
Asynchronous Pattern
Event-Based Asynchronous Pattern
Task-Based Asynchronous Pattern
Async Main Method
Foundation of Asynchronous Programming
Creating Tasks
Calling an Asynchronous Method
Using the Awaiter
Continuation with Tasks
Synchronization Context
Using Multiple Asynchronous Methods
Calling Asynchronous Methods Sequentially
Using Combinators
Using ValueTasks
Converting the Asynchronous Pattern
Error Handling
Handling Exceptions with Asynchronous Methods
Handling Exceptions with Multiple Asynchronous Methods
Using AggregateException Information
Async with Windows Apps
Configure Await
Switch to the UI Thread
Using IAsyncOperation
Avoid Blocking Scenarios
Summary
Chapter 16: Reflection, Metadata, and Dynamic Programming
Inspecting Code at Runtime and Dynamic Programming
Custom Attributes
Writing Custom Attributes
Specifying the AttributeUsage Attribute
Specifying Attribute Parameters
Specifying Optional Attribute Parameters
Custom Attribute Example: WhatsNewAttributes
The WhatsNewAttributes Library
The VectorClass Library
Using Reflection
The System.Type Class
Type Properties
Methods
The TypeView Example
The Assembly Class
Getting Details About Types Defined in an Assembly
Getting Details About Custom Attributes
Completing the WhatsNewAttributes Example
Using Dynamic Language Extensions for Reflection
Creating the Calculator Library
Instantiating a Type Dynamically
Invoking a Member with the Reflection API
Invoking a Member with the Dynamic Type
The Dynamic Type
Dynamic Behind the Scenes
DynamicObject and ExpandoObject
DynamicObject
ExpandoObject
Summary
Chapter 17: Managed and Unmanaged Memory
Memory
Memory Management Under the Hood
Value Data Types
Reference Data Types
Garbage Collection
Strong and Weak References
Working with Unmanaged Resources
Destructors or Finalizers
The IDisposable Interface
The using Statement
Implementing IDisposable and a Destructor
IDisposable and Finalizer Rules
Unsafe Code
Accessing Memory Directly with Pointers
Writing Unsafe Code with the unsafe Keyword
Pointer Syntax
Casting Pointers to Integer Types
Casting Between Pointer Types
void Pointers
Pointer Arithmetic
The sizeof Operator
Pointers to Structs: The Pointer Member Access Operator
Pointers to Class Members
Pointer Example: PointerPlayground
Using Pointers to Optimize Performance
Creating Stack-Based Arrays
QuickArray Example
Reference Semantics
Passing ref and returning ref
Ref and Arrays
Span
Spans Referencing the Managed Heap
Spans Referencing the Stack
Spans Referencing the Native Heap
Span Extension Methods
Platform Invoke
Summary
Chapter 18: Visual Studio 2017
Working with Visual Studio 2017
Visual Studio Editions
Visual Studio Settings
Creating a Project
Multi-Targeting .NET
Selecting a Project Type
Using Windows Universal Project Templates
Using .NET Core Project Templates
Using .NET Standard Templates
Exploring and Coding a Project
Solution Explorer
Working with Projects and Solutions
Adding Projects to a Solution
Setting the Startup Project
Discovering Types and Members
Previewing Items
Using Scopes
Adding Items to a Project
Managing References and Dependencies
Working with the Code Editor
The Folding Editor
Navigating Within the Editor
IntelliSense
CodeLens
Using Code Snippets
EditorConfig
Learning and Understanding Other Windows
Using the Design View Window
Using the Properties Window
Using the Class View Window
Using the Object Browser Window
Using the Server Explorer Window
Using the Cloud Explorer
Using the Document Outline
Arranging Windows
Building a Project
Building, Compiling, and Making Code
Debugging and Release Builds
Optimization
Debugger Symbols
Extra Source Code Debugging Commands
Selecting a Configuration
Editing Configurations
Debugging Your Code
Setting Breakpoints
Using Data Tips and Debugger Visualizers
Live Visual Tree
Monitoring and Changing Variables
Exceptions
Multithreading
Refactoring Tools
Diagnostic Tools
Creating and Using Containers with Docker
Hello Docker!
Running ASP.NET Core in a Docker Container
Creating a Dockerfile
Using Visual Studio
Summary
Part II: .NET Core and the Windows Runtime
Chapter 19: Libraries, Assemblies, Packages, and NuGet
The Hell of Libraries
Assemblies
Creating Libraries
.NET Standard
Creating a .NET Standard Library
Solution Files
Referencing Projects
Referencing NuGet Packages
NuGet Sources
Using .NET Framework Libraries
Using Shared Projects
Creating NuGet Packages
NuGet Packages with the Command Line
Supporting Multiple Platforms
NuGet Packages with Visual Studio
Summary
Chapter 20: Dependency Injection
What Is Dependency Injection?
Using a Service Without Dependency Injection
Using Dependency Injection
Using the .NET Core DI Container
Lifetime of Services
Using Singleton and Transient Services
Using Scoped Services
Using Custom Factories
Initialization of Services Using Options
Using Configuration Files
Creating Platform Independence
.NET Standard Library
WPF Application
UWP Application
Xamarin Application
Using Other DI Containers
Summary
Chapter 21: Tasks and Parallel Programming
Overview
Parallel Class
Looping with the Parallel.For Method
Stopping Parallel.For Early
Parallel For Initialization
Looping with the Parallel.ForEach Method
Invoking Multiple Methods with the Parallel.Invoke Method
Tasks
Starting Tasks
Tasks Using the Thread Pool
Synchronous Tasks
Tasks Using a Separate Thread
Futures—Results from Tasks
Continuation Tasks
Task Hierarchies
Returning Tasks from Methods
Waiting for Tasks
Value Tasks
Cancellation Framework
Cancellation of Parallel.For
Cancellation of Tasks
Data Flow
Using an Action Block
Source and Target Blocks
Connecting Blocks
Timers
Threading Issues
Race Conditions
Deadlocks
The lock Statement and Thread Safety
Interlocked
Monitor
SpinLock
WaitHandle
Mutex
Semaphore
Events
Barrier
ReaderWriterLockSlim
Locks with Await
Summary
Chapter 22: Files and Streams
Introduction
Managing the File System
Checking Drive Information
Working with the Path Class
Creating Files and Folders
Accessing and Modifying File Properties
Using File to Read and Write
Enumerating Files
Working with Streams
Working with File Streams
Creating a FileStream
Getting Stream Information
Analyzing Text File Encodings
Reading Streams
Writing Streams
Copying Streams
Using Random Access to Streams
Using Buffered Streams
Using Readers and Writers
The StreamReader Class
The StreamWriter Class
Reading and Writing Binary Files
Compressing Files
Using the Deflate Stream
Using Brotli
Zipping Files
Watching File Changes
Working with Memory Mapped Files
Using Accessors to Create Memory Mapped Files
Using Streams to Create Memory Mapped Files
Communicating with Pipes
Creating a Named Pipe Server
Creating a Named Pipe Client
Creating Anonymous Pipes
Using Files and Streams with the Windows Runtime
Windows App Editor
Mapping Windows Runtime Types to .NET Types
Summary
Chapter 23: Networking
Networking
The HttpClient Class
Making an Asynchronous Get Request
Throwing Exceptions
Passing Headers
Accessing the Content
Customizing Requests with HttpMessageHandler
Creating an HttpRequestMessage Using SendAsync
Using HttpClient with Windows Runtime
Working with the WebListener Class
Working with Utility Classes
URIs
IPAddress
IPHostEntry
Dns
Using TCP
Creating an HTTP Client Using TCP
Creating a TCP Listener
Creating a TCP Client
TCP Versus UDP
Using UDP
Building a UDP Receiver
Creating a UDP Sender
Using Multicasts
Using Sockets
Creating a Listener Using Sockets
Using NetworkStream with Sockets
Using Readers and Writers with Sockets
Implementing a Receiver Using Sockets
Summary
Chapter 24: Security
Introduction
Verifying User Information
Working with Windows Identities
Windows Principals
Using Claims
Encrypting Data
Creating and Verifying a Signature
Implementing Secure Data Exchange
Signing and Hashing Using RSA
Protecting Data
Implementing Data Protection
User Secrets
Access Control to Resources
Web Security
Encoding
SQL Injection
Cross-Site Request Forgery
Summary
Chapter 25: ADO.NET and Transactions
ADO.NET Overview
Sample Database
NuGet Packages and Namespaces
Using Database Connections
Managing Connection Strings
Connection Pools
Connection Information
Commands
ExecuteNonQuery
ExecuteScalar
ExecuteReader
Calling Stored Procedures
Asynchronous Data Access
Transactions with ADO.NET
Transactions with System.Transactions
Committable Transactions
Dependent Transactions
Ambient Transactions
Nested Scopes with Ambient Transactions
Summary
Chapter 26: Entity Framework Core
History of Entity Framework
Introducing EF Core
Creating a Model
Conventions, Annotations, and Fluent API
Creating a Context
Creating the Database
Deleting the Database
Writing to the Database
Reading from the Database
Updating Records
Deleting Records
Logging
Using Dependency Injection
Creating a Model
Creating a Relation
Data Annotations
Fluent API
Self-Contained Type Configuration
Scaffolding a Model from the Database
Mapping to Fields
Shadow Properties
Queries
Basic Queries
Client and Server Evaluation
Raw SQL Queries
Compiled Queries
Global Query Filters
EF.Functions
Relationships
Relationships Using Conventions
Explicit Loading Related Data
Eager Loading Related Data
Relationships Using Annotations
Relationships Using Fluent API
Table per Hierarchy with Conventions
Table per Hierarchy with Fluent API
Table Splitting
Owned Entities
Saving Data
Adding Objects with Relations
Object Tracking
Updating Objects
Updating Untracked Objects
Batching
Conflict Handling
The Last One Wins
The First One Wins
Context Pooling
Using Transactions
Using Implicit Transactions
Creating Explicit Transactions
Migrations
Preparing the Project File
Hosting Applications with ASP.NET Core MVC
Hosting .NET Core Console App
Creating Migrations
Applying Migrations Programmatically
Other Ways to Apply Migrations
Summary
Chapter 27: Localization
Global Markets
Namespace System.Globalization
Unicode Issues
Cultures and Regions
Specific, Neutral, and Invariant Cultures
Current Culture and CurrentUICulture
Number Formatting
Date Formatting
Cultures in Action
Sorting
Resources
Resource Readers and Writers
Using the Resource File Generator
Using Resource Files with ResourceManager
The System.Resources Namespace
Localization with ASP.NET Core
Registering Localization Services
Injecting Localization Services
Culture Providers
Using Resources from ASP.NET Core
Localizing with Controllers and Views
Localization with the Universal Windows Platform
Using Resources with UWP
Localization with the Multilingual App Toolkit
Summary
Chapter 28: Testing
Overview
Unit Testing with MSTest
Creating Unit Tests with MSTest
Running Unit Tests
Expecting Exceptions with MSTest
Testing All Code Paths
External Dependencies
Unit Testing with xUnit
Using xUnit with .NET Core
Creating Facts
Creating Theories
Using a Mocking Library
Live Unit Testing
Unit Testing with EF Core
UI Testing with Windows Apps
Web Integration, Load, and Performance Testing
ASP.NET Core Integration Tests
Creating the Web Test
Running the Web Test
Summary
Chapter 29: Tracing, Logging, and Analytics
Diagnostics Overview
Tracing with EventSource
Examining a Simple Use of EventSource
Understanding Tools for Tracing
Logman
Tracerpt
PerfView
Deriving from EventSource
Using Annotations with EventSource
Creating Event Manifest Schema
Using Activity IDs
Creating Custom Listeners
Writing Logs with the ILogger Interface
Configuring Providers
Using Scopes
Filtering
Configure Logging
Using ILogger Without Dependency Injection
Analytics with Visual Studio App Center
Summary
Part III: Web Applications And Services
Chapter 30: ASP.NET Core
ASP.NET Core
Web Technologies
HTML
CSS
JavaScript and TypeScript
Scripting Libraries
ASP.NET Web Project
Startup
Sample Application
Adding Client-Side Content
Using Tools for Client Content
Using Client-Side Libraries with Bower
Using a JavaScript Package Manager: npm
Bundling
Packaging with webpack
Request and Response
Request Headers
Query String
Encoding
Form Data
Cookies
Sending JSON
Dependency Injection
Defining a Service
Registering the Service
Injecting the Service
Calling the Controller
Simple Routing
Creating Custom Middleware
Session State
Configuring with ASP.NET Core
Reading the Configuration
Changing Configuration Providers
Different Configurations Based on the Environment
Summary
Chapter 31: ASP.NET Core MVC
Setting Up Services for ASP.NET Core MVC
Defining Routes
Adding Routes
Using Route Constraints
Creating Controllers
Understanding Action Methods
Using Parameters
Returning Data
Working with the Controller Base Class and POCO Controllers
Creating Views
Passing Data to Views
Understanding Razor Syntax
Creating Strongly Typed Views
Defining the Layout
Using a Default Layout Page
Using Sections
Defining Content with Partial Views
Using Partial Views from Server-Side Code
Returning Partial Views from the Controller
Working with View Components
Using Dependency Injection in Views
Importing Namespaces with Multiple Views
Receiving Data from the Client
Model Binder
Annotations and Validation
Working with HTML Helpers
Using Simple Helpers
Using Model Data
Defining HTML Attributes
Creating Lists
Using Strongly Typed Helpers
Working with Editor Extensions
Implementing Templates
Getting to Know Tag Helpers
Activating Tag Helpers
Using Anchor Tag Helpers
Using Label Tag Helpers
Using Input Tag Helpers
Using a Form with Validation
Environment Tag Helper
Creating Custom Tag Helpers
Creating Elements with Tag Helpers
Implementing Action Filters
Creating a Data-Driven Application
Defining a Model
Creating a Database
Creating a Service
Creating a Controller
Creating Views
Implementing Authentication and Authorization
Storing and Retrieving User Information
Starting Up the Identity System
Performing User Registration
Setting Up User Login
Authenticating Users
Authenticating Users with Azure Active Directory
Creating the Azure Active Directory B2C Tenant
Creating the ASP.NET Core Web Application with Azure AD B2C
Razor Pages
Creating a Razor Pages Project
Implementing Data Access
Using Inline Code
Using Inline Code with a Page Model
Using Code-Behind
Page Parameters
Summary
Chapter 32: Web API
Overview
Creating Services
Defining a Model
Creating a Service
Creating a Controller
Changing the Response Format
REST Results and Status Codes
Creating an Async Service
Creating a .NET Client
Sending GET Requests
Receiving XML from the Service
Sending POST Requests
Sending PUT Requests
Sending DELETE Requests
Writing to the Database
Using EF Core
Creating the Data Access Service
Creating Metadata with the OpenAPI or Swagger
Creating and Using OData Services
Creating a Data Model
Creating the Database
OData Startup Code
Creating the OData Controller
OData Query
Using Azure Functions
Creating Azure Functions
Using a Dependency Injection Container
Implementing GET, POST, and PUT Requests
Running the Azure Function
Summary
Part IV: Apps
Chapter 33: Windows Apps
Introducing Windows Apps
Windows Runtime
Hello, Windows
Application Manifest
Application Startup
Main Page
Intro to XAML
XAML Standard
Mapping Elements to Classes
Using Custom .NET Classes with XAML
Setting Properties as Attributes
Using Properties as Elements
Dependency Properties
Creating a Dependency Property
Value Changed Callbacks and Events
Routed Events
Attached Properties
Markup Extensions
Custom Markup Extensions
Conditional XAML
Controls
Framework-Derived UI Elements
Presenters
Parallax
Control-Derived Controls
Using a TextBox
Selecting a Date
Range Controls
Progress Bar
Slider
Content Controls
Buttons
Replacing the Content of the Button
Linking with the HyperlinkButton
Items Controls
Flyouts
Data Binding
Change Notification with INotifyPropertyChanged
Creating a List of Books
List Binding
Binding Events to Methods
Using Data Templates and the Data Template Selector
Binding Simple Objects
Value Conversion
Navigation
Navigating to the Initial Page
Overriding Page Class Navigation
Navigating Between Pages
Back Button
Hub
Pivot
NavigationView
Layout Panels
StackPanel
Canvas
Grid
VariableSizedWrapGrid
RelativePanel
Adaptive Triggers
XAML Views
Deferred Loading
Summary
Chapter 34: Patterns with XAML Apps
Why MVVM?
Defining the MVVM Pattern
Sharing Code
Using API Contracts with the Universal Windows Platform
Working with Shared Projects
Working with .NET Standard Libraries
Sample Solution
Models
Implementing Change Notification
Using the Repository Pattern
Services
View Models
Using IEditableObject
Concrete View Model Implementations
Commands
Services, ViewModels, and Dependency Injection
Views
Opening Dialogs from View Models
Navigation Between Pages
Adaptive User Interfaces
Showing Progress Information
Using Actions in List Items
Messaging Using Events
Using a Framework
Summary
Chapter 35: Styling Windows Apps
Styling
Shapes
Geometry
Geometries Using Segments
Geometries Using Path Markup
Transformation
Scaling
Translating
Rotating
Skewing
Transforming with Groups and Composite Transforms
Transforming Using a Matrix
Brushes
SolidColorBrush
LinearGradientBrush
ImageBrush
AcrylicBrush
Reveal Brushes
Styles and Resources
Styles
Resources
Accessing Resources from Code
Resource Dictionaries
Theme Resources
Defining Theme Resources
Selecting a Theme
Templates
Control Templates
Data Templates
Styling a ListView
DataTemplate for ListView Items
Item Container Style
Items Panel
List View Control Template
Animations
Timeline
Easing Functions
Keyframe Animations
Transitions
Reposition Transition
Pane Transition
Transitions for Items
Visual State Manager
Predefined States with Control Templates
Defining Custom States
Setting Custom States
Summary
Chapter 36: Advanced Windows Apps
Overview
App Lifetime
Application Execution States
Navigation Between Pages
Navigation State
Suspending the App
Activating the App from Suspension
Testing Suspension
Page State
Sharing Data
Sharing Source
Sharing Target
App Services
Creating the Model
Creating a Background Task for App Service Connections
Registering the App Service
Calling the App Service
Advanced Compiled Binding
Compiled Data Binding Lifetime
Binding to Methods
Phasing with x:Bind
Using Text
Using Fonts
Inline and Block Elements
Using Overflow Areas
Inking
AutoSuggest
Summary
Chapter 37: Xamarin.Forms
Starting with Xamarin Development
Architecture Xamarin with Android
Architecture Xamarin with iOS
Xamarin.Forms
Tools for Xamarin Development
Android
iOS
Visual Studio 2017
Visual Studio for Mac
Visual Studio App Center
Android Foundation
Activity
Resources
Displaying Lists
Defining a Model
Using the ListActivity
Implementing an Adapter
Navigation with Android
Showing a Message
iOS Foundation
iOS App Structure
Storyboard
Controller
Showing a Message
Xamarin.Forms Application
Windows Apps Hosting Xamarin
Android Hosting Xamarin
iOS Hosting Xamarin
Shared Project
Using the Common Libraries
Control Hierarchy
Pages
Navigation
Layout
Views
Data Binding
Commands
ListView and ViewCell
Summary
Index
EULA