book

Web API Development with ASP.NET Core 8

Name: Web API Development with ASP.NET Core 8
Author: Xiaodi Yan
ISBN: 9781804610954

by Xiaodi Yan

April 2024

Intermediate to advanced

804 pages

19h 30m

English

Packt Publishing

Read now

Unlock full access

Web API Development with ASP.NET Core 8
ContributorsAbout the authorAbout the reviewers
Preface
Who this book is forWhat this book coversTo get the most out of this bookDownload the example code filesConventions usedGet in touchShare Your ThoughtsDownload a free PDF copy of this book
Chapter 1: Fundamentals of Web APIs
What is a web API?What is a REST API?The constraints of RESTA REST API exampleIs my web API RESTful?Designing a REST-based APIIdentifying the resourcesDefining the relationships between resourcesIdentifying operationsDesigning the URL paths for resourcesMapping API operations to HTTP methodsAssigning response codesDocumenting the APIRPC and GraphQL APIsWhat is an RPC-based API?What is a GraphQL API?Real-time APIsThe problem with API pollingWhat is a real-time API?Which real-time communication technology is best for your application?Summary
Chapter 2: Getting Started with ASP.NET Core Web APIs
Technical requirementsSetting up the development environmentConfiguring VS CodeChecking the .NET SDKCreating a simple REST web API projectBuilding and running the projectBuilding the projectRunning the projectChanging the port numberHot ReloadTesting the API endpointSwagger UIDebuggingUnderstanding the MVC patternThe model and the controllerCreating a new model and controllerCreating a serviceImplementing a GET operationImplementing a CREATE operationImplementing an UPDATE operationDependency injectionUnderstanding DIDI in ASP.NET CoreDI tipsIntroduction to minimal APIsCreating a simple endpointUsing DI in minimal APIsWhat is the difference between minimal APIs and controller-based APIs?Summary
Chapter 3: ASP.NET Core Fundamentals (Part 1)
Technical requirementsRoutingWhat is attribute routing?Mapping HTTP methods to action methodsRoute constraintsBinding source attributesConfigurationUsing appsettings.jsonUsing the options patternOther configuration providersEnvironmentsUnderstanding the launchSettings.json fileSetting the environmentUnderstanding the priorities of configuration and environment variablesChecking the environment in the codeSummary
Chapter 4: ASP.NET Core Fundamentals (Part 2)
Technical requirementsLoggingUsing built-in logging providersLogging levelsLogging parametersUsing third-party logging providersStructured loggingWhat should/shouldn’t we log?MiddlewareWhat is middleware?Built-in middlewareCreating a custom middleware componentSummary
Chapter 5: Data Access in ASP.NET Core (Part 1: Entity Framework Core Fundamentals)
Technical requirementsWhy use ORM?Configuring the DbContext classCreating modelsCreating and configuring the DbContext classCreating the databaseAdding seed dataImplementing CRUD controllersCreating the controllerHow controllers workBasic LINQ queriesQuerying the dataFiltering the dataSorting and pagingCreating an entityUpdating an entityDeleting an entityConfiguring the mapping between models and databaseMapping conventionsData annotationsFluent APISeparating the mapping configurationsSummary
Chapter 6: Data Access in ASP.NET Core (Part 2 – Entity Relationships)
Technical requirementsUnderstanding one-to-many relationshipsOne-to-many configurationOne-to-many CRUD operationsUnderstanding one-to-one relationshipsOne-to-one configurationOne-to-one CRUD operationsUnderstanding many-to-many relationshipsMany-to-many configurationMany-to-many CRUD operationsUnderstanding owned entitiesSummary
Chapter 7: Data Access in ASP.NET Core (Part 3: Tips)
Technical requirementsUnderstanding DbContext poolingUnderstanding the difference between tracking versus no-tracking queriesUnderstanding the difference between IQueryable and IEnumerableClient evaluation versus server evaluationUsing raw SQL queriesFromSql() and FromSqlRaw()SqlQuery() and SqlQueryRaw()ExecuteSql() and ExecuteSqlRaw()Using bulk operationsExecuteUpdate()ExecuteDelete()Understanding concurrency conflictsNative database-generated concurrency tokenApplication-managed concurrency tokenHandling concurrency conflictsReverse engineeringOther ORM frameworksSummary
Chapter 8: Security and Identity in ASP.NET Core
Technical requirementsGetting started with authentication and authorizationCreating a sample project with authentication and authorizationUnderstanding the JWT token structureConsuming the APIConfiguring the Swagger UI to support authorizationDelving deeper into authorizationRole-based authorizationClaim-based authorizationUnderstanding the authorization processPolicy-based authorizationManaging users and rolesNew Identity API endpoints in ASP.NET Core 8Understanding OAuth 2.0 and OpenID ConnectWhat is OAuth 2.0?What is OpenID Connect?Integrating with other identity providersOther security topicsAlways use Hypertext Transfer Protocol Secure (HTTPS)Using a strong password policyImplementing two-factor authentication (2FA)Implementing rate-limitingUsing model validationUsing parameterized queriesUsing data protectionKeeping secrets safeKeeping the framework up to dateChecking the Open Web Application Security Project (OWASP) Top 10Summary

