Apps and Services with .NET 7

Book description

Bestselling author Mark Price is back to guide you through the coolest and most common technologies a .NET developer should know: Blazor, .NET MAUI, gRPC, GraphQL, SQL Server, Cosmos DB, OData, SignalR, Azure Functions, and more! Purchase of the print or Kindle book includes a free eBook in PDF format.

Key Features

  • Build services using a variety of technologies including Web API, OData, gRPC, GraphQL, SignalR, and Azure Functions
  • Learn how to use specialized libraries to improve all aspects of your applications, including performance and localization
  • Leverage .NET MAUI to develop cross-platform desktop and mobile apps with ease

Book Description

Apps and Services with .NET 7 is for .NET 6 and .NET 7 developers who want to kick their C# and .NET understanding up a gear by learning the practical skills and knowledge they need to build real-world applications and services. It covers specialized libraries that will help you monitor and improve performance, secure your data and applications, and internationalize your code and apps.

With chapters that put a variety of technologies into practice, including Web API, OData, gRPC, GraphQL, SignalR, and Azure Functions, this book will give you a broader scope of knowledge than other books that often focus on only a handful of .NET technologies. It covers the latest developments, libraries, and technologies that will help keep you up to date.

You’ll also leverage .NET MAUI to develop mobile apps for iOS and Android as well as desktop apps for Windows and macOS.

What you will learn

  • Learn how to build more efficient, secure, and scalable apps and services
  • Leverage specialized .NET libraries to improve your applications
  • Implement popular third-party libraries like Serilog and FluentValidation
  • Build cross-platform apps with .NET MAUI and integrate with native mobile features
  • Get familiar with a variety of technologies for implementing services like gRPC and GraphQL
  • Explore Blazor WebAssembly and use open-source Blazor component libraries
  • Store and manage data locally and in the cloud with SQL Server and Cosmos DB

Who this book is for

This book is for .NET developers interested in exploring more specialized libraries and implementation fundamentals behind building services and apps. You’ll need to know your way around .NET and C# quite well before you can dive in, so if you want to work your way up to this book, pick up Mark’s other .NET book, C# 11 and .NET 7 – Modern Cross-Platform Development Fundamentals, first.

