### Verify Xcode Installation Path

Source: https://github.com/dotnet/docs-maui/blob/main/docs/get-started/installation.md

This command verifies that Xcode is installed and returns the path to its installation directory. This is useful for troubleshooting when Xcode is not found by the .NET MAUI setup.

```console
xcode-select -p
```

--------------------------------

### IDeviceInstallationService Interface for .NET MAUI

Source: https://github.com/dotnet/docs-maui/blob/main/docs/data-cloud/push-notifications.md

Defines the contract for a service responsible for retrieving device installation information. It includes properties for the token and notification support, methods to get a device ID, and to retrieve device installation details with optional tags. This interface is intended for platform-specific implementations.

```csharp
using PushNotificationsDemo.Models;

namespace PushNotificationsDemo.Services;

public interface IDeviceInstallationService
{
    string Token { get; set; }
    bool NotificationsSupported { get; }
    string GetDeviceId();
    DeviceInstallation GetDeviceInstallation(params string[] tags);
}
```

--------------------------------

### List Installed .NET MAUI Workloads

Source: https://github.com/dotnet/docs-maui/blob/main/docs/get-started/installation.md

Lists all installed .NET MAUI workloads on your system. This command helps in verifying the installation status of various MAUI components, including Android and Windows specific workloads.

```dotnetcli
dotnet workload list
```

--------------------------------

### Install Android Emulator and System Images (Windows)

Source: https://github.com/dotnet/docs-maui/blob/main/docs/get-started/installation.md

Installs the Android emulator and a system image for API level 35 on Windows using the `sdkmanager` command. Requires the Android SDK command-line tools to be in the system's PATH.

```console
sdkmanager --install emulator

```

```console
sdkmanager --install "system-images;android-35;google_apis;x86_64"

```

--------------------------------

### Install Xcode Command Line Tools

Source: https://github.com/dotnet/docs-maui/blob/main/docs/get-started/installation.md

Acquires the Xcode command line tools necessary for .NET MAUI development on iOS and Mac Catalyst by running the `xcode-select --install` command in the terminal.

```console
xcode-select --install

```

--------------------------------

### PUT /api/notifications/installations

Source: https://github.com/dotnet/docs-maui/blob/main/docs/data-cloud/push-notifications.md

Creates or updates a device installation for push notifications. Requires device installation details in the request body.

```APIDOC
## PUT /api/notifications/installations

### Description
Creates or updates a device installation for push notifications. Requires device installation details in the request body.

### Method
PUT

### Endpoint
/api/notifications/installations

### Parameters
#### Request Body
- **deviceInstallation** (DeviceInstallation) - Required - The details of the device installation.

### Request Example
```json
{
  "deviceId": "string",
  "pushChannel": "string",
  "tags": ["string"]
}
```

### Response
#### Success Response (200)
- **None** - Indicates the installation was successfully created or updated.

#### Error Response
- **400 Bad Request** - If the request is invalid.
- **422 Unprocessable Entity** - If the operation could not be processed.
```

--------------------------------

### Install .NET MAUI Workload on Windows

Source: https://github.com/dotnet/docs-maui/blob/main/docs/get-started/installation.md

Installs the .NET MAUI workload on Windows using the .NET CLI. This command enables development for MAUI applications on the Windows platform.

```dotnetcli
dotnet workload install maui
```

--------------------------------

### Install .NET MAUI Workload

Source: https://github.com/dotnet/docs-maui/blob/main/docs/includes/install-create-macos.md

Installs the .NET MAUI workload, including necessary platform SDKs, from the specified NuGet source. This is a prerequisite for developing .NET MAUI apps.

```zsh
sudo dotnet workload install maui --source https://api.nuget.org/v3/index.json
```

--------------------------------

### Install .NET MAUI Workload using CLI

Source: https://github.com/dotnet/docs-maui/blob/main/docs/get-started/installation.md

These commands install the .NET MAUI workload necessary for developing .NET MAUI applications. The specific command varies slightly by operating system.

```dotnetcli
dotnet workload install maui
```

```dotnetcli
sudo dotnet workload install maui
```

```dotnetcli
dotnet workload install maui-android
```

--------------------------------

### Implement Page Navigation with Button

Source: https://github.com/dotnet/docs-maui/blob/main/docs/xaml/fundamentals/get-started.md

Creates a Button in the constructor of a .NET MAUI MainPage and assigns a click event handler to navigate to another page (HelloXamlPage). This code snippet shows how to programmatically instantiate UI elements and handle user interactions for navigation.

```csharp
public MainPage()
{
    InitializeComponent();

    Button button = new Button
    {
        Text = "Navigate!",
        HorizontalOptions = LayoutOptions.Center,
        VerticalOptions = LayoutOptions.Center
    };

    button.Clicked += async (sender, args) =>
    {
        await Navigation.PushAsync(new HelloXamlPage());
    };

    Content = button;
}
```

--------------------------------

### Install Android Emulator and System Images (macOS)

Source: https://github.com/dotnet/docs-maui/blob/main/docs/get-started/installation.md

Installs the Android emulator and a system image for API level 35 on macOS using the `sdkmanager` command. This command assumes an Apple Silicon Mac; replace `arm64-v8a` with `x86_64` for Intel Macs.

```console
./sdkmanager --install emulator

```

```console
./sdkmanager --install "system-images;android-35;google_apis;arm64-v8a"

```

--------------------------------

### Configure MAUI App Display Name and Description for Windows Start Menu Entry

Source: https://github.com/dotnet/docs-maui/blob/main/docs/windows/setup.md

This XML snippet demonstrates how to set the display name and description for a .NET MAUI Windows app's Start Menu entry by modifying the `<uap:VisualElements>` element within the _Package.appxmanifest_ file.

```xml
<uap:VisualElements
          DisplayName="My MAUI App"
          Description="MauiApp3"
          ... >
```

--------------------------------

### C# Code-Behind for MAUI Page

Source: https://github.com/dotnet/docs-maui/blob/main/docs/xaml/fundamentals/get-started.md

