public virtual void BindingShouldUpdateTargetWithBindingContext() { bool isInvoked = false; IBindingPath path = BindingPath.Create("test"); var bindingManager = new BindingManager(); var target = new BindingSourceAccessorMock { Source = new ObserverMock { GetActualSource = b => new object(), Path = path } }; var source = new BindingSourceAccessorMock { Source = new ObserverMock { IsValid = b => true } }; DataBinding binding = CreateDataBinding(target, source, bindingManager); target.SetValue = (func, context, arg3) => { context.ShouldEqual(binding.Context); arg3.ShouldBeTrue(); isInvoked = true; return(true); }; binding.UpdateTarget(); isInvoked.ShouldBeTrue(); }
public virtual void BindingShouldRaiseEventWhenUpdateSourceFalse() { bool isInvoked = false; IBindingPath path = BindingPath.Create("test"); var bindingManager = new BindingManager(); var target = new BindingSourceAccessorMock { Source = new ObserverMock { GetActualSource = b => new object(), Path = path } }; var source = new BindingSourceAccessorMock(); DataBinding binding = CreateDataBinding(target, source, bindingManager); source.SetValue = (func, context, arg3) => false; binding.BindingUpdated += (sender, args) => { args.Action.ShouldEqual(BindingAction.UpdateSource); args.Result.ShouldBeFalse(); isInvoked = true; }; binding.UpdateSource(); isInvoked.ShouldBeTrue(); }
public virtual void BindingShouldCallAttachDetachMethodInBehavior() { IBindingPath path = BindingPath.Create("test"); var bindingManager = new BindingManager(); var target = new BindingSourceAccessorMock { Source = new ObserverMock { GetActualSource = b => new object(), Path = path } }; var source = new BindingSourceAccessorMock(); DataBinding binding = CreateDataBinding(target, source, bindingManager); int countAttach = 0; int countDetach = 0; var first = new BindingBehaviorMock { Id = Guid.Empty, Attach = binding1 => { countAttach++; return(true); }, Detach = binding1 => countDetach++ }; binding.Behaviors.Add(first); countAttach.ShouldEqual(1); countDetach.ShouldEqual(0); binding.Behaviors.Remove(first); countAttach.ShouldEqual(1); countDetach.ShouldEqual(1); }
public void ProviderShouldReturnMultiPathObserverMultiPath() { var target = new BindingSourceModel(); var observerProvider = Cretate(); observerProvider.Observe(target, BindingPath.Create(GetMemberPath(target, model => model.NestedModel.IntProperty)), false).ShouldBeType <MultiPathObserver>(); }
public virtual void BindingShouldRaiseExceptionEventWhenUpdateSourceThrowException() { bool isInvoked = false; IBindingPath path = BindingPath.Create("test"); var bindingManager = new BindingManager(); var target = new BindingSourceAccessorMock { Source = new ObserverMock { GetActualSource = b => new object(), Path = path, IsValid = b => true } }; var source = new BindingSourceAccessorMock(); DataBinding binding = CreateDataBinding(target, source, bindingManager); source.SetValue = (func, context, arg3) => { throw new TestException(); }; binding.BindingException += (sender, args) => { args.Action.ShouldEqual(BindingAction.UpdateSource); args.Exception.InnerException.ShouldBeType <TestException>(); isInvoked = true; }; binding.UpdateSource(); isInvoked.ShouldBeTrue(); }
private IExpressionNode VisitExpression(IExpressionNode node) { var nodes = new List <IExpressionNode>(); string memberName = node.TryGetMemberName(true, true, nodes); if (memberName == null) { _isMulti = true; return(node); } if (nodes[0] is ResourceExpressionNode) { return(GetResourceMember(node, memberName, nodes)); } IBindingPath path = BindingPath.Create(memberName); if (path.IsEmpty) { return(GetOrAddBindingMember(memberName, (s, i) => new BindingMemberExpressionNode(memberName, s, i))); } string firstMember = path.Parts[0]; if (_lamdaParameters.Contains(firstMember)) { return(node); } return(GetOrAddBindingMember(memberName, (s, i) => new BindingMemberExpressionNode(memberName, s, i))); }
public BindingContextSource(object source, IBindingMemberInfo member) { _member = member; _observer = BindingServiceProvider .ObserverProvider .Observe(source, BindingPath.Create(member.Path), true); _observer.Listener = this; }
protected virtual ISingleBindingSourceAccessor GetAccessor(object model, string path, IDataContext context, bool isSource) { var observer = new MultiPathObserver(model, BindingPath.Create(path), false); var source = isSource ? new BindingSource(observer) : new BindingTarget(observer); return(new BindingSourceAccessor(source, context, !isSource)); }
public void SourceShouldReturnPathFromObserver() { var mock = new ObserverMock(); BindingSource target = CreateBindingSource(mock); target.Path.ShouldBeNull(); mock.Path = BindingPath.Create("test"); target.Path.ShouldEqual(mock.Path); }
private IExpressionNode GetResourceMember(IExpressionNode node, string memberName, IList <IExpressionNode> nodes) { IExpressionNode staticValue; if (_staticNodes.TryGetValue(node, out staticValue)) { return(staticValue); } IBindingPath path = BindingPath.Create(memberName); string firstMember = path.Parts[0]; Type type = BindingServiceProvider.ResourceResolver.ResolveType(firstMember, DataContext.Empty, false); var dynMember = (ResourceExpressionNode)nodes[0]; if (dynMember.Dynamic && type == null) { memberName = BindingExtensions.MergePath(path.Parts.Skip(1).ToArray()); return(GetOrAddBindingMember("$" + path.Path, (s, i) => new BindingMemberExpressionNode(firstMember, memberName, s, i))); } bool dynamicMember = false; IExpressionNode firstMemberNode = nodes[1]; if (!_staticNodes.TryGetValue(firstMemberNode, out staticValue)) { if (type == null) { IBindingResourceObject resourceObject = BindingServiceProvider .ResourceResolver .ResolveObject(firstMember, DataContext.Empty, true); var dynamicObject = resourceObject.Value as IDynamicObject; if (dynamicObject == null || path.Parts.Count <= 1) { staticValue = new ConstantExpressionNode(resourceObject.Value, resourceObject.Type); } else { staticValue = new ConstantExpressionNode(dynamicObject.GetMember(path.Parts[1], Empty.Array <object>())); dynamicMember = true; } } else { staticValue = new ConstantExpressionNode(type, typeof(Type)); } _staticNodes[firstMemberNode] = staticValue; if (dynamicMember) { _staticNodes[nodes[2]] = staticValue; } } if (firstMemberNode == node || (dynamicMember && node == nodes[2])) { return(staticValue); } return(node); }
public static IBindingToSyntax Bind([NotNull] this IBindingBuilder builder, [NotNull] object target, [NotNull] string targetPath) { Should.NotBeNull(builder, "builder"); Should.NotBeNull(target, "target"); Should.NotBeNullOrWhitespace(targetPath, "targetPath"); builder.Add(BindingBuilderConstants.Target, target); builder.Add(BindingBuilderConstants.TargetPath, BindingPath.Create(targetPath)); return(builder.GetOrAddSyntaxBuilder()); }
protected virtual ISingleBindingSourceAccessor GetAccessor(object model, string path, IDataContext context, bool isSource, Func<IDataContext, object> commandParameterDelegate = null) { var source = new MultiPathObserver(model, BindingPath.Create(path), false); if (commandParameterDelegate != null) { context = context.ToNonReadOnly(); context.AddOrUpdate(BindingBuilderConstants.CommandParameter, commandParameterDelegate); } return new BindingSourceAccessor(source, context, !isSource); }
public virtual void BindingShouldSuppressCycle() { var cycleItem1 = new CycleItem(); var cycleItem2 = new CycleItem(); var dataBinding = CreateDataBinding( new BindingSourceAccessor(new SinglePathObserver(cycleItem1, BindingPath.Create("Property"), true), DataContext.Empty, true), new BindingSourceAccessor(new SinglePathObserver(cycleItem2, BindingPath.Create("Property"), true), DataContext.Empty, false)); dataBinding.Behaviors.Add(new TwoWayBindingMode()); cycleItem2.Property = 10; Tracer.Warn("Item1: {0}, Item2: {1}", cycleItem1.Property, cycleItem2.Property); }
public virtual void BindingShouldBeRegisteredInBindingManager() { var target = new object(); IBindingPath path = BindingPath.Create("test"); var bindingManager = new BindingManager(); DataBinding binding = CreateDataBinding( new BindingSourceAccessorMock { Source = new ObserverMock { GetActualSource = b => target, Path = path } }, new BindingSourceAccessorMock(), bindingManager); bindingManager.Register(target, path.Path, binding); bindingManager.GetBindings(target).Single().ShouldEqual(binding); bindingManager.GetBindings(target, path.Path).Single().ShouldEqual(binding); }
public virtual void BindingShouldCorrectInitializeProperties() { IBindingPath path = BindingPath.Create("test"); var bindingManager = new BindingManager(); var target = new BindingSourceAccessorMock { Source = new ObserverMock { GetActualSource = b => new object(), Path = path } }; var source = new BindingSourceAccessorMock(); DataBinding binding = CreateDataBinding(target, source, bindingManager); binding.TargetAccessor.ShouldEqual(target); binding.SourceAccessor.ShouldEqual(source); binding.Behaviors.ShouldBeEmpty(); }
public static object GetValueFromPath(object src, string strPath, int firstMemberIndex = 0) { IBindingPath path = BindingPath.Create(strPath); for (int index = firstMemberIndex; index < path.Parts.Count; index++) { var item = path.Parts[index]; if (src == null) { return(null); } IBindingMemberInfo member = BindingServiceProvider .MemberProvider .GetBindingMember(src.GetType(), item, false, true); src = member.GetValue(src, null); } return(src); }
public virtual void BindingShouldAddSelfToDataContext() { IBindingPath path = BindingPath.Create("test"); var bindingManager = new BindingManager(); var target = new BindingSourceAccessorMock { Source = new ObserverMock { GetActualSource = b => new object(), Path = path } }; var source = new BindingSourceAccessorMock(); DataBinding binding = CreateDataBinding(target, source, bindingManager); var dataContext = binding.Context; dataContext.Count.ShouldEqual(1); dataContext.GetData(BindingConstants.Binding).ShouldEqual(binding); }
public virtual void BindingShouldNotAddSameBehavior() { IBindingPath path = BindingPath.Create("test"); var bindingManager = new BindingManager(); var target = new BindingSourceAccessorMock { Source = new ObserverMock { GetActualSource = b => new object(), Path = path } }; var source = new BindingSourceAccessorMock(); DataBinding binding = CreateDataBinding(target, source, bindingManager); var first = new BindingBehaviorMock { Id = Guid.Empty, Attach = binding1 => true }; binding.Behaviors.Add(first); ShouldThrow(() => binding.Behaviors.Add(first)); }
public virtual void BindingShouldThrowExceptionDuplicateIdBehavior() { IBindingPath path = BindingPath.Create("test"); var bindingManager = new BindingManager(); var target = new BindingSourceAccessorMock { Source = new BindingSourceMock { GetSource = b => new object(), Path = path } }; var source = new BindingSourceAccessorMock(); DataBinding binding = CreateDataBinding(target, source, bindingManager); var first = new BindingBehaviorMock { Id = Guid.Empty, Attach = binding1 => true }; var second = new BindingBehaviorMock { Id = Guid.Empty, Attach = binding1 => true }; binding.Behaviors.Add(first); ShouldThrow(() => binding.Behaviors.Add(second)); }
protected virtual IObserver CreateObserver(object source, string path, bool ignoreContext, IBindingMemberProvider memberProvider = null, IBindingContextManager contextManager = null) { if (memberProvider != null) { BindingServiceProvider.MemberProvider = memberProvider; } if (contextManager != null) { BindingServiceProvider.ContextManager = contextManager; } var bindingPath = BindingPath.Create(path); if (bindingPath.IsEmpty) { return(new EmptyPathObserver(source, bindingPath)); } if (bindingPath.IsSingle) { return(new SinglePathObserver(source, bindingPath, ignoreContext)); } return(new MultiPathObserver(source, bindingPath, ignoreContext)); }
public virtual void BindingShouldNotAddBehaviorIfAttachReturnsFalse() { IBindingPath path = BindingPath.Create("test"); var bindingManager = new BindingManager(); var target = new BindingSourceAccessorMock { Source = new ObserverMock { GetActualSource = b => new object(), Path = path } }; var source = new BindingSourceAccessorMock(); DataBinding binding = CreateDataBinding(target, source, bindingManager); var first = new BindingBehaviorMock { Id = Guid.Empty, Attach = binding1 => false }; binding.Behaviors.Add(first); binding.Behaviors.Count.ShouldEqual(0); binding.Behaviors.Contains(first).ShouldBeFalse(); }
public void ManagerShouldClearBindingIfBindingIsRegistered() { const string path = "test"; var target = new object(); var bindingMock = new DataBindingMock { TargetAccessor = new BindingSourceAccessorMock { Source = new ObserverMock { Path = BindingPath.Create(path), GetActualSource = b => target } } }; var manager = GetBindingManager(); manager.Register(target, path, bindingMock); manager.IsRegistered(bindingMock).ShouldBeTrue(); manager.Unregister(bindingMock); manager.IsRegistered(bindingMock).ShouldBeFalse(); bindingMock.IsDisposed.ShouldBeTrue(); }
private static IObserver CreateSource(object model, string path) { return(new MultiPathObserver(model, BindingPath.Create(path), false)); }
private static IBindingSource CreateSource(object model, string path) { var observer = new MultiPathObserver(model, BindingPath.Create(path), false); return(new BindingSource(observer)); }
/// <summary> /// Updates the relative source value. /// </summary> public void UpdateSource([NotNull] object target) { if (target == null) { throw BindingExceptionManager.InvalidBindingTarget(RelativeSourceNode.Path); } var path = RelativeSourceNode.Path ?? String.Empty; if (!String.IsNullOrEmpty(Path)) { path = BindingExtensions.MergePath(path, Path); } if (RelativeSourceNode.Type != RelativeSourceExpressionNode.SelfType) { if (RelativeSourceNode.Type == RelativeSourceExpressionNode.MemberSourceType) { target = BindingServiceProvider.ContextManager.GetBindingContext(target); } else { target = new ParentSourceValue(target, RelativeSourceNode); } } IObserver observer = BindingServiceProvider.ObserverProvider.Observe(target, BindingPath.Create(path), false); _bindingSource = new BindingSource(observer); }
public static IBindingModeInfoBehaviorSyntax ToSelf([NotNull] this IBindingToSyntax syntax, [NotNull] string selfPath) { Should.NotBeNull(selfPath, "selfPath"); return(syntax.ToSource(context => { object target = context.GetData(BindingBuilderConstants.Target, true); return new BindingSource(BindingServiceProvider.ObserverProvider.Observe(target, BindingPath.Create(selfPath), false)); })); }
public static IBindingModeInfoBehaviorSyntax To([NotNull] this IBindingToSyntax syntax, [NotNull] string sourcePath) { Should.NotBeNull(sourcePath, "sourcePath"); return(syntax.ToSource(context => { IBindingContext bindingContext = BindingServiceProvider .ContextManager .GetBindingContext(context.GetData(BindingBuilderConstants.Target, true), context.GetData(BindingBuilderConstants.TargetPath, true).Path); IObserver observer = BindingServiceProvider.ObserverProvider.Observe(bindingContext, BindingPath.Create(sourcePath), false); return new BindingSource(observer); })); }
public static IBindingModeInfoBehaviorSyntax To([NotNull] this IBindingToSyntax syntax, [NotNull] object source, [NotNull] string sourcePath) { Should.NotBeNull(source, "source"); Should.NotBeNull(sourcePath, "sourcePath"); return(syntax.ToSource(context => { IObserver observer = BindingServiceProvider.ObserverProvider.Observe(source, BindingPath.Create(sourcePath), false); return new BindingSource(observer); })); }
protected virtual IBindingPath GetBindingPath(string path) { return(BindingPath.Create(path)); }