Apps and Services with .NET 7 E-Book

Mark J. Price

• Herausgeber: Packt Publishing
• Kategorie: Fachliteratur
• Sprache: Englisch
• Veröffentlichungsjahr: 2022

Seitenzahl: 927

Beschreibung

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.

Leseprobe

Apps and Services with .NET 7

First Edition

Build practical projects with Blazor, .NET MAUI, gRPC, GraphQL, and other enterprise technologies

Mark J. Price

BIRMINGHAM—MUMBAI

Apps and Services with .NET 7

First Edition

Copyright © 2022 Packt Publishing

All rights reserved. No part of this book may be reproduced, stored in a retrieval system, or transmitted in any form or by any means, without the prior written permission of the publisher, except in the case of brief quotations embedded in critical articles or reviews.

Every effort has been made in the preparation of this book to ensure the accuracy of the information presented. However, the information contained in this book is sold without warranty, either express or implied. Neither the author, nor Packt Publishing or its dealers and distributors, will be held liable for any damages caused or alleged to have been caused directly or indirectly by this book.

Packt Publishing has endeavored to provide trademark information about all of the companies and products mentioned in this book by the appropriate use of capitals. However, Packt Publishing cannot guarantee the accuracy of this information.

Senior Publishing Product Manager: Suman Sen

Acquisition Editor – Peer Reviews: Saby Dsilva

Project Editor: Janice Gonsalves

Content Development Editor: Lucy Wan

Copy Editor: Safis Editing

Technical Editor: Aniket Shetty

Proofreader: Safis Editing

Indexer: Subalakshmi Govindhan

Presentation Designer: Rajesh Shirsath

First published: November 2022

Production reference: 1081122

Published by Packt Publishing Ltd.

Livery Place

35 Livery Street

Birmingham

B3 2PB, UK.

ISBN 978-1-80181-343-3

www.packt.com

Contributors

About the author

Mark J. Price is a Microsoft Specialist: Programming in C# and Architecting Microsoft Azure Solutions, with over 20 years of experience. Since 1993, he has passed more than 80 Microsoft programming exams and specializes in preparing others to pass them. Between 2001 and 2003, Mark was employed to write official courseware for Microsoft in Redmond, USA. His team wrote the first training courses for C# while it was still an early alpha version. While with Microsoft, he taught “train-the-trainer” classes to get Microsoft Certified Trainers up to speed on C# and .NET. Mark has spent most of his career training a wide variety of students, from 16-year-old apprentices to 70-year-old retirees, with the majority being professional developers. Mark holds a Computer Science BSc. Hons. degree.

About the reviewers

Damir Arh has many years of experience with software development and maintenance, from complex enterprise software projects to modern consumer-oriented mobile applications. Although he has worked with a wide spectrum of different languages, his favorite language remains C#. In his drive towards better development processes, he is a proponent of test-driven development, continuous integration, and continuous deployment. He shares his knowledge by speaking at local user groups and conferences, blogging, and writing articles. He has received the prestigious Microsoft MVP award for developer technologies 12 times in a row. In his spare time, he’s always on the move: hiking, geocaching, running, and rock climbing.

Tomasz Pęczek is a passionate developer, architect, blogger, speaker, and OSS contributor/maintainer in the .NET and Azure space. His commitment to sharing his knowledge and experiences has earned him a Microsoft MVP title in the Developer Technologies category.

Throughout his 18+ years of professional career, he has been designing and developing software that powers companies across the healthcare, banking, e-learning, and e-discovery industries. Currently, he is a Technical Fellow at Predica, where he focuses on ensuring that projects deliver true business value for clients and adhere to the highest industry standards.

His blog is at https://www.tpeczek.com/, and he can be found on Twitter as @tpeczek.

Join our book’s Discord space

Join the book’s Discord workspace for Ask me Anything sessions with the author.

https://packt.link/apps_and_services_dotnet7

Quick Chapter Reference