This C# snippet represents the code-behind file for a .NET MAUI page defined in XAML. It declares a partial class that inherits from `ContentPage` and includes a constructor that calls `InitializeComponent()`. This method is responsible for loading and initializing the UI elements defined in the associated XAML file.

```csharp
namespace MyMauiApp;

public partial class MainPage : ContentPage
{
    public MainPage()
    {
        InitializeComponent();
    }
}
```

--------------------------------

### Install Xcode Command Line Tools for iOS/macOS

Source: https://github.com/dotnet/docs-maui/blob/main/docs/get-started/installation.md

This command installs the necessary command line tools for Xcode, which are essential for .NET MAUI development on iOS and macOS. It should be run in the terminal.

```console
xcode-select --install
```

--------------------------------

### Define Device Installation Model in C#

Source: https://github.com/dotnet/docs-maui/blob/main/docs/data-cloud/push-notifications.md

The `DeviceInstallation` class represents a device installation in Azure Notification Hubs. It includes properties for `InstallationId`, `Platform`, `PushChannel`, and optional `Tags`. This model is used to register and manage devices that will receive push notifications.

```csharp
using System.ComponentModel.DataAnnotations;

namespace PushNotificationsAPI.Models;

public class DeviceInstallation
{
    [Required]
    public string InstallationId { get; set; }

    [Required]
    public string Platform { get; set; }

    [Required]
    public string PushChannel { get; set; }

    public IList<string> Tags { get; set; } = Array.Empty<string>();
}
```

--------------------------------

### Install .NET Upgrade Assistant via CLI

Source: https://github.com/dotnet/docs-maui/blob/main/docs/migration/upgrade-assistant.md

Installs the .NET Upgrade Assistant globally using the dotnet CLI. This command makes the upgrade-assistant tool available system-wide.

```dotnetcli
dotnet tool install -g upgrade-assistant
```

--------------------------------

### Configure .NET MAUI iOS Project SDK

Source: https://github.com/dotnet/docs-maui/blob/main/docs/migration/apple-projects.md

Example .NET 8 project configuration for a .NET for iOS app using the Microsoft.NET.Sdk. This setup enables features like nullable reference types and implicit usings, and specifies the target framework and supported OS platform version.

```xml
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net8.0-ios</TargetFramework>
    <OutputType>Exe</OutputType>
    <Nullable>enable</Nullable>
    <ImplicitUsings>true</ImplicitUsings>
    <SupportedOSPlatformVersion>13.0</SupportedOSPlatformVersion>
  </PropertyGroup>
</Project>
```

--------------------------------

### Implement Device Installation Service for Android

Source: https://github.com/dotnet/docs-maui/blob/main/docs/data-cloud/push-notifications.md

This C# class, `DeviceInstallationService`, implements `IDeviceInstallationService` for Android. It retrieves the device ID using `Secure.AndroidId`, checks for Google Play Services availability, and constructs the device installation payload for push notifications.

```csharp
using Android.Gms.Common;
using PushNotificationsDemo.Models;
using PushNotificationsDemo.Services;
using static Android.Provider.Settings;

namespace PushNotificationsDemo.Platforms.Android;

public class DeviceInstallationService : IDeviceInstallationService
{
    public string Token { get; set; }

    public bool NotificationsSupported
        => GoogleApiAvailability.Instance.IsGooglePlayServicesAvailable(Platform.AppContext) == ConnectionResult.Success;

    public string GetDeviceId()
        => Secure.GetString(Platform.AppContext.ContentResolver, Secure.AndroidId);

    public DeviceInstallation GetDeviceInstallation(params string[] tags)
    {
        if (!NotificationsSupported)
            throw new Exception(GetPlayServicesError());

        if (string.IsNullOrWhiteSpace(Token))
            throw new Exception("Unable to resolve token for FCMv1.");

        var installation = new DeviceInstallation
        {
            InstallationId = GetDeviceId(),
            Platform = "fcmv1",
            PushChannel = Token
        };

        installation.Tags.AddRange(tags);

        return installation;
    }

    string GetPlayServicesError()
    {
        int resultCode = GoogleApiAvailability.Instance.IsGooglePlayServicesAvailable(Platform.AppContext);

        if (resultCode != ConnectionResult.Success)
            return GoogleApiAvailability.Instance.IsUserResolvableError(resultCode) ?
                       GoogleApiAvailability.Instance.GetErrorString(resultCode) :
                       "This device isn't supported.";

        return "An error occurred preventing the use of push notifications.";
    }
}
```

--------------------------------

### Configure MAUI App Icon for Windows Start Menu Entry

Source: https://github.com/dotnet/docs-maui/blob/main/docs/windows/setup.md

This XML snippet shows how to configure the application icon for the .NET MAUI Windows Start Menu entry by modifying the `<MauiIcon>` element in the project file. It specifies the foreground file and color for the icon.

```xml
<MauiIcon Include="Resources\appicon.svg" ForegroundFile="Resources\appiconfg.svg" Color="#512BD4" />
```

--------------------------------

### Install .NET MAUI Workload on macOS

Source: https://github.com/dotnet/docs-maui/blob/main/docs/get-started/installation.md

Installs the .NET MAUI workload on macOS using the .NET CLI with administrative privileges. This is necessary for developing MAUI applications on macOS.

```dotnetcli
sudo dotnet workload install maui
```

--------------------------------

### List Installed .NET Versions

Source: https://github.com/dotnet/docs-maui/blob/main/docs/troubleshooting.md

This command provides detailed information about all installed .NET versions on the system, including SDKs, runtimes, and their locations. It's a useful diagnostic tool for identifying potential version conflicts that affect .NET MAUI template availability.

```bash
dotnet --info
```

--------------------------------

### Install .NET Upgrade Assistant with Ignore Failed Sources

Source: https://github.com/dotnet/docs-maui/blob/main/docs/migration/upgrade-assistant.md

Installs the .NET Upgrade Assistant globally, ignoring any failures related to NuGet feed sources. This is useful if you have custom NuGet feeds configured that might cause installation issues.

```dotnetcli
dotnet tool install -g --ignore-failed-sources upgrade-assistant
```

--------------------------------

### Set ContentPage Content with XAML