Chapter 9: Testing in ASP.NET Core (Part 1 – Unit Testing)
Technical requirementsIntroduction to testing in ASP.NET CoreWriting unit testsPreparing the sample applicationSetting up the unit tests projectWriting unit tests without dependenciesWriting unit tests with dependenciesUsing FluentAssertions to verify the test resultsTesting the database access layerHow can we test the database access layer?Creating a test fixtureUsing the test fixtureWriting tests for methods that change the databaseParallelism of xUnitUsing the repository patternTesting the happy path and the sad pathSummary
Chapter 10: Testing in ASP.NET Core (Part 2 – Integration Testing)
Technical requirementsWriting integration testsSetting up the integration test projectWriting basic integration tests with WebApplicationFactoryTesting with a database contextTesting with mock servicesTesting with authentication and authorizationPreparing the sample applicationCreating a test fixtureCreating the test classTesting the anonymous API endpointsTesting the authorized API endpointsCode coverageUsing data collectorsGenerating a code coverage reportSummary
Chapter 11: Getting Started with gRPC
Technical requirementsRecap of gRPCSetting up a gRPC projectCreating a new gRPC projectUnderstanding the gRPC project structureCreating protobuf messagesDefining a protobuf messageUnderstanding field numbersUnderstanding the field typesOther .NET typesCreating a protobuf serviceDefining a unary serviceCreating a gRPC clientDefining a server streaming serviceDefining a client streaming serviceDefining a bidirectional streaming serviceConsuming gRPC services in ASP.NET Core applicationsUpdating proto filesSummaryFurther reading
Chapter 12: Getting Started with GraphQL
Technical requirementsRecap of GraphQLSetting up a GraphQL API using HotChocolateAdding mutationsUsing variables in queriesDefining a GraphQL schemaScalar typesObject typesRetrieving related objects using resolversField resolversResolver for a list of objectsUsing data loadersBatch data loaderGroup data loaderDependency injectionUsing the Service attributeUnderstanding the lifetime of the injected servicesInterface and union typesInterfacesUnion typesFiltering, sorting, and paginationFilteringSortingPaginationVisualizing the GraphQL schemaSummaryFurther reading
Chapter 13: Getting Started with SignalR
Technical requirementsRecap of real-time web APIsSetting up SignalRBuilding SignalR clientsBuilding a TypeScript clientBuilding a Blazor clientUsing authentication and authorization in SignalRAdding authentication and authorization to the SignalR serverAdding a login endpointAuthenticating the TypeScript clientAuthenticating the Blazor clientManaging users and groupsManaging events in SignalRSending a message to a specific userUsing strongly typed hubsJoining groupsSending a message to a groupSending messages from other servicesConfiguring SignalR hubs and clientsConfiguring SignalR hubsHTTP configuration optionsAutomatically reconnectingScaling SignalRSummary
Chapter 14: CI/CD for ASP.NET Core Using Azure Pipelines and GitHub Actions
Technical requirementsIntroduction to CI/CDCI/CD concepts and terminologiesUnderstanding the importance of CI/CDContainerizing ASP.NET Core applications using DockerWhat is containerization?Installing DockerUnderstanding DockerfilesBuilding a Docker imageRunning a Docker containerCI/CD using Azure DevOps and Azure PipelinesPreparing the source codeCreating Azure resourcesCreating an Azure DevOps projectCreating a pull request pipelinePublishing the Docker image to ACRDeploying the application to Azure Web App for ContainersConfiguring settings and secretsGitHub ActionsPreparing the projectCreating GitHub ActionsPushing a Docker image to ACRSummary
Chapter 15: ASP.NET Core Web API Common Practices
Technical requirementsCommon practices of ASP.NET web API developmentUsing HTTPS instead of HTTPUsing HTTP status codes correctlyUsing asynchronous programmingUsing pagination for large collectionsSpecifying the response typesAdding comments to the endpointsUsing System.Text.Json instead of Newtonsoft.JsonOptimizing the performance by implementing cachingIn-memory cachingDistributed cachingResponse cachingOutput cachingWhat caching strategy should I use?Using HttpClientFactory to manage HttpClient instancesCreating a basic HttpClient instanceNamed HttpClient instancesTyped HttpClient instancesSummary
Chapter 16: Error Handling, Monitoring, and Observability
Technical requirementsError handlingHandling exceptionsHealth checksImplementing a basic health checkMonitoring and observabilityWhat is observability?Summary
Chapter 17: Cloud-Native Patterns
Technical requirementsDomain-driven designUbiquitous languageBounded contextDDD layersClean architectureMicroservicesWeb API design patternsCQRSSummaryFurther reading
Index
Why subscribe?
Other Books You May EnjoyPackt is searching for authors like youShare Your ThoughtsDownload a free PDF copy of this book

Overview

"Web API Development with ASP.NET Core 8" is an in-depth guide to building robust, scalable, and modern web APIs using the ASP.NET Core framework. By exploring essential software design patterns, database integration with Entity Framework Core, and advanced topics like security, CI/CD with Azure, and real-time communication, this book prepares you to develop professional-grade web APIs.

What this Book will help me do

Understand the principles of designing and implementing modern RESTful and GraphQL APIs.
Master the capabilities of ASP.NET Core 8 for building scalable and secure applications.
Use Entity Framework Core to handle database operations and complex queries for your projects.
Enhance applications with features like middleware, caching, and unit and integration testing.
Utilize cloud platforms like Azure to deploy and manage your web API applications efficiently.

Author(s)

None Yan is a seasoned software engineer with years of experience in web development, specializing in scalable API solutions. Passionate about knowledge sharing, None authored this book to help developers build modern web APIs that meet current industry demands. Their practical approach ensures readers gain robust, actionable skills applicable in real-world scenarios.

Who is it for?

This book is ideal for software developers who aim to excel in creating modern web APIs using ASP.NET Core. It caters to programmers with basic knowledge of C# and .NET, providing them with comprehensive guidance to enhance their development skills. If you're aspiring to build scalable, maintainable, and secure applications, this guide is for you.

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Ultimate ASP.NET Core Web API Development Guide

Publisher Resources

ISBN: 9781804610954

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills