internal static Exception DuplicateBindingRegistration(IDataBinding binding)
{
return
(new InvalidOperationException(
string.Format("The binding '{0}' has already been registered, dual registration is not possible.",
binding)));
}
private static void BindingExceptionHandlerImpl(IDataBinding dataBinding, BindingEventArgs bindingEventArgs)
{
if (bindingEventArgs.Exception != null)
{
Tracer.Error(bindingEventArgs.Exception.Message);
}
}
public void Register(object target, string path, IDataBinding binding, IDataContext context = null)
{
_bindingManager.Register(target, path, binding, context);
lock (_bindings)
_bindings.Add(new WeakReference(binding, true));
++BindingCount;
}
internal static Exception WrapBindingException(IDataBinding binding, BindingAction action, Exception exception)
{
string message =
$"A binding error has occurred, when update {(action == BindingAction.UpdateSource ? "source" : "target")}, path '{binding.TargetAccessor.Source.Path}', inner exception '{exception.Message}'";
return(new InvalidOperationException(message, exception));
}
public bool Attach(IDataBinding binding)
{
if (Interlocked.Exchange(ref _state, Attaching) != Available)
{
throw BindingExceptionManager.BehaviorInitialized(this);
}
try
{
_binding = binding;
if (OnAttached())
{
_state = Attached;
return(true);
}
_state = Available;
_binding = null;
return(false);
}
catch (Exception)
{
_state = Available;
_binding = null;
throw;
}
}
/// <summary>
/// Creates a series of instances of <see cref="IDataBinding" />.
/// </summary>
/// <param name="target">The specified binding target.</param>
/// <param name="bindingExpression">The specified binding expression.</param>
/// <param name="sources">The specified sources, if any.</param>
/// <returns>An instance of <see cref="IDataBinding" />.</returns>
public IList <IDataBinding> CreateBindingsFromString(object target, string bindingExpression, IList <object> sources = null)
{
Should.NotBeNull(target, "target");
Should.NotBeNullOrWhitespace(bindingExpression, "bindingExpression");
try
{
IList <IDataContext> parserResult = Parser.Parse(bindingExpression, (sources == null || sources.Count == 0)
? DataContext.Empty
: new DataContext(1)
{
{ BindingBuilderConstants.RawSources, sources }
});
var result = new IDataBinding[parserResult.Count];
for (int index = 0; index < parserResult.Count; index++)
{
IDataContext dataContext = parserResult[index];
dataContext.Add(BindingBuilderConstants.Target, target);
result[index] = BuildBinding(dataContext);
}
return(result);
}
catch (Exception exception)
{
return(new[]
{
CreateInvalidDataBinding(new InvalidOperationException(exception.Message, exception))
});
}
}
public bool Attach(IDataBinding binding)
{
if (BindingServiceProvider.ErrorProvider == null)
return false;
binding.BindingUpdated += BindingUpdatedDelegate;
return true;
}
public virtual void Register(object target, string path, IDataBinding binding, IDataContext context = null)
{
Should.NotBeNull(target, nameof(target));
Should.NotBeNull(path, nameof(path));
Should.NotBeNull(binding, nameof(binding));
var dataBinding = binding as DataBinding;
if (dataBinding == null)
{
if (ServiceProvider.AttachedValueProvider.GetValue <object>(binding, IsRegisteredMember, false) != null)
{
throw BindingExceptionManager.DuplicateBindingRegistration(binding);
}
ServiceProvider.AttachedValueProvider.SetValue(binding, IsRegisteredMember, Empty.TrueObject);
}
else
{
if (dataBinding.IsAssociated)
{
throw BindingExceptionManager.DuplicateBindingRegistration(binding);
}
dataBinding.IsAssociated = true;
}
ServiceProvider
.AttachedValueProvider
.AddOrUpdate(target, BindPrefix + path, binding, UpdateValueFactoryDelegate);
}
protected IDataBinding BuildBinding([NotNull] IDataContext context)
{
try
{
var handler = BindingInitializing;
if (handler != null)
{
handler(this, context);
}
object target;
IBindingPath targetPath;
IDataBinding binding = CreateBinding(context, out target, out targetPath);
if (!binding.IsDisposed)
{
BindingServiceProvider.BindingManager.Register(target, targetPath.Path, binding, context);
}
var initialized = BindingInitialized;
if (initialized != null)
{
initialized(this, binding);
}
return(binding);
}
catch (Exception exception)
{
return(CreateInvalidDataBinding(new InvalidOperationException(exception.Message, exception)));
}
}
internal static Exception WrapBindingException(IDataBinding binding, BindingAction action, Exception exception)
{
var sourcePaths = string.Join(", ", binding.SourceAccessor.Sources.Select(observer => observer.Path));
string message =
$"A binding error has occurred, when update {(action == BindingAction.UpdateSource ? "source" : "target")}, target '{binding.TargetAccessor.Source.Path}', source {sourcePaths}, inner exception '{exception.Message}'";
return(new InvalidOperationException(message, exception));
}
public void AddBinding(IDataBinding binding)
{
lock (_lockBindings)
{
_openBindings.Add(binding);
_bindings.Add(binding);
}
}
public virtual bool IsRegistered(IDataBinding binding)
{
Should.NotBeNull(binding, "binding");
var dataBinding = binding as DataBinding;
if (dataBinding == null)
return ServiceProvider.AttachedValueProvider.GetValue<object>(binding, IsRegisteredMember, false) != null;
return dataBinding.IsAssociated;
}
private void OnBindingException(IDataBinding sender, BindingExceptionEventArgs args)
{
UpdateErrors(new object[]
{
ValidatesOnExceptionsBehavior.ShowOriginalException
? args.OriginalException.Message
: args.Exception.Message
}, null);
}
public bool Attach(IDataBinding binding)
{
if (BindingServiceProvider.ErrorProvider == null)
{
return(false);
}
binding.BindingUpdated += BindingUpdatedDelegate;
return(true);
}
public static IDataBinding ResolvePath(
this IDataBinding dataContext,
string pathString
)
{
Path path = new Path(pathString);
return(dataContext.ResolvePath(path));
}
private static void OnBindingUpdated(IDataBinding sender, BindingEventArgs args)
{
IBindingErrorProvider errorProvider = BindingServiceProvider.ErrorProvider;
if (errorProvider != null)
{
SetErrors(errorProvider, sender, Empty.Array <object>());
}
}
private void OneTimeTargetHandler(IObserver sender, ValueChangedEventArgs args)
{
IDataBinding binding = Binding;
if (binding != null && binding.TargetAccessor.IsAllMembersAvailable() && binding.SourceAccessor.IsAllMembersAvailable())
{
binding.TargetAccessor.Source.ValueChanged -= OneTimeTargetHandler;
binding.UpdateTarget();
}
}
private static void OnBindingException(IDataBinding sender, BindingExceptionEventArgs args)
{
IBindingErrorProvider errorProvider = BindingServiceProvider.ErrorProvider;
if (errorProvider != null)
{
SetErrors(errorProvider, sender,
new object[] { ShowOriginalException?args.OriginalException.Message: args.Exception.Message });
}
}
private static void SetErrors(IBindingErrorProvider errorProvider, IDataBinding sender, object[] errors)
{
IBindingPathMembers pathMembers = sender.TargetAccessor.Source.GetPathMembers(false);
object target = pathMembers.PenultimateValue;
if (target != null && !target.IsUnsetValue())
{
errorProvider.SetErrors(target, Key + pathMembers.Path.Path, errors, sender.Context);
}
}
private void OneTimeSourceHandler(IObserver sender, ValueChangedEventArgs args)
{
IDataBinding binding = Binding;
if (binding != null && binding.TargetAccessor.IsAllMembersAvailable() && binding.SourceAccessor.IsAllMembersAvailable(true))
{
UnsubscribeSources(OneTimeSourceHandler);
binding.UpdateSource();
}
}
public override object ProvideValue(IServiceProvider serviceProvider)
{
var target = serviceProvider.GetService <IProvideValueTarget>();
if (target == null)
{
return(GetEmptyValue());
}
var targetObject = target.TargetObject;
var targetProperty = target.TargetProperty;
if (targetObject == null || targetProperty == null)
{
return(GetEmptyValue());
}
if (!(targetObject is DependencyObject))
{
var type = targetObject.GetType();
if (_sharedDpType == type || "System.Windows.SharedDp".Equals(type.FullName))
{
if (_sharedDpType == null)
{
_sharedDpType = type;
}
return(this);
}
}
#if WPF
if (targetObject is Setter || targetObject is DataTrigger || targetObject is Condition)
#else
if (targetObject is Setter)
#endif
{ return(this); }
if (_targetMemberName == string.Empty)
{
_targetMemberName = GetMemberName(targetObject, targetProperty);
}
if (_targetMemberName == null)
{
return(GetEmptyValue());
}
var isDesignMode = ServiceProvider.IsDesignMode;
IDataBinding binding = HasValue
? CreateBindingBuilder(targetObject, _targetMemberName).Build()
: CreateBinding(targetObject, _targetMemberName, isDesignMode);
if (isDesignMode && binding is InvalidDataBinding)
{
var exception = ((InvalidDataBinding)binding).Exception;
throw new InvalidOperationException(exception.Flatten(true), exception);
}
return(GetDefaultValue(targetObject, targetProperty, binding, _targetMemberName));
}
public virtual void Unregister(IDataBinding binding)
{
Should.NotBeNull(binding, nameof(binding));
object source = binding.TargetAccessor.Source.GetActualSource(false);
string path = binding.TargetAccessor.Source.Path.Path;
if (source != null && path != null)
{
ClearBindings(source, path);
}
}
public virtual bool IsRegistered(IDataBinding binding)
{
Should.NotBeNull(binding, nameof(binding));
var dataBinding = binding as DataBinding;
if (dataBinding == null)
{
return(ServiceProvider.AttachedValueProvider.GetValue <object>(binding, IsRegisteredMember, false) != null);
}
return(dataBinding.IsAssociated);
}
public static T GetOrAddValue <T>(IDataBinding binding, DataConstant <object> constant, Func <T> getValue)
{
object data;
if (!binding.Context.TryGetData(constant, out data))
{
data = getValue();
binding.Context.AddOrUpdate(constant, data);
}
return((T)data);
}
public void Detach(IDataBinding binding)
{
binding.BindingUpdated -= BindingUpdatedDelegate;
var errorProvider = BindingServiceProvider.ErrorProvider;
if (errorProvider == null)
return;
var context = new DataContext(binding.Context);
context.AddOrUpdate(BindingConstants.ClearErrors, true);
SetErrors(errorProvider, binding, Empty.Array<object>(), context);
}
/// <summary>
/// Walks tree of bound properties upwards towards the root.
/// Returns the absolute datapath of this binding.
/// </summary>
/// <param name="dataContext"></param>
/// <returns></returns>
public static Path GetAbsoluteBindingPath(this IDataBinding dataContext)
{
Path path = new Path();
IDataBinding current = dataContext;
while (current != null)
{
path.PathElements.AddFirst(current.LocalPath);
current = current.Parent;
}
return(path);
}
private void SetDefaultValue(IDataBinding dataBinding)
{
var singleAccessor = dataBinding.SourceAccessor as ISingleBindingSourceAccessor;
if (singleAccessor == null)
{
var sources = dataBinding.SourceAccessor.Sources;
for (int index = 0; index < sources.Count; index++)
SetDefaultValue(sources[index]);
}
else
SetDefaultValue(singleAccessor.Source);
}
// THIS IS IGNORING GLOBAL FLAGS
public static IDataBinding ResolvePath(
this IDataBinding dataContext,
Path path
)
{
IDataBinding current = dataContext;
foreach (PathElement pe in path.PathElements)
{
current = current.Step(pe);
}
return(current);
}
private void OneTimeHandler(IBindingSource sender, ValueChangedEventArgs args)
{
IDataBinding binding = Binding;
if (binding == null || !IsSourceAvailable() || !binding.UpdateTarget())
{
return;
}
UnsubscribeSources(OneTimeHandler);
if (_disposeBinding)
{
binding.Dispose();
}
}
private static void ClearBinding(IDataBinding binding)
{
binding.Dispose();
var dataBinding = binding as DataBinding;
if (dataBinding == null)
{
ServiceProvider.AttachedValueProvider.Clear(binding, IsRegisteredMember);
}
else
{
dataBinding.IsAssociated = false;
}
}
/// <summary>
/// Detaches this instance from its associated binding.
/// </summary>
public void Detach(IDataBinding binding)
{
if (_state == Available)
return;
try
{
OnDetached();
}
finally
{
_state = Available;
_binding = null;
}
}
public static void Init(IDataBinding dataBinding)
{
var a = new ExternalInput <string>();
var b = a.Select(v => v.Length).Select(v => (double)v).Average();
var r = b.Select(v => "(" + v + ")");
var z = r.Select(v => (long)v.Length).Sum();
var c = r.Count();
var x = a.Where(v => v.StartsWith("a")).Distinct();
dataBinding.Set(a, "a");
dataBinding.Set(b, "b");
dataBinding.Set(x, "x");
dataBinding.Set(z, "z");
dataBinding.Set(c, "c");
}
public void Detach(IDataBinding binding)
{
binding.BindingUpdated -= BindingUpdatedDelegate;
var errorProvider = BindingServiceProvider.ErrorProvider;
if (errorProvider == null)
{
return;
}
var context = new DataContext(binding.Context);
context.AddOrUpdate(BindingConstants.ClearErrors, true);
SetErrors(errorProvider, binding, Empty.Array <object>(), context);
}
/// <summary>
/// Builds an instance of <see cref="IDataBinding" />.
/// </summary>
/// <returns>
/// The builded <see cref="IDataBinding" />.
/// </returns>
protected IDataBinding BuildBinding([NotNull] IDataContext context)
{
try
{
object target;
IBindingPath targetPath;
IDataBinding binding = CreateBinding(context, out target, out targetPath);
BindingServiceProvider.BindingManager.Register(target, targetPath.Path, binding);
return(binding);
}
catch (Exception exception)
{
return(CreateInvalidDataBinding(new InvalidOperationException(exception.Message, exception)));
}
}
public bool Attach(IDataBinding binding)
{
if (_checkTwoWay && binding.Behaviors.Any(behavior => behavior is TwoWayBindingMode))
{
return(false);
}
if (_isTarget)
{
binding.TargetAccessor.DisableEqualityChecking = _value;
}
else
{
binding.SourceAccessor.DisableEqualityChecking = _value;
}
return(false);
}
public virtual void Register(object target, string path, IDataBinding binding, IDataContext context = null)
{
Should.NotBeNull(target, "target");
Should.NotBeNull(path, "path");
Should.NotBeNull(binding, "binding");
var dataBinding = binding as DataBinding;
if (dataBinding == null)
{
if (ServiceProvider.AttachedValueProvider.GetValue<object>(binding, IsRegisteredMember, false) != null)
throw BindingExceptionManager.DuplicateBindingRegistration(binding);
ServiceProvider.AttachedValueProvider.SetValue(binding, IsRegisteredMember, Empty.TrueObject);
}
else
{
if (dataBinding.IsAssociated)
throw BindingExceptionManager.DuplicateBindingRegistration(binding);
dataBinding.IsAssociated = true;
}
ServiceProvider
.AttachedValueProvider
.AddOrUpdate(target, BindPrefix + path, binding, UpdateValueFactoryDelegate);
}
/// <summary>
/// Attaches to the specified binding.
/// </summary>
/// <param name="binding">The binding to attach to.</param>
public bool Attach(IDataBinding binding)
{
if (Interlocked.Exchange(ref _state, Attaching) != Available)
throw BindingExceptionManager.BehaviorInitialized(this);
try
{
_binding = binding;
if (OnAttached())
{
_state = Attached;
return true;
}
_state = Available;
_binding = null;
return false;
}
catch (Exception)
{
_state = Available;
_binding = null;
throw;
}
}
protected virtual void AddBehaviors(IDataBinding binding, IDataContext context)
{
List<IBindingBehavior> behaviors = context.GetData(BindingBuilderConstants.Behaviors);
if (behaviors == null || behaviors.Count == 0)
{
for (int index = 0; index < _defaultBehaviors.Count; index++)
binding.Behaviors.Add(_defaultBehaviors[index].Clone());
return;
}
int count = behaviors.Count;
for (int index = 0; index < _defaultBehaviors.Count; index++)
{
IBindingBehavior behavior = _defaultBehaviors[index];
bool hasBehavior = false;
for (int i = 0; i < count; i++)
{
if (behaviors[i].Id == behavior.Id)
{
hasBehavior = true;
break;
}
}
if (!hasBehavior)
behaviors.Add(behavior.Clone());
}
behaviors.Sort(BehaviorComparer);
for (int index = 0; index < behaviors.Count; index++)
binding.Behaviors.Add(behaviors[index]);
}
protected virtual object GetDefaultValue(object targetObject, object targetProperty, IDataBinding binding, string targetPath)
{
#if WPF
var dp = targetProperty as DependencyProperty;
if (dp != null)
return ((DependencyObject)targetObject).GetValue(dp);
#endif
var eventInfo = targetProperty as EventInfo;
if (eventInfo != null)
return CreateDelegateForEvent(eventInfo);
if (_targetMemberInfo == null)
_targetMemberInfo = BindingServiceProvider
.MemberProvider
.GetBindingMember(targetObject.GetType(), targetPath, false, false);
if (_targetMemberInfo == null)
return GetEmptyValue();
#if WPF
eventInfo = _targetMemberInfo.Member as EventInfo;
if (eventInfo != null)
return CreateDelegateForEvent(eventInfo);
#endif
return _targetMemberInfo.GetValue(targetObject, null);
}
public void Unregister(IDataBinding binding)
{
_bindingManager.Unregister(binding);
}
bool IBindingBehavior.Attach(IDataBinding binding)
{
return Attach(binding);
}
public bool Attach(IDataBinding binding)
{
if (_checkTwoWay && binding.Behaviors.Any(behavior => behavior is TwoWayBindingMode))
return false;
if (_isTarget)
binding.TargetAccessor.DisableEqualityChecking = _value;
else
binding.SourceAccessor.DisableEqualityChecking = _value;
return false;
}
private static void SetErrors(IBindingErrorProvider errorProvider, IDataBinding sender, object[] errors, IDataContext context)
{
IBindingPathMembers pathMembers = sender.TargetAccessor.Source.GetPathMembers(false);
object target = pathMembers.PenultimateValue;
if (target != null && !target.IsUnsetValue())
errorProvider.SetErrors(target, Key + pathMembers.Path.Path, errors, context ?? sender.Context);
}
private static void OnBindingUpdated(IDataBinding sender, BindingEventArgs args)
{
if (args.Exception == null)
{
IBindingErrorProvider errorProvider = BindingServiceProvider.ErrorProvider;
if (errorProvider != null)
SetErrors(errorProvider, sender, Empty.Array<object>(), null);
}
else
{
IBindingErrorProvider errorProvider = BindingServiceProvider.ErrorProvider;
if (errorProvider != null)
SetErrors(errorProvider, sender,
new object[] { ShowOriginalException ? args.OriginalException.Message : args.Exception.Message }, null);
}
}
private static void OnBindingUpdated(IDataBinding sender, BindingEventArgs args)
{
IBindingErrorProvider errorProvider = BindingServiceProvider.ErrorProvider;
if (errorProvider != null)
SetErrors(errorProvider, sender, Empty.Array<object>(), null);
}
void IBindingBehavior.Detach(IDataBinding binding)
{
Detach(binding);
}
private static void BindingExceptionHandlerImpl(IDataBinding dataBinding, BindingEventArgs bindingEventArgs)
{
if (bindingEventArgs.Exception != null)
Tracer.Error(bindingEventArgs.Exception.Message);
}
public static void RaiseBindingException(IDataBinding binding, BindingEventArgs args)
{
BindingExceptionHandler?.Invoke(binding, args);
}
internal static Exception DuplicateBindingRegistration(IDataBinding binding)
{
return new InvalidOperationException($"The binding '{binding}' has already been registered, dual registration is not possible.");
}
internal static Exception WrapBindingException(IDataBinding binding, BindingAction action, Exception exception)
{
string message =
$"A binding error has occurred, when update {(action == BindingAction.UpdateSource ? "source" : "target")}, path '{binding.TargetAccessor.Source.Path}', inner exception '{exception.Message}'";
return new InvalidOperationException(message, exception);
}
public IList<IDataBinding> CreateBindingsFromString(object target, string bindingExpression, IList<object> sources = null)
{
Should.NotBeNull(target, "target");
Should.NotBeNullOrWhitespace(bindingExpression, "bindingExpression");
try
{
IList<IDataContext> parserResult = Parser.Parse(bindingExpression, DataContext.Empty, target, sources);
var result = new IDataBinding[parserResult.Count];
for (int index = 0; index < parserResult.Count; index++)
result[index] = BuildBinding(parserResult[index]);
return result;
}
catch (Exception exception)
{
return new[]
{
CreateInvalidDataBinding(new InvalidOperationException(exception.Message, exception))
};
}
}
/// <summary>
/// Attaches to the specified binding.
/// </summary>
/// <param name="binding">The binding to attach to.</param>
bool IBindingBehavior.Attach(IDataBinding binding)
{
return true;
}
private static void ClearBinding(IDataBinding binding)
{
binding.Dispose();
var dataBinding = binding as DataBinding;
if (dataBinding == null)
ServiceProvider.AttachedValueProvider.Clear(binding, IsRegisteredMember);
else
dataBinding.IsAssociated = false;
}
private static IDataBinding UpdateValueFactory(object o, IDataBinding dataBinding, IDataBinding arg3, object state)
{
ClearBinding(arg3);
return dataBinding;
}
public virtual void Unregister(IDataBinding binding)
{
Should.NotBeNull(binding, "binding");
object source = binding.TargetAccessor.Source.GetActualSource(false);
string path = binding.TargetAccessor.Source.Path.Path;
if (source != null && path != null)
ClearBindings(source, path);
}
public void Detach(IDataBinding binding)
{
}
public bool IsRegistered(IDataBinding binding)
{
return _bindingManager.IsRegistered(binding);
}
private static void OnBindingException(IDataBinding sender, BindingExceptionEventArgs args)
{
IBindingErrorProvider errorProvider = BindingServiceProvider.ErrorProvider;
if (errorProvider != null)
SetErrors(errorProvider, sender,
new object[] { ShowOriginalException ? args.OriginalException.Message : args.Exception.Message }, null);
}
private void OnBindingException(IDataBinding sender, BindingEventArgs args)
{
if (args.Exception == null || args.OriginalException == null)
return;
UpdateErrors(new object[]
{
ValidatesOnExceptionsBehavior.ShowOriginalException
? args.OriginalException.Message
: args.Exception.Message
}, null);
}
