public void FieldInjectionFromSingleInstanceOfType() { ImplWithInstanceIndex.instanceCount = 0; BindingBuilder bb = new BindingBuilder(); bb.BindTypeToSingleInstance(typeof(ImplWithInstanceIndex)); Injector injector = UniInjectUtils.CreateInjector(); injector.AddBindings(bb); NeedsFieldInjection needsInjection1 = injector.CreateAndInject <NeedsFieldInjection>(); NeedsFieldInjection needsInjection2 = injector.CreateAndInject <NeedsFieldInjection>(); NeedsFieldInjection needsInjection3 = injector.CreateAndInject <NeedsFieldInjection>(); // Assert injection was successful Assert.NotNull(needsInjection1); Assert.NotNull(needsInjection2); Assert.NotNull(needsInjection3); // Assert only one instance was created Assert.AreEqual(1, needsInjection1.implWithInstanceCounter.instanceIndex); Assert.AreEqual(1, needsInjection2.implWithInstanceCounter.instanceIndex); Assert.AreEqual(1, needsInjection3.implWithInstanceCounter.instanceIndex); Assert.AreEqual(1, ImplWithInstanceIndex.instanceCount); }
public void Describe(DescribeSortCriterionContext describe) { var builder = new BindingBuilder(); foreach (var bindingProvider in _bindingProviders) { bindingProvider.GetMemberBindings(builder); } var groupedMembers = builder.Build().GroupBy(b => b.Property.DeclaringType).ToDictionary(b => b.Key, b => b); foreach (var typeMembers in groupedMembers.Keys) { var descriptor = describe.For(typeMembers.Name, new LocalizedString(typeMembers.Name.CamelFriendly()), T("Members for {0}", typeMembers.Name)); foreach (var member in groupedMembers[typeMembers]) { var closureMember = member; descriptor.Element(member.Property.Name, member.DisplayName, member.Description, context => ApplyFilter(context, closureMember.Property), context => DisplaySortCriterion(context, closureMember.DisplayName.Text), SortCriterionFormProvider.FormName ); } } }
public void TestSendAndReceiveWithFanout() { var admin = new RabbitAdmin(this.connectionFactory); var exchange = new FanoutExchange("fanout"); admin.DeclareExchange(exchange); this.template.Exchange = exchange.Name; admin.DeclareBinding(BindingBuilder.Bind(queue).To(exchange)); this.template.Execute <object>( delegate { var consumer = this.CreateConsumer(this.template); var tag = consumer.ConsumerTag; Assert.IsNotNull(tag); try { this.template.ConvertAndSend("message"); var result = this.GetResult(consumer); Assert.AreEqual("message", result); } finally { consumer.Stop(); } return(null); }); }
public void TestSendAndReceiveWithTopicConsumeInBackground() { var admin = new RabbitAdmin(this.connectionFactory); var exchange = new TopicExchange("topic"); admin.DeclareExchange(exchange); this.template.Exchange = exchange.Name; admin.DeclareBinding(BindingBuilder.Bind(queue).To(exchange).With("*.end")); var template = new RabbitTemplate(new CachingConnectionFactory()); template.Exchange = exchange.Name; var consumer = this.template.Execute( delegate { var consumerinside = this.CreateConsumer(template); var tag = consumerinside.ConsumerTag; Assert.IsNotNull(tag); return(consumerinside); }); template.ConvertAndSend("foo", "message"); var result = this.GetResult(consumer); Assert.AreEqual(null, result); this.template.ConvertAndSend("foo.end", "message"); result = this.GetResult(consumer); Assert.AreEqual("message", result); consumer.Stop(); }
public void FieldInjectionFromNewInstancesOfType() { ImplWithInstanceIndex.instanceCount = 0; BindingBuilder bb = new BindingBuilder(); bb.BindTypeToNewInstances(typeof(ImplWithInstanceIndex)); Injector injector = UniInjectUtils.CreateInjector(); injector.AddBindings(bb); NeedsFieldInjection needsInjection1 = injector.CreateAndInject <NeedsFieldInjection>(); NeedsFieldInjection needsInjection2 = injector.CreateAndInject <NeedsFieldInjection>(); NeedsFieldInjection needsInjection3 = injector.CreateAndInject <NeedsFieldInjection>(); // Assert injection was successful Assert.NotNull(needsInjection1); Assert.NotNull(needsInjection2); Assert.NotNull(needsInjection3); // Assert that different instances were injected. Assert.AreEqual(1, needsInjection1.implWithInstanceCounter.instanceIndex); Assert.AreEqual(2, needsInjection2.implWithInstanceCounter.instanceIndex); Assert.AreEqual(3, needsInjection3.implWithInstanceCounter.instanceIndex); Assert.AreEqual(3, ImplWithInstanceIndex.instanceCount); }
// ------------------------------------------------------------ // IBindingRoot // ------------------------------------------------------------ /// <summary> /// /// </summary> /// <typeparam name="T"></typeparam> /// <returns></returns> public IBindingToSyntax <T> Bind <T>() { var builder = new BindingBuilder <T>(typeof(T)); bindingFactories.Add(builder); return(builder); }
/// <inheritdoc/> public IBindingCollection DiscoverAndSetupBindings() { _logger.Trace("Discover and setup bindings"); var bindingCollections = new ConcurrentBag <IBindingCollection>(); var allTypes = _typeFinder.All; _logger.Trace("Find all binding conventions"); var conventionTypes = _typeFinder.FindMultiple <IBindingConvention>(); _scheduler.PerformForEach(conventionTypes, (Action <Type>)(conventionType => { _logger.Trace((string)$"Handle convention type {conventionType.AssemblyQualifiedName}"); var convention = _bootContainer.Get(conventionType) as IBindingConvention; var servicesToResolve = allTypes.Where(service => convention.CanResolve(service)); var bindings = new ConcurrentBag <Binding>(); _scheduler.PerformForEach(servicesToResolve, service => { var bindingBuilder = new BindingBuilder(Binding.For(service)); convention.Resolve(service, bindingBuilder); bindings.Add(bindingBuilder.Build()); }); var bindingCollection = new BindingCollection(bindings); bindingCollections.Add(bindingCollection); })); var aggregatedBindingCollection = new BindingCollection(bindingCollections.ToArray()); return(aggregatedBindingCollection); }
public IList <IBindingBuilder> CreateBuildersFromString(object target, string bindingExpression, IList <object> sources = null, IDataContext context = null) { Should.NotBeNull(target, nameof(target)); Should.NotBeNull(bindingExpression, nameof(bindingExpression)); try { var parserResult = Parser.Parse(target, bindingExpression, sources, context); var result = new IBindingBuilder[parserResult.Count]; for (int index = 0; index < parserResult.Count; index++) { var builder = new BindingBuilder(parserResult[index]); builder.Add(BindingBuilderConstants.BuildDelegate, _buildDelegate); result[index] = builder; } return(result); } catch (Exception exception) { exception = new InvalidOperationException(exception.Message, exception); var builder = new BindingBuilder(); builder.Add(BindingBuilderConstants.Target, target); builder.Add(ProviderConstant, this); builder.Add(ExceptionConstant, exception); builder.Add(BindingBuilderConstants.BuildDelegate, CreateInvalidaDataBindingDelegate); return(new IBindingBuilder[] { builder }); } }
private void RebindQueue(string routingKey) { var ctx = ContextRegistry.GetContext(); var factory = ctx.GetObject("ConnectionFactory") as IConnectionFactory; try { IAmqpAdmin amqpAdmin = new RabbitAdmin(factory); TopicExchange mktDataExchange = new TopicExchange("APP.STOCK.MARKETDATA", false, false); Spring.Messaging.Amqp.Core.Queue mktDataQueue = new Spring.Messaging.Amqp.Core.Queue("APP.STOCK.MARKETDATA"); if (!string.IsNullOrEmpty(_currentBinding)) { amqpAdmin.RemoveBinding(BindingBuilder.Bind(mktDataQueue).To(mktDataExchange).With(_currentBinding)); } _currentBinding = routingKey; if (!string.IsNullOrEmpty(_currentBinding)) { amqpAdmin.DeclareBinding(BindingBuilder.Bind(mktDataQueue).To(mktDataExchange).With(_currentBinding)); txtRoutingKey.Text = _currentBinding; } } catch (Exception ex) { log.ErrorFormat("Uncaught application exception.", ex); } }
private void ReadScope(XElement element, BindingBuilder<object> builder) { XAttribute scopeAttribute = element.Attribute("scope"); if (scopeAttribute == null || String.IsNullOrEmpty(scopeAttribute.Value)) { builder.InTransientScope(); return; } string value = scopeAttribute.Value.ToLower(); switch (value) { case "transient": builder.InTransientScope(); break; case "singleton": builder.InSingletonScope(); break; case "thread": builder.InThreadScope(); break; case "request": builder.InRequestScope(); break; default: throw new ConfigurationErrorsException(String.Format("The 'bind' element has an unknown value '{0}' for its 'scope' attribute. Valid values are transient, singleton, thread, and request.", value)); } }
public List <IBinding> GetBindings() { BindingBuilder bb = new BindingBuilder(); bb.BindTypeToNewInstances(typeof(DeleteNotesAction)); bb.BindTypeToNewInstances(typeof(SplitNotesAction)); bb.BindTypeToNewInstances(typeof(MergeNotesAction)); bb.BindTypeToNewInstances(typeof(SetNoteTypeAction)); bb.BindTypeToNewInstances(typeof(AddNoteAction)); bb.BindTypeToNewInstances(typeof(MoveNoteToAjacentSentenceAction)); bb.BindTypeToNewInstances(typeof(MoveNotesToOtherVoiceAction)); bb.BindTypeToNewInstances(typeof(MoveNotesAction)); bb.BindTypeToNewInstances(typeof(ExtendNotesAction)); bb.BindTypeToNewInstances(typeof(ToggleNoteTypeAction)); bb.BindTypeToNewInstances(typeof(DeleteSentencesAction)); bb.BindTypeToNewInstances(typeof(MergeSentencesAction)); bb.BindTypeToNewInstances(typeof(SentenceFitToNoteAction)); bb.BindTypeToNewInstances(typeof(SetMusicGapAction)); bb.BindTypeToNewInstances(typeof(SetVideoGapAction)); bb.BindTypeToNewInstances(typeof(ChangeBpmAction)); return(bb.GetBindings()); }
/// <summary> /// /// </summary> /// <param name="type"></param> /// <returns></returns> public IBindingToSyntax <object> Bind(Type type) { var builder = new BindingBuilder <object>(type); bindingFactories.Add(builder); return(builder); }
public static void DslBindingExpression(this BindingBuilder builder, IEnumerable <Declaration> declarations, LambdaExpression expression) { var rewriter = new ExpressionRewriter(declarations); var rewrittenExpression = rewriter.Rewrite(expression); builder.BindingExpression(rewrittenExpression); }
public List <IBinding> GetBindings() { BindingBuilder bb = new BindingBuilder(); bb.BindExistingInstance(ApplicationManager.Instance); bb.BindExistingInstance(SceneNavigator.Instance); bb.BindExistingInstance(SettingsManager.Instance); bb.BindExistingInstance(SongMetaManager.Instance); bb.BindExistingInstance(ThemeManager.Instance); bb.BindExistingInstance(CursorManager.Instance); bb.BindExistingInstance(UiManager.Instance); bb.BindExistingInstance(MidiManager.Instance); bb.BindExistingInstance(AudioManager.Instance); bb.BindExistingInstance(I18NManager.Instance); EventSystem eventSystem = GameObjectUtils.FindComponentWithTag <EventSystem>("EventSystem"); bb.BindExistingInstance(eventSystem); // Lazy binding of settings, because they are not needed in every scene and loading the settings takes time. bb.BindExistingInstanceLazy(() => SettingsManager.Instance.Settings); bb.BindExistingInstanceLazy(() => StatsManager.Instance.Statistics); return(bb.GetBindings()); }
public List <IBinding> GetBindings() { BindingBuilder bb = new BindingBuilder(); bb.BindExistingInstance(this); return(bb.GetBindings()); }
public List <UniInject.IBinding> GetBindings() { BindingBuilder bb = new BindingBuilder(); bb.BindExistingInstance(uiDoc); return(bb.GetBindings()); }
public void TestSendAndReceiveWithNonDefaultExchange() { var admin = new RabbitAdmin(this.connectionFactory); var exchange = new TopicExchange("topic"); admin.DeclareExchange(exchange); admin.DeclareBinding(BindingBuilder.Bind(queue).To(exchange).With("*.end")); this.template.Execute <object>( delegate { var consumer = this.CreateConsumer(this.template); var tag = consumer.ConsumerTag; Assert.IsNotNull(tag); this.template.ConvertAndSend("topic", "foo", "message"); try { var result = this.GetResult(consumer); Assert.AreEqual(null, result); this.template.ConvertAndSend("topic", "foo.end", "message"); result = this.GetResult(consumer); Assert.AreEqual("message", result); } finally { consumer.Channel.BasicCancel(tag); } return(null); }); }
/// <summary> /// Creates a series of instances of <see cref="IBindingBuilder" />. /// </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="IBindingBuilder" />.</returns> public IList <IBindingBuilder> CreateBuildersFromString(object target, string bindingExpression, IList <object> sources = null) { Should.NotBeNull(target, "target"); Should.NotBeNullOrWhitespace(bindingExpression, "bindingExpression"); try { var parserResult = Parser.Parse(bindingExpression, sources.IsNullOrEmpty() ? DataContext.Empty : new DataContext(1) { { BindingBuilderConstants.RawSources, sources } }); var result = new IBindingBuilder[parserResult.Count]; for (int index = 0; index < parserResult.Count; index++) { var builder = new BindingBuilder(parserResult[index]); builder.Add(BindingBuilderConstants.Target, target); builder.Add(BindingBuilderConstants.BuildDelegate, _buildDelegate); result[index] = builder; } return(result); } catch (Exception exception) { exception = new InvalidOperationException(exception.Message, exception); var builder = new BindingBuilder(); builder.Add(BindingBuilderConstants.Target, target); builder.Add(ProviderConstant, this); builder.Add(ExceptionConstant, exception); builder.Add(BindingBuilderConstants.BuildDelegate, CreateInvalidaDataBindingDelegate); return(new IBindingBuilder[] { builder }); } }
public List <IBinding> GetBindings() { BindingBuilder bb = new BindingBuilder(); // Note that the SceneData and SongMeta are loaded on access here if not done yet. bb.BindExistingInstance(SceneData); bb.BindExistingInstance(SongMeta); bb.BindExistingInstance(songAudioPlayer); bb.BindExistingInstance(songVideoPlayer); bb.BindExistingInstance(noteArea); bb.BindExistingInstance(noteAreaDragHandler); bb.BindExistingInstance(songEditorLayerManager); bb.BindExistingInstance(microphonePitchTracker); bb.BindExistingInstance(songEditorNoteRecorder); bb.BindExistingInstance(selectionController); bb.BindExistingInstance(editorNoteDisplayer); bb.BindExistingInstance(canvas); bb.BindExistingInstance(graphicRaycaster); bb.BindExistingInstance(historyManager); bb.BindExistingInstance(songMetaChangeEventStream); bb.BindExistingInstance(lyricsArea); bb.BindExistingInstance(midiFileImporter); bb.BindExistingInstance(this); return(bb.GetBindings()); }
public static void BindAllSystemsInAssemblies(this IApplication application, params Assembly[] assemblies) { if (null == application) { throw new ArgumentNullException(nameof(application)); } var systemType = typeof(ISystem); var applicableSystems = assemblies .SelectMany(assembly => assembly.GetTypes()) .Where(type => { if (type.IsInterface || type.IsAbstract) { return(false); } return(systemType.IsAssignableFrom(type)); }) .ToList(); if (false == applicableSystems.Any()) { return; } var container = application.Container; foreach (var system in applicableSystems) { var configuration = new BindingBuilder().AsSingleton().WithName(system.Name).Build(); container.Bind(systemType, system, configuration); } }
private void ReadName(XElement element, BindingBuilder<object> builder) { var nameAttribute = element.Attribute("name"); if (nameAttribute != null) builder.Named(nameAttribute.Value); }
private static void ConfigureMediaBindings(BindingBuilder builder) { builder.HandleCommand <VideoConvertedCommand>() .WithHandle <MediaHelper>() .WithHandle <EventsService>() .WithHandle <NewsService>() .WithHandle <BulletinsService>(); }
internal static async Task <IBindingBuilder> GetBindingBuilder(HTMLViewEngine viewEngine, object viewModel, JavascriptBindingMode mode, object additional = null, IJavascriptObjectBuilderStrategyFactory strategyFactory = null) { var mapper = viewEngine.GetMapper(viewModel, mode, strategyFactory); var bindingBuilder = new BindingBuilder(mapper, viewEngine.Logger, additional); await bindingBuilder.Init(); return(bindingBuilder); }
static Binding Bind(Type type, object target) { var containerBindingBuilder = new BindingBuilder(Binding.For(type)); var scope = containerBindingBuilder.To(target); scope.Singleton(); return(containerBindingBuilder.Build()); }
private static void ConfigureMediaBindings(BindingBuilder builder) { builder.HandleCommand <VideoConvertedCommand>() .WithHandle <VideoHandler>() .WithHandle <EventHandler>() .WithHandle <NewsHandler>() .WithHandle <SocialHandler>(); }
/// <summary> /// Bind using a builder for fluent configuration /// </summary> /// <param name="container">container to act on</param> /// <param name="builderAction">configuration handler</param> /// <typeparam name="T">Type to bind to</typeparam> public static void Bind <T>(this IDependencyContainer container, Action <BindingBuilder <T> > builderAction) { var builder = new BindingBuilder <T>(); builderAction(builder); var config = builder.Build(); container.Bind <T>(config); }
private static void ConfigureLikeBindings(BindingBuilder builder) { builder.HandleCommand <AddLikeCommand>() .WithHandle <LikeHandle>() .WithHandle <LikeNotificationHandle>(); builder.HandleCommand <RemoveLikeCommand>() .WithHandle <LikeHandle>(); }
/// <summary> /// Bind using a builder for fluent configuration /// </summary> /// <param name="container">container to act on</param> /// <param name="builderAction">configuration handler</param> /// <typeparam name="TFrom">Type to bind from</typeparam> /// <typeparam name="TTo">Type to bind to</typeparam> public static void Bind <TFrom, TTo>(this IDependencyContainer container, Action <BindingBuilder> builderAction) where TTo : TFrom { var builder = new BindingBuilder(); builderAction(builder); var config = builder.Build(); container.Bind <TFrom, TTo>(config); }
protected async Task <BindingInContext> BindInContext(HtmlViewEngine engine, object dataContext, JavascriptBindingMode mode = JavascriptBindingMode.TwoWay) { var cacher = new SessionCacher(); var mapper = new BidirectionalMapper(dataContext, engine, null, null, mode, engine.Logger, cacher); var builder = new BindingBuilder(mapper, engine.Logger) as IBindingBuilder; var binding = await builder.CreateBinding(false); return(new BindingInContext(binding, cacher)); }
public ConesForm() { InitializeComponent(); var set = BindingSet <BaseForm <ConesViewModel>, ConesViewModel> .Create(this, ViewModel); this.Bind(BindingBuilder.BindOn(Cone1).For("Text").To("Cone1").Build <ConesForm, ConesViewModel>()); this.Bind(BindingBuilder.BindOn(Cone2).For("Text").To("Cone2").Build <ConesForm, ConesViewModel>()); this.Bind(BindingBuilder.BindOn(Cone3).For("Text").To("Cone3").Build <ConesForm, ConesViewModel>()); this.Bind(BindingBuilder.BindOn(Cone4).For("Text").To("Cone4").Build <ConesForm, ConesViewModel>()); }
private static void ConfigureGroupBindings(BindingBuilder builder) { builder.HandleCommand <HideGroupCommand>() .WithHandle <GroupHandle>() .WithHandle <GroupActivitiesHandle>(); builder.HandleCommand <UnhideGroupCommand>() .WithHandle <GroupHandle>() .WithHandle <GroupActivitiesHandle>(); }
private void ReadMetadata(XElement element, BindingBuilder<object> builder) { foreach (XElement metadataElement in element.Elements("metadata")) { XAttribute keyAttribute = metadataElement.RequiredAttribute("key"); XAttribute valueAttribute = metadataElement.RequiredAttribute("value"); builder.WithMetadata(keyAttribute.Value, valueAttribute.Value); } }
public List <IBinding> GetBindings() { BindingBuilder bb = new BindingBuilder(); bb.BindExistingInstance(this); bb.BindExistingInstance(songRouletteController); bb.BindExistingInstance(songAudioPlayer); bb.BindExistingInstance(songVideoPlayer); return(bb.GetBindings()); }
public void BuilderShouldUseTargetBindingContextForSource4() { const string sourcePath = "IntProperty"; var targetObj = new BindingSourceEventNotifierModel(); var builder = new BindingBuilder(); builder.Bind(targetObj, () => model => model.ObjectProperty).To<BindingSourceModel>(() => model => model.IntProperty); IList<Func<IDataContext, IBindingSource>> sources = builder.GetData(BindingBuilderConstants.Sources); IBindingSource source = sources.Single().Invoke(builder); BindingParserTest.BindingSourceShouldBeValidDataContext(targetObj, source, sourcePath); var sourceObj = new BindingSourceModel(); BindingServiceProvider.ContextManager.GetBindingContext(targetObj).Value = sourceObj; BindingParserTest.BindingSourceShouldBeValidDataContext(targetObj, source, sourcePath); }
public void BuilderShouldUseTargetBindingContextForSource2() { const string targetPath = "Text"; const string sourcePath = "IntProperty"; var targetObj = new object(); var builder = new BindingBuilder(); builder.Bind(targetObj, targetPath).To<BindingSourceModel>(() => (model, ctx) => model.IntProperty); IList<Func<IDataContext, IObserver>> sources = builder.GetData(BindingBuilderConstants.Sources); IObserver source = sources.Single().Invoke(builder); BindingParserTest.BindingSourceShouldBeValidDataContext(targetObj, source, sourcePath); var sourceObj = new BindingSourceModel(); BindingServiceProvider.ContextManager.GetBindingContext(targetObj).Value = sourceObj; BindingParserTest.BindingSourceShouldBeValidDataContext(targetObj, source, sourcePath); }
public void ParserShouldParseSingleExpression2() { const string targetPath = "Text"; const string sourcePath = "SourceText"; const string binding = "Text $context.SourceText"; var target = new object(); IBindingParser bindingParser = CreateBindingParser(); var context = new BindingBuilder(bindingParser.Parse(binding, EmptyContext, target, null).Single()); IBindingPath path = context.GetData(BindingBuilderConstants.TargetPath); path.Path.ShouldEqual(targetPath); var sources = context.GetData(BindingBuilderConstants.Sources); IBindingSource source = sources.Single().Invoke(context); BindingSourceShouldBeValid(source, AttachedMemberConstants.DataContext + "." + sourcePath, target); }
public void ParserShouldParseSingleExpression1() { const string targetPath = "Text"; const string sourcePath = "SourceText"; const string binding = "Text SourceText"; var target = new object(); IBindingParser bindingParser = CreateBindingParser(); var context = new BindingBuilder(bindingParser.Parse(target, binding, null, null).Single()); IBindingPath path = context.GetData(BindingBuilderConstants.TargetPath); path.Path.ShouldEqual(targetPath); var sources = context.GetData(BindingBuilderConstants.Sources); IObserver source = sources.Single().Invoke(context); BindingSourceShouldBeValidDataContext(target, source, sourcePath); }
public void Handle(XmlModule module, XElement element) { XAttribute serviceAttribute = element.RequiredAttribute("service"); Type service = GetTypeFromAttributeValue(serviceAttribute); var binding = new Binding(service); var builder = new BindingBuilder<object>(binding, _kernel); module.AddBinding(binding); if (!HandleTarget(element, builder)) throw new ConfigurationErrorsException("The 'bind' element does not define either a 'to' or 'toProvider' attribute."); ReadName(element, builder); ReadMetadata(element, builder); ReadScope(element, builder); }
public void ParserShouldUseTargetBindingContextForSource() { const string targetPath = "Text"; const string sourcePath = "IntProperty"; const string binding = "Text IntProperty"; var target = new object(); IBindingParser bindingParser = CreateBindingParser(); var context = new BindingBuilder(bindingParser.Parse(binding, EmptyContext, target, null).Single()); IBindingPath path = context.GetData(BindingBuilderConstants.TargetPath); path.Path.ShouldEqual(targetPath); var sources = context.GetData(BindingBuilderConstants.Sources); IBindingSource source = sources.Single().Invoke(context); BindingSourceShouldBeValidDataContext(target, source, sourcePath); var sourceObj = new BindingSourceModel(); BindingServiceProvider.ContextManager.GetBindingContext(target).Value = sourceObj; BindingSourceShouldBeValidDataContext(target, source, sourcePath); }
public void BuilderShouldUseConverterParameter2() { Func<IDataContext, object> parameter = context => null; var builder = new BindingBuilder(); builder.Bind(new object(), "test").To("test").WithConverterParameter(parameter); builder.GetData(BindingBuilderConstants.ConverterParameter).ShouldEqual(parameter); }
public void BuilderShouldUseConverterParameter1() { var parameter = new object(); var builder = new BindingBuilder(); builder.Bind(new object(), "test").To("test").WithConverterParameter(parameter); builder.GetData(BindingBuilderConstants.ConverterParameter).Invoke(builder).ShouldEqual(parameter); }
public void BuilderShouldUseSourceObject1() { const string targetPath = "Text"; const string sourcePath = "IntProperty"; var targetObj = new object(); var sourceObj = new BindingSourceModel(); var builder = new BindingBuilder(); builder.Bind(targetObj, targetPath).To(sourceObj, sourcePath); IList<Func<IDataContext, IBindingSource>> sources = builder.GetData(BindingBuilderConstants.Sources); IBindingSource source = sources.Single().Invoke(builder); BindingParserTest.BindingSourceShouldBeValid(source, sourcePath, sourceObj); }
public void BuilderShouldUseDynamicMember5() { const string targetPath = "Text"; var targetObj = new object(); var builder = new BindingBuilder(); var src = new BindingSourceModel { ObjectProperty = "test" }; builder.Bind(targetObj, targetPath).To(src, () => model => model.Member<string>("ObjectProperty").Member<int>("Length") + 0); IList<Func<IDataContext, IBindingSource>> sources = builder.GetData(BindingBuilderConstants.Sources); IBindingSource source = sources.Single().Invoke(builder); source.Path.Path.ShouldEqual("ObjectProperty.Length"); source.GetSource(true).ShouldEqual(src); var data = builder.GetData(BindingBuilderConstants.MultiExpression); data.Invoke(builder, new object[] { ((string)src.ObjectProperty).Length }).ShouldEqual(((string)src.ObjectProperty).Length); }
public void BuilderShouldUseBindingContextExtension4() { const string targetPath = "Text"; const string sourcePath = "IntProperty"; var targetObj = new object(); var builder = new BindingBuilder(); builder.Bind(targetObj, targetPath).To<BindingSourceModel>(() => model => BindingSyntaxEx.Self<object>().DataContext<BindingSourceModel>().IntProperty); IList<Func<IDataContext, IBindingSource>> sources = builder.GetData(BindingBuilderConstants.Sources); IBindingSource source = sources.Single().Invoke(builder); source.Path.Path.ShouldEqual(AttachedMemberConstants.DataContext + "." + sourcePath); }
public void BuilderShouldUseDynamicMember3() { const string targetPath = "Text"; var targetObj = new object(); var builder = new BindingBuilder(); var src = new BindingSourceModel { ObjectProperty = new BindingSourceModel { StringProperty = "test" } }; builder.Bind(targetObj, targetPath).To<BindingSourceModel>(() => model => model.GetObjectProperty().Member<string>("StringProperty").Member<int>("Length")); IList<Func<IDataContext, IBindingSource>> sources = builder.GetData(BindingBuilderConstants.Sources); IBindingSource source = sources.Single().Invoke(builder); BindingParserTest.BindingSourceShouldBeValidDataContext(targetObj, source, string.Empty); var sourceObj = new BindingSourceModel(); BindingServiceProvider.ContextManager.GetBindingContext(targetObj).Value = sourceObj; BindingParserTest.BindingSourceShouldBeValidDataContext(targetObj, source, string.Empty); var data = builder.GetData(BindingBuilderConstants.MultiExpression); data.Invoke(builder, new[] { src }).ShouldEqual(((BindingSourceModel)src.GetObjectProperty()).StringProperty.Length); }
public void BuilderShouldUseLambdaExpression2() { var builder = new BindingBuilder(); builder.Bind(new object(), "empty") .To<BindingSourceModel>(() => model => model.StringProperty.OfType<char>().Count(c => c == '1') + ((BindingSourceModel)model.ObjectProperty).IntProperty); var expression = builder.GetData(BindingBuilderConstants.MultiExpression); expression.Invoke(builder, new object[] { "1", 10 }).ShouldEqual(11); expression.Invoke(builder, new object[] { "", 0 }).ShouldEqual(0); var list = builder.GetData(BindingBuilderConstants.Sources); list.Count.ShouldEqual(2); list[0].Invoke(builder).Path.Path.ShouldEqual(GetMemberPath<BindingSourceModel>(model => model.StringProperty)); list[1].Invoke(builder).Path.Path.ShouldEqual(GetMemberPath<BindingSourceModel>(model => ((BindingSourceModel)model.ObjectProperty).IntProperty)); }
public void BuilderShouldUseSelfExpression1() { var builder = new BindingBuilder(); var sourceModel = new BindingSourceModel(); builder.Bind(sourceModel, "empty").To<BindingSourceModel>(() => model => BindingSyntaxEx.Self<BindingSourceModel>()); var source = builder.GetData(BindingBuilderConstants.Sources).Single().Invoke(builder); builder.GetData(BindingBuilderConstants.MultiExpression).ShouldBeNull(); source.Path.IsEmpty.ShouldBeTrue(); source.GetSource(true).ShouldEqual(sourceModel); var pathMembers = source.GetPathMembers(true); pathMembers.LastMember.GetValue(pathMembers.PenultimateValue, null).ShouldEqual(sourceModel); }
public void BuilderShouldUseElementSource2() { const string name = "name"; var builder = new BindingBuilder(); var targetObj = new BindingSourceModel { ObjectProperty = "test" }; var relativeObj = new BindingSourceModel(); bool isInvoked = false; IEventListener eventListener = null; var memberMock = new BindingMemberInfoMock { TryObserveMember = (o, listener) => { eventListener = listener; return null; } }; var treeManagerMock = new VisualTreeManagerMock { FindByName = (o, s) => { o.ShouldEqual(targetObj); s.ShouldEqual(name); isInvoked = true; return relativeObj; }, GetRootMember = type => memberMock }; BindingServiceProvider.VisualTreeManager = treeManagerMock; builder.Bind(targetObj, "empty").To<BindingSourceModel>(() => model => BindingSyntaxEx.Element<BindingSourceModel>(name).ObjectProperty); var source = builder.GetData(BindingBuilderConstants.Sources).Single().Invoke(builder); builder.GetData(BindingBuilderConstants.MultiExpression).ShouldBeNull(); source.Path.Path.ShouldEqual(GetMemberPath(targetObj, model => model.ObjectProperty)); source.GetSource(true).ShouldEqual(relativeObj); var pathMembers = source.GetPathMembers(true); pathMembers.LastMember.GetValue(pathMembers.PenultimateValue, null).ShouldEqual(relativeObj.ObjectProperty); isInvoked.ShouldBeTrue(); isInvoked = false; eventListener.ShouldNotBeNull(); eventListener.Handle(this, EventArgs.Empty); isInvoked.ShouldBeTrue(); }
public void BuilderShouldUseEventArgs2() { var builder = new BindingBuilder(); builder.Bind(new object(), "empty").To<BindingSourceModel>(() => model => BindingSyntaxEx.EventArgs<EventArgs>().GetType().Name); builder.Add(BindingConstants.CurrentEventArgs, EventArgs.Empty); var expression = builder.GetData(BindingBuilderConstants.MultiExpression); expression(builder, Empty.Array<object>()).ShouldEqual(EventArgs.Empty.GetType().Name); }
public void BuilderShouldUseGetErrorsMethod4() { var builder = new BindingBuilder(); var sourceModel = new BindingSourceModel(); builder.Bind(sourceModel, "empty").To(sourceModel, () => model => BindingSyntaxEx.GetErrors("1", "2").Concat(BindingSyntaxEx.GetErrors(model.ObjectProperty))); var sources = builder.GetData(BindingBuilderConstants.Sources).Select(func => func(builder)).ToArray(); sources[0].GetSource(true).ShouldEqual(sourceModel); sources[1].GetSource(true).ShouldEqual(sourceModel); if (sources[0].Path.IsEmpty) sources[1].Path.Path.ShouldEqual(GetMemberPath(sourceModel, model => model.ObjectProperty)); else sources[0].Path.Path.ShouldEqual(GetMemberPath(sourceModel, model => model.ObjectProperty)); var behaviors = builder.GetOrAddBehaviors().OfType<NotifyDataErrorsAggregatorBehavior>().ToArray(); builder.AddOrUpdate(BindingConstants.Binding, new DataBindingMock { Behaviors = behaviors }); var behavior = behaviors.Single(b => !b.ErrorPaths.IsNullOrEmpty()); behavior.ErrorPaths.SequenceEqual(new[] { "1", "2" }).ShouldBeTrue(); behaviors.ForEach(aggregatorBehavior => aggregatorBehavior.Errors = new[] { "1" }); var expression = builder.GetData(BindingBuilderConstants.MultiExpression); var errors = (IEnumerable<object>)expression(builder, new object[] { sourceModel, sourceModel }); errors.SequenceEqual(behaviors[0].Errors.Concat(behaviors[1].Errors)).ShouldBeTrue(); }
public void BuilderShouldUseGetErrorsMethod3() { var builder = new BindingBuilder(); var sourceModel = new BindingSourceModel(); builder.Bind(sourceModel, "empty").To(sourceModel, () => model => BindingSyntaxEx.GetErrors("1", "2", model.ObjectProperty)); var source = builder.GetData(BindingBuilderConstants.Sources).Single().Invoke(builder); source.Path.Path.ShouldEqual(GetMemberPath(sourceModel, model => model.ObjectProperty)); source.GetSource(true).ShouldEqual(sourceModel); var behavior = builder.GetOrAddBehaviors().OfType<NotifyDataErrorsAggregatorBehavior>().Single(); behavior.ErrorPaths.SequenceEqual(new[] { "1", "2" }).ShouldBeTrue(); builder.AddOrUpdate(BindingConstants.Binding, new DataBindingMock { Behaviors = new[] { behavior } }); var expression = builder.GetData(BindingBuilderConstants.MultiExpression); behavior.Errors = new List<object> { "test" }; expression(builder, new object[] { sourceModel }).ShouldEqual(behavior.Errors); }
public void BuilderShouldUseResource2() { const string key = "key"; var builder = new BindingBuilder(); var sourceModel = new BindingSourceModel { ObjectProperty = "test" }; BindingServiceProvider.ResourceResolver.AddObject(key, sourceModel); builder.Bind(sourceModel, "empty").To<BindingSourceModel>(() => model => BindingSyntaxEx.Self<BindingSourceModel>().ObjectProperty); var source = builder.GetData(BindingBuilderConstants.Sources).Single().Invoke(builder); builder.GetData(BindingBuilderConstants.MultiExpression).ShouldBeNull(); source.Path.Path.ShouldEqual(GetMemberPath(sourceModel, model => model.ObjectProperty)); source.GetSource(true).ShouldEqual(sourceModel); var pathMembers = source.GetPathMembers(true); pathMembers.LastMember.GetValue(pathMembers.PenultimateValue, null).ShouldEqual(sourceModel.ObjectProperty); }
public void BuilderShouldUseLambdaExpression3() { var builder = new BindingBuilder(); builder.Bind(new object(), "empty") .To<BindingSourceModel>(() => model => model.StringProperty.OfType<char>().Select(s => s == null ? 10 + 4 : 3 + 10).FirstOrDefault() == 0 ? false : true || true); var expression = builder.GetData(BindingBuilderConstants.MultiExpression); expression.Invoke(builder, new object[] { "1" }).ShouldEqual("1".OfType<char>().Select(s => s == null ? 10 + 4 : 3 + 10).FirstOrDefault() == 0 ? false : true || true); expression.Invoke(builder, new object[] { "2" }).ShouldEqual("2".OfType<char>().Select(s => s == null ? 10 + 4 : 3 + 10).FirstOrDefault() == 0 ? false : true || true); var list = builder.GetData(BindingBuilderConstants.Sources); list.Count.ShouldEqual(1); list[0].Invoke(builder).Path.Path.ShouldEqual(GetMemberPath<BindingSourceModel>(model => model.StringProperty)); }
public void BuilderShouldUseBindingContextExtension1() { const string targetPath = "Text"; var targetObj = new object(); var builder = new BindingBuilder(); builder.Bind(targetObj, targetPath).To<BindingSourceModel>(() => model => BindingSyntaxEx.DataContext<BindingSourceModel>()); IList<Func<IDataContext, IBindingSource>> sources = builder.GetData(BindingBuilderConstants.Sources); IBindingSource source = sources.Single().Invoke(builder); BindingParserTest.BindingSourceShouldBeValidDataContext(targetObj, source, string.Empty); var sourceObj = new BindingSourceModel(); BindingServiceProvider.ContextManager.GetBindingContext(targetObj).Value = sourceObj; BindingParserTest.BindingSourceShouldBeValidDataContext(targetObj, source, string.Empty); }
public void BuilderShouldUseTargetNullValue() { var nullValue = new object(); var builder = new BindingBuilder(); builder.Bind(new object(), "test").To("test").WithTargetNullValue(nullValue); builder.GetData(BindingBuilderConstants.TargetNullValue).ShouldEqual(nullValue); }
public void BuilderShouldUseEventArgs3() { var builder = new BindingBuilder(); builder.Bind(new object(), "empty").To<BindingSourceModel>(() => model => BindingSyntaxEx.EventArgs<BindingSourceModel>().ObjectProperty); var sourceModel = new BindingSourceModel { ObjectProperty = "test" }; builder.Add(BindingConstants.CurrentEventArgs, sourceModel); var expression = builder.GetData(BindingBuilderConstants.MultiExpression); expression(builder, Empty.Array<object>()).ShouldEqual(sourceModel.ObjectProperty); }
public void BuilderShouldUseResourceMethod2() { const string key = "key"; var builder = new BindingBuilder(); var sourceModel = new BindingSourceModel(); var result = new BindingSourceModel { ObjectProperty = "Test" }; BindingServiceProvider.ResourceResolver.AddMethod<string, object, BindingSourceModel>(key, (s1, s2, context) => { s1.ShouldEqual(key); s2.ShouldEqual(builder); context.ShouldEqual(builder); return result; }); builder.Bind(sourceModel, "empty").To<BindingSourceModel>(() => model => BindingSyntaxEx.ResourceMethod<BindingSourceModel>(key, key, builder).ObjectProperty); var sources = builder.GetData(BindingBuilderConstants.Sources); sources.Count.ShouldEqual(1); sources[0].Invoke(builder).Path.Path.ShouldEqual(string.Empty); var expression = builder.GetData(BindingBuilderConstants.MultiExpression); expression(builder, Empty.Array<object>()).ShouldEqual(result.ObjectProperty); }
public void BuilderShouldUseLambdaExpression1() { var builder = new BindingBuilder(); builder.Bind(new object(), "empty") .To<BindingSourceModel>(() => model => model.IntProperty + 100 + model.NestedModel.IntProperty + int.Parse(model.NestedModel["1"])); var expression = builder.GetData(BindingBuilderConstants.MultiExpression); expression.Invoke(builder, new object[] { 10, 10, "10" }).ShouldEqual(130); expression.Invoke(builder, new object[] { -10, 10, "-100" }).ShouldEqual(0); var list = builder.GetData(BindingBuilderConstants.Sources); list.Count.ShouldEqual(3); list[0].Invoke(builder).Path.Path.ShouldEqual(GetMemberPath<BindingSourceModel>(model => model.IntProperty)); list[1].Invoke(builder).Path.Path.ShouldEqual(GetMemberPath<BindingSourceModel>(model => model.NestedModel.IntProperty)); list[2].Invoke(builder).Path.Path.ShouldEqual(GetMemberPath<BindingSourceModel>(model => model.NestedModel["1"])); }
public void BuilderShouldUseConverterCulture3() { var builder = new BindingBuilder(); builder.Bind(CultureInfo.InvariantCulture, "test").To("test").WithConverterCulture(() => o => BindingSyntaxEx.Self<CultureInfo>()); builder.GetData(BindingBuilderConstants.ConverterCulture).Invoke(builder).ShouldEqual(CultureInfo.InvariantCulture); }
public void BuilderShouldUseConverterParameter3() { var builder = new BindingBuilder(); builder.Bind(builder, "test").To("test").WithConverterParameter(() => o => BindingSyntaxEx.Self<object>()); builder.GetData(BindingBuilderConstants.ConverterParameter).Invoke(builder).ShouldEqual(builder); }