### Assign and Invoke for Control References and Imperative Setup

Source: https://context7.com/communitytoolkit/maui.markup/llms.txt

Use `Assign` to capture a control's reference into a variable mid-chain and `Invoke` to execute imperative setup logic against the element inline.

```csharp
using CommunityToolkit.Maui.Markup;

Entry? usernameEntry = null;
Entry? passwordEntry = null;

var layout = new VerticalStackLayout
{
    Children =
    {
        new Entry()
            .Placeholder("Username")
            .Assign(out usernameEntry)          // capture reference
            .Invoke(e => e.Completed += (_, _) => passwordEntry?.Focus()),

        new Entry()
            .Placeholder("Password")
            .Assign(out passwordEntry)
            .Invoke(e => { e.IsPassword = true; e.ReturnType = ReturnType.Go; })
    }
};

// usernameEntry and passwordEntry are now accessible
usernameEntry?.Focus();
```

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

### Create Grid with Label and Entry using MAUI Markup

Source: https://github.com/communitytoolkit/maui.markup/blob/main/README.md

This example demonstrates creating a Grid with defined rows and columns using MAUI Markup extensions. It includes a Label and an Entry, with the Entry data-bound to a ViewModel property and configured with specific keyboard, color, font size, and margin properties. Use this for defining complex UI layouts fluently in C#.

```csharp
using static CommunityToolkit.Maui.Markup.GridRowsColumns;

class SampleContentPage : ContentPage
{
    public SampleContentPage()
    {
        Content = new Grid
        {
            RowDefinitions = Rows.Define(
                (Row.TextEntry, 36)),

            ColumnDefinitions = Columns.Define(
                (Column.Description, Star),
                (Column.Input, Stars(2))),

            Children = 
            {
                new Label()
                    .Text("Code:")
                    .Row(Row.TextEntry).Column(Column.Description),

                new Entry
                {
                    Keyboard = Keyboard.Numeric,
                    BackgroundColor = Colors.AliceBlue,
                }.Row(Row.TextEntry).Column(Column.Input)
                 .FontSize(15)
                 .Placeholder("Enter number")
                 .TextColor(Colors.Black)
                 .Height(44)
                 .Margin(5, 5)
                 .Bind(Entry.TextProperty, static (ViewModel vm) vm => vm.RegistrationCode)
            }
        };
    }

    enum Row { TextEntry }
    enum Column { Description, Input }
}
```

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

### Fluent Sizing for Entry

Source: https://github.com/communitytoolkit/maui.markup/blob/main/README.md

Set the size of a UI element fluently using the Size extension method. This example sets the width and height of an Entry.

```csharp
new Entry().Size(200, 40);
```

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

### Fluent Data Binding with Entry

Source: https://github.com/communitytoolkit/maui.markup/blob/main/README.md

Define data bindings fluently using the Bind extension method. This example binds the Entry's Text property to a ViewModel property.

```csharp
new Entry()
    .Bind(Entry.TextProperty, static (ViewModel vm) => vm.RegistrationCode);
```

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

### Alignment Extensions

Source: https://context7.com/communitytoolkit/maui.markup/llms.txt

Set HorizontalOptions and VerticalOptions using Center, Start, End, Fill, Top, and Bottom extensions. Directional Left() and Right() helpers are available via the LeftToRight sub-namespace.

```csharp
using CommunityToolkit.Maui.Markup;
using CommunityToolkit.Maui.Markup.LeftToRight; // for Left() / Right()

new Label().Text("Centered").Center();
new Button().Text("Save").End().Bottom();
new BoxView().FillHorizontal().Top();

// Left-to-right directional alignment
new Label().Text("Left-aligned").Left();
```

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

### Create FuncMultiConverter for double x double to string

Source: https://context7.com/communitytoolkit/maui.markup/llms.txt

Use FuncMultiConverter for type-safe IMultiValueConverter implementations with Func delegates. This example converts two doubles (width and height) to a formatted string representing area.