Table of contents

  1. Preface
    1. Where to find the code solutions
    2. What this book covers
    3. What you need for this book
    4. Get in touch
  2. Introducing Apps and Services with .NET
    1. Introducing this book and its contents
      1. A companion book to continue your learning journey
      2. What you will learn in this book
      3. My learning philosophy
      4. Fixing my mistakes
      5. Project naming and port numbering conventions
      6. Treating warnings as errors
    2. App and service technologies
      1. Building websites and apps using ASP.NET Core
      2. Building web and other services
      3. Windows Communication Foundation (WCF)
      4. Summary of choices for services
      5. Building Windows-only apps
        1. Understanding legacy Windows application platforms
        2. Understanding modern .NET support for legacy Windows platforms
      6. Building cross-platform mobile and desktop apps
      7. .NET MAUI alternatives
        1. Understanding Uno platform
        2. Understanding Avalonia
    3. Setting up your development environment
      1. Choosing the appropriate tool and application type for learning
        1. Using Visual Studio Code for cross-platform development
        2. Using GitHub Codespaces for development in the cloud
        3. Using Visual Studio for Mac for general development
        4. Using Visual Studio for Windows for general development
        5. What I used
      2. Deploying cross-platform
      3. Downloading and installing Visual Studio 2022 for Windows
        1. Visual Studio 2022 for Windows keyboard shortcuts
      4. Downloading and installing Visual Studio Code
        1. Installing other extensions
        2. Understanding Visual Studio Code versions
        3. Visual Studio Code keyboard shortcuts
      5. Finding the solution code on GitHub
      6. Consuming Azure resources
    4. Using an analyzer to write better code
      1. Suppressing warnings
      2. Fixing the code
    5. What’s new in C# and .NET?
      1. Understanding .NET support
      2. Understanding .NET Runtime and .NET SDK versions
      3. What’s new in C# 8 and .NET Core 3?
        1. Default interface methods
        2. Switch expressions
        3. Using declarations
        4. Nullable reference types
        5. Indices and ranges
      4. What’s new in C# 9 and .NET 5?
        1. Record types and init-only setters
        2. Top-level statements
        3. Target-typed new
      5. What’s new in C# 10 and .NET 6?
        1. Top-level statements and implicitly imported namespaces by default
        2. Checking for null in method parameters
      6. What’s new in C# 11 and .NET 7?
        1. Raw string literals
        2. Requiring properties to be set during instantiation
        3. Generic math support
    6. Making good use of the GitHub repository for this book
      1. Raising issues with the book
      2. Giving me feedback
      3. Downloading solution code from the GitHub repository
    7. Where to go for help
      1. Reading Microsoft documentation
      2. Getting help for the dotnet tool
      3. Searching for answers using Google
      4. Subscribing to the official .NET blog
      5. Watching Scott Hanselman’s videos
    8. Practicing and exploring
      1. Exercise 1.1 – Test your knowledge
      2. Exercise 1.2 – Explore topics
    9. Summary
  3. Managing Relational Data Using SQL Server
    1. Understanding modern databases
      1. Using a sample relational database
      2. Connecting to a SQL Server database
      3. Installing and setting up SQL Server
        1. Installing SQL Server Developer Edition for Windows
        2. Visual Studio Code extension for working with SQL Server
      4. Creating the Northwind sample database on Windows
      5. Setting up Azure SQL Database
      6. Installing Azure SQL Edge in Docker
    2. Managing data with Transact-SQL
      1. T-SQL data types
        1. Documenting with comments
        2. Declaring variables
        3. Specifying data types
        4. Controlling flow
        5. Operators
      2. Data Manipulation Language (DML)
        1. DML for adding, updating, and deleting data
      3. Data Definition Language (DDL)
    3. Managing data with low-level APIs
      1. Understanding the types in ADO.NET
      2. Creating a console app for working with ADO.NET
      3. Executing queries and working with data readers using ADO.NET
      4. Working with ADO.NET asynchronously
      5. Executing stored procedures using ADO.NET
    4. Managing data with EF Core
      1. Understanding Entity Framework Core
      2. Scaffolding models using an existing database
      3. Setting up the dotnet-ef tool
      4. Defining EF Core models
      5. Using EF Core conventions to define the model
      6. Using EF Core annotation attributes to define the model
      7. Using the EF Core Fluent API to define the model
      8. Understanding data seeding with the Fluent API
      9. Defining the Northwind database model
      10. Querying the Northwind model
    5. Mapping inheritance hierarchies with EF Core
      1. Table-per-hierarchy (TPH) mapping strategy
      2. Table-per-type (TPT) mapping strategy
      3. Table-per-concrete-type (TPC) mapping strategy
      4. Configuring inheritance hierarchy mapping strategies
      5. Example of hierarchy mapping strategies
    6. Building a reusable entity data model
      1. Creating a class library for entity models using SQL Server
      2. Creating a class library for the data context using SQL Server
      3. Calculated properties on entity creation
      4. Creating a test project to check the integration of the class libraries
      5. Writing unit tests for entity models
      6. Running unit tests using Visual Studio 2022
      7. Running unit tests using Visual Studio Code
    7. Cleaning up data resources
      1. Removing Azure resources
      2. Removing Docker resources
    8. Practicing and exploring
      1. Exercise 2.1 – Test your knowledge
      2. Exercise 2.2 – Practice benchmarking ADO.NET against EF Core
      3. Exercise 2.3 – Explore topics
      4. Exercise 2.4 – Explore Dapper
    9. Summary
  4. Managing NoSQL Data Using Azure Cosmos DB
    1. Understanding NoSQL databases
      1. Cosmos DB and its APIs
      2. Document modeling
      3. Consistency levels
      4. Hierarchy of components
      5. Throughput provisioning
      6. Partition strategies
      7. Data storage design
      8. Migrating data to Cosmos DB
    2. Creating Cosmos DB resources
      1. Using an emulator on Windows to create Azure Cosmos DB resources
      2. Using the Azure portal to create Azure Cosmos DB resources
      3. Using a .NET app to create Azure Cosmos DB resources
    3. Manipulating data with Core (SQL) API
      1. Performing CRUD operations with Cosmos SQL API
      2. Understanding SQL queries
      3. Understanding server-side programming
    4. Manipulating graph data with Gremlin API
    5. Cleaning up Azure resources
    6. Practicing and exploring
      1. Exercise 3.1 – Test your knowledge
      2. Exercise 3.2 – Practice data modeling and partitioning
      3. Exercise 3.3 – Explore topics
      4. Exercise 3.4 – Explore NoSQL databases
      5. Exercise 3.5 – Download cheat sheets
      6. Exercise 3.6 – Read a Gremlin guide
    7. Summary
  5. Benchmarking Performance, Multitasking, and Concurrency
    1. Understanding processes, threads, and tasks
    2. Monitoring performance and resource usage
      1. Evaluating the efficiency of types
      2. Monitoring performance and memory using diagnostics
        1. Useful members of the Stopwatch and Process types
        2. Implementing a Recorder class
      3. Measuring the efficiency of processing strings
      4. Monitoring performance and memory using Benchmark.NET
    3. Running tasks asynchronously
      1. Running multiple actions synchronously
      2. Running multiple actions asynchronously using tasks
        1. Starting tasks
      3. Waiting for tasks
        1. Using wait methods with tasks
      4. Continuing with another task
      5. Nested and child tasks
      6. Wrapping tasks around other objects
    4. Synchronizing access to shared resources
      1. Accessing a resource from multiple threads
      2. Applying a mutually exclusive lock to a conch
        1. Understanding the lock statement
        2. Avoiding deadlocks
      3. Synchronizing events
      4. Making CPU operations atomic
      5. Applying other types of synchronization
    5. Understanding async and await
      1. Improving responsiveness for console apps
      2. Working with async streams
      3. Improving responsiveness for GUI apps
      4. Improving scalability for web applications and web services
      5. Common types that support multitasking
      6. Using await in catch blocks
    6. Practicing and exploring
      1. Exercise 4.1 – Test your knowledge
      2. Exercise 4.2 – Explore topics
      3. Exercise 4.3 – Read more about parallel programming
    7. Summary
  6. Implementing Popular Third-Party Libraries
    1. Which third-party libraries are most popular?
      1. What is covered in my books
      2. What could be covered in my books
    2. Working with images
      1. Generating grayscale thumbnails
      2. ImageSharp packages for drawing and the web
    3. Logging with Serilog
      1. Structured event data
      2. Serilog sinks
      3. Logging to the console and a rolling file with Serilog
    4. Mapping between objects
      1. Testing an AutoMapper configuration
      2. Performing live mappings between models
    5. Making fluent assertions in unit testing
      1. Making assertions about strings
      2. Making assertions about collections and arrays
      3. Making assertions about dates and times
    6. Validating data
      1. Understanding the built-in validators
      2. Performing custom validation
      3. Customizing validation messages
      4. Defining a model and validator
      5. Testing the validator
      6. Integrating with ASP.NET Core
    7. Generating PDFs
      1. Creating class libraries to generate PDF documents
      2. Creating a console app to generate PDF documents
    8. Practicing and exploring
      1. Exercise 5.1 – Test your knowledge
      2. Exercise 5.2 – Explore topics
    9. Summary
  7. Observing and Modifying Code Execution Dynamically
    1. Working with reflection and attributes
      1. Versioning of assemblies
      2. Reading assembly metadata
      3. Creating custom attributes
      4. Understanding compiler-generated types and members
      5. Making a type or member obsolete
      6. Dynamically loading assemblies and executing methods
      7. Doing more with reflection
    2. Working with expression trees
      1. Understanding components of expression trees
      2. Executing the simplest expression tree
    3. Creating source generators
      1. Implementing the simplest source generator
      2. Doing more with source generators
    4. Practicing and exploring
      1. Exercise 6.1 – Test your knowledge
      2. Exercise 6.2 – Explore topics
    5. Summary
  8. Handling Dates, Times, and Internationalization
    1. Working with dates and times
      1. Specifying date and time values
      2. Formatting date and time values
      3. Date and time calculations
      4. Microseconds and nanoseconds
      5. Globalization with dates and times
      6. Localizing the DayOfWeek enum
      7. Working with only a date or a time
    2. Working with time zones
      1. Understanding DateTime and TimeZoneInfo
      2. Exploring DateTime and TimeZoneInfo
    3. Working with cultures
      1. Detecting and changing the current culture
      2. Temporarily using the invariant culture
      3. Localizing your user interface
      4. Defining and loading resources
      5. Testing globalization and localization
    4. Practicing and exploring
      1. Exercise 7.1 – Test your knowledge
      2. Exercise 7.2 – Explore topics
      3. Exercise 7.3 – Learn from expert Jon Skeet
    5. Summary
  9. Protecting Your Data and Applications
    1. Understanding the vocabulary of protection
      1. Keys and key sizes
      2. IVs and block sizes
      3. Salts
      4. Generating keys and IVs
    2. Encrypting and decrypting data
      1. Encrypting symmetrically with AES
    3. Hashing data
      1. Hashing with the commonly used SHA256
    4. Signing data
      1. Signing with SHA256 and RSA
    5. Generating random numbers
      1. Generating random numbers for games and similar apps
      2. Generating random numbers for cryptography
    6. Authenticating and authorizing users
      1. Authentication and authorization mechanisms
        1. Identifying a user
        2. User membership
      2. Implementing authentication and authorization
      3. Protecting application functionality
      4. Real-world authentication and authorization
    7. Practicing and exploring
      1. Exercise 8.1 – Test your knowledge
      2. Exercise 8.2 – Practice protecting data with encryption and hashing
      3. Exercise 8.3 – Practice protecting data with decryption
      4. Exercise 8.4 – Explore topics
      5. Exercise 8.5 – Review Microsoft encryption recommendations
    8. Summary
  10. Building and Securing Web Services Using Minimal APIs
    1. Building web services using ASP.NET Core Minimal APIs
      1. Understanding Minimal APIs route mappings
      2. Understanding parameter mapping
      3. Understanding return values
      4. Documenting a Minimal APIs service
      5. Setting up an ASP.NET Core Web API project
      6. Testing web services using Visual Studio Code extensions
      7. Excluding paths from OpenAPI documentation
    2. Relaxing the same origin security policy using CORS
      1. Configuring HTTP logging for the web service
      2. Creating a web page JavaScript client
      3. Creating a .NET client
      4. Understanding CORS
      5. Enabling CORS for specific endpoints
      6. Understanding other CORS policy options
    3. Preventing denial-of-service attacks using rate limiting
      1. Rate limiting using the AspNetCoreRateLimit package
      2. Creating a rate-limited console client
      3. Rate limiting using ASP.NET Core middleware
    4. Understanding identity services
      1. JWT bearer authorization
      2. Authenticating service clients using JWT bearer authentication
    5. Practicing and exploring
      1. Exercise 9.1 – Test your knowledge
      2. Exercise 9.2 – Review Microsoft HTTP API design policy
      3. Exercise 9.3 – Explore topics
    6. Summary
  11. Exposing Data via the Web Using OData
    1. Understanding OData
      1. Understanding the OData standard
      2. Understanding OData queries
    2. Building a web service that supports OData
      1. Defining OData models for the EF Core models
      2. Testing the OData models
      3. Creating and testing OData controllers
    3. Testing OData services using Visual Studio Code extensions
      1. Querying OData services using REST Client
        1. Understanding OData standard query options
        2. Understanding OData operators
        3. Understanding OData functions
        4. Exploring OData queries
      2. Using logs to review the efficiency of OData requests
    4. Versioning OData controllers
    5. Enabling entity inserts, updates, and deletes
    6. Building clients for OData services
      1. Calling services in the Northwind MVC website
      2. Revisiting the introductory query
    7. Practicing and exploring
      1. Exercise 10.1 – Test your knowledge
      2. Exercise 10.2 – Explore topics
    8. Summary
  12. Combining Data Sources Using GraphQL
    1. Understanding GraphQL
      1. GraphQL query document format
        1. Requesting fields
        2. Specifying filters and arguments
      2. Understanding other GraphQL capabilities
      3. Understanding the ChilliCream GraphQL platform
    2. Building a service that supports GraphQL
      1. Defining the GraphQL schema for Hello World
      2. Writing and executing GraphQL queries
      3. Naming GraphQL queries
      4. Understanding field conventions
    3. Defining GraphQL queries for EF Core models
      1. Adding support for EF Core
      2. Exploring GraphQL queries with Northwind
    4. Building a .NET client for a GraphQL service
      1. Understanding GraphQL responses
      2. Using REST Client as a GraphQL client
      3. Using an ASP.NET Core MVC project as a GraphQL client
      4. Testing the .NET client
      5. Understanding Strawberry Shake
        1. Creating a console app client
    5. Implementing GraphQL mutations
    6. Practicing and exploring
      1. Exercise 11.1 – Test your knowledge
      2. Exercise 11.2 – Explore topics
      3. Exercise 11.3 – Practice building .NET clients
    7. Summary
  13. Building Efficient Microservices Using gRPC
    1. Understanding gRPC
      1. How gRPC works
      2. Defining gRPC contracts with .proto files
      3. gRPC benefits
      4. gRPC limitations
      5. Types of gRPC methods
      6. Microsoft’s gRPC packages
    2. Building a gRPC service and client
      1. Building a Hello World gRPC service
      2. Building a Hello World gRPC client
      3. Testing a gRPC service and client
    3. Implementing gRPC for an EF Core model
      1. Implementing the gRPC service
      2. Implementing the gRPC client
      3. Getting request and response metadata
      4. Adding a deadline for higher reliability
    4. Implementing gRPC JSON transcoding
      1. Enabling gRPC JSON transcoding
      2. Testing gRPC JSON transcoding
      3. Comparing with gRPC-Web
    5. Practicing and exploring
      1. Exercise 12.1 – Test your knowledge
      2. Exercise 12.2 – Explore topics
    6. Summary
  14. Broadcasting Real-Time Communication Using SignalR
    1. Understanding SignalR
      1. The history of real-time communication on the web
      2. AJAX
      3. WebSocket
      4. Introducing SignalR
      5. Azure SignalR Service
      6. Designing method signatures
    2. Building a live communication service using SignalR
      1. Defining some shared models
      2. Enabling a server-side SignalR hub
    3. Building a web client using the SignalR JavaScript library
      1. Adding a chat page to the MVC website
      2. Testing the chat feature
    4. Building a .NET console app client
      1. Creating a .NET client for SignalR
      2. Testing the .NET console app client
    5. Streaming data using SignalR
      1. Defining a hub for streaming
      2. Creating a .NET console app client for streaming
      3. Testing the streaming service and client
    6. Practicing and exploring
      1. Exercise 13.1 – Test your knowledge
      2. Exercise 13.2 – Explore topics
    7. Summary
  15. Building Serverless Nanoservices Using Azure Functions
    1. Understanding Azure Functions
      1. Azure Functions triggers and bindings
      2. NCRONTAB expressions
      3. Azure Functions versions and languages
      4. Azure Functions hosting models
      5. Azure Functions hosting plans
      6. Azure Storage requirements
      7. Testing locally with Azurite
      8. Azure Functions authorization levels
      9. Azure Functions support for dependency injection
      10. Installing Azure Functions Core Tools
    2. Building an Azure Functions project
      1. Using Visual Studio 2022
      2. Using Visual Studio Code
      3. Using the func CLI
      4. Reviewing the Azure Functions project
      5. Implementing a simple function
      6. Testing a simple function
    3. Responding to timer and resource triggers
      1. Implementing a timer triggered function
      2. Testing the Timer triggered function
      3. Implementing a function that works with queues and BLOBs
      4. Testing the function that works with queues and BLOBs
    4. Publishing an Azure Functions project to the cloud
      1. Using Visual Studio 2022 to publish
      2. Using Visual Studio Code to publish
    5. Cleaning up Azure Functions resources
    6. Practicing and exploring
      1. Exercise 14.1 – Test your knowledge
      2. Exercise 14.2 – Explore topics
    7. Summary
  16. Building Web User Interfaces Using ASP.NET Core
    1. Setting up an ASP.NET Core MVC website
      1. Creating an ASP.NET Core MVC website
      2. Exploring the default ASP.NET Core MVC website
      3. Understanding visitor registration
      4. Reviewing an MVC website project structure
      5. Referencing an EF Core class library and registering a data context
    2. Defining web user interfaces with Razor views
      1. Understanding Razor views
      2. Prototyping with Bootstrap
        1. Breakpoints and containers
        2. Rows and columns
        3. Color themes
        4. Tables
        5. Buttons and links
        6. Badges
        7. Alerts
        8. Good practice for Bootstrap
      3. Understanding Razor syntax and expressions
      4. Understanding HTML Helper methods
      5. Defining a strongly typed Razor view
    3. Localizing and globalizing with ASP.NET Core
      1. Creating resource files
        1. Using Visual Studio 2022
        2. Using Visual Studio Code
      2. Localizing Razor views with an injected view localizer
      3. Understanding the Accept-Language header
    4. Defining web user interfaces with Tag Helpers
      1. Comparing HTML Helpers and Tag Helpers
      2. Exploring the Anchor Tag Helper
      3. Exploring the Cache Tag Helpers
      4. Exploring the Environment Tag Helper
      5. Understanding how cache busting with Tag Helpers works
      6. Exploring Forms-related Tag Helpers
    5. Practicing and exploring
      1. Exercise 15.1 – Test your knowledge
      2. Exercise 15.2 – Practice building user interfaces with Bootstrap
      3. Exercise 15.3 – Explore topics
    6. Summary
  17. Building Web Components Using Blazor WebAssembly
    1. Understanding Blazor
      1. Blazor hosting models
      2. Deployment choices for Blazor WebAssembly apps
      3. The browser compatibility analyzer for Blazor WebAssembly
      4. CSS and JavaScript isolation
      5. Blazor components
      6. Blazor routing to page components
      7. How to pass route parameters
        1. Setting parameters from a query string
        2. Route constraints for parameters
        3. Base component classes
      8. How to navigate Blazor routes to page components
    2. Building Blazor components
      1. Building and testing a Blazor progress bar component
      2. Building and testing a Blazor dialog box component
      3. Building and testing a Blazor alert component
    3. Building a Blazor data component
      1. Making the component a routable page component
      2. Getting entities into a component by building a web service
      3. Getting entities into a component by calling the web service
    4. Implementing caching using local storage
      1. Interop with JavaScript modules
      2. Building a local storage service
    5. Building Progressive Web Apps
      1. Implementing offline support for PWAs
    6. Practicing and exploring
      1. Exercise 16.1 – Test your knowledge
      2. Exercise 16.2 – Practice building Blazor components
      3. Exercise 16.3 – Practice building an IndexedDB interop service
      4. Exercise 16.4 – Explore topics
    7. Summary
  18. Leveraging Open-Source Blazor Component Libraries
    1. Understanding open-source Blazor component libraries
    2. Exploring Radzen Blazor components
      1. Enabling the Radzen dialog, notification, context menu, and tooltip components
      2. Using the Radzen tooltip and context menu components
      3. Using the Radzen notification and dialog components
    3. Building a web service for Northwind entities
      1. Using the Radzen tabs, image, and icon components
      2. Using the Radzen HTML editor component
      3. Using the Radzen chart component
      4. Using the Radzen form components
      5. Testing the employees page component
    4. Practicing and exploring
      1. Exercise 17.1 – Test your knowledge
      2. Exercise 17.2 – Practice by exploring MudBlazor
      3. Exercise 17.3 – Explore topics
    5. Summary
  19. Building Mobile and Desktop Apps Using .NET MAUI
    1. Understanding XAML
      1. Simplifying code using XAML
      2. .NET MAUI namespaces
      3. Type converters
      4. Choosing between .NET MAUI controls
      5. Markup extensions
    2. Understanding .NET MAUI
      1. Development tools for mobile first, cloud first
      2. Installing .NET MAUI workloads manually
        1. Using Windows to create iOS and macOS apps
      3. .NET MAUI user interface components
        1. Shell control
        2. ListView control
        3. Entry and Editor controls
      4. .NET MAUI handlers
      5. Writing platform-specific code
    3. Building mobile and desktop apps using .NET MAUI
      1. Creating a virtual Android device for local app testing
      2. Enabling Windows developer mode
      3. Creating a .NET MAUI solution
      4. Adding shell navigation and more content pages
      5. Implementing more content pages
    4. Using shared resources
      1. Defining resources to share across an app
      2. Referencing shared resources
      3. Changing shared resources dynamically
    5. Using data binding
      1. Binding to elements
    6. Understanding MVVM
      1. INotifyPropertyChanged interface
      2. ObservableCollection class
      3. Creating a view model with two-way data binding
      4. Creating views for the customers list and customer details
      5. Testing the .NET MAUI app
    7. Consuming a web service from a mobile app
      1. Creating a Minimal API web service for customers
      2. Configuring the web service to allow unsecure requests
      3. Connecting to local web services while testing
      4. Configuring the iOS app to allow unsecure connections
      5. Configuring the Android app to allow unsecure connections
      6. Getting customers from the web service
    8. Practicing and exploring
      1. Exercise 18.1 – Test your knowledge
      2. Exercise 18.2 – Explore topics
    9. Summary
  20. Integrating .NET MAUI Apps with Blazor and Native Platforms
    1. Building .NET MAUI Blazor Hybrid apps
      1. Creating a .NET MAUI Blazor project
      2. Adding a shell and .NET MAUI pages
      3. Creating a minimal API web service for categories
      4. Configuring the .NET MAUI app to allow unsecure connections
      5. Implementing the Model-View-ViewModel pattern
      6. Getting categories from the web service
    2. Integrating with native platforms
      1. Working with the system clipboard
      2. Picking files from the local filesystem
        1. Enabling media and file picking on Windows
        2. Enabling media and file picking on Android
        3. Enabling media and file picking on iOS
        4. Integrating with the media and file picker
      3. Creating new windows
      4. Getting device information
        1. Enabling device information on Android
        2. Adding device information to the app
      5. Integrating with desktop menu bars
      6. Popping up a toast notification
    3. Using third-party control libraries
    4. Practicing and exploring
      1. Exercise 19.1 – Test your knowledge
      2. Exercise 19.2 – Explore the code samples
      3. Exercise 19.3 – Explore topics
    5. Summary
  21. Introducing the Survey Project Challenge
    1. What have you learned in this book?
      1. Technologies covered in this book
    2. Why a survey project?
      1. What is the best way to learn?
      2. Attributes of a good learning project
      3. Alternative project ideas
      4. Features of survey and polling tools
      5. Question types
      6. Polling and quizzes
      7. Analyzing the responses
    3. What are the product requirements?
      1. Minimal requirements overview
        1. Minimal website requirements
        2. Minimal question item types
        3. Minimal survey design requirements
        4. Minimal data storage requirements
        5. Minimal analysis app requirements
      2. Ideas for extended requirements
        1. Extended website requirements
        2. Extended question item types
        3. Extended survey design requirements
        4. Extended data storage requirements
        5. Extended analysis app requirements
    4. Promote your abilities
    5. Summary
  22. Epilogue
    1. Second edition coming November 2023
    2. Next steps on your C# and .NET learning journey
    3. Good luck!
  23. Index

Product information

  • Title: Apps and Services with .NET 7
  • Author(s): Mark J. Price
  • Release date: November 2022
  • Publisher(s): Packt Publishing
  • ISBN: 9781801813433