book

C# 8.0 and .NET Core 3.0 – Modern Cross-Platform Development - Fourth Edition

Name: C# 8.0 and .NET Core 3.0 – Modern Cross-Platform Development - Fourth Edition
Author: Mark J. Price
ISBN: 9781788478120

by Mark J. Price

October 2019

Intermediate to advanced

818 pages

18h 2m

English

Packt Publishing

Read now

Unlock full access

Hello, C#! Welcome, .NET!
Setting up your development environmentUsing Visual Studio Code for cross-platform developmentUsing Visual Studio 2019 for Windows app developmentUsing Visual Studio for Mac for mobile developmentRecommended tools for chaptersDeploying cross-platformUnderstanding Microsoft Visual Studio Code versionsDownloading and installing Visual Studio CodeInstalling other extensionsUnderstanding .NETUnderstanding the .NET FrameworkUnderstanding the Mono and Xamarin projectsUnderstanding .NET CoreUnderstanding future versions of .NETUnderstanding .NET Core supportWhat is different about .NET Core?Understanding .NET Standard.NET platforms and tools used by the book editionsUnderstanding intermediate languageUnderstanding .NET NativeComparing .NET technologiesBuilding console apps using Visual Studio CodeWriting code using Visual Studio CodeCompiling and running code using dotnet CLIDownloading solution code from a GitHub repositoryUsing Git with Visual Studio CodeCloning the book solution code repositoryLooking for helpReading Microsoft documentationGetting help for the dotnet toolGetting definitions of types and their membersLooking for answers on Stack OverflowSearching for answers using GoogleSubscribing to the official .NET blogPracticing and exploringExercise 1.1 – Test your knowledgeExercise 1.2 – Practice C# anywhereExercise 1.3 – Explore topicsSummary
Speaking C#
Introducing C#Understanding language versions and featuresC# 1.0C# 2.0C# 3.0C# 4.0C# 5.0C# 6.0C# 7.0C# 7.1C# 7.2C# 7.3C# 8.0Discovering your C# compiler versionsEnabling a specific language version compilerUnderstanding C# basicsUnderstanding C# grammarStatementsCommentsBlocksUnderstanding C# vocabularyHelp for writing correct codeVerbs are methodsNouns are types, fields, and variablesRevealing the extent of the C# vocabularyWorking with variablesNaming things and assigning valuesLiteral valuesStoring textUnderstanding verbatim stringsStoring numbersStoring whole numbersStoring real numbersWriting code to explore number sizesComparing double and decimal typesStoring BooleansUsing Visual Studio Code workspacesStoring any type of objectStoring dynamic typesDeclaring local variablesSpecifying and inferring the type of a local variableGetting default values for typesStoring multiple valuesWorking with null valuesMaking a value type nullableUnderstanding nullable reference typesEnabling nullable and non-nullable reference typesDeclaring non-nullable variables and parametersChecking for nullExploring console applications furtherDisplaying output to the userFormatting using numbered positional argumentsFormatting using interpolated stringsUnderstanding format stringsGetting text input from the userImporting a namespaceSimplifying the usage of the consoleGetting key input from the userGetting argumentsSetting options with argumentsHandling platforms that do not support an APIPracticing and exploringExercise 2.1 – Test your knowledgeExercise 2.2 – Practice number sizes and rangesExercise 2.3 – Explore topicsSummary
Controlling Flow and Converting Types
Operating on variablesUnary operatorsBinary arithmetic operatorsAssignment operatorsLogical operatorsConditional logical operatorsBitwise and binary shift operatorsMiscellaneous operatorsUnderstanding selection statementsBranching with the if statementWhy you should always use braces with if statementsPattern matching with the if statementBranching with the switch statementPattern matching with the switch statementSimplifying switch statements with switch expressionsUnderstanding iteration statementsLooping with the while statementLooping with the do statementLooping with the for statementLooping with the foreach statementUnderstanding how foreach works internallyCasting and converting between typesCasting numbers implicitly and explicitlyConverting with the System.Convert typeRounding numbersUnderstanding the default rounding rulesTaking control of rounding rulesConverting from any type to a stringConverting from a binary object to a stringParsing from strings to numbers or dates and timesAvoiding exceptions using the TryParse methodHandling exceptions when converting typesWrapping error-prone code in a try blockCatching all exceptionsCatching specific exceptionsChecking for overflowThrowing overflow exceptions with the checked statementDisabling compiler overflow checks with the unchecked statementPracticing and exploringExercise 3.1 – Test your knowledgeExercise 3.2 – Explore loops and overflowExercise 3.3 – Practice loops and operatorsExercise 3.4 – Practice exception handlingExercise 3.5 – Test your knowledge of operatorsExercise 3.6 – Explore topicsSummary
Writing, Debugging, and Testing Functions
Writing functionsWriting a times table functionWriting a function that returns a valueWriting mathematical functionsConverting numbers from ordinal to cardinalCalculating factorials with recursionDocumenting functions with XML commentsDebugging during developmentCreating code with a deliberate bugSetting a breakpointNavigating with the debugging toolbarDebugging windowsStepping through codeCustomizing breakpointsLogging during development and runtimeInstrumenting with Debug and TraceWriting to the default trace listenerConfiguring trace listenersSwitching trace levelsUnit testing functionsCreating a class library that needs testingWriting unit testsRunning unit testsPracticing and exploringExercise 4.1 – Test your knowledgeExercise 4.2 – Practice writing functions with debugging and unit testingExercise 4.3 – Explore topicsSummary
Building Your Own Types with Object-Oriented Programming
Talking about object-oriented programmingBuilding class librariesCreating a class libraryDefining a classUnderstanding membersInstantiating a classReferencing an assemblyImporting a namespace to use a typeManaging multiple filesUnderstanding objectsInheriting from System.ObjectStoring data within fieldsDefining fieldsUnderstanding access modifiersSetting and outputting field valuesStoring a value using an enum typeStoring multiple values using an enum typeStoring multiple values using collectionsMaking a field staticMaking a field constantMaking a field read-onlyInitializing fields with constructorsSetting fields with default literalsWriting and calling methodsReturning values from methodsCombining multiple returned values using tuplesNaming the fields of a tupleInferring tuple namesDeconstructing tuplesDefining and passing parameters to methodsOverloading methodsPassing optional parameters and naming argumentsControlling how parameters are passedSplitting classes using partialControlling access with properties and indexersDefining readonly propertiesDefining settable propertiesDefining indexersPracticing and exploringExercise 5.1 – Test your knowledgeExercise 5.2 – Explore topicsSummary
Implementing Interfaces and Inheriting Classes
Setting up a class library and console applicationSimplifying methodsImplementing functionality using methodsImplementing functionality using operatorsImplementing functionality using local functionsRaising and handling eventsCalling methods using delegatesDefining and handling delegatesDefining and handling eventsImplementing interfacesCommon interfacesComparing objects when sortingComparing objects using a separate classDefining interfaces with default implementationsMaking types safely reusable with genericsWorking with generic typesWorking with generic methodsManaging memory with reference and value typesWorking with struct typesReleasing unmanaged resourcesEnsuring that Dispose is calledInheriting from classesExtending classesHiding membersOverriding membersPreventing inheritance and overridingUnderstanding polymorphismCasting within inheritance hierarchiesImplicit castingExplicit castingAvoiding casting exceptionsInheriting and extending .NET typesInheriting exceptionsExtending types when you can't inheritUsing static methods to reuse functionalityUsing extension methods to reuse functionalityPracticing and exploringExercise 6.1 – Test your knowledgeExercise 6.2 – Practice creating an inheritance hierarchyExercise 6.3 – Explore topicsSummary
Understanding and Packaging .NET Types
Introducing .NET Core 3.0.NET Core 1.0.NET Core 1.1.NET Core 2.0.NET Core 2.1.NET Core 2.2.NET Core 3.0Understanding .NET Core componentsUnderstanding assemblies, packages, and namespacesUnderstanding dependent assembliesUnderstanding the Microsoft .NET Core App platformUnderstanding NuGet packagesUnderstanding frameworksImporting a namespace to use a typeRelating C# keywords to .NET typesSharing code cross-platform with .NET Standard class librariesPublishing your applications for deploymentCreating a console application to publishUnderstanding dotnet commandsCreating new projectsManaging projectsPublishing a self-contained appDecompiling assembliesPackaging your libraries for NuGet distributionReferencing a NuGet packageFixing dependenciesPackaging a library for NuGetTesting your packagePorting from .NET Framework to .NET CoreCould you port?Should you port?Differences between .NET Framework and .NET CoreUnderstanding the .NET Portability AnalyzerUsing non-.NET Standard librariesPracticing and exploringExercise 7.1 – Test your knowledgeExercise 7.2 – Explore topicsSummary
Working with Common .NET Types
Working with numbersWorking with big integersWorking with complex numbersWorking with textGetting the length of a stringGetting the characters of a stringSplitting a stringGetting part of a stringChecking a string for contentJoining, formatting, and other string membersBuilding strings efficientlyPattern matching with regular expressionsChecking for digits entered as textUnderstanding the syntax of a regular expressionExamples of regular expressionsSplitting a complex comma-separated stringStoring multiple objects in collectionsCommon features of all collectionsUnderstanding collection choicesListsDictionariesStacksQueuesSetsWorking with listsWorking with dictionariesSorting collectionsUsing specialized collectionsUsing immutable collectionsWorking with spans, indexes, and rangesUsing memory efficiently using spansIdentifying positions with the Index typeIdentifying ranges with the Range typeUsing indexes and rangesWorking with network resourcesWorking with URIs, DNS, and IP addressesPinging a serverWorking with types and attributesVersioning of assembliesReading assembly metadataCreating custom attributesDoing more with reflectionInternationalizing your codePracticing and exploringExercise 8.1 – Test your knowledgeExercise 8.2 – Practice regular expressionsExercise 8.3 – Practice writing extension methodsExercise 8.4 – Explore topicsSummary
Working with Files, Streams, and Serialization
Managing the filesystemHandling cross-platform environments and filesystemsManaging drivesManaging directoriesManaging filesManaging pathsGetting file informationControlling how you work with filesReading and writing with streamsWriting to text streamsWriting to XML streamsDisposing of file resourcesCompressing streamsCompressing with the Brotli algorithmHigh-performance streams using pipelinesAsynchronous streamsEncoding and decoding textEncoding strings as byte arraysEncoding and decoding text in filesSerializing object graphsSerializing as XMLGenerating compact XMLDeserializing XML filesSerializing with JSONHigh-performance JSON processingPracticing and exploringExercise 9.1 – Test your knowledgeExercise 9.2 – Practice serializing as XMLExercise 9.3 – Explore topicsSummary
Protecting Your Data and Applications
Understanding the vocabulary of protectionKeys and key sizesIVs and block sizesSaltsGenerating keys and IVsEncrypting and decrypting dataEncrypting symmetrically with AESHashing dataHashing with the commonly used SHA256Signing dataSigning with SHA256 and RSAGenerating random numbersGenerating random numbers for gamesGenerating random numbers for cryptographyWhat's new in cryptographyAuthenticating and authorizing usersImplementing authentication and authorizationProtecting application functionalityPracticing and exploringExercise 10.1 – Test your knowledgeExercise 10.2 – Practice protecting data with encryption and hashingExercise 10.3 – Practice protecting data with decryptionExercise 10.4 – Explore topicsSummary

Working with Databases Using Entity Framework Core
Understanding modern databasesUnderstanding Entity FrameworkUsing a sample relational databaseSetting up SQLite for macOSSetting up SQLite for WindowsCreating the Northwind sample database for SQLiteManaging the Northwind sample database with SQLiteStudioSetting up EF CoreChoosing an EF Core data providerConnecting to the databaseDefining EF Core modelsEF Core conventionsEF Core annotation attributesEF Core Fluent APIUnderstanding data seedingBuilding an EF Core modelDefining the Category and Product entity classesDefining the Northwind database context classQuerying EF Core modelsFiltering and sorting productsLogging EF CoreLogging with query tagsPattern matching with LikeDefining global filtersLoading patterns with EF CoreEager loading entitiesEnabling lazy loadingExplicit loading entitiesManipulating data with EF CoreInserting entitiesUpdating entitiesDeleting entitiesPooling database contextsTransactionsDefining an explicit transactionPracticing and exploringExercise 11.1 – Test your knowledgeExercise 11.2 – Practice exporting data using different serialization formatsExercise 11.3 – Explore the EF Core documentationSummary
Querying and Manipulating Data Using LINQ
Writing LINQ queriesExtending sequences with the Enumerable classFiltering entities with WhereTargeting a named methodSimplifying the code by removing the explicit delegate instantiationTargeting a lambda expressionSorting entitiesSorting by a single property using OrderBySorting by a subsequent property using ThenByFiltering by typeWorking with sets and bags using LINQUsing LINQ with EF CoreBuilding an EF Core modelFiltering and sorting sequencesProjecting sequences into new typesJoining and grouping sequencesAggregating sequencesSweetening LINQ syntax with syntactic sugarUsing multiple threads with parallel LINQCreating an app that benefits from multiple threadsUsing Windows 10Using macOSFor all operating systemsCreating your own LINQ extension methodsWorking with LINQ to XMLGenerating XML using LINQ to XMLReading XML using LINQ to XMLPracticing and exploringExercise 12.1 – Test your knowledgeExercise 12.2 – Practice querying with LINQExercise 12.3 – Explore topicsSummary
Improving Performance and Scalability Using Multitasking
Understanding processes, threads, and tasksMonitoring performance and resource usageEvaluating the efficiency of typesMonitoring performance and memory useImplementing the Recorder classMeasuring the efficiency of processing stringsRunning tasks asynchronouslyRunning multiple actions synchronouslyRunning multiple actions asynchronously using tasksWaiting for tasksContinuing with another taskNested and child tasksSynchronizing access to shared resourcesAccessing a resource from multiple threadsApplying a mutually exclusive lock to a resourceUnderstanding the lock statement and avoiding deadlocksMaking CPU operations atomicApplying other types of synchronizationUnderstanding async and awaitImproving responsiveness for console appsImproving responsiveness for GUI appsImproving scalability for web applications and web servicesCommon types that support multitaskingUsing await in catch blocksWorking with async streamsPracticing and exploringExercise 13.1 – Test your knowledgeExercise 13.2 – Explore topicsSummary
Practical Applications of C# and .NET
Understanding app models for C# and .NETBuilding websites using ASP.NET CoreBuilding websites using a web content management systemUnderstanding web applicationsBuilding and consuming web servicesBuilding intelligent appsNew features for ASP.NET CoreASP.NET Core 1.0ASP.NET Core 1.1ASP.NET Core 2.0ASP.NET Core 2.1ASP.NET Core 2.2ASP.NET Core 3.0Understanding SignalRUnderstanding BlazorJavaScript and friendsSilverlight – C# and .NET using a pluginWebAssembly – a target for BlazorBlazor on the server-side or client-sideUnderstanding the bonus chaptersBuilding Windows desktop appsBuilding cross-platform mobile appsBuilding an entity data model for NorthwindCreating a class library for Northwind entity modelsCreating a class library for a Northwind database contextSummary
Building Websites Using ASP.NET Core Razor Pages
Understanding web developmentUnderstanding HTTPClient-side web developmentUnderstanding ASP.NET CoreClassic ASP.NET versus modern ASP.NET CoreCreating an ASP.NET Core projectTesting and securing the websiteEnabling static and default filesExploring Razor PagesEnabling Razor PagesDefining a Razor PageUsing shared layouts with Razor PagesUsing code-behind files with Razor PagesUsing Entity Framework Core with ASP.NET CoreConfigure Entity Framework Core as a serviceManipulating data using Razor pagesEnabling a model to insert entitiesDefining a form to insert new suppliersUsing Razor class librariesUsing a Razor class libraryPracticing and exploringExercise 15.1 – Test your knowledgeExercise 15.2 – Practice building a data-driven web pageExercise 15.3 – Explore topicsSummary
Building Websites Using the Model-View-Controller Pattern
Setting up an ASP.NET Core MVC websiteCreating and exploring an ASP.NET Core MVC websiteReviewing the ASP.NET Core MVC websiteReviewing the ASP.NET Core Identity databaseExploring an ASP.NET Core MVC websiteUnderstanding ASP.NET Core MVC startupUnderstanding the default MVC routeUnderstanding controllers and actionsUnderstanding filtersUsing a filter to secure an action methodUsing a filter to cache a responseUsing a filter to define a custom routeUnderstanding entity and view modelsUnderstanding viewsCustomizing an ASP.NET Core MVC websiteDefining a custom styleSetting up the category imagesUnderstanding Razor syntaxDefining a typed viewTesting the customized home pagePassing parameters using a route valueUnderstanding model bindersValidating the modelUnderstanding view helper methodsQuerying a database and using display templatesImproving scalability using asynchronous tasksMaking controller action methods asynchronousUsing other project templatesInstalling additional template packsPracticing and exploringExercise 16.1 – Test your knowledgeExercise 16.2 – Practice implementing MVC by implementing a category detail pageExercise 16.3 – Practice improving scalability by understanding and implementing async action methodsExercise 16.4 – Explore topicsSummary
Building Websites Using a Content Management System
Understanding the benefits of a CMSUnderstanding basic CMS featuresUnderstanding enterprise CMS featuresUnderstanding CMS platformsUnderstanding Piranha CMSCreating and exploring a Piranha CMS websiteEditing site and page contentCreating a new top-level pageCreating a new child pageReviewing the blog archiveExploring authentication and authorizationExploring configurationTesting the new contentUnderstanding routingUnderstanding mediaUnderstanding the application serviceUnderstanding content typesUnderstanding component typesUnderstanding standard fieldsReviewing some content typesUnderstanding standard blocksReviewing component types and standard blocksDefining components, content types, and templatesReviewing the standard page typeReviewing the blog archive page typeDefining custom content and component typesCreating custom regionsCreating an entity data modelCreating custom page typesCreating custom view modelsDefining custom content templates for content typesConfiguring start up and importing from a databaseTesting the Northwind CMS websiteUploading images and creating the catalog rootImporting category and product contentManaging catalog contentReviewing how Piranha stores contentPracticing and exploringExercise 17.1 – Test your knowledgeExercise 17.2 – Practice defining a block type for rendering YouTube videosExercise 17.3 – Explore topicsSummary
Building and Consuming Web Services
Building web services using ASP.NET Core Web APIUnderstanding web service acronymsCreating an ASP.NET Core Web API projectReviewing the web service's functionalityCreating a web service for the Northwind databaseCreating data repositories for entitiesImplementing a Web API controllerConfiguring the customers repository and Web API controllerSpecifying problem detailsDocumenting and testing web servicesTesting GET requests using a browserTesting HTTP requests with REST Client extensionEnabling SwaggerTesting requests with Swagger UIConsuming services using HTTP clientsUnderstanding HttpClientConfiguring HTTP clients using HttpClientFactoryEnabling Cross-Origin Resource SharingImplementing advanced featuresImplementing Health Check APIImplementing Open API analyzers and conventionsUnderstanding endpoint routingConfiguring endpoint routingUnderstanding other communication technologiesUnderstanding Windows Communication Foundation (WCF)Understanding gRPCPracticing and exploringExercise 18.1 – Test your knowledgeExercise 18.2 – Practice creating and deleting customers with HttpClientExercise 18.3 – Explore topicsSummary
Building Intelligent Apps Using Machine Learning
Understanding machine learningUnderstanding the machine learning life cycleUnderstanding datasets for training and testingUnderstanding machine learning tasksUnderstanding Microsoft Azure Machine LearningUnderstanding ML.NETUnderstanding Infer.NETUnderstanding ML.NET learning pipelinesUnderstanding model training conceptsUnderstanding missing values and key typesUnderstanding features and labelsMaking product recommendationsProblem analysisData gathering and processingCreating the NorthwindML website projectCreating the data and view modelsImplementing the controllerTraining the recommendation modelsImplementing a shopping cart with recommendationsTesting the product recommendations websitePracticing and exploringExercise 19.1 – Test your knowledgeExercise 19.2 – Practice with samplesExercise 19.3 – Explore topicsSummary
Building Windows Desktop Apps
Understanding legacy Windows application platformsUnderstanding .NET Core 3.0 support for legacy Windows platformsInstalling Microsoft Visual Studio 2019 for WindowsWorking with Windows FormsBuilding a new Windows Forms applicationReviewing a new Windows Forms applicationMigrating a legacy Windows Forms applicationMigrating a Windows Forms appMigrating WPF apps to .NET Core 3.0Migrating legacy apps using the Windows Compatibility PackUnderstanding the modern Windows platformUnderstanding Universal Windows PlatformUnderstanding Fluent Design SystemFilling user interface elements with acrylic brushesConnecting user interface elements with animationsParallax views and Reveal lightingUnderstanding XAML StandardSimplifying code using XAMLChoosing common controlsUnderstanding markup extensionsCreating a modern Windows appEnabling developer modeCreating a UWP projectExploring common controls and acrylic brushesExploring RevealInstalling more controlsUsing resources and templatesSharing resourcesReplacing a control templateUsing data bindingBinding to elementsCreating an HTTP service to bind toDownloading the web service's certificateBinding to data from a secure HTTP serviceCreating the user interface to call the HTTP serviceConverting numbers to imagesTesting the HTTP service data bindingPracticing and exploringExercise 20.1 – Test your knowledgeExercise 20.2 – Explore topicsSummary
Building Cross-Platform Mobile Apps Using Xamarin.Forms
Understanding Xamarin and Xamarin.FormsHow Xamarin.Forms extends XamarinMobile first, cloud firstUnderstanding additional functionalityUnderstanding the INotificationPropertyChanged interfaceUnderstanding dependency servicesUnderstanding Xamarin.Forms user interface componentsUnderstanding the ContentPage viewUnderstanding the Entry and Editor controlsUnderstanding the ListView controlBuilding mobile apps using Xamarin.FormsAdding Android SDKsCreating a Xamarin.Forms solutionCreating an entity model with two-way data bindingCreating a component for dialing phone numbersCreating views for the customers list and customer detailsImplementing the customer list viewImplementing the customer detail viewSetting the main page for the mobile appTesting the mobile appConsuming a web service from a mobile appConfiguring the web service to allow insecure requestsConfiguring the iOS app to allow insecure connectionsAdding NuGet packages for consuming a web serviceGetting customers from the web servicePracticing and exploringExercise 21.1 – Test your knowledgeExercise 21.2 - Explore topicsSummaryEpilogue

Content preview from C# 8.0 and .NET Core 3.0 – Modern Cross-Platform Development - Fourth Edition

Chapter 21 Building Cross-Platform Mobile Apps Using Xamarin.Forms

This chapter is about learning how to take C# mobile by building a cross-platform mobile app for iOS and Android. The mobile app will allow the listing and management of customers in the Northwind database.

Apart from UWP apps in Chapter 20, Building Windows Desktop Apps, this is the only chapter that does not use .NET Core 3.0. But by 2020, with the release of .NET 5.0, all app models, including mobile, will share the same unified .NET platform.

Mobile development cannot be learned in a single chapter, but like web development, mobile development is so important these days that I wanted to introduce you to some of what is possible. Think of this chapter as a bonus. This chapter ...

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

C# 9 and .NET 5 – Modern Cross-Platform Development - Fifth Edition

Publisher Resources

ISBN: 9781788478120

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

C# 8.0 and .NET Core 3.0 – Modern Cross-Platform Development - Fourth Edition

by Mark J. Price

Chapter 21

Building Cross-Platform Mobile Apps Using Xamarin.Forms

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.