```csharp
using CommunityToolkit.Maui.Markup;

// Standalone multi-converter: double × double → string
var areaConverter = new FuncMultiConverter<double, double, string>(
    convert: static ((double? w, double? h) t)
        => $"Area: {(t.w ?? 0) * (t.h ?? 0):F1} m²");

new Label()
    .Bind(
        Label.TextProperty,
        [
            new Binding(nameof(RoomViewModel.Width)),
            new Binding(nameof(RoomViewModel.Height))
        ],
        areaConverter);
```

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

### Initialize .NET MAUI Community Toolkit Markup

Source: https://github.com/communitytoolkit/maui.markup/blob/main/src/CommunityToolkit.Maui.Markup/ReadMe.txt

Call the UseMauiCommunityToolkitMarkup() extension method in your MauiProgram.cs file to initialize the toolkit.

```csharp
using CommunityToolkit.Maui.Markup;

public static MauiApp CreateMauiApp()
{
    var builder = MauiApp.CreateBuilder();

    // Initialise the toolkit
 	builder.UseMauiApp<App>().UseMauiCommunityToolkitMarkup();

    // the rest of your logic...
}
```

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

### Initialize .NET MAUI Markup Toolkit

Source: https://context7.com/communitytoolkit/maui.markup/llms.txt

Register the toolkit with the MAUI application builder. This is a required step for using the toolkit's features. It also enables C# Hot Reload for compatible UI pages when a debugger is attached.

```csharp
using CommunityToolkit.Maui.Markup;

public static class MauiProgram
{
    public static MauiApp CreateMauiApp()
    {
        var builder = MauiApp.CreateBuilder();
        builder
            .UseMauiApp<App>()
            .UseMauiCommunityToolkitMarkup(); // required — registers toolkit
        return builder.Build();
    }
}
```

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

### Initialize .NET MAUI Community Toolkit Markup

Source: https://github.com/communitytoolkit/maui.markup/blob/main/README.md

Call this extension method in your MauiProgram.cs to initialize the toolkit. Ensure the CommunityToolkit.Maui.Markup namespace is included.

```csharp
using CommunityToolkit.Maui.Markup;

public static MauiApp CreateMauiApp()
{
    var builder = MauiApp.CreateBuilder();
    // Initialise the toolkit
    builder.UseMauiApp<App>().UseMauiCommunityToolkitMarkup();
    // the rest of your logic...
}
```

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

### UseMauiCommunityToolkitMarkup — Toolkit initialization

Source: https://context7.com/communitytoolkit/maui.markup/llms.txt

Registers the CommunityToolkit.Maui.Markup with the MAUI application builder. It also wires up the C# Hot Reload handler when a debugger is attached.

```APIDOC
## UseMauiCommunityToolkitMarkup

### Description
Registers the toolkit with the MAUI application builder. When a debugger is attached it also wires up the C# Hot Reload handler so that UI pages that implement `ICommunityToolkitHotReloadHandler` receive live reload notifications.

### Method
Extension method on `MauiAppBuilder`

### Usage
```csharp
// MauiProgram.cs
using CommunityToolkit.Maui.Markup;

public static class MauiProgram
{
    public static MauiApp CreateMauiApp()
    {
        var builder = MauiApp.CreateBuilder();
        builder
            .UseMauiApp<App>()
            .UseMauiCommunityToolkitMarkup(); // required — registers toolkit
        return builder.Build();
    }
}
```
```

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

### Visual Element Sizing Extensions

Source: https://context7.com/communitytoolkit/maui.markup/llms.txt

Simplify setting WidthRequest, HeightRequest, MinimumWidthRequest, and MinimumHeightRequest using Size, Width, Height, and MinSize extensions. Size(double) sets both width and height.

```csharp
using CommunityToolkit.Maui.Markup;

// Fixed width and height
new Button().Text("OK").Size(120, 44);

// Square
new Image { Source = "icon.png" }.Size(48);

// Only one dimension
new ProgressBar().Width(200).Height(4);

// Minimum constraints
new Editor().MinSize(200, 80);
```

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

### Attaching Behaviors and Effects to Visual Elements

Source: https://context7.com/communitytoolkit/maui.markup/llms.txt

Use `Behaviors` to add `Behavior` instances and `Effects` to add `Effect` instances to elements. Both accept a `params` span for multiple additions.

