Index
A
- Additional Tools for Xcode / Improving HTTP performance with transient caching
- advanced scenarios
- about / Advanced scenarios
- push to pull / Push to pull
- rich Media for push messages / Rich Media for push messages
- Ahead-of-Time (AOT) / Introduction to .NET Core
- Android
- Xamarin on / Xamarin on Android – Mono Droid
- Android services / Android services
- App Center
- telemetry and diagnostic options / App Center telemetry and diagnostics
- App Center, for Xamarin
- about / App Center for Xamarin
- integration, with source repository and builds / Integration with the source repository and builds
- distribution rings, setting up / Setting up distribution rings
- AppCenter distribution groups / AppCenter distribution groups
- App Center distribution to production / App Center distribution to production
- AppCenter releases / AppCenter releases
- App Center telemetry data
- exporting, to Azure / Exporting App Center telemetry data to Azure
- Apple Push Notification Service (APNS) / General constraints
- application Insights data model
- about / Application Insights data model
- trace / Application Insights data model
- events / Application Insights data model
- metrics / Application Insights data model
- Application Insights telemetry data
- collecting, with Azure Functions / Collecting telemetry with Azure Functions
- application integrity, with tests
- maintaining / Maintaining application integrity with tests
- unit tests, implementing / Arrange, Act, and Assert
- unit test, implementing / Arrange, Act, and Assert
- unit tests, creating with mocks / Creating unit tests with mocks
- fixtures tests / Fixtures and data-driven tests
- data-driven tests / Fixtures and data-driven tests
- application layout
- about / Application layout
- consumer expectations / Consumer expectations
- platform imperatives / Platform imperatives
- development cost / Development cost
- Application Lifecycle Management (ALM) / Azure DevOps
- app model
- selecting / Choosing the right app model
- Azure virtual machines / Azure virtual machines
- containers, in Azure / Containers in Azure
- architectural patterns
- using / Useful architectural patterns
- ARM template
- creating / Creating an ARM template
- concepts / ARM template concepts
- Azure DevOps, using for / Using Azure DevOps for ARM templates
- Arrange, Act, Assert (AAA) / Arrange, Act, and Assert
- artifact, types
- about / Release artifacts
- Azure Pipelines / Release artifacts
- TFVC / Release artifacts
- Git / Release artifacts
- GitHub / Release artifacts
- Jenkins / Release artifacts
- Azure Container Registry / Release artifacts
- Docker / Release artifacts
- Kubernetes / Release artifacts
- Azure Artifacts (NuGet, Maven, and npm) / Release artifacts
- external or on-premises TFS / Release artifacts
- ASP.NET Core
- about / ASP.NET Core
- telemetry data, collecting with / Collecting telemetry data with ASP.NET Core
- ASP.NET Core Identity / ASP.NET Core Identity
- asynchronous execution patterns
- about / Asynchronous execution patterns
- service initialization pattern / Service initialization pattern
- asynchronous event, handling / Asynchronous event handling
- asynchronous command / The asynchronous command
- Asynchronous Programming Model (APM) / Asynchronous event handling
- Atomic, Consistent, Isolated, Durable (ACID) / Relational database resources
- awaitables
- utilizing / Utilizing tasks and awaitables
- Azure
- App Center telemetry data, exporting to / Exporting App Center telemetry data to Azure
- Azure Active Directory (Azure AD) / Azure AD
- Azure AD B2C / Azure AD B2C
- Azure App Service / Azure App Service
- Azure blobs
- types / Azure blobs
- Azure Cache
- for Redis / Azure Cache for Redis
- Azure Container Services (ACS)
- with Kubernetes / Azure Container Services with Kubernetes
- about / Azure Container Services with Kubernetes
- Azure DevOps
- about / Azure DevOps
- sections / Azure DevOps
- using / Using Azure DevOps and Git
- Git repository, creating with / Creating a Git repository with Azure DevOps
- using, for ARM templates / Using Azure DevOps for ARM templates
- Azure DevOps releases
- about / Azure DevOps releases, Azure web application release
- release artifacts / Release artifacts
- release stages / Release stages
- release gates / Release gates and triggers
- triggers / Release gates and triggers
- Azure Event Grid / Azure Event Grid
- Azure functions
- about / Azure functions
- execution models / Azure functions
- Azure Functions
- developing / Developing Azure Functions
- implementing / Implementing Azure Functions
- triggers / Function triggers and bindings
- bindings / Function triggers and bindings
- configuring / Configuring functions
- hosting / Hosting functions
- creating / Creating our first Azure function
- Application Insights telemetry data, collecting with / Collecting telemetry with Azure Functions
- Azure Logic Apps / Azure Logic Apps
- Azure Notification Hub
- about / Azure Notification Hub, Notification hub
- infrastructure / Notification Hub infrastructure
- notification namespace / Notification namespace
- used, for notifications / Notifications using Azure Notification Hub
- Azure Notification Hub, used for Azure Notification Hubations
- registration / Registration
- notification / Notification
- Azure Pipelines / Release artifacts
- Azure repository models / Repository
- Azure Resource Manager (ARM)
- about / Azure service providers and resource types
- CI phase / The CI phase
- Azure serverless
- about / Azure serverless
- Azure functions / Azure functions
- Azure Logic Apps / Azure Logic Apps
- Azure Event Grid / Azure Event Grid
- Azure Serverless / Understanding Azure Serverless
- Azure service
- overview / An overview of Azure services
- providers / Azure service providers and resource types
- resource types / Azure service providers and resource types
- Azure Service
- telemetry data, collecting for / Collecting telemetry data for Azure Service
- Azure Service Bus / Queue-based processing
- Azure Service Fabric
- microservices / Microservices with Azure Service Fabric
- Azure Service Fabric Mesh / Service Fabric Mesh
- Azure storage
- about / Azure storage
- Azure blobs / Azure blobs
- Azure files / Azure files
- Azure queues / Azure queues
- Azure tables / Azure tables
- Azure virtual machines / Azure virtual machines
- Azure Web App
- for App Service / Azure Web App for App Service
- Azure web application release / Azure web application release
B
- BindingMode / Model-View-ViewModel (MVVM) implementation
- branches
- workflow / Branching strategy
- branching strategy / Branching strategy
- branch policies / Pull request/merge
- Business to Business (B2B) / Azure AD
C
- CI/CD / Introducing CI/CD
- CI/CD, with GitFlow
- about / CI/CD with GitFlow
- development / Development
- feature branch, merging in development branch through pull request / Pull request/merge
- CI phase / The CI phase
- release branch / Release branch
- hotfix branches / Hotfix branches
- production / Production
- cloud architecture
- about / Cloud architecture
- gateway aggregation / Gateway aggregation
- backends for frontends / Backends for frontends
- materialized view / A materialized view
- cache-aside pattern / The cache-aside pattern
- queue-based load leveling / Queue-based load leveling
- competing consumers / Competing consumers
- publisher pattern / The publisher/subscriber pattern
- subscriber pattern / The publisher/subscriber pattern
- circuit breaker / The circuit breaker and retry patterns
- retry patterns / The circuit breaker and retry patterns
- Cognitive Services
- about / Understanding Cognitive Services
- Vision API / Understanding Cognitive Services
- Speech API / Understanding Cognitive Services
- language APIs / Understanding Cognitive Services
- Search APIs / Understanding Cognitive Services
- Decision API / Understanding Cognitive Services
- command pattern / The command pattern
- Common Language Infrastructure (CLI) / Introduction to .NET Core, Introduction to Xamarin
- computer vision / Computer vision
- consistency spectrum / Consistency spectrum
- consumer expectations / Consumer expectations
- consumers
- creating, with blocking collections / Creating producers/consumers with blocking collections
- Core Common Language Runtime (Core CLR) / .NET Standard and .NET Native
- Cosmos DB
- about / Cosmos DB
- fundamentals / The basics of Cosmos DB
- global distribution / Global distribution
- consistency spectrum / Consistency spectrum
- pricing model / Pricing
- in depth / Cosmos DB in depth
- partitioning / Partitioning
- indexing / Indexing
- programmability / Programmability
- change feed / Change feed
- cross-module integrity, with integration tests
- maintaining / Maintaining cross-module integrity with integration tests
- client-server communication, testing / Testing the client-server communication
- platform tests, implementing / Implementing platform tests
- cross-platform application
- development / Cross-platform development
- fully native applications, developing / Developing fully native applications
- hybrid applications / Hybrid applications
- native cross-platform frameworks / Native cross-platform frameworks
- custom controls
- creating / Creating custom controls
- custom renderer
- creating / Creating a custom renderer
- custom Xamarin.Forms control
- creating / Creating a custom Xamarin.Forms control
D
- data
- modeling / Modeling data
- documents, creating / Creating and accessing documents
- documents, accessing / Creating and accessing documents
- denormalized / Denormalized data
- referenced data / Referenced data
- analyzing / Analyzing data
- data-binding essentials / Data-binding essentials
- data-driven views
- creating / Creating data-driven views
- data-binding essentials / Data-binding essentials
- value converters, using / Value converters
- triggers / Triggers
- visual states / Visual states
- data access models
- about / Data access models
- SQL API / SQL API
- MongoDB API / MongoDB API
- others / Others
- data access patterns
- about / Data access patterns
- transient data / Data access patterns
- reference data / Data access patterns
- static data / Data access patterns
- repository pattern, implementing / Implementing the repository pattern
- observable repository / Observable repository
- data resolver / Data resolver
- Database Transaction Unit (DTU) / Relational database resources, Pricing
- Data Binding / Xamarin.Forms
- data cache
- using, SQLite / Persistent data cache using SQLite
- data clusters
- vehicles / Modeling data
- users / Modeling data
- auctions / Modeling data
- data store model
- about / Data stores
- relational database resources / Relational database resources
- Azure storage / Azure storage
- Cosmos DB / Cosmos DB
- Azure Cache, for Redis / Azure Cache for Redis
- data transfer object (DTO) / Xamarin application anatomy
- Data Transformation Object (DTO) / Creating and accessing documents
- Decision API / Understanding Cognitive Services
- decorator pattern / Decorator
- design techniques
- about / Platform imperatives
- fluid layout / Platform imperatives
- orientation change / Platform imperatives
- restructure / Platform imperatives
- resize / Platform imperatives
- development branches
- managing / Managing development branches
- development cost / Development cost
- development services / Development services
- distributed systems / An introduction to distributed systems
- distribution
- with AppCenter / Distribution with AppCenter
- Dynamic Link Library (DLL) / Creating a runtime agnostic application
E
- Electronic Data Interchange (EDI) / Using connectors
- Enterprise Application Integration (EAI) / Using connectors
- Enterprise Integration Pack (EIP) / Azure Logic Apps, Using connectors
- entity data model (EDM) / Implement retrieval actions
- entity Framework / Entity Framework
- Entity Framework Core / Entity Framework Core
- Entity tag (ETag) / Entity tag (ETag) validation
- event aggregator pattern / Event aggregator
- Event Grid / Event aggregation
- event hubs / Event aggregation
- eventual consistency / Consistency spectrum
- execution method / Single execution guarantee
F
- Firebase Cloud Messaging (FCM) / Notification providers, General constraints
- fixture / Fixtures and data-driven tests
- floating action button (FAB) / Layouts
- framework-dependent / Creating a runtime agnostic application
- fully native applications
- developing / Developing fully native applications
G
- Git
- using / Using Azure DevOps and Git
- Git repository
- creating, with Azure DevOps / Creating a Git repository with Azure DevOps
- global distribution / Global distribution
- Global System for Mobile Communications (GSM) / Improving HTTP performance with transient caching
- Graph API / The Graph API and Project Rome, The Graph API
H
- HTTP performance, with transient caching
- improving / Improving HTTP performance with transient caching
- cache-aside pattern, implementing / Client cache aside
- Entity tag (ETag), validating / Entity tag (ETag) validation
- key-value store, implementing / Key/value store
- hybrid applications / Hybrid applications
I
- identity as a service (IDaaS) / Azure AD
- IdentityServer / IdentityServer
- Infrastructure as a Service (IaaS) / Choosing the right app model
- Infrastructure as Code (IaC) / An introduction to distributed systems, Azure virtual machines, Creating an ARM template
- insights
- collecting, for Xamarin applications / Collecting insights for Xamarin applications
- integration, with Azure services
- about / Integration with Azure services
- repository / Repository
- queue-based processing / Queue-based processing
- event aggregation / Event aggregation
- integration tests
- cross-module integrity, maintaining with / Maintaining cross-module integrity with integration tests
- Inversion of Control (IoC) / Model-View-ViewModel (MVVM) implementation, Inversion of Control
- iOS
- Xamarin on / Xamarin on iOS – Mono Touch
- backgrounding / iOS backgrounding
J
- Just-In-Time (JIT) / Introduction to .NET Core
K
- key-value pair (KVP) / Azure tables
L
- language API / Understanding Cognitive Services
- Language Understanding Service (LUIS) / Language Understanding Service
- layouts / Layouts
- Line of Business (LOB) / Xamarin.Forms development domains
- line of business (LOB) application / Azure AD
- logical tasks / Logical tasks
- Logic App
- developing / Developing a Logic App
- implementing / Implementing Logic Apps
- connectors, using / Using connectors
- creating / Creating our first Logic App
- workflow, execution control / Workflow execution control
- Long Term Evolution (LTE) / Improving HTTP performance with transient caching
M
- master/detail view / Master/detail view
- Mean Time To Detect (MTTD) / Testing
- Mean Time To Restore (MTTR) / Testing
- microservice
- creating / Creating our first microservice
- setting up / Initial setup
- retrieval actions, implementing / Implement retrieval actions
- patch updates, implementing / Implementing patch updates
- soft delete, implementing / Implementing a soft delete
- Microsoft Authentication Library (MSAL) / Azure AD
- Microsoft Developer Network (MSDN) / Azure DevOps
- Microsoft Intermediate Language (MSIL) / Xamarin on iOS – Mono Touch
- Model-View-Adapter (MVA) / Model-View-Controller (MVC) implementation
- Model-View-Controller (MVC)
- implementing / Model-View-Controller (MVC) implementation
- Model-View-Presenter (MVP) / Model-View-Controller (MVC) implementation
- Model-View-ViewModel (MVVM)
- Model View Intent (MVI) / The command pattern
- MongoDB API / MongoDB API
- Mono Compiler (MCS) / Introduction to .NET Core
- multi-page views / Multi-page views
N
- .NET
- reactive Extensions for / Reactive Extensions for .NET
- .NET Core
- about / Introduction to .NET Core, .NET Core, Defining a runtime and self-contained deployment, Defining a framework
- developing with / Developing with .NET Core
- runtime agnostic application, creating / Creating a runtime agnostic application
- runtime, defining / Defining a runtime and self-contained deployment
- self-contained deployment, defining / Defining a runtime and self-contained deployment
- .NET Core applications
- deploying / Deploying .NET Core applications
- .NET Foundation / .NET Foundation
- .NET Foundation projects
- about / Notable .NET Foundation projects
- .NET Core / .NET Core
- ASP.NET Core / ASP.NET Core
- Roslyn / Roslyn
- reactive Extensions, for .NET / Reactive Extensions for .NET
- entity Framework / Entity Framework
- IdentityServer / IdentityServer
- Xamarin / Xamarin and Xamarin.Forms
- Xamarin.Forms / Xamarin and Xamarin.Forms
- xUnit.net / xUnit.net
- .NET Native / .NET Standard and .NET Native
- .NET Standard
- using, with Xamarin / Using .NET Standard with Xamarin
- about / .NET Standard and .NET Native
- native asynchronous execution
- about / Native asynchronous execution
- Android services / Android services
- iOS, backgrounding / iOS backgrounding
- native components / Native components
- native controls
- native cross-platform frameworks / Native cross-platform frameworks
- native domains
- customizing / Customizing native domains
- platform-specifics, configuration / Platform specifics
- Xamarin.Forms effects / Xamarin.Forms effects
- composite, customizations / Composite customizations
- Native Notification Services
- about / Understanding Native Notification Services
- notification providers / Notification providers
- notifications, sending with PNS / Sending notifications with PNS
- general constraints / General constraints
- navigation structure
- implementing / Implementing navigation structure
- single-page view / Single-page view
- simple navigation / Simple navigation
- multi-page views / Multi-page views
- master/detail view / Master/detail view
- notification providers / Notification providers
- notification service
- creating / Creating a notification service
- requirements, defining / Defining the requirements
- device registration / Device registration
- notifications, transmitting / Transmitting notifications
- multiple devices, broadcasting / Broadcasting to multiple devices
- advanced scenarios / Advanced scenarios
O
- OpenID Identity Connect (OIDC) / Securing the application
P
- Page Object Pattern (POP) / Page Object Pattern
- Personal Access Token (PAT) / Creating a Git repository with Azure DevOps
- Platform Abstraction Layer (PAL) / Introduction to .NET Core
- platform extensions / Platform extensions
- platform imperatives / Platform imperatives
- Platform Notification System (PNS)
- about / Notification providers, Notification hub
- notifications, sending with / Sending notifications with PNS
- notification, sending with / Sending notifications with PNS
- portable class library (PCL) / SQLite.NET
- PowerShell Desired State Configuration (DSC) / Azure virtual machines
- presentation architecture
- selecting / Selecting the presentation architecture
- Model-View-Controller (MVC), implementing / Model-View-Controller (MVC) implementation
- Model-View-ViewModel (MVVM), implementing / Model-View-ViewModel (MVVM) implementation
- pricing model / Pricing
- producers
- creating, with blocking collections / Creating producers/consumers with blocking collections
- Progressive Web Apps (PWAs) / Hybrid applications
- Project Rome
- about / The Graph API and Project Rome, Project Rome
- device relay / Device relay
- user activities / User activities
- notifications / Notifications
- remote Sessions / Remote Sessions
- nearby sharing / Nearby sharing
Q
- QA process
- about / The QA process
- code review / Code review
- testing / Testing
- static code, analyzing with SonarQube / Static code analysis with SonarQube
R
- Read-Eval-Print-Loop (REPL) / Xamarin.UITests
- Realm / Understanding Realm
- Redis
- Azure Cache for / Azure Cache for Redis
- Redis cache
- integrating / Integrating with Redis cache
- relational database resources / Relational database resources
- release artifacts / Release artifacts
- release gates / Release gates and triggers
- release stages / Release stages
- release templates
- creating / Creating and using release templates
- using / Creating and using release templates
- Azure DevOps releases / Azure DevOps releases
- Xamarin release template / Xamarin release template
- Azure web application release / Azure web application release
- Request Unit (RU) / Pricing
- Roslyn / Roslyn
- Rotor / Introduction to .NET Core
- Runtime Identifier (RID) / Defining a runtime and self-contained deployment
S
- Search API
- about / Understanding Cognitive Services, Search API
- search query completion / Search query completion
- Web Search API / Web Search API
- image search / Image search
- entity search / Other
- news search / Other
- video search / Other
- visual search / Other
- local business search / Other
- security token service (STS) / Securing the application
- self-contained / Defining a runtime and self-contained deployment
- Server Message Block (SMB) / Azure files
- Service-Oriented Architecture (SOA) / An introduction to distributed systems
- services
- hosting / Hosting the services
- Azure Web App, for App Service / Azure Web App for App Service
- containerizing / Containerizing services
- session consistency / Consistency spectrum
- Shared Source Common Language Infrastructure (SSCLI) / Introduction to .NET Core
- signal strength / Improving HTTP performance with transient caching
- simple navigation / Simple navigation
- single-page view / Single-page view
- Single Page Application (SPA) / Hybrid applications
- Software Defined Networking (SDN) / Service Fabric Mesh
- SonarLint
- used, for analyzing local / Local analysis with SonarLint
- Speech API
- about / Understanding Cognitive Services, Speech APIs
- speech to text / Speech to text
- Language Understanding Service (LUIS) / Language Understanding Service
- speech to text / Speech to text
- SQL API / SQL API
- SQLite
- used, for data cache / Persistent data cache using SQLite
- SQLite.NET / SQLite.NET
- static code, analyzing with SonarQube
- about / Static code analysis with SonarQube
- SonarLint, used for analyzing local / Local analysis with SonarLint
- CI analysis / CI analysis
- external Roslyn analyzers / External Roslyn analyzers
- strong consistency / Consistency spectrum
- synchronization context / Synchronization context
- System Under Test (SUT) / Fixtures and data-driven tests
T
- task-based execution / Task-based execution
- Task Asynchronous Programming (TAP) model / Task-based execution
- tasks
- utilizing / Utilizing tasks and awaitables
- Team Foundation Version Control (TFVC) / Using Azure DevOps and Git
- telemetry data model
- collecting, App Center SDK used / Telemetry data model
- application, coupling / Advanced application telemetry
- collecting, for Azure Service / Collecting telemetry data for Azure Service
- collecting, with ASP.NET Core / Collecting telemetry data with ASP.NET Core
- Test-Driven Development (TDD) / Maintaining application integrity with tests
- TFS Online / Azure DevOps
- Time-based One-Time Password (TOTP) / ASP.NET Core Identity
- Time To Live (TTL) / Implementing a soft delete
- transcription service, features
- short utterance / Speech to text
- continuous transcription / Speech to text
- intent recognition / Speech to text
- batch transcription / Speech to text
- triggers
- about / Triggers, Release gates and triggers
- types / Triggers
U
- UI components
- layouts / Layouts
- Xamarin.Forms, view elements / Xamarin.Forms view elements
- native components / Native components
- UI test
- automating / Automated UI tests
- Xamarin.UITests / Xamarin.UITests
- Page Object Pattern (POP) / Page Object Pattern
- Universal Windows Platform (UWP)
- about / Universal Windows Platform
- application, creating / Creating UWP applications
- user experience (UX) / Utilizing tasks and awaitables
V
- Validate / Using Azure DevOps for ARM templates
- value converters
- using / Value converters
- Virtual machines (VMs) / An introduction to distributed systems, Azure virtual machines
- Vision API / Understanding Cognitive Services
- Visual State Manager (VSM) / Triggers
- visual states / Visual states
- Visual Studio App Center / Visual Studio App Center
- Visual Studio Team Services / Azure DevOps
W
- web application
- securing / Securing the application
- ASP.NET Core Identity / ASP.NET Core Identity
- Azure Active Directory (Azure AD) / Azure AD
- Azure AD B2C / Azure AD B2C
- Windows Notification Service (WNS) / Notification providers
- Windows Presentation Foundation (WPF) / Model-View-ViewModel (MVVM) implementation
- Windows Runtime (WinRT) / Universal Windows Platform
X
- Xamarin
- about / Xamarin and Xamarin.Forms, Introduction to Xamarin
- on iOS / Xamarin on iOS – Mono Touch
- on Android / Xamarin on Android – Mono Droid
- .NET Standard, using with / Using .NET Standard with Xamarin
- versus Xamarin.Forms / Xamarin versus Xamarin.Forms
- Xamarin.Android build / Xamarin.Android build
- Xamarin.Forms
- about / Xamarin and Xamarin.Forms, Xamarin.Forms
- versus Xamarin / Xamarin versus Xamarin.Forms
- using / Using Xamarin.Forms and native controls
- view elements / Xamarin.Forms view elements
- used, for creating development domains / Xamarin.Forms development domains
- Xamarin.Forms application
- anatomy / Xamarin application anatomy
- Xamarin.Forms control
- creating / Creating a Xamarin.Forms control
- Xamarin.Forms domain
- about / Xamarin.Forms shared domain
- using, styles / Using styles
- behaviors, creating / Creating behaviors
- properties, attaching / Attached properties
- XAML markup extensions / XAML markup extensions
- Xamarin.iOS pipeline / Xamarin.iOS pipeline
- Xamarin.UITests / Xamarin.UITests
- Xamarin application
- creating / Creating your first Xamarin application
- insights, collecting for / Collecting insights for Xamarin applications
- Xamarin application packages
- creating / Creating Xamarin application packages
- environment-specific configurations / Environment-specific configurations
- artifacts, creating / Creating and utilizing artifacts
- artifacts, utilizing / Creating and utilizing artifacts
- Xamarin build template
- using / Using Xamarin build templates
- Xamarin release template / Xamarin release template
- XAML Standard / XAML Standard
- xUnit.net / xUnit.net