Source: https://github.com/dotnet/docs-maui/blob/main/docs/xaml/fundamentals/get-started.md

Defines the structure and content of a .NET MAUI ContentPage using XAML. It includes a Label with various text formatting properties. This demonstrates how XAML elements map to .NET MAUI classes and their properties.

```xaml
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="XamlSamples.HelloXamlPage"
             Title="Hello XAML Page">
    <Label Text="Hello, XAML!"
           VerticalOptions="Center"
           HorizontalTextAlignment="Center"
           Rotation="-15"
           FontSize="18"
           FontAttributes="Bold"
           TextColor="Blue" />
</ContentPage>
```

--------------------------------

### Install .NET xcsync CLI Tool (Global)

Source: https://github.com/dotnet/docs-maui/blob/main/docs/macios/xcsync.md

Installs the preview version of the .NET xcsync tool globally. This command requires a specific NuGet feed for the prerelease version. It is a prerequisite for using xcsync commands via the CLI or Visual Studio Code extension.

```dotnetcli
dotnet tool install dotnet-xcsync -g --prerelease --add-source https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet9/nuget/v3/index.json
```

--------------------------------

### Install .NET MAUI Workload for Android on Linux

Source: https://github.com/dotnet/docs-maui/blob/main/docs/get-started/installation.md

Installs the .NET MAUI workload specifically for Android development on Linux. This command enables the creation of Android applications using .NET MAUI on Linux systems.

```dotnetcli
dotnet workload install maui-android
```

--------------------------------

### Launch Android Emulator from Command Line

Source: https://github.com/dotnet/docs-maui/blob/main/docs/android/emulator/troubleshooting.md

This command starts the Android emulator from the command line with specific AVD configurations. It allows for detailed output and control over emulator startup parameters, useful for debugging.

```cmd
"C:\Program Files (x86)\Android\android-sdk\emulator\emulator.exe" -partition-size 2000 -no-boot-anim -verbose -feature WindowsHypervisorPlatform -avd pixel_5_-_api_30 -prop monodroid.avdname=pixel_5_-_api_30
```

--------------------------------

### Manage Device Installations in .NET MAUI Azure Notification Hubs

Source: https://github.com/dotnet/docs-maui/blob/main/docs/data-cloud/push-notifications.md

Handles the creation, updating, and deletion of device installations with Azure Notification Hubs. It validates input parameters such as InstallationId, Platform, and PushChannel, and maps platform names to the NotificationPlatform enum. Errors during hub operations are caught and logged.

```csharp
private Dictionary<string, NotificationPlatform> _installationPlatform;

_installationPlatform = new Dictionary<string, NotificationPlatform>
{
    { nameof(NotificationPlatform.Apns).ToLower(), NotificationPlatform.Apns },
    { nameof(NotificationPlatform.FcmV1).ToLower(), NotificationPlatform.FcmV1 }
};

public async Task<bool> CreateOrUpdateInstallationAsync(DeviceInstallation deviceInstallation, CancellationToken token)
{
    if (string.IsNullOrWhiteSpace(deviceInstallation?.InstallationId) ||
        string.IsNullOrWhiteSpace(deviceInstallation?.Platform) ||
        string.IsNullOrWhiteSpace(deviceInstallation?.PushChannel))
        return false;

    var installation = new Installation()
    {
        InstallationId = deviceInstallation.InstallationId,
        PushChannel = deviceInstallation.PushChannel,
        Tags = deviceInstallation.Tags
    };

    if (_installationPlatform.TryGetValue(deviceInstallation.Platform, out var platform))
        installation.Platform = platform;
    else
        return false;

    try
    {
        await _hub.CreateOrUpdateInstallationAsync(installation, token);
    }
    catch
    {
        return false;
    }

    return true;
}

public async Task<bool> DeleteInstallationByIdAsync(string installationId, CancellationToken token)
{
    if (string.IsNullOrWhiteSpace(installationId))
        return false;

    try
    {
        await _hub.DeleteInstallationAsync(installationId, token);
    }
    catch
    {
        return false;
    }

    return true;
}
```

--------------------------------

### Define Basic UI Layout in XAML for .NET MAUI

Source: https://github.com/dotnet/docs-maui/blob/main/docs/xaml/fundamentals/get-started.md

This XAML code defines the basic structure of a user interface in a .NET MAUI application, including a StackLayout containing a Slider, Label, and Button. It sets up the visual elements that will be interacted with via code.

```xaml
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="XamlSamples.XamlPlusCodePage"
             Title="XAML + Code Page">
    <StackLayout>
        <Slider VerticalOptions="Center" />
        <Label Text="A simple Label"
               FontSize="18"
               HorizontalOptions="Center"
               VerticalOptions="Center" />
        <Button Text="Click Me!"
                HorizontalOptions="Center"
                VerticalOptions="Center" />
    </StackLayout>
</ContentPage>
```

--------------------------------

### xcsync CLI Help Command Synopsis

Source: https://github.com/dotnet/docs-maui/blob/main/docs/macios/xcsync.md

Displays the help and usage information for the xcsync command-line tool. This is a standard command to get an overview of available commands and options.

```dotnetcli
xcsync -h|--help
```

--------------------------------

### Check .NET Runtime Version

Source: https://github.com/dotnet/docs-maui/blob/main/docs/includes/install-create-macos.md

This command checks the installed version of the .NET runtime on your system. Ensure you have the latest version compatible with .NET MAUI.

```zsh
dotnet --version
```

--------------------------------

### Check FastFollow Asset Pack Installation Status

Source: https://github.com/dotnet/docs-maui/blob/main/docs/android/asset-packs.md

This C# code snippet shows how to check if a FastFollow asset pack is installed in a .NET MAUI application. It utilizes the Xamarin.Google.Android.Play.Asset.Delivery NuGet package to get the AssetPackManager and query the pack's location.

```csharp
using Xamarin.Google.Android.Play.Core.AssetPacks;

var assetPackManager = AssetPackManagerFactory.GetInstance(this);
AssetPackLocation assetPackPath = assetPackManager.GetPackLocation("myfastfollowpack");
string assetsFolderPath = assetPackPath?.AssetsPath() ?? null;
if (assetsFolderPath is null)
{
    // FastFollow asset pack isn't installed.
}
```