```csharp
using CommunityToolkit.Maui.Markup;

// Behaviors on an Entry
new Entry()
    .Placeholder("Email")
    .Behaviors(
        new EmailValidationBehavior(),
        new CharacterValidationBehavior { CharacterType = CharacterType.Email });

// Routing effects on a BoxView
new BoxView { Color = Colors.Cyan }
    .Effects(Effect.Resolve("MyApp.ShadowEffect"));
```

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

### Grid Placement Extensions

Source: https://context7.com/communitytoolkit/maui.markup/llms.txt

Use Row, Column, RowSpan, and ColumnSpan extensions to position elements within a Grid. Supports integer indices and type-safe enums for placement and spanning.

```csharp
using CommunityToolkit.Maui.Markup;

enum Row    { Header, Content, Footer }
enum Column { Left, Center, Right }

// Integer-based placement
new Label().Text("A").Row(0).Column(1);

// With explicit span
new BoxView().Row(0, span: 2).Column(0); // occupies rows 0–1

// Enum-based (type-safe)
new Label().Text("Header")
    .Row(Row.Header)
    .Column(Column.Left, Column.Right); // spans Left→Right (3 columns)

new ActivityIndicator()
    .Row(Row.Content)
    .Column(Column.Center)
    .ColumnSpan(1);
```

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

### AppThemeBinding and AppThemeColorBinding

Source: https://context7.com/communitytoolkit/maui.markup/llms.txt

Set bindable properties to different values based on the OS theme (light or dark). AppThemeColorBinding is a helper for Color properties.

```csharp
using CommunityToolkit.Maui.Markup;

new Label()
    .Text("Hello World")
    // Generic value variant
    .AppThemeBinding(Label.BackgroundColorProperty,
        light: Colors.White,
        dark: Colors.Black)
    // Colour-specific helper
    .AppThemeColorBinding(Label.TextColorProperty,
        light: Colors.Black,
        dark: Colors.White);

// Inside a Style<T>
var labelStyle = new Style<Label>(Label.FontSizeProperty, 16)
    .AddAppThemeBinding(Label.TextColorProperty, Colors.DarkGray, Colors.LightGray)
    .AddAppThemeBinding(Label.BackgroundColorProperty, Colors.White, Colors.Gray);
```

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

### C# Hot Reload Integration with ICommunityToolkitHotReloadHandler

Source: https://context7.com/communitytoolkit/maui.markup/llms.txt

Implement `ICommunityToolkitHotReloadHandler` to receive typed notifications during C# Hot Reload, enabling UI tree rebuilds without an app restart.

```csharp
using CommunityToolkit.Maui.Markup;

public class HomePage : ContentPage, ICommunityToolkitHotReloadHandler
{
    public HomePage() => Build();

    public void OnHotReload(IReadOnlyList<Type> types)
    {
        // Called automatically by the toolkit when hot-reload fires
        if (types.Contains(GetType()))
            MainThread.BeginInvokeOnMainThread(Build);
    }

    void Build()
    {
        Content = new VerticalStackLayout
        {
            Children =
            {
                new Label()
                    .Text("Live reloaded UI")
                    .Center()
                    .FontSize(20)
                    .Bold()
            }
        }.Center();
    }
}
```

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

### Fluent Style Setters with AddAppThemeBinding

Source: https://context7.com/communitytoolkit/maui.markup/llms.txt

Chain style setters fluently using Style<T>.Add. AddAppThemeBinding creates an AppThemeBinding setter for a property, supporting light and dark themes. AddAppThemeBindings can set multiple theme bindings at once.

```csharp
using CommunityToolkit.Maui.Markup;

var entryStyle = new Style<Entry>(
        (Entry.FontSizeProperty, 15),
        (Entry.HeightRequestProperty, 44))
    .AddAppThemeBinding(Entry.TextColorProperty,
        light: Colors.Black,
        dark:  Colors.White)
    .AddAppThemeBindings(
        (Entry.BackgroundColorProperty, Colors.White,    Colors.DarkGray),
        (Entry.PlaceholderColorProperty, Colors.LightGray, Colors.Gray))
    .CanCascade(true);

new Entry()
    .Placeholder("Username")
    .Style(entryStyle);
```

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

### Configure FlexLayout Child Properties with Grow, Shrink, and Basis

Source: https://context7.com/communitytoolkit/maui.markup/llms.txt