Introducing Apps and Services with .NET 1Managing Relational Data Using SQL Server 43Managing NoSQL Data Using Azure Cosmos DB 113Benchmarking Performance, Multitasking, and Concurrency 151Implementing Popular Third-Party Libraries 189Observing and Modifying Code Execution Dynamically 225Handling Dates, Times, and Internationalization 249Protecting Your Data and Applications 285Building and Securing Web Services Using Minimal APIs 319Exposing Data via the Web Using OData 361Combining Data Sources Using GraphQL 389Building Efficient Microservices Using gRPC 429Broadcasting Real-Time Communication Using SignalR 457Building Serverless Nanoservices Using Azure Functions 483Building Web User Interfaces Using ASP.NET Core 525Building Web Components Using Blazor WebAssembly 569Leveraging Open-Source Blazor Component Libraries 613Building Mobile and Desktop Apps Using .NET MAUI 647Integrating .NET MAUI Apps with Blazor and Native Platforms 707Introducing the Survey Project Challenge 751Epilogue 761Index 763

Contents

Preface

Where to find the code solutions

What this book covers

What you need for this book

Get in touch

Introducing Apps and Services with .NET

Introducing this book and its contents

A companion book to continue your learning journey

What you will learn in this book

My learning philosophy

Fixing my mistakes

Project naming and port numbering conventions

Treating warnings as errors

App and service technologies

Building websites and apps using ASP.NET Core

Building web and other services

Windows Communication Foundation (WCF)

Summary of choices for services

Building Windows-only apps

Understanding legacy Windows application platforms

Understanding modern .NET support for legacy Windows platforms

Building cross-platform mobile and desktop apps

.NET MAUI alternatives

Understanding Uno platform

Understanding Avalonia

Setting up your development environment

Choosing the appropriate tool and application type for learning

Using Visual Studio Code for cross-platform development

Using GitHub Codespaces for development in the cloud

Using Visual Studio for Mac for general development

Using Visual Studio for Windows for general development

What I used

Deploying cross-platform

Downloading and installing Visual Studio 2022 for Windows

Visual Studio 2022 for Windows keyboard shortcuts

Downloading and installing Visual Studio Code

Installing other extensions

Understanding Visual Studio Code versions

Visual Studio Code keyboard shortcuts

Finding the solution code on GitHub

Consuming Azure resources

Using an analyzer to write better code

Suppressing warnings

Fixing the code

What’s new in C# and .NET?

Understanding .NET support

Understanding .NET Runtime and .NET SDK versions

What’s new in C# 8 and .NET Core 3?

Default interface methods

Switch expressions

Using declarations

Nullable reference types

Indices and ranges

What’s new in C# 9 and .NET 5?

Record types and init-only setters

Top-level statements

Target-typed new

What’s new in C# 10 and .NET 6?

Top-level statements and implicitly imported namespaces by default

Checking for null in method parameters

What’s new in C# 11 and .NET 7?

Raw string literals

Requiring properties to be set during instantiation

Generic math support

Making good use of the GitHub repository for this book

Raising issues with the book

Giving me feedback

Downloading solution code from the GitHub repository

Where to go for help

Reading Microsoft documentation

Getting help for the dotnet tool

Searching for answers using Google

Subscribing to the official .NET blog

Watching Scott Hanselman’s videos

Practicing and exploring

Exercise 1.1 – Test your knowledge

Exercise 1.2 – Explore topics

Summary

Managing Relational Data Using SQL Server

Understanding modern databases

Using a sample relational database

Connecting to a SQL Server database

Installing and setting up SQL Server

Installing SQL Server Developer Edition for Windows

Visual Studio Code extension for working with SQL Server

Creating the Northwind sample database on Windows

Setting up Azure SQL Database

Installing Azure SQL Edge in Docker

Managing data with Transact-SQL

T-SQL data types

Documenting with comments

Declaring variables

Specifying data types

Controlling flow

Operators

Data Manipulation Language (DML)

DML for adding, updating, and deleting data

Data Definition Language (DDL)

Managing data with low-level APIs

Understanding the types in ADO.NET

Creating a console app for working with ADO.NET

Executing queries and working with data readers using ADO.NET

Working with ADO.NET asynchronously

Executing stored procedures using ADO.NET

Managing data with EF Core

Understanding Entity Framework Core

Scaffolding models using an existing database

Setting up the dotnet-ef tool

Defining EF Core models

Using EF Core conventions to define the model

Using EF Core annotation attributes to define the model

Using the EF Core Fluent API to define the model

Understanding data seeding with the Fluent API

Defining the Northwind database model

Querying the Northwind model

Mapping inheritance hierarchies with EF Core

Table-per-hierarchy (TPH) mapping strategy

Table-per-type (TPT) mapping strategy