--------------------------------

### Implement Device Installation Service for iOS Push Notifications

Source: https://github.com/dotnet/docs-maui/blob/main/docs/data-cloud/push-notifications.md

This C# class, `DeviceInstallationService`, implements the `IDeviceInstallationService` interface for .NET MAUI iOS apps. It retrieves the device's unique identifier and checks for notification support based on the iOS version. It also handles the APNS token and constructs the device installation payload for push notification services.

```csharp
using PushNotificationsDemo.Services;
using PushNotificationsDemo.Models;
using UIKit;

namespace PushNotificationsDemo.Platforms.iOS;

public class DeviceInstallationService : IDeviceInstallationService
{
    const int SupportedVersionMajor = 13;
    const int SupportedVersionMinor = 0;

    public string Token { get; set; }

    public bool NotificationsSupported =>
        UIDevice.CurrentDevice.CheckSystemVersion(SupportedVersionMajor, SupportedVersionMinor);

    public string GetDeviceId() =>
        UIDevice.CurrentDevice.IdentifierForVendor.ToString();

    public DeviceInstallation GetDeviceInstallation(params string[] tags)
    {
        if (!NotificationsSupported)
            throw new Exception(GetNotificationsSupportError());

        if (string.IsNullOrWhiteSpace(Token))
            throw new Exception("Unable to resolve token for APNS");

        var installation = new DeviceInstallation
        {
            InstallationId = GetDeviceId(),
            Platform = "apns",
            PushChannel = Token
        };

        installation.Tags.AddRange(tags);

        return installation;
    }

    string GetNotificationsSupportError()
    {
        if (!NotificationsSupported)
            return $"This app only supports notifications on iOS {SupportedVersionMajor}.{SupportedVersionMinor} and above. You are running {UIDevice.CurrentDevice.SystemVersion}.";

        if (Token == null)
            return "This app can support notifications but you must enable this in your settings.";

        return "An error occurred preventing the use of push notifications";
    }
}
```

--------------------------------

### Get Preference with Type Casting in .NET MAUI

Source: https://github.com/dotnet/docs-maui/blob/main/docs/platform-integration/storage/preferences.md

Provides an example of retrieving a preference value in .NET MAUI where the type is explicitly cast, often used for numerical types like long integers. This is an alternative to the generic Get method when type inference might be ambiguous or when dealing with specific numeric types.

```csharp
long value = Preferences.Get("master_date", (long)0);
```

--------------------------------

### Create a dashed Polyline in XAML

Source: https://github.com/dotnet/docs-maui/blob/main/docs/user-interface/controls/shapes/polyline.md

This XAML example shows how to create a dashed polyline by utilizing the StrokeDashArray and StrokeDashOffset properties in addition to Stroke and Points. StrokeDashArray defines the pattern of dashes and gaps, while StrokeDashOffset specifies where the dashing starts.

```xaml
<Polyline Points="0,0 10,30 15,0 18,60 23,30 35,30 40,0 43,60 48,30 100,30"
          Stroke="Red"
          StrokeThickness="2"
          StrokeDashArray="1,1"
          StrokeDashOffset="6" />
```

--------------------------------

### Create Android Keystore using keytool

Source: https://github.com/dotnet/docs-maui/blob/main/docs/android/deployment/publish-cli.md

Generates a new keystore file for signing Android applications. This is a one-time setup. The command uses `keytool` from the JDK to create a key pair with specified parameters like filename, alias, key algorithm, key size, and validity period.

```console
keytool -genkeypair -v -keystore {filename}.keystore -alias {keyname} -keyalg RSA -keysize 2048 -validity 10000
```

```console
keytool -genkeypair -v -keystore myapp.keystore -alias myapp -keyalg RSA -keysize 2048 -validity 10000
```

--------------------------------

### DeviceInstallation Model for .NET MAUI

Source: https://github.com/dotnet/docs-maui/blob/main/docs/data-cloud/push-notifications.md

Defines the data structure for a device installation, including its ID, platform, push channel, and associated tags. This model is used to transfer device information between the client and the backend service. It utilizes System.Text.Json.Serialization for JSON property mapping.

```csharp
using System.Text.Json.Serialization;

namespace PushNotificationsDemo.Models;

public class DeviceInstallation
{
    [JsonPropertyName("installationId")]
    public string InstallationId { get; set; }

    [JsonPropertyName("platform")]
    public string Platform { get; set; }

    [JsonPropertyName("pushChannel")]
    public string PushChannel { get; set; }

    [JsonPropertyName("tags")]
    public List<string> Tags { get; set; } = new List<string>();
}
```

--------------------------------

### Quadratic Bezier Curve Command in MAUI

Source: https://github.com/dotnet/docs-maui/blob/main/docs/user-interface/controls/shapes/path-markup-syntax.md

Creates a quadratic Bezier curve using a single control point and an end point. The control point influences both start and end tangents. Example: 'Q 100,200 300,200'.

```text
Q controlPoint endPoint
q controlPoint endPoint
Q 100,200 300,200
```

--------------------------------

### Install .NET MAUI App on Physical Device

Source: https://github.com/dotnet/docs-maui/blob/main/docs/deployment/nativeaot.md

This command installs the specified .NET MAUI application archive (*.ipa*) onto your physical iOS device, identified by its device ID.

```bash
xcrun devicectl device install app --device <device-identifier> <path-to-ipa>
```

--------------------------------

### Build .NET MAUI App with InstallAndroidDependencies Target

Source: https://github.com/dotnet/docs-maui/blob/main/docs/get-started/installation.md

This command builds a .NET MAUI app while specifying the `InstallAndroidDependencies` MSBuild target. It also sets the Android SDK directory and accepts SDK licenses. The `-f` flag specifies the target framework, and `-p` is used for passing properties like `AndroidSdkDirectory` and `AcceptAndroidSDKLicenses`.

```dotnetcli
cd MyMauiApp
dotnet build -t:InstallAndroidDependencies -f:net9.0-android -p:AndroidSdkDirectory="/path/to/sdk" -p:AcceptAndroidSDKLicenses=True
```