Attach per-child FlexLayout properties like Grow, Shrink, and Basis to any BindableObject within a FlexLayout. These mirror CSS flexbox child properties for controlling item sizing and flexibility.

```csharp
using CommunityToolkit.Maui.Markup;
using Microsoft.Maui.Layouts;

new FlexLayout
{
    Direction   = FlexDirection.Row,
    Wrap        = FlexWrap.Wrap,
    Children =
    {
        new Label().Text("Tag 1")
            .Grow(1)
            .Shrink(0)
            .Basis(new FlexBasis(120, isRelative: false)),

        new Label().Text("Tag 2")
            .Grow(2)
            .AlignSelf(FlexAlignSelf.Center),

        new Label().Text("Tag 3")
            .Order(0)            // render first despite position in Children
            .Basis(0.3f, isRelative: true)  // 30 % of container
    }
};
```

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

### Font and Text Styling Extensions

Source: https://context7.com/communitytoolkit/maui.markup/llms.txt

Easily apply font properties like family, size, weight, style, and color using Font, FontSize, Bold, Italic, TextColor, and Text extensions. The composite Font() method accepts multiple properties.

```csharp
using CommunityToolkit.Maui.Markup;

new Label()
    .Text("Hello", Colors.DarkBlue)          // text + color in one call
    .Font(family: "OpenSans", size: 18, bold: true)
    .TextColor(Colors.Navy);

new Entry()
    .Placeholder("Search…", Colors.Gray)
    .FontSize(14)
    .TextColor(Colors.Black);

new Button()
    .Text("Submit")
    .Bold()
    .FontSize(16);
```

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

### Spacing Extensions

Source: https://context7.com/communitytoolkit/maui.markup/llms.txt

Apply Margin and Padding to Views and Elements using Margin, Margins, Padding, and Paddings extensions. Supports symmetric, per-side, and Thickness struct configurations.

```csharp
using CommunityToolkit.Maui.Markup;

// Symmetric margin (horizontal, vertical)
new Label().Text("Info").Margin(16, 8);

// Per-side margin
new Button().Text("Go").Margins(left: 8, top: 4, right: 8, bottom: 4);

// Thickness struct
new Frame().Padding(new Thickness(12, 8));

// Per-side padding
new ContentPage().Paddings(left: 16, top: 0, right: 16, bottom: 16);
```

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

### Multi-binding with Inline Converter

Source: https://context7.com/communitytoolkit/maui.markup/llms.txt

Combine multiple bindings into a single target property using a typed Func. Supports an optional converter and convertBack. Useful for simple multi-value scenarios.

```csharp
using CommunityToolkit.Maui.Markup;

// Combine first and last name into a single Label
new Label()
    .Bind<Label, string, string, string>(
        Label.TextProperty,
        new Binding(nameof(PersonViewModel.FirstName)),
        new Binding(nameof(PersonViewModel.LastName)),
        convert: static ((string? first, string? last) names)
            => $"{names.first} {names.last}");

// Three-source multi-bind: show "City, State ZIP"
new Label()
    .Bind<Label, string, string, string, string>(
        Label.TextProperty,
        new Binding(nameof(AddressViewModel.City)),
        new Binding(nameof(AddressViewModel.State)),
        new Binding(nameof(AddressViewModel.Zip)),
        convert: static ((string? city, string? state, string? zip) a)
            => $"{a.city}, {a.state} {a.zip}");
```

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

### Fluent Typed Style Definition with Style<T>

Source: https://context7.com/communitytoolkit/maui.markup/llms.txt

Define styles using a strongly-typed wrapper around Microsoft.Maui.Controls.Style. Supports inheritance, app-theme bindings, behaviors, and triggers.

```csharp
using CommunityToolkit.Maui.Markup;

// Define a reusable label style
var headingStyle = new Style<Label>(
        (Label.FontSizeProperty, 24),
        (Label.FontAttributesProperty, FontAttributes.Bold))
    .AddAppThemeBinding(Label.TextColorProperty, Colors.Black, Colors.White)
    .ApplyToDerivedTypes(true);

// Apply via fluent extension
new Label()
    .Text("Dashboard")
    .Style(headingStyle);

// Inherit from a base style
var subheadingStyle = new Style<Label>(Label.FontSizeProperty, 18)
    .BasedOn(headingStyle);

// Use in a ResourceDictionary (implicit cast to Style)
Resources.Add("HeadingStyle", headingStyle);
```

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