Table-per-concrete-type (TPC) mapping strategy

Configuring inheritance hierarchy mapping strategies

Example of hierarchy mapping strategies

Building a reusable entity data model

Creating a class library for entity models using SQL Server

Creating a class library for the data context using SQL Server

Calculated properties on entity creation

Creating a test project to check the integration of the class libraries

Writing unit tests for entity models

Running unit tests using Visual Studio 2022

Running unit tests using Visual Studio Code

Cleaning up data resources

Removing Azure resources

Removing Docker resources

Practicing and exploring

Exercise 2.1 – Test your knowledge

Exercise 2.2 – Practice benchmarking ADO.NET against EF Core

Exercise 2.3 – Explore topics

Exercise 2.4 – Explore Dapper

Summary

Managing NoSQL Data Using Azure Cosmos DB

Understanding NoSQL databases

Cosmos DB and its APIs

Document modeling

Consistency levels

Hierarchy of components

Throughput provisioning

Partition strategies

Data storage design

Migrating data to Cosmos DB

Creating Cosmos DB resources

Using an emulator on Windows to create Azure Cosmos DB resources

Using the Azure portal to create Azure Cosmos DB resources

Using a .NET app to create Azure Cosmos DB resources

Manipulating data with Core (SQL) API

Performing CRUD operations with Cosmos SQL API

Understanding SQL queries

Understanding server-side programming

Manipulating graph data with Gremlin API

Cleaning up Azure resources

Practicing and exploring

Exercise 3.1 – Test your knowledge

Exercise 3.2 – Practice data modeling and partitioning

Exercise 3.3 – Explore topics

Exercise 3.4 – Explore NoSQL databases

Exercise 3.5 – Download cheat sheets

Exercise 3.6 – Read a Gremlin guide

Summary

Benchmarking Performance, Multitasking, and Concurrency

Understanding processes, threads, and tasks

Monitoring performance and resource usage

Evaluating the efficiency of types

Monitoring performance and memory using diagnostics

Useful members of the Stopwatch and Process types

Implementing a Recorder class

Measuring the efficiency of processing strings

Monitoring performance and memory using Benchmark.NET

Running tasks asynchronously

Running multiple actions synchronously

Running multiple actions asynchronously using tasks

Starting tasks

Waiting for tasks

Using wait methods with tasks

Continuing with another task

Nested and child tasks

Wrapping tasks around other objects

Synchronizing access to shared resources

Accessing a resource from multiple threads

Applying a mutually exclusive lock to a conch

Understanding the lock statement

Avoiding deadlocks

Synchronizing events

Making CPU operations atomic

Applying other types of synchronization

Understanding async and await

Improving responsiveness for console apps

Working with async streams

Improving responsiveness for GUI apps

Improving scalability for web applications and web services

Common types that support multitasking

Using await in catch blocks

Practicing and exploring

Exercise 4.1 – Test your knowledge

Exercise 4.2 – Explore topics

Exercise 4.3 – Read more about parallel programming

Summary

Implementing Popular Third-Party Libraries

Which third-party libraries are most popular?

What is covered in my books

What could be covered in my books

Working with images

Generating grayscale thumbnails

ImageSharp packages for drawing and the web

Logging with Serilog

Structured event data

Serilog sinks

Logging to the console and a rolling file with Serilog

Mapping between objects

Testing an AutoMapper configuration

Performing live mappings between models

Making fluent assertions in unit testing

Making assertions about strings

Making assertions about collections and arrays

Making assertions about dates and times

Validating data

Understanding the built-in validators

Performing custom validation

Customizing validation messages

Defining a model and validator

Testing the validator

Integrating with ASP.NET Core

Generating PDFs

Creating class libraries to generate PDF documents

Creating a console app to generate PDF documents

Practicing and exploring

Exercise 5.1 – Test your knowledge

Exercise 5.2 – Explore topics

Summary

Observing and Modifying Code Execution Dynamically

Working with reflection and attributes

Versioning of assemblies

Reading assembly metadata

Creating custom attributes

Understanding compiler-generated types and members

Making a type or member obsolete

Dynamically loading assemblies and executing methods

Doing more with reflection

Working with expression trees

Understanding components of expression trees

Executing the simplest expression tree

Creating source generators

Implementing the simplest source generator

Doing more with source generators

Practicing and exploring

