x:Bind Functions - usage of BindBack is unclear

[Polarts]

The description of two way function binding doesn't seem to clarify how the functions should work, and there's no example for the implementation of a BindBack function.

Since x:Bind Functions are used for converting data, I'd expect that a BindBack function would require a return statement of the source type and set it to the source property. However, it seems like this is not the intended functionality, as the set of a property is never called on a two-way x:Bind with BindBack.

According to this unofficial sample it seems as if the BindBack function should directly set the source property, so rather than working as a performant substitute for a classic converter, it works like a "ValueChanged" callback, which is counter-intuitive to the way that bindings work.

Is this how BindBack functions are supposed to work? If so, what's the difference between them and "ValueChanged" callbacks?
I'd like to get some clarification on this topic, since there doesn't seem to be much info about it around the internet.
Also, it would be nice if the documentation page contained an example for an implemented BindBack function.

Thanks

---

Document Details

⚠ Do not edit this section. It is required for docs.microsoft.com ➟ GitHub issue linking.

• ID: 9fdf7014-70bd-f562-046a-432f5f5caf11
• Version Independent ID: f45e3d08-66e0-1b74-2c0d-595345e7f3b1
• Content: Functions in x:Bind - UWP applications
• Content Source: windows-apps-src/data-binding/function-bindings.md
• Product: uwp
• Technology: data-and-files
• GitHub Login: @lastnameholiu
• Microsoft Alias: alholiu

[GrantMeStrength]

AI Generated answer attached. Jim, would this be accurate?

The x:Bind with BindBack in UWP (Universal Windows Platform) is indeed a topic that can be a bit confusing without clear documentation and examples. Your understanding and the observations from the unofficial sample lead to a correct interpretation of how BindBack functions are intended to work, which might differ from initial expectations based on traditional data binding concepts.

Understanding BindBack
The primary purpose of x:Bind is to provide a more performant and type-safe way of binding data in UWP compared to the older {Binding} syntax. When you use x:Bind in Two-Way binding mode, you typically specify a Mode=TwoWay parameter to enable updates to flow from the target back to the source.

The BindBack function is used in scenarios where the data conversion needs to happen not just from source to target (which is handled by the converter parameter in x:Bind) but also from target back to source when the target changes. However, the intuitive expectation that BindBack functions like a traditional converter that simply returns a value to be automatically assigned to the source property is not accurate.

Instead, BindBack acts more like a "ValueChanged" callback where you manually handle the update to the source property based on the target's new value. This means that within the BindBack function, you should directly set the source property to its new value, reflecting the change from the target.

Why Use BindBack Over "ValueChanged" Callbacks?
While BindBack and "ValueChanged" callbacks might seem to serve similar purposes, there are nuances:

Declarative Binding: BindBack keeps the logic related to updating the source property in the context of the binding declaration, making it clearer that this logic is specifically for handling changes from the target back to the source.
Consistency and Maintainability: Using BindBack maintains consistency in your data binding strategy, keeping both the forward and backward conversions within the x:Bind syntax. This can make the code more maintainable and easier to understand at a glance, especially for others reviewing your code or for you when coming back to it after some time.
Separation of Concerns: "ValueChanged" callbacks might be used for a variety of reasons unrelated to updating a source property based on a change in the target. Using BindBack specifically for the reverse data flow in two-way bindings helps maintain a clear separation of concerns.
Example of BindBack Implementation
While official examples in the documentation would be ideal, here's a basic conceptual example to illustrate how BindBack could be implemented:

xml
Copy code

In your ViewModel:

csharp
Copy code
public void IntToStringBindBack(string value)
{
if (int.TryParse(value, out int result))
{
this.SomeProperty = result;
}
// Optionally handle the case where conversion fails
}
In this example, IntToStringBindBack directly sets SomeProperty in the ViewModel based on the value from the TextBox. This approach ensures that you're manually handling the conversion and assignment back to the source property, which is the intended functionality of BindBack.

Conclusion
BindBack functions are indeed meant to directly set the source property, acting more like a manual "ValueChanged" handler within the context of two-way x:Bind bindings. The distinction between BindBack and general "ValueChanged" callbacks lies in their specific use cases and the structured approach BindBack provides for handling reverse data flow in bindings. Your feedback about the lack of clear examples and detailed explanations in the official documentation is valid, and it would be beneficial for the documentation to include explicit BindBack examples for developers.