--------------------------------

### MAUI Image Fading with FadeToAsync

Source: https://github.com/dotnet/docs-maui/blob/main/docs/user-interface/includes/basic-animation-dotnet10.md

Fades an image in or out by modifying its Opacity property using the FadeToAsync method. The animation starts from the element's current opacity and transitions to the specified value over a given duration. The example shows fading an image in over 4 seconds.

```csharp
image.Opacity = 0;
await image.FadeToAsync(1, 4000);
```

--------------------------------

### Create SearchBar in XAML and C#

Source: https://github.com/dotnet/docs-maui/blob/main/docs/user-interface/controls/searchbar.md

Demonstrates how to create a SearchBar control in .NET MAUI using both XAML and C# code. Sets the Placeholder property to guide user input.

```xaml
<SearchBar Placeholder="Search items..." />
```

```csharp
SearchBar searchBar = new SearchBar { Placeholder = "Search items..." };
```

--------------------------------

### Create MAUI LineSegment in XAML

Source: https://github.com/dotnet/docs-maui/blob/main/docs/user-interface/controls/shapes/geometries.md

Defines a LineSegment within a MAUI Path object. The LineSegment requires a 'Point' property specifying the end point, while the starting point is inherited from the parent PathFigure. This example demonstrates creating a closed path forming a triangle.

```xaml
<Path Stroke="Black"      
      Aspect="Uniform"
      HorizontalOptions="Start">
    <Path.Data>
        <PathGeometry>
            <PathGeometry.Figures>
                <PathFigureCollection>
                    <PathFigure IsClosed="True"
                                StartPoint="10,100">
                        <PathFigure.Segments>
                            <PathSegmentCollection>
                                <LineSegment Point="100,100" />
                                <LineSegment Point="100,50" />
                            </PathSegmentCollection>
                        </PathFigure.Segments>
                    </PathFigure>
                </PathFigureCollection>
            </PathGeometry.Figures>
        </PathGeometry>
    </Path.Data>
</Path>
```

--------------------------------

### Define MAUI Page Structure with XAML

Source: https://github.com/dotnet/docs-maui/blob/main/docs/xaml/fundamentals/get-started.md

This XAML snippet defines the basic structure of a .NET MAUI page. It includes XML namespace declarations for .NET MAUI and the XAML standard, and uses the `x:Class` attribute to link the XAML to its C# code-behind class. The content within `<ContentPage>` defines the visual elements of the page.

```xaml
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="MyMauiApp.MainPage">
    ...
</ContentPage>
```

--------------------------------

### Update Label with Slider Value (Sender Object)

Source: https://github.com/dotnet/docs-maui/blob/main/docs/xaml/fundamentals/get-started.md

This C# code snippet demonstrates retrieving the Slider's current value by casting the 'sender' object to a Slider. This method is useful when you need to access other properties of the Slider control itself, beyond just its value.

```csharp
void OnSliderValueChanged(object sender, ValueChangedEventArgs args)
{
    valueLabel.Text = ((Slider)sender).Value.ToString("F3");
}
```

--------------------------------

### Example of MainLauncher Activity element in AndroidManifest.xml

Source: https://github.com/dotnet/docs-maui/blob/main/docs/android/manifest.md

This XML fragment demonstrates the structure of an <activity/> element when it's designated as the MainLauncher. It includes the activity name, label, and an intent-filter to handle the main action and launcher category.

```xml
<activity android:label="My Maui App"
          android:name="crc64bdb9c38958c20c7c.MainActivity">
  <intent-filter>
    <action android:name="android.intent.action.MAIN" />
    <category android:name="android.intent.category.LAUNCHER" />
  </intent-filter>
</activity>
```

--------------------------------

### List Keys in Android Keystore using keytool

Source: https://github.com/dotnet/docs-maui/blob/main/docs/android/deployment/publish-cli.md

Lists the keys stored within a specified keystore file. This command is useful for verifying the contents of your keystore after creation or for retrieving key information.

```console
keytool -list -keystore {filename}.keystore
```

```console
keytool -list -keystore myapp.keystore
```

--------------------------------

### Open map with driving navigation - C#

Source: https://github.com/dotnet/docs-maui/blob/main/docs/platform-integration/appmodel/maps.md

Opens the installed map app to a specific location and specifies driving navigation mode. Uses the MapLaunchOptions type to set the navigation mode. This allows users to get directions from their current location to the specified destination.

```csharp
Location location = new Location(49.612414, -117.151147);

await Map.OpenAsync(location, new MapLaunchOptions
{
    NavigationMode = NavigationMode.Driving
});
```

--------------------------------

### Update Label with Slider Value (Event Args)

Source: https://github.com/dotnet/docs-maui/blob/main/docs/xaml/fundamentals/get-started.md

This C# code snippet shows how to update a Label's text with the new value of a Slider using the ValueChangedEventArgs. The 'args.NewValue' provides direct access to the updated value. This approach is suitable when only the new value is needed.

```csharp
void OnSliderValueChanged(object sender, ValueChangedEventArgs args)
{
    valueLabel.Text = args.NewValue.ToString("F3");
}
```

--------------------------------

### Create Android Virtual Device (Windows)

Source: https://github.com/dotnet/docs-maui/blob/main/docs/get-started/installation.md

Creates a new Android Virtual Device (AVD) named 'MyAndroidVirtualDevice-API35' using a specific system image on Windows via the `avdmanager` command.

```console
avdmanager create avd -n MyAndroidVirtualDevice-API35 -k "system-images;android-35;google_apis;x86_64"

```

--------------------------------

### Implement NotificationsController methods for API operations

Source: https://github.com/dotnet/docs-maui/blob/main/docs/data-cloud/push-notifications.md

This C# code defines the core methods for the NotificationsController: UpdateInstallation, DeleteInstallation, and RequestPush. These methods handle PUT, DELETE, and POST requests respectively, interacting with the INotificationService to perform operations like creating/updating installations, deleting installations, and sending push notifications.