Exercise 6.1 – Test your knowledge

Exercise 6.2 – Explore topics

Summary

Handling Dates, Times, and Internationalization

Working with dates and times

Specifying date and time values

Formatting date and time values

Date and time calculations

Microseconds and nanoseconds

Globalization with dates and times

Localizing the DayOfWeek enum

Working with only a date or a time

Working with time zones

Understanding DateTime and TimeZoneInfo

Exploring DateTime and TimeZoneInfo

Working with cultures

Detecting and changing the current culture

Temporarily using the invariant culture

Localizing your user interface

Defining and loading resources

Testing globalization and localization

Practicing and exploring

Exercise 7.1 – Test your knowledge

Exercise 7.2 – Explore topics

Exercise 7.3 – Learn from expert Jon Skeet

Summary

Protecting Your Data and Applications

Understanding the vocabulary of protection

Keys and key sizes

IVs and block sizes

Salts

Generating keys and IVs

Encrypting and decrypting data

Encrypting symmetrically with AES

Hashing data

Hashing with the commonly used SHA256

Signing data

Signing with SHA256 and RSA

Generating random numbers

Generating random numbers for games and similar apps

Generating random numbers for cryptography

Authenticating and authorizing users

Authentication and authorization mechanisms

Identifying a user

User membership

Implementing authentication and authorization

Protecting application functionality

Real-world authentication and authorization

Practicing and exploring

Exercise 8.1 – Test your knowledge

Exercise 8.2 – Practice protecting data with encryption and hashing

Exercise 8.3 – Practice protecting data with decryption

Exercise 8.4 – Explore topics

Exercise 8.5 – Review Microsoft encryption recommendations

Summary

Building and Securing Web Services Using Minimal APIs

Building web services using ASP.NET Core Minimal APIs

Understanding Minimal APIs route mappings

Understanding parameter mapping

Understanding return values

Documenting a Minimal APIs service

Setting up an ASP.NET Core Web API project

Testing web services using Visual Studio Code extensions

Excluding paths from OpenAPI documentation

Relaxing the same origin security policy using CORS

Configuring HTTP logging for the web service

Creating a web page JavaScript client

Creating a .NET client

Understanding CORS

Enabling CORS for specific endpoints

Understanding other CORS policy options

Preventing denial-of-service attacks using rate limiting

Rate limiting using the AspNetCoreRateLimit package

Creating a rate-limited console client

Rate limiting using ASP.NET Core middleware

Understanding identity services

JWT bearer authorization

Authenticating service clients using JWT bearer authentication

Practicing and exploring

Exercise 9.1 – Test your knowledge

Exercise 9.2 – Review Microsoft HTTP API design policy

Exercise 9.3 – Explore topics

Summary

Exposing Data via the Web Using OData

Understanding OData

Understanding the OData standard

Understanding OData queries

Building a web service that supports OData

Defining OData models for the EF Core models

Testing the OData models

Creating and testing OData controllers

Testing OData services using Visual Studio Code extensions

Querying OData services using REST Client

Understanding OData standard query options

Understanding OData operators

Understanding OData functions

Exploring OData queries

Using logs to review the efficiency of OData requests

Versioning OData controllers

Enabling entity inserts, updates, and deletes

Building clients for OData services

Calling services in the Northwind MVC website

Revisiting the introductory query

Practicing and exploring

Exercise 10.1 – Test your knowledge

Exercise 10.2 – Explore topics

Summary

Combining Data Sources Using GraphQL

Understanding GraphQL

GraphQL query document format

Requesting fields

Specifying filters and arguments

Understanding other GraphQL capabilities

Understanding the ChilliCream GraphQL platform

Building a service that supports GraphQL

Defining the GraphQL schema for Hello World

Writing and executing GraphQL queries

Naming GraphQL queries

Understanding field conventions

Defining GraphQL queries for EF Core models

Adding support for EF Core

Exploring GraphQL queries with Northwind

Building a .NET client for a GraphQL service

Understanding GraphQL responses

Using REST Client as a GraphQL client

Using an ASP.NET Core MVC project as a GraphQL client

Testing the .NET client

Understanding Strawberry Shake

Creating a console app client

Implementing GraphQL mutations

Practicing and exploring

Exercise 11.1 – Test your knowledge

Exercise 11.2 – Explore topics