### Apply Dynamic Resources to Label Properties

Source: https://context7.com/communitytoolkit/maui.markup/llms.txt

Use DynamicResource to bind a BindableProperty to a dynamic resource. The element automatically updates when the resource dictionary value changes at runtime, useful for theme switching.

```csharp
using CommunityToolkit.Maui.Markup;

new Label()
    .DynamicResource(Label.TextColorProperty, "PrimaryTextColor")
    .DynamicResource(Label.FontSizeProperty,  "BodyFontSize");

// Multiple resources in one call
new Button()
    .DynamicResources(
        (Button.BackgroundColorProperty, "AccentColor"),
        (Button.TextColorProperty,       "ButtonTextColor"),
        (Button.FontSizeProperty,        "ButtonFontSize"));
```

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

### FormattedText for Inline Label Styling

Source: https://context7.com/communitytoolkit/maui.markup/llms.txt

Build a `Label.FormattedText` with multiple `Span` objects in a single fluent call, simplifying verbose inline object initializer syntax.

```csharp
using CommunityToolkit.Maui.Markup;

new Label()
    .FormattedText(
        new Span { Text = "Hello ",    TextColor = Colors.Black,  FontSize = 16 },
        new Span { Text = "World",     TextColor = Colors.Blue,   FontAttributes = FontAttributes.Bold },
        new Span { Text = "!",         TextColor = Colors.Red,    FontSize = 20 });
```

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

### Typed Command Binding with Lambda Expressions

Source: https://context7.com/communitytoolkit/maui.markup/llms.txt

Bind a control's default command and optionally its command parameter to an ICommand property on a ViewModel via a type-safe lambda. Eliminates magic property name strings and works with various controls.

```csharp
// Bind Button.Command to ViewModel.SubmitCommand
new Button()
    .Text("Submit")
    .BindCommand(static (OrderViewModel vm) => vm.SubmitCommand);
```

```csharp
// Bind command AND command parameter from the same ViewModel
new Button()
    .Text("Delete")
    .BindCommand(
        static (ItemViewModel vm) => vm.DeleteCommand,
        parameterGetter: static (ItemViewModel vm) => vm.SelectedItem);
```

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

### Braces Usage

Source: https://github.com/communitytoolkit/maui.markup/blob/main/CONTRIBUTING.md

Always use braces `{}` after control flow statements like `if`, `for`, `foreach`, `do`, and `while`. This improves code readability and prevents potential errors.

```csharp
if (something is not null)
{
   ActOnIt();
}
```

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

### Set AbsoluteLayout Bounds with Proportional and Fixed Values

Source: https://context7.com/communitytoolkit/maui.markup/llms.txt

Use LayoutBounds and LayoutFlags to position and size children within an AbsoluteLayout. LayoutFlags determines if bounds are proportional (0.0-1.0) or absolute device-independent units.

```csharp
using CommunityToolkit.Maui.Markup;
using Microsoft.Maui.Layouts;

new AbsoluteLayout
{
    Children =
    {
        // Position at (10, 20), auto-size
        new Label().Text("Top-left")
            .LayoutBounds(10, 20),

        // Proportional position + fixed size
        new BoxView { Color = Colors.Blue }
            .LayoutFlags(AbsoluteLayoutFlags.PositionProportional)
            .LayoutBounds(0.5, 0.5, 100, 40),   // centered horizontally/vertically

        // All-proportional: fill 80 % width, 10 % height at bottom
        new Frame()
            .LayoutFlags(AbsoluteLayoutFlags.All)
            .LayoutBounds(0.1, 0.9, 0.8, 0.1)
    }
};
```

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

### BindCommand — Typed command binding

Source: https://context7.com/communitytoolkit/maui.markup/llms.txt

Binds a control's default command and optionally its command parameter to an ICommand property on a ViewModel via a type-safe lambda.