```csharp
[HttpPut]
[Route("installations")]
[ProducesResponseType((int)HttpStatusCode.OK)]
[ProducesResponseType((int)HttpStatusCode.BadRequest)]
[ProducesResponseType((int)HttpStatusCode.UnprocessableEntity)]
public async Task<IActionResult> UpdateInstallation(
    [Required] DeviceInstallation deviceInstallation)
{
    var success = await _notificationService
        .CreateOrUpdateInstallationAsync(deviceInstallation, HttpContext.RequestAborted);

    if (!success)
        return new UnprocessableEntityResult();

    return new OkResult();
}

[HttpDelete()]
[Route("installations/{installationId}")]
[ProducesResponseType((int)HttpStatusCode.OK)]
[ProducesResponseType((int)HttpStatusCode.BadRequest)]
[ProducesResponseType((int)HttpStatusCode.UnprocessableEntity)]
public async Task<ActionResult> DeleteInstallation(
    [Required][FromRoute] string installationId)
{
    // Probably want to ensure deletion even if the connection is broken
    var success = await _notificationService
        .DeleteInstallationByIdAsync(installationId, CancellationToken.None);

    if (!success)
        return new UnprocessableEntityResult();

    return new OkResult();
}

[HttpPost]
[Route("requests")]
[ProducesResponseType((int)HttpStatusCode.OK)]
[ProducesResponseType((int)HttpStatusCode.BadRequest)]
[ProducesResponseType((int)HttpStatusCode.UnprocessableEntity)]
public async Task<IActionResult> RequestPush(
    [Required] NotificationRequest notificationRequest)
{
    if ((notificationRequest.Silent &&
        string.IsNullOrWhiteSpace(notificationRequest?.Action)) ||
        (!notificationRequest.Silent &&
        string.IsNullOrWhiteSpace(notificationRequest?.Text)))
        return new BadRequestResult();

    var success = await _notificationService
        .RequestNotificationAsync(notificationRequest, HttpContext.RequestAborted);

    if (!success)
        return new UnprocessableEntityResult();

    return new OkResult();
}
```

--------------------------------

### Load .NET MAUI Shell Pages at App Startup (XAML)

Source: https://github.com/dotnet/docs-maui/blob/main/docs/fundamentals/shell/pages.md

This code example shows how to configure .NET MAUI Shell pages to be created and loaded when the application starts. Instead of using ContentTemplate, it directly assigns ContentPage instances to the Content property of ShellContent. While this loads pages immediately, it can potentially lead to a slower startup experience for the user. The 'Content' property is the default content property for ShellContent, so it doesn't need explicit declaration.

```xaml
<Shell xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
       xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
       xmlns:views="clr-namespace:Xaminals.Views"
       x:Class="Xaminals.AppShell">
    <TabBar>
     <ShellContent Title="Cats"
                   Icon="cat.png">
         <views:CatsPage />
     </ShellContent>
     <ShellContent Title="Dogs"
                   Icon="dog.png">
         <views:DogsPage />
     </ShellContent>
     <ShellContent Title="Monkeys"
                   Icon="monkey.png">
         <views:MonkeysPage />
     </ShellContent>
    </TabBar>
</Shell>
```

--------------------------------

### C#: Custom EmptyView for MAUI CarouselView

Source: https://github.com/dotnet/docs-maui/blob/main/docs/user-interface/controls/carouselview/emptyview.md

This C# code demonstrates the equivalent setup of a MAUI CarouselView's empty view as shown in the XAML example. It instantiates a SearchBar and CarouselView, setting the EmptyView to a custom FilterData object and EmptyViewTemplate to a DataTemplate containing a Label.

```csharp
SearchBar searchBar = new SearchBar { ... };
CarouselView carouselView = new CarouselView
{
    EmptyView = new FilterData { Filter = searchBar.Text },
    EmptyViewTemplate = new DataTemplate(() =>
    {
        return new Label { ... };
    })
};
```

--------------------------------

### Create Horizontal Linear Gradient in C#

Source: https://github.com/dotnet/docs-maui/blob/main/docs/user-interface/graphics/paint.md

Demonstrates how to create a horizontal linear gradient using the LinearGradientPaint class in .NET MAUI. This involves setting the start and end colors, and configuring the EndPoint to (1,0) for a horizontal interpolation. The example then applies this gradient to fill a rounded rectangle.

```csharp
LinearGradientPaint linearGradientPaint = new LinearGradientPaint
{
    StartColor = Colors.Yellow,
    EndColor = Colors.Green,
    // StartPoint is already (0,0)
    EndPoint = new Point(1, 0)
};

RectF linearRectangle = new RectF(10, 10, 200, 100);
cb.SetFillPaint(linearGradientPaint, linearRectangle);
cb.SetShadow(new SizeF(10, 10), 10, Colors.Grey);
cb.FillRoundedRectangle(linearRectangle, 12);
```

--------------------------------

### xUnit Fact Unit Tests (C#)

Source: https://github.com/dotnet/docs-maui/blob/main/docs/deployment/unit-testing.md

Example of writing unit tests using the xUnit 'Fact' attribute in C#. These tests are for invariant conditions that are always true. Includes a passing and a failing test example.

```csharp
namespace MyUnitTests
{
    public class MyTests
    {
        [Fact]
        public void PassingTest()
        {
            Assert.AreEqual(4, 2+2);
        }

        [Fact]
        public void FailingTest()
        {
            Assert.AreEqual(5, 2+2);
        }
    }
}
```

--------------------------------

### Build and Sign .NET MAUI App (CLI)

Source: https://github.com/dotnet/docs-maui/blob/main/docs/android/deployment/publish-cli.md

Command to build and sign a .NET MAUI application from the command line. It specifies the target framework, build configuration, and essential parameters for Android app signing using a keystore. Ensure you replace placeholders with your actual keystore filename, key name, and passwords.

```console
dotnet publish -f net8.0-android -c Release -p:AndroidKeyStore=true -p:AndroidSigningKeyStore={filename}.keystore -p:AndroidSigningKeyAlias={keyname} -p:AndroidSigningKeyPass={password} -p:AndroidSigningStorePass={password}
```