Exercise 11.3 – Practice building .NET clients

Summary

Building Efficient Microservices Using gRPC

Understanding gRPC

How gRPC works

Defining gRPC contracts with .proto files

gRPC benefits

gRPC limitations

Types of gRPC methods

Microsoft’s gRPC packages

Building a gRPC service and client

Building a Hello World gRPC service

Building a Hello World gRPC client

Testing a gRPC service and client

Implementing gRPC for an EF Core model

Implementing the gRPC service

Implementing the gRPC client

Getting request and response metadata

Adding a deadline for higher reliability

Implementing gRPC JSON transcoding

Enabling gRPC JSON transcoding

Testing gRPC JSON transcoding

Comparing with gRPC-Web

Practicing and exploring

Exercise 12.1 – Test your knowledge

Exercise 12.2 – Explore topics

Summary

Broadcasting Real-Time Communication Using SignalR

Understanding SignalR

The history of real-time communication on the web

AJAX

WebSocket

Introducing SignalR

Azure SignalR Service

Designing method signatures

Building a live communication service using SignalR

Defining some shared models

Enabling a server-side SignalR hub

Building a web client using the SignalR JavaScript library

Adding a chat page to the MVC website

Testing the chat feature

Building a .NET console app client

Creating a .NET client for SignalR

Testing the .NET console app client

Streaming data using SignalR

Defining a hub for streaming

Creating a .NET console app client for streaming

Testing the streaming service and client

Practicing and exploring

Exercise 13.1 – Test your knowledge

Exercise 13.2 – Explore topics

Summary

Building Serverless Nanoservices Using Azure Functions

Understanding Azure Functions

Azure Functions triggers and bindings

NCRONTAB expressions

Azure Functions versions and languages

Azure Functions hosting models

Azure Functions hosting plans

Azure Storage requirements

Testing locally with Azurite

Azure Functions authorization levels

Azure Functions support for dependency injection

Installing Azure Functions Core Tools

Building an Azure Functions project

Using Visual Studio 2022

Using Visual Studio Code

Using the func CLI

Reviewing the Azure Functions project

Implementing a simple function

Testing a simple function

Responding to timer and resource triggers

Implementing a timer triggered function

Testing the Timer triggered function

Implementing a function that works with queues and BLOBs

Testing the function that works with queues and BLOBs

Publishing an Azure Functions project to the cloud

Using Visual Studio 2022 to publish

Using Visual Studio Code to publish

Cleaning up Azure Functions resources

Practicing and exploring

Exercise 14.1 – Test your knowledge

Exercise 14.2 – Explore topics

Summary

Building Web User Interfaces Using ASP.NET Core

Setting up an ASP.NET Core MVC website

Creating an ASP.NET Core MVC website

Exploring the default ASP.NET Core MVC website

Understanding visitor registration

Reviewing an MVC website project structure

Referencing an EF Core class library and registering a data context

Defining web user interfaces with Razor views

Understanding Razor views

Prototyping with Bootstrap

Breakpoints and containers

Rows and columns

Color themes

Tables

Buttons and links

Badges

Alerts

Good practice for Bootstrap

Understanding Razor syntax and expressions

Understanding HTML Helper methods

Defining a strongly typed Razor view

Localizing and globalizing with ASP.NET Core

Creating resource files

Using Visual Studio 2022

Using Visual Studio Code

Localizing Razor views with an injected view localizer

Understanding the Accept-Language header

Defining web user interfaces with Tag Helpers

Comparing HTML Helpers and Tag Helpers

Exploring the Anchor Tag Helper

Exploring the Cache Tag Helpers

Exploring the Environment Tag Helper

Understanding how cache busting with Tag Helpers works

Exploring Forms-related Tag Helpers

Practicing and exploring

Exercise 15.1 – Test your knowledge

Exercise 15.2 – Practice building user interfaces with Bootstrap

Exercise 15.3 – Explore topics

Summary

Building Web Components Using Blazor WebAssembly

Understanding Blazor

Blazor hosting models

Deployment choices for Blazor WebAssembly apps

The browser compatibility analyzer for Blazor WebAssembly

CSS and JavaScript isolation

Blazor components

Blazor routing to page components

How to pass route parameters

Setting parameters from a query string

Route constraints for parameters

Base component classes

How to navigate Blazor routes to page components

Building Blazor components

