Index
A
Action methods
Action results
ActivatorUtilities class, resolving services
Angular
appsettings.Development.json File
SeeConfiguration
appsettings.json File
SeeConfiguration
Arrays, model binding
ASP.NET Core
application frameworks
Blazor
MVC framework
Razor Pages
architecture
gRPC
platform
SignalR
utility frameworks
ASP.NET Core Identity
Entity Framework Core
ASP.NET Core Identity
access denied endpoint
application configuration
authentication cookie
authentication middleware
authentication vs. authorization
authN
authorization
Authorize attribute
endpoints
web services
authorization middleware
Authorize attribute
AuthenticationSchemes argument
Roles argument
authZ
Blazor applications
changing passwords
ClaimsPrincipal class
creating roles
creating users
database configuration
database migration
database reset
deleting roles
deleting users
disabling redirection
editing roles
editing users
Entity Framework Core
enumerating roles
enumerating users
IdentityResult class
IdentityRole class
Identity Server
IdentityUser class
importance of HTTPS
logging in
logging out
management tools
OAuth
options pattern
package, adding
PasswordOptions class
password validation
redirection URLs
RoleManager<T> class
role membership
scaffolding
seed data
service configuration
SignInManager<T> class
two-factor authentication
UserManager<T> class
UserOptions class
validating user details
web services
bearer tokens
cookie authentication
JSON Web Token
ASP.NET Core Platform
SeePlatform
Authentication
SeeASP.NET Core Identity
Authorization
SeeASP.NET Core Identity
B
Blazor
advantages
application errors
element ID
architecture
attributes, parameters
attribute splatting
authorization
AuthorizeRouteView component
AuthorizeView component
bindings
configuring
DateTime bindings
defining
Blazor Server
Blazor WebAssembly
cascading parameters
client-side code
components
applying
attributes
bulk attributes
cascading parameters
child content
code-only
code section
combining
configuration
content section
creating
custom bindings
custom events
custom form
DataAnnotationsValidator
element references
forms
generic templates
InvokeAsync method
invoking from other code
JavaScript
@key expression
LayoutView
partial classes
restricting element reuse
StateHasChanged method
tag helper
templates
ValidationMessage
ValidationSummary
connection errors
element classes
element ID
testing with Fiddler
data validation
components
element classes
disadvantages
EditForm component
enabling
Entity Framework Core
dependency injection scopes
repeated queries
errors
events
attributes
default actions
event types
handler methods names
handler parameters
inline expressions
parameters
propagation
form features
forms
CRUD operations
EditContext features
HTTP connection
hub
imports file, creating
InputCheckbox component
InputDate component
InputNumber component
InputTextArea component
InputText component
JavaScript file
@layout expression
layouts
lifecycle
Parameter attribute
@ref expression
rendering modes
retaining references, @ref expression
routing
configuring fallback
default route
layouts
MapFallbackToPage method
navigation
NavigationManager service
NavLink component
@page directive
receiving route data
Router component
RouteView component
WebAssembly
SeeWebAssembly, Blazor
Blazor Server
SeeBlazor
Blazor WebAssembly
SeeBlazor
Bootstrap CSS framework
Bower
C
C#
anonymous types
asynchronous methods
asynchronous enumerable
async keyword
await keyword
tasks
collection initializers
extension methods
index initializers
interfaces
default implementations
extension methods
lambda expressions
expression forms
functions
methods
properties
nameof expressions
non-nullable reference types
null coalescing operator
null conditional operator
object initializers
pattern matching
properties
auto-implemented
read-only
string interpolation
type inference
var keyword
Caching
SeeServices
Circular references
SeeEntity Framework Core
Client-Side packages
SeeStatic Content
Collections, model binding
Configuration
appsettings.json File
ASPNETCORE_ENVIRONMENT
command-line arguments
determining the environment
environment-specific configuration
IConfiguration interface
IsDevelopment method
IsProduction method
IsStaging method
launch.json File
launchSettings.json File
listing secrets
middleware components
user secrets
initializing
reading secrets
storing secrets
tooling
Containers, creating
Content Delivery Networks
Content Negotiation
Controllers
Cookies
CookieOptions class
IsEssential property
ITrackingConsentFeature interface
sessions
SeeSessions
tracking cookies
UseCookiePolicy method
D
Data validation
attributes
Range
Required
ModelState property
Debugging
Dependency injection
ActivatorUtilities class
CreateInstance method
GetServiceOrCreateInstance method
AddScoped method
AddSingleton method
AddTransient method
concrete-class services
ConfigureServices method
accessing services
controllers
dependency chains
endpoints
adaptor functions
method parameters
Entity Framework Core scopes
exceptions
factory functions
filters
FromServices attribute
GetRequiredService method
GetService method
HttpContext object
RequestServices property
IServiceProvider interface, extension methods
middleware
constructor parameter
HttpContext object
multiple implementations
options pattern
service lifecycles
AddTransient method
methods
scoped services
singleton services
transient services
service location
singleton pattern
tight coupling
type brokers
unbound types
whether to use
Design patterns
Dictionaries, model binding
Docker
E
Endpoints, controllers
Entity Framework Core
AddDbContext<T> method
ASP.NET Core Identity
changing primary keys
Column attribute
connection strings
multiple active result sets
context class
creating related data
creating services
data model classes
global tools, installing
LINQ queries
logging sensitive data
migrations
applying
creating
NuGet packages, installing
related data
circular references
Include method
projecting new objects
related data properties, resetting
seeding data
SQL types
storing data
migrations
SaveChangesAsync method
SaveChanges method
Errata, reporting
Exceptions
developer exception page
HTML error responses
status code responses
F
Files, sending using action results
Filters
action filters
attributes
authorization filters
dependency injection
exception filters
execution order
factories
FilterContext class
global filters
IActionFilter interface
IAlwaysRunResultFilter interface
IAsyncActionFilter interface
IAsyncAlwaysRunResultFilter interface
IAsyncAuthorizationFilter interface
IAsyncExceptionFilter interface
IAsyncPageFilter interface
IAsyncResourceFilter interface
IAsyncResultFilter interface
IAuthorizationFilter interface
IExceptionFilter interface
IFilterFactory interface
interfaces
IOrderedFilter interface
IPageFilter interface
IResourceFilter interface
IResultFilter interface
lifecycle
reusing filters
using scopes
ordering
page filters
RequireHttps
resource filters
result filters
always-run filters
context objects
reusing filters
ServiceFilter attribute
short-circuiting
types
Forms
Blazor form features
button elements
asp-action attribute
asp-controller attribute
asp-page attribute
creating data
creating related data
separate request
single request
CSRF protection
AutoValidateAntiForgeryToken attribute
controllers
IgnoreAntiForgeryToken attribute
JavaScript clients
Razor Pages
security token
ValidateAntiForgeryToken attribute
deleting data
editing data
elements
asp-* attributes
asp-action attribute
asp-controller attribute
asp-page attribute
target
input elements
asp-for attribute
Column attribute
DisplayFormat attribute
formatting values
id attribute
name attribute
related data
type attribute
value attribute
label elements
asp-for attribute
for attribute
Post/Redirect/Get pattern
reading data
resetting
select elements
asp-for attribute
asp-items attribute
SelectList class
SelectListItem class
tag helpers
textarea elements, asp-for attribute
G
General Data Protection Regulation
SeeCookies
Globbing selectors
GraphQL
gRPC
H
Host header, request filtering
HTML Forms
SeeForms
HTML, Safe Encoding
HttpContext class
HttpRequest class
HttpResponse class
HTTPS
configuring
detecting HTTPS requests
development certificates
enabling
redirection from
status codes
Strict Transport Security
SSL
TLS
I
Identity
SeeASP.NET Core Identity
J, K
jQuery
client-side validation packages
installing package
model validation messages
JSON
serializer configuration
web services
JSON.NET Serializer
L
Library Manager
SeeStatic Content
Lists, model binding
LocalDB
Logging
categories
ILogger<T> interface
log levels
messages
providers
console
Debug
EventSource
list
SQL queries
M
Middleware
branching
built-in middleware
context objects
cookies
creating
exception handling
Host header filtering
HTTPS
Map method
MapWhen method
next function
request pipeline
response caching
SeeServices
response compression, UseResponseCompression method
return path
Run middleware
sessions
short-circuiting
static files
terminal middleware
URL routing
SeeRouting
UseDeveloperExceptionPage
UseEndpoints
Use method
UseMiddleware method
UseRouting
using classes
Model binding
arrays
specifying indices
BindNever attribute
BindProperties attribute
collections
arrays
collections of complex types
dictionaries
key/value pairs
lists
sequences
sets
simple collections
complex types
binding to a property
nested types
property binding
selectively binding properties
default values
FromBody attribute
FromForm attribute
FromHeader attribute
FromQuery attribute
FromRoute attribute
FromService attribute
manual binding
TryUpdateModelAsync method
nested types
nullable parameters
over binding
Razor Pages
search locations
simple types
default values
source selection
TryUpdateModelAsync method
understanding
Model validation
AddModelError method
client-side validation
extending
JavaScript packages
explicit validation
GetValidationState method
IsValid property
metadata validation
mismatched model types
model state dictionary
new view model objects
Razor Pages
remote validation
understanding
validating checkboxes
validation attributes
Compare attribute
custom attributes
Range attribute
RegularExpression attribute
Required attribute
StringLength attribute
validation messages
attributes
configuring
element highlighting
jQuery
model-level messages
property-level messages
tag helper
ValidationSummary values
validation states
web services controllers
Model-View-Controller Pattern
MVC Framework
action results
ControllerBase class
controllers
defining
ModelState property
enabling
MVC pattern
NonController attribute
pattern
Razor
SeeViews
separation of concerns
views
SeeViews
N
.NET Core SDK
NuGet
null values
O
OpenAPI
SeeWeb Services
Options pattern
P, Q
Pages, model expressions
PATCH method
Platform
client-side packages
SeeStatic Content
configuration
SeeConfiguration
Cookies
SeeCookies
distributed cache
exceptions
SeeExceptions
Host header
HTTPS
SeeHTTPS
Logging
SeeLogging
middleware
SeeMiddleware
options pattern
request features
request pipeline
branching
return path
services
sessions
SeeSessions
static content
SeeStatic Content
understanding
Program class
Projects
adding items
adding packages
appsettings files
appsettings.json file
SeeConfiguration
building projects
client-side packages
compiling projects
creating
dotnet new command
creation
csproj project file
debugging
Empty template
entry point
global.json file
launch.json File
launchSettings.json file
LibMan
managing packages
client-side
tool
opening
request pipeline, short-circuiting
running
scaffolding
Startup class
templates
tool packages
R
Razor
SeeViews
Razor Component
SeeBlazor
Razor Pages
action results
Page method, implied
redirections
code-behind classes
common base classes
configuration
creating
dependency injection
generated class
HTTP methods
@inject directive
layouts
model validation
multiple handler methods
@page directive
page model
base class
code-behind class
generating URLs
handler parameter/variable
multiple handler methods
multiple HTTP methods
properties
Url property
page view
partial views
MVC Framework
search path
registering tag helpers
routing
conventions
default URL
defining a route
routing convention
runtime compilation
view components, using
React
Redis
SeeServices
Repository pattern
Response compressions
RESTFul web services
SeeWeb Services
Routing
ambiguous routes
avoiding
ordering
applying middleware
areas
convention routing
defining endpoints
Endpoints, RequestDelegate
endpoint selection
GetEndpoint method
fallback routes
generating URLs
HttpContext.RouteValues property
IEndpointRouteBuilder methods
MapControllerRoute method
MapDefaultControllerRoute method
Razor Pages
route selection
URL patterns
catch-all segments
complex patterns
constraints
default values
optional segments
regular expressions
RouteValuesDictionary class
segment variables
WithMetadata method
S
Scaffolding
Security
SeeASP.NET Core Identity
Services
AddDistributedSqlServerCache
application lifetime service
caching
AddDistributedMemoryCache method
AddStackExchangeRedisCahce method
database preparation
data cache
DistributedCacheEntryOptions class
distributed caching
IDistributedCache implementations
IDistributedCache interface
memory cache options
NuGet package
persistent caching
SQL Server cache options
response caching
AddResponseCaching method
Cache-Control header
UseResponseCaching method
Vary header
Sessions
configuration
data cache
ISession interface
session data
SignalR
Single page applications
Singleton pattern
Source maps
SportsStore
administration
Blazor Server
cart
checkout
client-side packages
connection strings
creating projects
data model
deployment
Entity Framework Core
filtering categories
migrations
navigation menu
page counts, fixing
pagination
repository pattern
security
sessions
tag helpers
unit testing
validation
SQL Server, LocalDB
Startup class
Configure method
SeeMiddleware
ConfigureServices method
SeeDependency Injection
Startup Class, enabling MVC
Static Content
Bower
Library Manager
initializing project
installing packages
middleware
wwwroot folder
Status code responses
T
Tag Helper Components
SeeTag Helpers
Tag Helpers
anchor elements
Razor Pages
attributes
HtmlAttributeName attribute
naming convention
Blazor
built-in helpers
cache busting
caching content
cache expiry
distributed caching
variations
components
creating
expanding selection
TagHelperComponent class
TagHelperComponentTagHelper class
context data
TagHelperContext class
ViewContext attribute
coordination
creating
CSS stylesheets
enabling
environment element
forms
SeeForms
globbing
HtmlAttributeNotBound attribute
HtmlTargetElement attribute
images
img elements
JavaScript files
link elements
model expressions
output
ProcessAsync method
Process method
property naming convention
registering
scope
increasing
restricting
script elements
cache busting
content delivery networks
selecting
short-hand elements
suppressing output
TagBuilder class
TagHelperContext class
TagHelperOutput class
validation messages
view components
ViewContext attribute
_ViewImports.cshtml file
Temp data
SeeViews
Type broker pattern
U
Unit testing
Assert methods
creating the test project
Fact attribute
isolating components
mocking
Moq package
MSTest
NUnit
project templates
running tests
writing tests
XUnit
URL Routing
SeeRouting
User Secrets
SeeConfiguration
V
View Components
applying
Component.InvokeAsync expression
custom HTML element
Razor Pages
tag helper
vc element
context data
parent view
creating
hybrid classes
controllers
Razor Pages
ViewComponent attribute
ViewComponentContext attribute
Invoke method
parent views
results
HTML fragments
partial views
ViewComponent attribute
ViewComponent class
context data
properties
Views
AddControllersWithViews method
AddRazorRuntimeCompilation method
compilation package
content encoding, disable
content-encoding
CSHTML files
directives
@addTagHelper
@attribute
@functions
@implements
@inherits
@inject
@model
@namespace
@page
@section
@using
expressions
@
attribute values
@await
code blocks
conditional expressions
element content
@foreach
@if
@Model
sequences
@switch
@try
generated classes
generating URLs
Url property
HTML content-encoding
IntelliSense support
JSON content-encoding
layouts
configuring
disabling
optional sections
overriding the default layout
RenderSection method
section expressions
sections
selecting a layout
selecting programmatically
model expressions
partial views
HTML Helper
partial element
RazorPage<T> class
Razor syntax
recompilation
registering tag helpers
search path
selecting by name
shared views
temp data
keep method
peek method
TempData attribute
TempData property
templated delegates
view bag
view components
view import file
view model object
view start files
Visual Studio
browser selection
installing
LocalDB
workloads
Visual Studio Code
environment selection
installing
LocalDB
W, X, Y, Z
WebAssembly, Blazor
base element
base URL
components
CSS styles
HttpClient service
layout
navigation URLs
placeholder components
project creation
project template
setup
shared code
Web Pages
Web Services
action methods, results
action results
actions, HTTP method attributes
ApiController attribute
authentication
authorization
content formatting
custom formatters
default policy
JSON formatting
restricting formats
XML formatting
content negotiation
Accept header
Consumes attribute
respecting Accept header
URL
controllers
asynchronous actions
attributes
ControllerBase class
creating
dependency injection
FromServices attribute
model binding
SeeModel binding
services
data validation
SeeData validation
endpoints
GraphQL
gRPC
HTTP PATCH method
JSON Patch
JSON.NET Serializer
JsonPatchDocument<T> class
NuGet package
specification
model validation
null properties
OpenAPI
API Analyzer
conflicts
Nuget Package
ProducesResponseType attribute
Related data
remote model validation
REST
routing
URLs/HTTP Methods
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.