diff --git a/src/Avalonia.Base/AvaloniaObject.cs b/src/Avalonia.Base/AvaloniaObject.cs
index 7a0ae7d1d9..e54dc13a83 100644
--- a/src/Avalonia.Base/AvaloniaObject.cs
+++ b/src/Avalonia.Base/AvaloniaObject.cs
@@ -611,7 +611,7 @@ namespace Avalonia
internal IDisposable Bind(
AvaloniaProperty property,
- BindingExpression expression,
+ UntypedBindingExpressionBase expression,
BindingPriority priority)
{
return property.RouteBind(this, expression, priority);
diff --git a/src/Avalonia.Base/AvaloniaProperty.cs b/src/Avalonia.Base/AvaloniaProperty.cs
index 48993ee402..934bb29cde 100644
--- a/src/Avalonia.Base/AvaloniaProperty.cs
+++ b/src/Avalonia.Base/AvaloniaProperty.cs
@@ -569,7 +569,7 @@ namespace Avalonia
/// The priority.
internal abstract IDisposable RouteBind(
AvaloniaObject o,
- BindingExpression source,
+ UntypedBindingExpressionBase source,
BindingPriority priority);
///
diff --git a/src/Avalonia.Base/Data/BindingNotification.cs b/src/Avalonia.Base/Data/BindingNotification.cs
index a58059d891..ed017e29a1 100644
--- a/src/Avalonia.Base/Data/BindingNotification.cs
+++ b/src/Avalonia.Base/Data/BindingNotification.cs
@@ -1,5 +1,6 @@
using System;
using System.Diagnostics;
+using System.Runtime.CompilerServices;
namespace Avalonia.Data
{
@@ -288,4 +289,17 @@ namespace Avalonia.Data
a?.Message == b?.Message;
}
}
+
+ internal static class BindingErrorTypeExtensions
+ {
+ public static BindingValueType ToBindingValueType(this BindingErrorType type)
+ {
+ return type switch
+ {
+ BindingErrorType.Error => BindingValueType.BindingError,
+ BindingErrorType.DataValidationError => BindingValueType.DataValidationError,
+ _ => BindingValueType.Value,
+ };
+ }
+ }
}
diff --git a/src/Avalonia.Base/Data/BindingOperations.cs b/src/Avalonia.Base/Data/BindingOperations.cs
index 1dd845cded..be7218950f 100644
--- a/src/Avalonia.Base/Data/BindingOperations.cs
+++ b/src/Avalonia.Base/Data/BindingOperations.cs
@@ -24,7 +24,7 @@ namespace Avalonia.Data
_ = property ?? throw new ArgumentNullException(nameof(property));
_ = binding ?? throw new ArgumentNullException(nameof(binding));
- if (binding.Source is BindingExpression expression)
+ if (binding.Expression is { } expression)
{
return target.Bind(property, expression, BindingPriority.LocalValue);
}
diff --git a/src/Avalonia.Base/Data/Core/BindingError.cs b/src/Avalonia.Base/Data/Core/BindingError.cs
new file mode 100644
index 0000000000..b1cc9b9caf
--- /dev/null
+++ b/src/Avalonia.Base/Data/Core/BindingError.cs
@@ -0,0 +1,18 @@
+using System;
+using System.Diagnostics;
+
+namespace Avalonia.Data.Core;
+
+internal class BindingError
+{
+ public BindingError(Exception exception, BindingErrorType errorType)
+ {
+ Debug.Assert(errorType != BindingErrorType.None);
+
+ Exception = exception;
+ ErrorType = errorType;
+ }
+
+ public Exception Exception { get; }
+ public BindingErrorType ErrorType { get; }
+}
diff --git a/src/Avalonia.Base/Data/Core/BindingExpression.Observable.cs b/src/Avalonia.Base/Data/Core/BindingExpression.Observable.cs
deleted file mode 100644
index 121e455fb8..0000000000
--- a/src/Avalonia.Base/Data/Core/BindingExpression.Observable.cs
+++ /dev/null
@@ -1,56 +0,0 @@
-using System;
-
-namespace Avalonia.Data.Core;
-
-// Mostly for unit tests, BindingExpression implements IObservable and IObserver.
-// We limit support to a single subscriber in this scenario.
-internal partial class BindingExpression : IObservable, IObserver
-{
- IDisposable IObservable.Subscribe(IObserver observer)
- {
- if (observer is null)
- throw new ArgumentNullException(nameof(observer));
- if (_sink is not null)
- throw new InvalidOperationException(
- $"An {nameof(BindingExpression)} may only have a single subscriber.");
-
- _sink = new ObservableSink(observer);
- Start(produceValue: true);
- return this;
- }
-
- void IObserver.OnCompleted() { }
- void IObserver.OnError(Exception error) { }
- void IObserver.OnNext(object? value) => SetValue(value);
-
- private class ObservableSink : IBindingExpressionSink
- {
- private IObserver _observer;
- public ObservableSink(IObserver observer) => _observer = observer;
-
- public void OnChanged(BindingExpression instance, bool hasValueChanged, bool hasErrorChanged)
- {
- instance.GetDataValidationState(out var state, out var error);
-
- if (instance.IsDataValidationEnabled || error is not null)
- {
- BindingNotification notification;
-
- if (state.HasFlag(BindingValueType.BindingError) && error is not null)
- notification = new(error, BindingErrorType.Error, instance.GetValue());
- else if (state.HasFlag(BindingValueType.DataValidationError) && error is not null)
- notification = new(error, BindingErrorType.DataValidationError, instance.GetValue());
- else
- notification = new(instance.GetValue());
-
- _observer.OnNext(notification);
- }
- else if (hasValueChanged)
- {
- _observer.OnNext(instance.GetValue());
- }
- }
-
- public void OnCompleted(BindingExpression instance) => _observer.OnCompleted();
- }
-}
diff --git a/src/Avalonia.Base/Data/Core/BindingExpression.ValueEntry.cs b/src/Avalonia.Base/Data/Core/BindingExpression.ValueEntry.cs
deleted file mode 100644
index 40cbf88b1b..0000000000
--- a/src/Avalonia.Base/Data/Core/BindingExpression.ValueEntry.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-using System;
-using Avalonia.PropertyStore;
-using Avalonia.Styling;
-
-namespace Avalonia.Data.Core;
-
-internal partial class BindingExpression : IValueEntry, ISetterInstance
-{
- bool IValueEntry.HasValue
- {
- get
- {
- Start(produceValue: false);
- return _value is not null;
- }
- }
-
- AvaloniaProperty IValueEntry.Property => _targetProperty ?? throw new Exception();
-
- bool IValueEntry.GetDataValidationState(out BindingValueType state, out Exception? error)
- {
- GetDataValidationState(out state, out error);
- return IsDataValidationEnabled;
- }
-
- object? IValueEntry.GetValue()
- {
- Start(produceValue: false);
- return GetValueOrDefault();
- }
-
- void IValueEntry.Unsubscribe() => Stop();
-}
diff --git a/src/Avalonia.Base/Data/Core/BindingExpression.cs b/src/Avalonia.Base/Data/Core/BindingExpression.cs
index d18f8fec15..c7e9b79cf9 100644
--- a/src/Avalonia.Base/Data/Core/BindingExpression.cs
+++ b/src/Avalonia.Base/Data/Core/BindingExpression.cs
@@ -10,6 +10,7 @@ using Avalonia.Data.Core.ExpressionNodes;
using Avalonia.Data.Core.Parsers;
using Avalonia.Logging;
using Avalonia.Threading;
+using Avalonia.Utilities;
namespace Avalonia.Data.Core;
@@ -20,22 +21,13 @@ namespace Avalonia.Data.Core;
/// A represents a untyped binding which has been
/// instantiated on an object.
///
-internal partial class BindingExpression : IDescription, IDisposable
+internal partial class BindingExpression : UntypedBindingExpressionBase, IDescription, IDisposable
{
- internal static readonly WeakReference NullReference = new(null);
private readonly WeakReference? _source;
- private readonly WeakReference _target;
private readonly BindingMode _mode;
private readonly IReadOnlyList _nodes;
private readonly TargetTypeConverter? _targetTypeConverter;
- private bool _isRunning;
- private BindingPriority _priority;
- private bool _produceValue;
- private IBindingExpressionSink? _sink;
- private AvaloniaProperty? _targetProperty;
- private WeakReference? _value;
- private BindingError? _error;
- private UncommonFields? _uncommon;
+ private readonly UncommonFields? _uncommon;
///
/// Initializes a new instance of the class.
@@ -53,9 +45,7 @@ internal partial class BindingExpression : IDescription, IDisposable
///
/// The binding mode.
/// The format string to use.
- /// The target to which the value will be written.
/// The null target value.
- /// The target property.
///
/// A final type converter to be run on the produced value.
///
@@ -69,28 +59,20 @@ internal partial class BindingExpression : IDescription, IDisposable
bool enableDataValidation = false,
BindingMode mode = BindingMode.OneWay,
string? stringFormat = null,
- AvaloniaObject? target = null,
object? targetNullValue = null,
- AvaloniaProperty? targetProperty = null,
TargetTypeConverter? targetTypeConverter = null)
+ : base(enableDataValidation)
{
if (mode == BindingMode.Default)
throw new ArgumentException("Binding mode cannot be Default.", nameof(mode));
- if (target is null && mode is BindingMode.TwoWay or BindingMode.OneWayToSource)
- throw new ArgumentException("Target cannot be null for TwoWay or OneWayToSource bindings.", nameof(target));
- if (targetProperty is null && mode is BindingMode.TwoWay or BindingMode.OneWayToSource)
- throw new ArgumentException("Target property cannot be null for TwoWay or OneWayToSource bindings.", nameof(target));
if (source == AvaloniaProperty.UnsetValue)
source = null;
_source = new(source);
- _target = new(target);
- _targetProperty = targetProperty;
_mode = mode;
_nodes = nodes;
_targetTypeConverter = targetTypeConverter;
- IsDataValidationEnabled = enableDataValidation;
if (converter is not null ||
converterCulture is not null ||
@@ -139,83 +121,15 @@ internal partial class BindingExpression : IDescription, IDisposable
}
}
- public BindingPriority Priority => _priority;
public Type? SourceType => (LeafNode as ISettableNode)?.ValueType;
- public AvaloniaProperty? TargetProperty => _targetProperty;
- public Type TargetType => _targetProperty?.PropertyType ?? typeof(object);
public IValueConverter? Converter => _uncommon?._converter;
public CultureInfo ConverterCulture => _uncommon?._converterCulture ?? CultureInfo.CurrentCulture;
public object? ConverterParameter => _uncommon?._converterParameter;
public object? FallbackValue => _uncommon is not null ? _uncommon._fallbackValue : AvaloniaProperty.UnsetValue;
- public bool IsDataValidationEnabled { get; }
- public bool HasDataValidationError => _error?.ErrorType == BindingValueType.DataValidationError;
public object? TargetNullValue => _uncommon?._targetNullValue ?? AvaloniaProperty.UnsetValue;
public ExpressionNode LeafNode => _nodes[_nodes.Count - 1];
public string? StringFormat => _uncommon?._stringFormat;
- ///
- /// Gets the current value of the binding expression.
- ///
- ///
- /// The current value or if the binding was unable
- /// to read a value.
- ///
- ///
- /// The binding expression has not been started.
- ///
- public object? GetValue()
- {
- if (!_isRunning)
- throw new InvalidOperationException("BindingExpression has not been started.");
- if (_value is null)
- return AvaloniaProperty.UnsetValue;
- else if (_value == NullReference)
- return null;
- else if (_value.TryGetTarget(out var value))
- return value;
- else
- return AvaloniaProperty.UnsetValue;
- }
-
- ///
- /// Gets the current value of the binding expression or the default value for the target property.
- ///
- ///
- /// The current value or the target property default.
- ///
- ///
- /// The binding expression has not been started.
- ///
- public object? GetValueOrDefault()
- {
- var result = GetValue();
- if (result == AvaloniaProperty.UnsetValue)
- result = GetCachedDefaultValue();
- return result;
- }
-
- ///
- /// Gets the data validation state, if supported.
- ///
- /// The binding error state.
- /// The current binding error, if any.
- ///
- /// True if the expression supports data validation, otherwise false.
- ///
- public void GetDataValidationState(out BindingValueType state, out Exception? error)
- {
- if (_error is not null)
- {
- state = _error.ErrorType;
- error = _error.Exception;
- }
- else
- {
- state = BindingValueType.Value;
- error = null;
- }
- }
-
///
/// Writes the specified value to the binding source if possible.
///
@@ -223,7 +137,7 @@ internal partial class BindingExpression : IDescription, IDisposable
///
/// True if the value could be written to the binding source; otherwise false.
///
- public bool SetValue(object? value)
+ public override bool WriteValueToSource(object? value)
{
if (_nodes.Count == 0 || LeafNode is not ISettableNode setter || setter.ValueType is not { } type)
return false;
@@ -261,7 +175,7 @@ internal partial class BindingExpression : IDescription, IDisposable
}
// Don't set the value if it's unchanged.
- if (LeafNode.IsValueAlive && IdentityEquals(LeafNode.Value, value, type))
+ if (LeafNode.IsValueAlive && TypeUtilities.IdentityEquals(LeafNode.Value, value, type))
return true;
try
@@ -274,61 +188,6 @@ internal partial class BindingExpression : IDescription, IDisposable
}
}
- ///
- /// Initializes the binding expression with the specified subscriber and target property but
- /// does not start it.
- ///
- /// The subscriber.
- /// The target property.
- /// The priority of the binding.
- ///
- /// is different to that passed in the constructor, if one was
- /// passed there.
- ///
- public void Initialize(
- IBindingExpressionSink subscriber,
- AvaloniaProperty targetProperty,
- BindingPriority priority)
- {
- if (_targetProperty is not null && _targetProperty != targetProperty)
- throw new AvaloniaInternalException(
- "StartAsLocalValueBinding was called with a property different to that passed in constructor.");
-
- _sink = subscriber;
- _targetProperty = targetProperty;
- _priority = priority;
- }
-
- ///
- /// Starts the binding expression with the specified subscriber and target property..
- ///
- /// The subscriber.
- /// The target property.
- /// The priority of the binding.
- public void Start(
- IBindingExpressionSink subscriber,
- AvaloniaProperty targetProperty,
- BindingPriority priority)
- {
- Initialize(subscriber, targetProperty, priority);
- Start(produceValue: true);
- }
-
- ///
- /// Terminates the binding.
- ///
- public void Dispose()
- {
- if (_sink is null)
- return;
-
- Stop();
-
- var sink = _sink;
- _sink = null;
- sink.OnCompleted(this);
- }
-
///
/// Creates an from an expression tree.
///
@@ -342,9 +201,7 @@ internal partial class BindingExpression : IDescription, IDisposable
/// Whether data validation should be enabled for the binding.
/// The fallback value.
/// The binding mode.
- /// The target to which the value will be written.
/// The null target value.
- /// The target property.
/// Whether to allow reflection for target type conversion.
[RequiresUnreferencedCode(TrimmingMessages.ExpressionNodeRequiresUnreferencedCodeMessage)]
internal static BindingExpression Create(
@@ -356,9 +213,7 @@ internal partial class BindingExpression : IDescription, IDisposable
bool enableDataValidation = false,
Optional fallbackValue = default,
BindingMode mode = BindingMode.OneWay,
- AvaloniaObject? target = null,
object? targetNullValue = null,
- AvaloniaProperty? targetProperty = null,
bool allowReflection = true)
where TIn : class?
{
@@ -374,9 +229,7 @@ internal partial class BindingExpression : IDescription, IDisposable
converterParameter: converterParameter,
enableDataValidation: enableDataValidation,
mode: mode,
- target: target,
targetNullValue: targetNullValue,
- targetProperty: targetProperty,
targetTypeConverter: allowReflection ?
TargetTypeConverter.GetReflectionConverter() :
TargetTypeConverter.GetDefaultConverter());
@@ -400,7 +253,12 @@ internal partial class BindingExpression : IDescription, IDisposable
// The leaf node has changed. If the binding mode is not OneWayToSource, publish the
// value to the target.
if (_mode != BindingMode.OneWayToSource)
- UpdateAndPublishValue(value, dataValidationError);
+ {
+ var error = dataValidationError is not null ?
+ new BindingError(dataValidationError, BindingErrorType.DataValidationError) :
+ null;
+ ConvertAndPublishValue(value, error);
+ }
// If the binding mode is OneTime, then stop the binding.
if (_mode == BindingMode.OneTime)
@@ -448,21 +306,17 @@ internal partial class BindingExpression : IDescription, IDisposable
if (ShouldLogError(out var target))
Log(target, error, errorPoint);
- // Clear the current value.
- UpdateValue(AvaloniaProperty.UnsetValue, null, out var hasValueChanged, out _);
-
- // And store the error.
- _error = new(
+ // Clear the current value and publish the error.
+ var bindingError = new BindingError(
new BindingChainException(error, Description, errorPoint.ToString()),
- BindingValueType.BindingError);
-
- PublishValue(hasValueChanged, hasErrorChanged: true);
+ BindingErrorType.Error);
+ ConvertAndPublishValue(AvaloniaProperty.UnsetValue, bindingError);
}
internal void OnDataValidationError(Exception error)
{
- _error = new(error, BindingValueType.DataValidationError);
- PublishValue(hasValueChanged: false, hasErrorChanged: true);
+ var bindingError = new BindingError(error, BindingErrorType.DataValidationError);
+ PublishValue(UnchangedValue, bindingError);
}
private string CalculateErrorPoint(int nodeIndex)
@@ -478,27 +332,6 @@ internal partial class BindingExpression : IDescription, IDisposable
return result.ToString();
}
- private object? GetCachedDefaultValue()
- {
- Debug.Assert(_targetProperty is not null);
-
- if (_uncommon?._isDefaultValueInitialized == true)
- return _uncommon._defaultValue;
-
- if (_target.TryGetTarget(out var target))
- {
- _uncommon ??= new();
- _uncommon._isDefaultValueInitialized = true;
-
- if (_targetProperty.IsDirect)
- _uncommon._defaultValue = ((IDirectPropertyAccessor)_targetProperty).GetUnsetValue(target.GetType());
- else
- _uncommon._defaultValue = ((IStyledPropertyAccessor)_targetProperty).GetDefaultValue(target.GetType());
- }
-
- return _uncommon?._defaultValue ?? AvaloniaProperty.UnsetValue;
- }
-
private void Log(AvaloniaObject target, string error, LogEventLevel level = LogEventLevel.Warning)
{
if (!Logger.TryGet(level, LogArea.Binding, out var log))
@@ -507,7 +340,7 @@ internal partial class BindingExpression : IDescription, IDisposable
log.Log(
target,
"An error occurred binding {Property} to {Expression}: {Message}",
- (object?)_targetProperty ?? "(unknown)",
+ (object?)TargetProperty ?? "(unknown)",
Description,
error);
}
@@ -520,7 +353,7 @@ internal partial class BindingExpression : IDescription, IDisposable
log.Log(
target,
"An error occurred binding {Property} to {Expression} at {ExpressionErrorPoint}: {Message}",
- (object?)_targetProperty ?? "(unknown)",
+ (object?)TargetProperty ?? "(unknown)",
Description,
errorPoint,
error);
@@ -528,42 +361,28 @@ internal partial class BindingExpression : IDescription, IDisposable
private bool ShouldLogError([NotNullWhen(true)] out AvaloniaObject? target)
{
- if (!_target.TryGetTarget(out target))
+ if (!TryGetTarget(out target))
return false;
if (_nodes.Count > 0 && _nodes[0] is SourceNode sourceNode)
return sourceNode.ShouldLogErrors(target);
return true;
}
- private void Start(bool produceValue)
+ protected override void StartCore()
{
- Debug.Assert(_sink is not null);
-
- if (_isRunning)
- return;
-
- _isRunning = true;
- _produceValue = produceValue;
-
if (_source?.TryGetTarget(out var source) == true)
{
if (_nodes.Count > 0)
- {
_nodes[0].SetSource(source, null);
- }
else
- {
- _value = new(source);
- _error = null;
- PublishValue(hasValueChanged: true, hasErrorChanged: false);
- }
+ PublishValue(source);
if (_mode is BindingMode.TwoWay or BindingMode.OneWayToSource &&
- _target.TryGetTarget(out var target) &&
- _targetProperty is not null)
+ TryGetTarget(out var target) &&
+ TargetProperty is not null)
{
if (_mode is BindingMode.OneWayToSource)
- SetValue(target.GetValue(_targetProperty));
+ PublishValue(target.GetValue(TargetProperty));
target.PropertyChanged += OnTargetPropertyChanged;
}
@@ -572,58 +391,31 @@ internal partial class BindingExpression : IDescription, IDisposable
{
OnNodeError(-1, "Binding Source is null.");
}
-
- _produceValue = true;
}
- private void Stop()
+ protected override void StopCore()
{
foreach (var node in _nodes)
node.Reset();
if (_mode is BindingMode.TwoWay or BindingMode.OneWayToSource &&
- _target.TryGetTarget(out var target))
+ TryGetTarget(out var target))
{
target.PropertyChanged -= OnTargetPropertyChanged;
}
-
- _isRunning = false;
- _value = null;
}
- private void UpdateValue(
- object? value,
- Exception? dataValidationError,
- out bool hasValueChanged,
- out bool hasErrorChanged)
+ private void ConvertAndPublishValue(object? value, BindingError? error)
{
var isTargetNullValue = false;
- var hadError = _error is not null;
// All values other than DoNothing should be passed to the converter.
if (value != BindingOperations.DoNothing && Converter is { } converter)
- value = Convert(converter, ConverterParameter, value, TargetType);
+ value = Convert(converter, ConverterParameter, value, TargetType, ref error);
// Check this here as the converter may return DoNothing.
if (value == BindingOperations.DoNothing)
- {
- hasValueChanged = hasErrorChanged = false;
- return;
- }
-
- // Set the data validation error.
- _error = dataValidationError is not null ?
- new(dataValidationError, BindingValueType.DataValidationError) :
- null;
-
- // If we have a data validation error and the value is Unset then we keep the
- // current value.
- if (dataValidationError is not null && value == AvaloniaProperty.UnsetValue)
- {
- hasValueChanged = false;
- hasErrorChanged = true;
return;
- }
// TargetNullValue only applies when the value is null: UnsetValue indicates that there
// was a binding error so we don't want to use TargetNullValue in that case.
@@ -647,7 +439,7 @@ internal partial class BindingExpression : IDescription, IDisposable
else if (_targetTypeConverter is not null)
{
// Otherwise, if we have a target type converter, convert the value to the target type.
- value = ConvertFrom(_targetTypeConverter, value);
+ value = ConvertFrom(_targetTypeConverter, value, ref error);
}
}
@@ -656,78 +448,30 @@ internal partial class BindingExpression : IDescription, IDisposable
if (value == AvaloniaProperty.UnsetValue && FallbackValue != AvaloniaProperty.UnsetValue)
value = ConvertFallback(FallbackValue, nameof(FallbackValue));
- // Update the stored value.
- var oldValue = _value;
-
- if (value is null)
- _value = NullReference;
- else
- _value = new(value);
-
- hasValueChanged = !Equals(oldValue, _value);
- hasErrorChanged = _error is not null || (_error is null && hadError);
- }
-
- private void PublishValue(bool hasValueChanged, bool hasErrorChanged)
- {
- if (!hasValueChanged && !hasErrorChanged)
- return;
-
- if (_sink is not null && _produceValue)
- {
- if (Dispatcher.UIThread.CheckAccess())
- {
- _sink.OnChanged(this, hasValueChanged, hasErrorChanged);
- }
- else
- {
- // To avoid allocating closure in the outer scope we need to capture variables
- // locally. This allows us to skip most of the allocations when on UI thread.
- var sink = _sink;
- var v = hasValueChanged;
- var e = hasErrorChanged;
- Dispatcher.UIThread.Post(() => sink.OnChanged(this, v, e));
- }
- }
- }
-
- private void UpdateAndPublishValue(object? value, Exception? dataValidationError)
- {
- UpdateValue(
- value,
- dataValidationError,
- out var hasValueChanged,
- out var hasErrorChanged);
-
- if (hasValueChanged || hasErrorChanged)
- PublishValue(hasValueChanged, hasErrorChanged);
+ // Publish the value.
+ PublishValue(value, error);
}
private void WriteTargetValueToSource()
{
- if (_mode != BindingMode.OneWayToSource)
- return;
+ Debug.Assert(_mode == BindingMode.OneWayToSource);
- if (_target.TryGetTarget(out var target) &&
- _targetProperty is not null &&
- target.GetValue(_targetProperty) is var value &&
- !Equals(value, LeafNode.Value))
+ if (TryGetTarget(out var target) &&
+ TargetProperty is not null &&
+ target.GetValue(TargetProperty) is var value &&
+ !TypeUtilities.IdentityEquals(value, LeafNode.Value, TargetType))
{
- SetValue(value);
+ WriteValueToSource(value);
}
}
- private void OnSourceChanged(object? source)
- {
- if (_nodes.Count > 0)
- _nodes[0].SetSource(source, null);
- }
-
private void OnTargetPropertyChanged(object? sender, AvaloniaPropertyChangedEventArgs e)
{
- if (e.Property == _targetProperty)
+ Debug.Assert(_mode is BindingMode.TwoWay or BindingMode.OneWayToSource);
+
+ if (e.Property == TargetProperty)
{
- SetValue(e.NewValue);
+ WriteValueToSource(e.NewValue);
}
}
@@ -735,7 +479,8 @@ internal partial class BindingExpression : IDescription, IDisposable
IValueConverter converter,
object? converterParameter,
object? value,
- Type targetType)
+ Type targetType,
+ ref BindingError? error)
{
try
{
@@ -750,7 +495,7 @@ internal partial class BindingExpression : IDescription, IDisposable
if (ShouldLogError(out var target))
Log(target, $"{message}: {e.Message}", LogEventLevel.Warning);
- _error = new(new InvalidCastException(message + '.', e), BindingValueType.BindingError);
+ error = new(new InvalidCastException(message + '.', e), BindingErrorType.Error);
return AvaloniaProperty.UnsetValue;
}
}
@@ -763,53 +508,31 @@ internal partial class BindingExpression : IDescription, IDisposable
if (_targetTypeConverter.TryConvert(fallback, TargetType, ConverterCulture, out var result))
return result;
- if (_target.TryGetTarget(out var target))
+ if (TryGetTarget(out var target))
Log(target, $"Could not convert {fallbackName} '{fallback}' to '{TargetType}'.", LogEventLevel.Error);
return AvaloniaProperty.UnsetValue;
}
- private object? ConvertFrom(TargetTypeConverter? converter, object? value)
+ private object? ConvertFrom(TargetTypeConverter? converter, object? value, ref BindingError? error)
{
- if (converter is null || _targetProperty is null)
+ if (converter is null)
return value;
- var targetType = _targetProperty.PropertyType;
-
- if (converter.TryConvert(value, targetType, ConverterCulture, out var result))
+ if (converter.TryConvert(value, TargetType, ConverterCulture, out var result))
return result;
var valueString = value?.ToString() ?? "(null)";
var valueTypeName = value?.GetType().FullName ?? "null";
- var message = $"Could not convert '{valueString}' ({valueTypeName}) to '{targetType}'.";
+ var message = $"Could not convert '{valueString}' ({valueTypeName}) to '{TargetType}'.";
if (ShouldLogError(out var target))
Log(target, message, LogEventLevel.Warning);
- _error = new(new InvalidCastException(message), BindingValueType.BindingError);
+ error = new(new InvalidCastException(message), BindingErrorType.Error);
return AvaloniaProperty.UnsetValue;
}
- private static bool IdentityEquals(object? a, object? b, Type type)
- {
- if (type.IsValueType || type == typeof(string))
- return Equals(a, b);
- else
- return ReferenceEquals(a, b);
- }
-
- private class BindingError
- {
- public BindingError(Exception exception, BindingValueType errorType)
- {
- Exception = exception;
- ErrorType = errorType;
- }
-
- public Exception Exception { get; }
- public BindingValueType ErrorType { get; }
- }
-
private class UncommonFields
{
public IValueConverter? _converter;
@@ -818,7 +541,5 @@ internal partial class BindingExpression : IDescription, IDisposable
public object? _fallbackValue;
public string? _stringFormat;
public object? _targetNullValue;
- public object? _defaultValue;
- public bool _isDefaultValueInitialized;
}
}
diff --git a/src/Avalonia.Base/Data/Core/BindingExpressionBase.cs b/src/Avalonia.Base/Data/Core/BindingExpressionBase.cs
new file mode 100644
index 0000000000..ee6f524a0a
--- /dev/null
+++ b/src/Avalonia.Base/Data/Core/BindingExpressionBase.cs
@@ -0,0 +1,10 @@
+using Avalonia.Styling;
+
+namespace Avalonia.Data.Core;
+
+public abstract class BindingExpressionBase : ISetterInstance
+{
+ private protected BindingExpressionBase()
+ {
+ }
+}
diff --git a/src/Avalonia.Base/Data/Core/ExpressionNodes/ExpressionNode.cs b/src/Avalonia.Base/Data/Core/ExpressionNodes/ExpressionNode.cs
index 88f3bfaa57..fc86213373 100644
--- a/src/Avalonia.Base/Data/Core/ExpressionNodes/ExpressionNode.cs
+++ b/src/Avalonia.Base/Data/Core/ExpressionNodes/ExpressionNode.cs
@@ -59,7 +59,7 @@ internal abstract class ExpressionNode
{
get
{
- return _value == BindingExpression.NullReference ||
+ return _value == UntypedBindingExpressionBase._nullReference ||
_value?.TryGetTarget(out _) == true;
}
}
@@ -137,7 +137,7 @@ internal abstract class ExpressionNode
// If the source is null then the value is null. We explicitly do not want to call
// OnSourceChanged as we don't want to raise errors for subsequent nodes in the
// binding change.
- _value = BindingExpression.NullReference;
+ _value = BindingExpression._nullReference;
}
else if (source != oldSource)
{
@@ -199,11 +199,20 @@ internal abstract class ExpressionNode
if (valueOrNotification is BindingNotification notification)
{
if (notification.ErrorType == BindingErrorType.Error)
+ {
SetError(notification.Error!);
+ }
else if (notification.ErrorType == BindingErrorType.DataValidationError)
- SetValue(notification.Value, notification.Error);
+ {
+ if (notification.HasValue)
+ SetValue(notification.Value, notification.Error);
+ else
+ SetDataValidationError(notification.Error!);
+ }
else
+ {
SetValue(notification.Value, null);
+ }
}
else
{
@@ -237,11 +246,11 @@ internal abstract class ExpressionNode
// - The new value is different to the old value
if (_value is null ||
dataValidationError is not null ||
- (dataValidationError is null && Owner.HasDataValidationError) ||
+ (dataValidationError is null && Owner.ErrorType == BindingErrorType.DataValidationError) ||
_value.TryGetTarget(out var oldValue) == false ||
!Equals(oldValue, value))
{
- _value = value is null ? BindingExpression.NullReference : new(value);
+ _value = value is null ? BindingExpression._nullReference : new(value);
Owner.OnNodeValueChanged(Index, value, dataValidationError);
}
}
diff --git a/src/Avalonia.Base/Data/Core/IBindingExpressionSink.cs b/src/Avalonia.Base/Data/Core/IBindingExpressionSink.cs
index f37673769b..a068536e1c 100644
--- a/src/Avalonia.Base/Data/Core/IBindingExpressionSink.cs
+++ b/src/Avalonia.Base/Data/Core/IBindingExpressionSink.cs
@@ -3,18 +3,32 @@
internal interface IBindingExpressionSink
{
///
- /// Called when a 's value or error state
+ /// Called when an 's value or error state
/// changes.
///
/// The binding expression.
+ ///
+ /// Indicates whether represents a new value produced by the binding.
+ ///
+ ///
+ /// Indicates whether represents a new error produced by the binding.
+ ///
+ ///
+ /// The new binding value; if is true.
+ ///
+ ///
+ /// The new binding error; if is true.
+ ///
void OnChanged(
- BindingExpression instance,
+ UntypedBindingExpressionBase instance,
bool hasValueChanged,
- bool hasErrorChanged);
+ bool hasErrorChanged,
+ object? value,
+ BindingError? error);
///
- /// Called when a completes.
+ /// Called when an completes.
///
/// The binding expression.
- void OnCompleted(BindingExpression instance);
+ void OnCompleted(UntypedBindingExpressionBase instance);
}
diff --git a/src/Avalonia.Base/Data/Core/UntypedBindingExpressionBase.cs b/src/Avalonia.Base/Data/Core/UntypedBindingExpressionBase.cs
new file mode 100644
index 0000000000..352f12064c
--- /dev/null
+++ b/src/Avalonia.Base/Data/Core/UntypedBindingExpressionBase.cs
@@ -0,0 +1,455 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using Avalonia.PropertyStore;
+using Avalonia.Reactive;
+using Avalonia.Threading;
+using Avalonia.Utilities;
+
+namespace Avalonia.Data.Core;
+
+///
+/// Base class for binding expressions which produce untyped values.
+///
+internal abstract class UntypedBindingExpressionBase : BindingExpressionBase, IDisposable, IValueEntry
+{
+ protected static readonly object UnchangedValue = new();
+ internal static readonly WeakReference _nullReference = new(null);
+ private readonly bool _isDataValidationEnabled;
+ private object? _defaultValue;
+ private BindingError? _error;
+ private bool _isDefaultValueInitialized;
+ private bool _isRunning;
+ private bool _produceValue;
+ private IBindingExpressionSink? _sink;
+ private WeakReference? _target;
+ private WeakReference? _value;
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// Whether data validation is enabled.
+ public UntypedBindingExpressionBase(bool isDataValidationEnabled)
+ {
+ _isDataValidationEnabled = isDataValidationEnabled;
+ }
+
+ ///
+ /// Gets the current error state of the binding expression.
+ ///
+ public BindingErrorType ErrorType => _error?.ErrorType ?? BindingErrorType.None;
+
+ ///
+ /// Gets a value indicating whether data validation is enabled for the binding expression.
+ ///
+ public bool IsDataValidationEnabled => _isDataValidationEnabled;
+
+ ///
+ /// Gets a value indicating whether the binding expression is currently running.
+ ///
+ public bool IsRunning => _isRunning;
+
+ ///
+ /// Gets the priority of the binding expression.
+ ///
+ public BindingPriority Priority { get; private set; }
+
+ ///
+ /// Gets the which the binding expression is targeting.
+ ///
+ public AvaloniaProperty? TargetProperty { get; private set; }
+
+ ///
+ /// Gets the target type of the binding expression; that is, the type that values produced by
+ /// the expression should be converted to.
+ ///
+ public Type TargetType { get; private set; } = typeof(object);
+
+ bool IValueEntry.HasValue
+ {
+ get
+ {
+ Start(produceValue: false);
+ return _value is not null;
+ }
+ }
+
+ AvaloniaProperty IValueEntry.Property => TargetProperty ?? throw new Exception();
+
+ ///
+ /// Produces an observable which can be used to observe the value of the binding expression.
+ ///
+ /// An observable subject.
+ ///
+ /// The binding expression is already instantiated on an AvaloniaObject.
+ ///
+ ///
+ /// This method is mostly here for backwards compatibility with
+ /// and unit testing and we may want to remove it in future. In particular its usefulness in
+ /// terms of unit testing is limited in that it preserves the semantics of binding expressions
+ /// as expected by unit tests, not necessarily the semantics that will be used when the
+ /// expression is used as an instantiated in a
+ /// . Unit tests should be migrated to not test the behaviour of
+ /// binding expressions through an observable, and instead test the behaviour of the binding
+ /// when applied to an .
+ ///
+ /// A binding expression may only act as an observable or as a binding expression targeting an
+ /// AvaloniaObject, not both.
+ ///
+ public IAvaloniaSubject ToObservable()
+ {
+ if (_sink is ObservableSink s)
+ return s;
+ if (_sink is not null)
+ throw new InvalidOperationException(
+ "Cannot call AsObservable on a to binding expression which is already " +
+ "instantiated on an AvaloniaObject.");
+
+ var o = new ObservableSink(this);
+ _sink = o;
+ return o;
+ }
+
+ ///
+ /// Produces an observable which can be used to observe the value of the binding expression
+ /// for unit testing.
+ ///
+ /// The .
+ /// An observable subject.
+ ///
+ /// The binding expression is already instantiated on an AvaloniaObject.
+ ///
+ ///
+ /// This method should be considered obsolete and new unit tests should not be written to use
+ /// it. For more information see .
+ ///
+ public IAvaloniaSubject ToObservable(Type targetType)
+ {
+ var o = ToObservable();
+ TargetType = targetType;
+ return o;
+ }
+
+ ///
+ /// Terminates the binding.
+ ///
+ public virtual void Dispose()
+ {
+ if (_sink is null)
+ return;
+
+ Stop();
+
+ var sink = _sink;
+ _sink = null;
+ sink.OnCompleted(this);
+ }
+
+ ///
+ /// Gets the current value of the binding expression.
+ ///
+ ///
+ /// The current value or if the binding was unable
+ /// to read a value.
+ ///
+ ///
+ /// The binding expression has not been started.
+ ///
+ public object? GetValue()
+ {
+ if (!IsRunning)
+ throw new InvalidOperationException("BindingExpression has not been started.");
+ if (_value is null)
+ return AvaloniaProperty.UnsetValue;
+ else if (_value == _nullReference)
+ return null;
+ else if (_value.TryGetTarget(out var value))
+ return value;
+ else
+ return AvaloniaProperty.UnsetValue;
+ }
+
+ ///
+ /// Gets the current value of the binding expression or the default value for the target property.
+ ///
+ ///
+ /// The current value or the target property default.
+ ///
+ public object? GetValueOrDefault()
+ {
+ var result = GetValue();
+ if (result == AvaloniaProperty.UnsetValue)
+ result = GetCachedDefaultValue();
+ return result;
+ }
+
+ ///
+ /// Attaches the binding expression to a subscriber with the specified subscriber but does not
+ /// start it.
+ ///
+ /// The subscriber.
+ /// The target object.
+ /// The target property.
+ /// The priority of the binding.
+ public void Attach(
+ IBindingExpressionSink sink,
+ AvaloniaObject target,
+ AvaloniaProperty targetProperty,
+ BindingPriority priority)
+ {
+ if (_sink is not null)
+ throw new InvalidOperationException("BindingExpression was already instantiated.");
+
+ _sink = sink;
+ _target = new(target);
+ TargetProperty = targetProperty;
+ TargetType = targetProperty.PropertyType;
+ Priority = priority;
+ }
+
+ ///
+ /// Initializes the binding expression with the specified subscriber and target property and
+ /// starts it.
+ ///
+ /// The subscriber.
+ /// The target object.
+ /// The target property.
+ /// The priority of the binding.
+ public void Start(
+ IBindingExpressionSink subscriber,
+ AvaloniaObject target,
+ AvaloniaProperty targetProperty,
+ BindingPriority priority)
+ {
+ Attach(subscriber, target, targetProperty, priority);
+ Start(produceValue: true);
+ }
+
+ ///
+ /// When overridden in a derived class, writes the specified value to the binding source if
+ /// possible.
+ ///
+ /// The value to write.
+ ///
+ /// True if the value could be written to the binding source; otherwise false.
+ ///
+ public abstract bool WriteValueToSource(object? value);
+
+ bool IValueEntry.GetDataValidationState(out BindingValueType state, out Exception? error)
+ {
+ if (_error is not null)
+ {
+ state = _error.ErrorType switch
+ {
+ BindingErrorType.Error => BindingValueType.BindingError,
+ BindingErrorType.DataValidationError => BindingValueType.DataValidationError,
+ _ => throw new InvalidOperationException("Invalid BindingErrorType."),
+ };
+ error = _error.Exception;
+ }
+ else
+ {
+ state = BindingValueType.Value;
+ error = null;
+ }
+
+ return IsDataValidationEnabled;
+ }
+
+ object? IValueEntry.GetValue()
+ {
+ Start(produceValue: false);
+ return GetValueOrDefault();
+ }
+
+ void IValueEntry.Unsubscribe() => Stop();
+
+ ///
+ /// When overridden in a derived class, starts the binding expression.
+ ///
+ ///
+ /// This method should not be called directly; instead call .
+ ///
+ protected abstract void StartCore();
+
+ ///
+ /// When overridden in a derived class, stops the binding expression.
+ ///
+ ///
+ /// This method should not be called directly; instead call .
+ ///
+ protected abstract void StopCore();
+
+ ///
+ /// Publishes a new value and/or error state to the target.
+ ///
+ /// The new value, or .
+ /// The new binding or data validation error.
+ protected void PublishValue(object? value, BindingError? error = null)
+ {
+ // When binding to DataContext and the expression results in a binding error, the binding
+ // expression should produce null rather than UnsetValue in order to not propagate
+ // incorrect DataContexts from parent controls while things are being set up.
+ if (TargetProperty == StyledElement.DataContextProperty &&
+ value == AvaloniaProperty.UnsetValue &&
+ error?.ErrorType == BindingErrorType.Error)
+ {
+ value = null;
+ }
+
+ var hasValueChanged = value != UnchangedValue && !TypeUtilities.IdentityEquals(value, GetValue(), TargetType);
+ var hasErrorChanged = error is not null || _error is not null;
+
+ if (hasValueChanged)
+ _value = value is null ? _nullReference : new(value);
+ _error = error;
+
+ if (!_produceValue || _sink is null)
+ return;
+
+ if (Dispatcher.UIThread.CheckAccess())
+ {
+ _sink.OnChanged(this, hasValueChanged, hasErrorChanged, GetValueOrDefault(), _error);
+ }
+ else
+ {
+ // To avoid allocating closure in the outer scope we need to capture variables
+ // locally. This allows us to skip most of the allocations when on UI thread.
+ var sink = _sink;
+ var vc = hasValueChanged;
+ var ec = hasErrorChanged;
+ var v = GetValueOrDefault();
+ var e = _error;
+ Dispatcher.UIThread.Post(() => sink.OnChanged(this, vc, ec, v, e));
+ }
+ }
+
+ ///
+ /// Starts the binding expression by calling .
+ ///
+ ///
+ /// Indicates whether the binding expression should produce an initial value.
+ ///
+ protected void Start(bool produceValue)
+ {
+ if (_isRunning)
+ return;
+
+ _isRunning = true;
+
+ try
+ {
+ _produceValue = produceValue;
+ StartCore();
+ }
+ finally
+ {
+ _produceValue = true;
+ }
+ }
+
+ ///
+ /// Stops the binding expression by calling .
+ ///
+ protected void Stop()
+ {
+ StopCore();
+ _isRunning = false;
+ _value = null;
+ }
+
+ ///
+ /// Tries to retrieve the target for the binding expression.
+ ///
+ ///
+ /// When this method returns, contains the target object, if it is available.
+ ///
+ /// true if the target was retrieved; otherwise, false.
+ protected bool TryGetTarget([NotNullWhen(true)] out AvaloniaObject? target)
+ {
+ if (_target is not null)
+ return _target.TryGetTarget(out target);
+ target = null!;
+ return false;
+ }
+
+ private object? GetCachedDefaultValue()
+ {
+ if (_isDefaultValueInitialized == true)
+ return _defaultValue;
+
+ if (TargetProperty is not null && _target?.TryGetTarget(out var target) == true)
+ {
+ if (TargetProperty.IsDirect)
+ _defaultValue = ((IDirectPropertyAccessor)TargetProperty).GetUnsetValue(target.GetType());
+ else
+ _defaultValue = ((IStyledPropertyAccessor)TargetProperty).GetDefaultValue(target.GetType());
+
+ _isDefaultValueInitialized = true;
+ return _defaultValue;
+ }
+
+ return AvaloniaProperty.UnsetValue;
+ }
+
+ private sealed class ObservableSink : LightweightObservableBase,
+ IBindingExpressionSink,
+ IAvaloniaSubject
+ {
+ private readonly UntypedBindingExpressionBase _expression;
+ private WeakReference? _value;
+
+ public ObservableSink(UntypedBindingExpressionBase expression) => _expression = expression;
+
+ void IBindingExpressionSink.OnChanged(
+ UntypedBindingExpressionBase instance,
+ bool hasValueChanged,
+ bool hasErrorChanged,
+ object? value,
+ BindingError? error)
+ {
+ if (instance.IsDataValidationEnabled || error is not null)
+ {
+ BindingNotification notification;
+
+ if (error?.ErrorType == BindingErrorType.Error)
+ notification = new(error.Exception, BindingErrorType.Error, value);
+ else if (error?.ErrorType == BindingErrorType.DataValidationError)
+ notification = new(error.Exception, BindingErrorType.DataValidationError, value);
+ else
+ notification = new(value);
+
+ PublishNext(notification);
+ }
+ else if (hasValueChanged)
+ {
+ PublishNext(value);
+ }
+ }
+
+ void IBindingExpressionSink.OnCompleted(UntypedBindingExpressionBase instance) => PublishCompleted();
+
+ void IObserver.OnCompleted() { }
+ void IObserver.OnError(Exception error) { }
+ void IObserver.OnNext(object? value) => _expression.WriteValueToSource(value);
+
+ protected override void Initialize() => _expression.Start(produceValue: true);
+ protected override void Deinitialize() => _expression.Stop();
+
+ protected override void Subscribed(IObserver