Building and testing a Blazor progress bar component

Building and testing a Blazor dialog box component

Building and testing a Blazor alert component

Building a Blazor data component

Making the component a routable page component

Getting entities into a component by building a web service

Getting entities into a component by calling the web service

Implementing caching using local storage

Interop with JavaScript modules

Building a local storage service

Building Progressive Web Apps

Implementing offline support for PWAs

Practicing and exploring

Exercise 16.1 – Test your knowledge

Exercise 16.2 – Practice building Blazor components

Exercise 16.3 – Practice building an IndexedDB interop service

Exercise 16.4 – Explore topics

Summary

Leveraging Open-Source Blazor Component Libraries

Understanding open-source Blazor component libraries

Exploring Radzen Blazor components

Enabling the Radzen dialog, notification, context menu, and tooltip components

Using the Radzen tooltip and context menu components

Using the Radzen notification and dialog components

Building a web service for Northwind entities

Using the Radzen tabs, image, and icon components

Using the Radzen HTML editor component

Using the Radzen chart component

Using the Radzen form components

Testing the employees page component

Practicing and exploring

Exercise 17.1 – Test your knowledge

Exercise 17.2 – Practice by exploring MudBlazor

Exercise 17.3 – Explore topics

Summary

Building Mobile and Desktop Apps Using .NET MAUI

Understanding XAML

Simplifying code using XAML

.NET MAUI namespaces

Type converters

Choosing between .NET MAUI controls

Markup extensions

Understanding .NET MAUI

Development tools for mobile first, cloud first

Installing .NET MAUI workloads manually

Using Windows to create iOS and macOS apps

.NET MAUI user interface components

Shell control

ListView control

Entry and Editor controls

.NET MAUI handlers

Writing platform-specific code

Building mobile and desktop apps using .NET MAUI

Creating a virtual Android device for local app testing

Enabling Windows developer mode

Creating a .NET MAUI solution

Adding shell navigation and more content pages

Implementing more content pages

Using shared resources

Defining resources to share across an app

Referencing shared resources

Changing shared resources dynamically

Using data binding

Binding to elements

Understanding MVVM

INotifyPropertyChanged interface

ObservableCollection class

Creating a view model with two-way data binding

Creating views for the customers list and customer details

Testing the .NET MAUI app

Consuming a web service from a mobile app

Creating a Minimal API web service for customers

Configuring the web service to allow unsecure requests

Connecting to local web services while testing

Configuring the iOS app to allow unsecure connections

Configuring the Android app to allow unsecure connections

Getting customers from the web service

Practicing and exploring

Exercise 18.1 – Test your knowledge

Exercise 18.2 – Explore topics

Summary

Integrating .NET MAUI Apps with Blazor and Native Platforms

Building .NET MAUI Blazor Hybrid apps

Creating a .NET MAUI Blazor project

Adding a shell and .NET MAUI pages

Creating a minimal API web service for categories

Configuring the .NET MAUI app to allow unsecure connections

Implementing the Model-View-ViewModel pattern

Getting categories from the web service

Integrating with native platforms

Working with the system clipboard

Picking files from the local filesystem

Enabling media and file picking on Windows

Enabling media and file picking on Android

Enabling media and file picking on iOS

Integrating with the media and file picker

Creating new windows

Getting device information

Enabling device information on Android

Adding device information to the app

Integrating with desktop menu bars

Popping up a toast notification

Using third-party control libraries

Practicing and exploring

Exercise 19.1 – Test your knowledge

Exercise 19.2 – Explore the code samples

Exercise 19.3 – Explore topics

Summary

Introducing the Survey Project Challenge

What have you learned in this book?

Technologies covered in this book

Why a survey project?

What is the best way to learn?

Attributes of a good learning project

Alternative project ideas

Features of survey and polling tools

Question types

Polling and quizzes

Analyzing the responses

What are the product requirements?

Minimal requirements overview

Minimal website requirements

Minimal question item types

Minimal survey design requirements

Minimal data storage requirements

Minimal analysis app requirements

Ideas for extended requirements

Extended website requirements

Extended question item types

Extended survey design requirements

Extended data storage requirements

Extended analysis app requirements

Promote your abilities

Summary

Epilogue

Second edition coming November 2023

Next steps on your C# and .NET learning journey

Good luck!

Index

Landmarks

Cover

Table of Contents

Index