```APIDOC
## BindCommand

### Description
Binds a control's default command (and optionally its command parameter) to an `ICommand` property on a ViewModel via a type-safe lambda. Eliminates magic property name strings and works with `Button`, `ImageButton`, `SwipeItem`, and any bindable that exposes a default command property.

### Method
Extension method on `BindableObject`

### Parameters
- **commandGetter**: A lambda expression to get the `ICommand` from the ViewModel.
- **parameterGetter**: Optional lambda expression to get the command parameter from the ViewModel.

### Usage Examples

**Bind Button.Command to ViewModel.SubmitCommand:**
```csharp
new Button()
    .Text("Submit")
    .BindCommand(static (OrderViewModel vm) => vm.SubmitCommand);
```

**Bind command AND command parameter from the same ViewModel:**
```csharp
new Button()
    .Text("Delete")
    .BindCommand(
        static (ItemViewModel vm) => vm.DeleteCommand,
        parameterGetter: static (ItemViewModel vm) => vm.SelectedItem);
```
```

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

### Inline Value Converters

Source: https://context7.com/communitytoolkit/maui.markup/llms.txt

Implement IValueConverter using type-safe FuncConverter delegates for custom data binding logic. Supports conversion, reverse conversion, parameters, and CultureInfo. Includes built-in NotConverter and ToStringConverter.

```csharp
using CommunityToolkit.Maui.Markup;

// Bool → Color
var activeColorConverter = new FuncConverter<bool, Color>(
    convert:     b => b is true ? Colors.Green : Colors.Red,
    convertBack: c => c == Colors.Green);

new BoxView()
    .Bind(BoxView.ColorProperty,
          static (DeviceViewModel vm) => vm.IsOnline,
          converter: activeColorConverter);

// Int → formatted string
new Label()
    .Bind(Label.TextProperty,
          static (CartViewModel vm) => vm.ItemCount,
          convert: static (int? n) => $"{n ?? 0} item(s)");

// Built-in: logical NOT
new ActivityIndicator()
    .Bind(ActivityIndicator.IsVisibleProperty,
          static (LoadViewModel vm) => vm.IsLoaded,
          converter: NotConverter.Instance);

// Built-in: ToString with format
new Label()
    .Bind(Label.TextProperty,
          static (StatsViewModel vm) => vm.Score,
          converter: new ToStringConverter("Score: {0}"));
```

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

### Enum-Named Grid Row/Column Definitions

Source: https://context7.com/communitytoolkit/maui.markup/llms.txt

Define Grid row and column collections using enum values for type-safe referencing. Uses GridLength helpers like Auto, Star, and Stars(n).

```csharp
using CommunityToolkit.Maui.Markup;
using static CommunityToolkit.Maui.Markup.GridRowsColumns;

class ProfilePage : ContentPage
{
    enum Row    { Avatar, Name, Bio, Actions }
    enum Column { Label, Value }

    public ProfilePage()
    {
        Content = new Grid
        {
            RowDefinitions = Rows.Define(
                (Row.Avatar,  100),
                (Row.Name,    Auto),
                (Row.Bio,     Stars(2)),
                (Row.Actions, 60)),

            ColumnDefinitions = Columns.Define(
                (Column.Label, Stars(1)),
                (Column.Value, Stars(2))),

            Children =
            {
                new Image { Source = "avatar.png" }
                    .Row(Row.Avatar).Column(Column.Label, Column.Value), // span both columns

                new Label().Text("Name:")
                    .Row(Row.Name).Column(Column.Label),

                new Label()
                    .Bind(Label.TextProperty, static (ProfileViewModel vm) => vm.FullName)
                    .Row(Row.Name).Column(Column.Value),

                new Label()
                    .Bind(Label.TextProperty, static (ProfileViewModel vm) => vm.Bio)
                    .Row(Row.Bio).Column(Column.Label, Column.Value),

                new Button().Text("Save")
                    .BindCommand(static (ProfileViewModel vm) => vm.SaveCommand)
                    .Row(Row.Actions).Column(Column.Label, Column.Value)
            }
        };
    }
}
```

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

### File Scoped Namespaces

Source: https://github.com/communitytoolkit/maui.markup/blob/main/CONTRIBUTING.md

Use file-scoped namespaces to reduce code verbosity. This is a C# 10 feature that simplifies namespace declarations.