--------------------------------

### Creating .NET MAUI Todo App via CLI

Source: https://github.com/dotnet/docs-maui/blob/main/docs/whats-new/dotnet-9.md

Shows how to create a .NET MAUI project with sample content, including a functional todo app, using the .NET CLI. The `--sample-content` or `-sc` option is used to include the pre-built todo app features. This simplifies the setup for users who want to quickly explore or utilize the sample application.

```dotnetcli
dotnet new maui --sample-content -n MyProject
```

--------------------------------

### Create MAUI PolyBezierSegment in XAML

Source: https://github.com/dotnet/docs-maui/blob/main/docs/user-interface/controls/shapes/geometries.md

Defines a PolyBezierSegment within a MAUI Path object to create cubic Bezier curves. The 'Points' property takes a collection of points defining the curves and their control points. The starting point is inherited from the parent PathFigure. This example shows two connected Bezier curves.

```xaml
<Path Stroke="Black">
    <Path.Data>
        <PathGeometry>
            <PathGeometry.Figures>
                <PathFigureCollection>
                    <PathFigure StartPoint="10,10">
                        <PathFigure.Segments>
                            <PathSegmentCollection>
                                <PolyBezierSegment Points="0,0 100,0 150,100 150,0 200,0 300,10" />
                            </PathSegmentCollection>
                        </PathFigure.Segments>
                    </PathFigure>
                </PathFigureCollection>
            </PathGeometry.Figures>
        </PathGeometry>
    </Path.Data>
</Path>
```

--------------------------------

### Configure .NET MAUI App with DI Registrations

Source: https://github.com/dotnet/docs-maui/blob/main/docs/data-cloud/push-notifications.md

This code snippet illustrates how to configure the .NET MAUI application's entry point by calling custom extension methods for service and view registration within the CreateMauiApp method. It also includes standard MAUI app configuration like UseMauiApp and ConfigureFonts. The method returns the built MauiApp.

```csharp
public static class MauiProgram
{
    public static MauiApp CreateMauiApp()
    {
        var builder = MauiApp.CreateBuilder();
        builder
            .UseMauiApp<App>()
            .ConfigureFonts(fonts =>
            {
                fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
                fonts.AddFont("OpenSans-Semibold.ttf", "OpenSansSemibold");
            })
            .RegisterServices()
            .RegisterViews();

#if DEBUG
            builder.Logging.AddDebug();
#endif
            return builder.Build();
    }
}
```

--------------------------------

### Configure CarouselView EmptyViewTemplate in C#

Source: https://github.com/dotnet/docs-maui/blob/main/docs/user-interface/controls/carouselview/emptyview.md

This C# code illustrates the equivalent setup for a CarouselView's EmptyViewTemplate as shown in the XAML example. It involves creating a SearchBar and CarouselView, assigning the SearchBar's text to the EmptyView, and instantiating a SearchTermDataTemplateSelector for the EmptyViewTemplate. Data binding is also applied to the ItemsSource.

```csharp
SearchBar searchBar = new SearchBar { ... };
CarouselView carouselView = new CarouselView()
{
    EmptyView = searchBar.Text,
    EmptyViewTemplate = new SearchTermDataTemplateSelector { ... }
};
carouselView.SetBinding(ItemsView.ItemsSourceProperty, static (MonkeysViewModel vm) => vm.Monkeys);
```

--------------------------------

### Use Special Keys in Keyboard Accelerator (F1 Example)

Source: https://github.com/dotnet/docs-maui/blob/main/docs/user-interface/keyboard-accelerators.md

Demonstrates defining keyboard accelerators that utilize special keys, such as function keys. This example shows how to specify the F1 key for both Mac Catalyst and Windows using platform-specific constants in XAML. For Windows, an integer representation is also noted as an alternative.

```xaml
<MenuFlyoutItem Text="Help"
                Command="{Binding HelpCommand}">
    <MenuFlyoutItem.KeyboardAccelerators>
        <!-- Alternatively, 112 can be used to specify F1 on Windows -->
        <KeyboardAccelerator Modifiers="None"
                             Key="{OnPlatform MacCatalyst=UIKeyInputF1, WinUI=F1}" />
    </MenuFlyoutItem.KeyboardAccelerators>
</MenuFlyoutItem>
```

--------------------------------

### Draw Dashed Rectangle Stroke in XAML

Source: https://github.com/dotnet/docs-maui/blob/main/docs/user-interface/controls/shapes/index.md

This XAML example illustrates how to draw a rectangle with a dashed outline in .NET MAUI. By setting the StrokeDashArray and StrokeDashOffset properties on a Rectangle element, developers can define the pattern and starting position of dashes for the shape's stroke. This allows for custom visual styling of shape borders.

```xaml
<Rectangle Fill="DarkBlue"
           Stroke="Red"
           StrokeThickness="4"
           StrokeDashArray="1,1"
           StrokeDashOffset="6"
           WidthRequest="150"
           HeightRequest="50"
           HorizontalOptions="Start" />
```

--------------------------------

### Control Safe Area with SafeAreaEdges in .NET MAUI (C#)

Source: https://github.com/dotnet/docs-maui/blob/main/docs/ios/platform-specifics/page-safe-area-layout.md

Provides examples of setting the `SafeAreaEdges` property in C# for .NET MAUI applications. This allows programmatic control over safe area behavior for pages, layouts, and scroll views, offering flexibility in runtime adjustments.

```csharp
using Microsoft.Maui;
using Microsoft.Maui.Controls;

// On a page
this.SafeAreaEdges = SafeAreaEdges.All;

// On a layout
myGrid.SafeAreaEdges = SafeAreaEdges.Container;

// Keyboard-aware
myScrollView.SafeAreaEdges = SafeAreaEdges.SoftInput;
```

--------------------------------

### MAUI App Entry Point Creation - C#

Source: https://github.com/dotnet/docs-maui/blob/main/docs/fundamentals/single-project.md

This C# code defines the entry point for a .NET MAUI application. The `CreateMauiApp` method in the `MauiProgram` class configures the application builder and specifies the main application class (`App`). It's the minimal setup required to launch a MAUI app.

