CompiledBindings

CompiledBindings generates code to observe changes in properties. You can fine-tune this behavior using special operators:

• \. (Backslash Dot): Forces the compiler to check for INotifyPropertyChanged at runtime instead of compile time. This is useful when binding to properties of an interface (like IList.Count) where the specific implementation type is unknown.
• /. (Slash Dot): Tells the compiler to stop listening for changes on that property. Use this for optimization when a property (like a collection instance) is returned but the instance itself never changes, even if its contents do.

Forcing Notifications on Get-Only Properties

By default, no change-listening code is generated for auto-generated get-only properties. To force the compiler to generate listening code for a property that changes (even if it's get-only), use the [ReadOnly(false)] attribute in your C# code.

<!-- Force runtime INPC check for IList.Count -->
<TextBlock Text="{x:Bind serialNumbersList.SelectedItems\.Count}"/>

<!-- Stop listening to changes on the SelectedItems instance itself -->
<TextBlock Text="{x:Bind serialNumbersList/.SelectedItems\.Count}"/>

You can use various operators within a {x:Bind} expression to perform logic at compile time:

• Binary Operators: +, -, *, /, = (eq), != (ne), < (lt), > (gt), <= (le), >= (ge)
• Unary Operators: -, +, ! (not)
• Logical Operators: && (and), || (or)
• Coalesce Operator: ? : (e.g., IsChange ? Collapsed : Visible)
• Null Check Operator: ?? (e.g., Movie.Title ?? 'no title')
• Cast Operator: (namespace:Type)expression (e.g., ((local:Movie)itemsList.SelectedItem).Title)
• As Operator: expression as namespace:Type (e.g., (itemsList.SelectedItem as local:Movie).Title)
• New Operator: new namespace:Type(args)
• Interpolated Strings: Starts with $ followed by a string literal. Supports {} for expressions and optional formatting (e.g., $'Value: {Prop:0.###}')
• Is Operator: Used for multi-expression matching (e.g., IntProp1 is 0 or 1 or IntProp1 is ge 0 and le 10). It also supports type checking (e.g., ObjProp is system:String).

<!-- Example of is-operator with comparison -->
<Label IsVisible="{x:Bind IntProp1 is ge 0 and le 10}"/>

<!-- Example of interpolated string -->
<Label Text="{x:Bind $'Decimal value: {DecimalProp:0.###}, Boolean value: {BooleanProp}'}" />

By default, the data source is the root control/page/window.

Setting DataType

• Xamarin Forms: Use the x:DataType attribute.
• WPF: Since x:DataType is not natively available, declare the http://compiledbindings.com/x namespace (e.g., xmlns:mx="http://compiledbindings.com/x"), add it to mc:Ignorable="d mx", and use mx:DataType="local:MainViewModel".
• DataTemplates: You must specify the data type in a DataTemplate. You can use x:DataType (or mx:DataType for WPF) or set DataType={x:Null} to reset it.

Automatic Type Detection with IsItemsSource

When binding to the ItemsSource of a collection control (e.g., CollectionView, ListBox), set IsItemsSource=true. This allows the compiler to automatically detect the element type for the ItemTemplate, provided the template is defined as a direct XAML child of the collection control.

<!-- WPF Data Source Setup -->
<Window ...
      xmlns:mx="http://compiledbindings.com/x"
      mc:Ignorable="d mx"
      mx:DataType="local:MainViewModel">

<!-- Automatic type detection for ItemsSource -->
<CollectionView ItemsSource="{x:Bind Movies, IsItemsSource=true}">
    <CollectionView.ItemTemplate>
        <DataTemplate>
            <Label Text="{x:Bind Title}"/>
        </DataTemplate>
    </CollectionView.ItemTemplate>
</CollectionView>

You can use a method or an extension method as a target for {x:Bind} or {x:Set} using OneTime or OneWay modes.

Requirements for Instance Methods

• Must have exactly one parameter.

Requirements for Extension Methods

• Must have exactly two parameters: the first must be the this parameter of the control, and the second is the parameter to which the expression is set.

Setup Steps

1. Declare the http://compiledbindings.com/ namespace (e.g., with prefix m).
2. Mark the namespace as ignorable in mc:Ignorable.
3. For extension methods, declare the namespace of the extension class using using:Namespace.

Example

C# Extension Method:

public static void SetFocused(this VisualElement visualElement, bool focused)
{
    if (focused)
    {
    	visualElement.Focus();
    }
}

XAML Usage:

<ContentPage 
    xmlns="http://schemas.microsoft.com/dotnet/2021/xaml"
    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
    xmlns:m="http://compiledbindings.com/"
    xmlns:extension="using:CompiledBindingsDemo.Extensions"
    mc:Ignorable="d m mx">

  <Entry m:SetFocused="{x:Bind IsNameFocused}" />
</ContentPage>