```csharp
namespace CommunityToolkit.Maui.Converters;

using System;

class BoolToObjectConverter
{
}
```

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

### Null Checking with 'is'

Source: https://github.com/communitytoolkit/maui.markup/blob/main/CONTRIBUTING.md

Prefer using the 'is' operator for null checks over '=='. This applies to both checking for null and not null conditions.

```csharp
// null
if (something is null)
{

}

// or not null
if (something is not null)
{
   
}
```

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

### Bind (typed single binding) — Expression-based ViewModel binding

Source: https://context7.com/communitytoolkit/maui.markup/llms.txt

Binds a BindableProperty on any BindableObject to a ViewModel property using a compile-time-checked lambda expression. Supports optional inline converters, BindingMode, stringFormat, targetNullValue, and fallbackValue.

```APIDOC
## Bind (typed single binding)

### Description
Binds a `BindableProperty` on any `BindableObject` to a ViewModel property using a compile-time-checked lambda expression. Supports optional inline `convert`/`convertBack` lambdas, `BindingMode`, `stringFormat`, `targetNullValue`, and `fallbackValue` without needing a separate `IValueConverter` class.

### Method
Extension method on `BindableObject`

### Parameters
- **property**: The `BindableProperty` to bind.
- **getter**: A lambda expression to get the ViewModel property value.
- **setter**: Optional lambda expression to set the ViewModel property value (for two-way binding).
- **mode**: Optional `BindingMode`.
- **convert**: Optional lambda expression for one-way conversion.
- **convertBack**: Optional lambda expression for two-way conversion.
- **stringFormat**: Optional format string.
- **targetNullValue**: Optional value when the source is null.
- **fallbackValue**: Optional value when the source binding fails.

### Usage Examples

**Simple one-way binding:**
```csharp
new Label()
    .Bind(Label.TextProperty, static (LoginViewModel vm) => vm.UserName);
```

**Two-way binding with inline converter (bool → string):**
```csharp
new Label()
    .Bind(
        Label.TextProperty,
        static (SettingsViewModel vm) => vm.IsEnabled,
        mode: BindingMode.OneWay,
        convert: static (bool? isEnabled) => isEnabled is true ? "Active" : "Inactive");
```

**Two-way binding with convert + convertBack:**
```csharp
new Entry()
    .Bind(
        Entry.TextProperty,
        static (ProfileViewModel vm) => vm.Age,
        setter: static (vm, value) => vm.Age = value,
        mode: BindingMode.TwoWay,
        convert: static (int? age) => age?.ToString() ?? string.Empty,
        convertBack: static (string? text) => int.TryParse(text, out var n) ? n : 0);
```
```

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

### Typed Single Binding with Lambda Expressions

Source: https://context7.com/communitytoolkit/maui.markup/llms.txt

Bind a BindableProperty to a ViewModel property using compile-time-checked lambda expressions. Supports inline converters, BindingMode, stringFormat, targetNullValue, and fallbackValue without needing a separate IValueConverter class.

```csharp
// Simple one-way binding
new Label()
    .Bind(Label.TextProperty, static (LoginViewModel vm) => vm.UserName);
```

```csharp
// Two-way binding with inline converter (bool → string)
new Label()
    .Bind(
        Label.TextProperty,
        static (SettingsViewModel vm) => vm.IsEnabled,
        mode: BindingMode.OneWay,
        convert: static (bool? isEnabled) => isEnabled is true ? "Active" : "Inactive");
```

```csharp
// Two-way binding with convert + convertBack
new Entry()
    .Bind(
        Entry.TextProperty,
        static (ProfileViewModel vm) => vm.Age,
        setter: static (vm, value) => vm.Age = value,
        mode: BindingMode.TwoWay,
        convert: static (int? age) => age?.ToString() ?? string.Empty,
        convertBack: static (string? text) => int.TryParse(text, out var n) ? n : 0);
```

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

### Type Checking with 'is'

Source: https://github.com/communitytoolkit/maui.markup/blob/main/CONTRIBUTING.md

Prefer using the 'is' operator for type checking instead of casting. This allows for type-safe checking and casting in a single operation.

```csharp
if (something is Bucket bucket)
{
   bucket.Empty();
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.