```csharp
namespace MyMauiApp;

public static class MauiProgram
{
    public static MauiApp CreateMauiApp()
    {
        var builder = MauiApp.CreateBuilder();
        builder
            .UseMauiApp<App>();

        return builder.Build();
    }
}
```

--------------------------------

### App-Wide Resource Dictionary in .NET MAUI

Source: https://github.com/dotnet/docs-maui/blob/main/docs/deployment/performance.md

This example shows how to define app-wide resources, like styles, in the Application's resource dictionary to avoid duplication and reduce XAML parsing at startup. Resources used throughout the app should be centralized here.

```xaml
<Application xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="MyMauiApp.App">
     <Application.Resources>
        <Style x:Key="HeadingLabelStyle"
               TargetType="Label">
            <Setter Property="HorizontalOptions"
                    Value="Center" />
            <Setter Property="FontSize"
                    Value="Large" />
            <Setter Property="TextColor"
                    Value="Red" />
        </Style>
     </Application.Resources>
</Application>
```

--------------------------------

### Display Button Click Alert (.NET MAUI 9.0 and earlier)

Source: https://github.com/dotnet/docs-maui/blob/main/docs/xaml/fundamentals/get-started.md

This C# code snippet shows an asynchronous event handler for a Button's Clicked event. It casts the 'sender' to a Button to retrieve its 'Text' property and displays it in an alert dialog using 'DisplayAlert'. This handler can be reused for multiple buttons.

```csharp
async void OnButtonClicked(object sender, EventArgs args)
{
    Button button = (Button)sender;
    await DisplayAlert("Clicked!", "The button labeled '" + button.Text + "' has been clicked", "OK");
}
```

--------------------------------

### Configure app actions at startup - C#

Source: https://github.com/dotnet/docs-maui/blob/main/docs/platform-integration/appmodel/app-actions.md

Configures app actions by calling AddAppAction and OnAppAction on the IEssentialsBuilder during application startup. This allows defining unique actions with IDs, titles, and handling their invocation.

```csharp
builder.ConfigureEssentials(essentialsBuilder =>
{
    essentialsBuilder
        .OnAppAction(AppAction);

    // Register app actions
    essentialsBuilder
        .AddAppAction(new AppAction("id_1", "Title 1", "Subtitle 1", null));
});

// ...

void AppAction(AppAction appAction)
{
    // Action logic here
}

```

--------------------------------

### Defining Content Property in .NET MAUI XAML

Source: https://github.com/dotnet/docs-maui/blob/main/docs/xaml/fundamentals/essential-syntax.md

Demonstrates how the ContentPropertyAttribute in .NET MAUI XAML allows elements defined between the start and end tags of a class to be assigned to the designated content property. This example shows the standard XAML structure for defining content within a ContentPage.

```xaml
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="XamlSamples.XamlPlusCodePage"
             Title="XAML + Code Page">
    <ContentPage.Content>
        <Grid>
            ...
        </Grid>
    </ContentPage.Content>
</ContentPage>
```

--------------------------------

### Initialize .NET MAUI Maps Control

Source: https://github.com/dotnet/docs-maui/blob/main/docs/user-interface/controls/map.md

Demonstrates how to initialize the .NET MAUI Maps control by adding the Microsoft.Maui.Controls.Maps NuGet package and calling the UseMauiMaps() extension method in the MauiProgram.cs file. This setup is required for using Map APIs in your project. Ensure the NuGet package is installed and the builder is configured correctly.

```csharp
public static class MauiProgram
{
    public static MauiApp CreateMauiApp()
    {
        var builder = MauiApp.CreateBuilder();
        builder
            .UseMauiApp<App>()
            .ConfigureFonts(fonts =>
            {
                fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
                fonts.AddFont("OpenSans-Semibold.ttf", "OpenSansSemibold");
            })
            .UseMauiMaps();

        return builder.Build();
    }
}
```

--------------------------------

### Configure API Key and Backend Endpoint in .NET MAUI

Source: https://github.com/dotnet/docs-maui/blob/main/docs/data-cloud/push-notifications.md

This C# code snippet defines a static class 'Config' to hold API key and backend service endpoint configurations. It initializes these values in a static constructor, requiring users to replace placeholder strings with their actual API key and backend service URL. The backend URL should follow the format 'https://<api_app_name>.azurewebsites.net/'.

```csharp
public static partial class Config
{
    static Config()
    {
        ApiKey = "<your_api_key>";
        BackendServiceEndpoint = "<your_api_app_url>";
    }
}
```

--------------------------------

### Display Button Click Alert (.NET MAUI 10.0 and later)

Source: https://github.com/dotnet/docs-maui/blob/main/docs/xaml/fundamentals/get-started.md

This C# code snippet demonstrates an asynchronous event handler for a Button's Clicked event in .NET MAUI 10.0+. It casts the 'sender' to a Button to access its 'Text' property and shows it in an alert using 'DisplayAlertAsync'. This handler is designed for reuse across multiple buttons.

```csharp
async void OnButtonClicked(object sender, EventArgs args)
{
    Button button = (Button)sender;
    await DisplayAlertAsync("Clicked!", "The button labeled '" + button.Text + "' has been clicked", "OK");
}
```

--------------------------------

### Publish .NET MAUI Mac Catalyst App (CLI)

Source: https://github.com/dotnet/docs-maui/blob/main/docs/mac-catalyst/deployment/publish-ad-hoc.md

Publishes a .NET MAUI Mac Catalyst app using the `dotnet publish` command. This command handles building, signing, and packaging the application into a .pkg file for distribution. It requires specifying the target framework, build configuration, link mode, and various code signing parameters.

```dotnetcli
dotnet publish -f net8.0-maccatalyst -c Release -p:MtouchLink=SdkOnly -p:CreatePackage=true -p:EnableCodeSigning=true  -p:CodesignKey="Apple Development: John Smith (AY2GDE9QM7)" -p:CodesignProvision="MyMauiApp (Ad-hoc)" -p:CodesignEntitlements="Platforms\MacCatalyst\Entitlements.plist" -p:UseHardenedRuntime=true
```