public void Bind(IBindingToSyntax <ILog> logBinding, IBindingToSyntax <IEventPublisher> eventPublisherBinding, IBindingToSyntax <Func <string, ILog> > logFactory) { logBinding.To <ConsoleLog>(); logFactory.ToMethod(c => caller => c.Kernel.Get <ConsoleLog>()); eventPublisherBinding.To <NullEventPublisher>(); }
public static void Convert(Func <LambdaExpression> expression, IBindingToSyntax syntax) { Should.NotBeNull(expression, "expression"); var hasClosure = expression.HasClosure(); if (hasClosure || syntax.Builder.Contains(BindingBuilderConstants.NoCache)) { var ex = expression(); if (hasClosure) { ex.TraceClosureWarn(); } Convert(ex, syntax); return; } Action <IBindingToSyntax>[] callbacks; lock (Cache) { if (!Cache.TryGetValue(expression, out callbacks)) { callbacks = ConvertInternal(expression(), syntax, false); Cache[expression] = callbacks; } } for (int i = 0; i < callbacks.Length; i++) { callbacks[i].Invoke(syntax); } }
/// <summary> /// Indicates that the service should be bound to a mocked instance of the specified type. /// </summary> /// <typeparam name="T">The service that is being mocked.</typeparam> /// <param name="builder">The builder that is building the binding.</param> /// <returns>The syntax for adding more information to the binding.</returns> public static IBindingWhenInNamedWithOrOnSyntax <T> ToMock <T>(this IBindingToSyntax <T> builder) { var bindingConfiguration = builder.BindingConfiguration; bindingConfiguration.ProviderCallback = builder.Kernel.Components.Get <IMockProviderCallbackProvider>().GetCreationCallback(); return(builder as IBindingWhenInNamedWithOrOnSyntax <T>); }
public static IBindingModeInfoBehaviorSyntax ToSelf <TTarget>( [NotNull] this IBindingToSyntax <TTarget> syntaxGeneric, [NotNull] Expression <Func <TTarget, object> > selfPath) { Should.NotBeNull(selfPath, "selfPath"); return(ToSelf(syntaxGeneric, BindingExtensions.GetMemberPath(selfPath))); }
public static IBindingModeInfoBehaviorSyntax <TSource> To <TTarget, TSource>( [NotNull] this IBindingToSyntax <TTarget, TSource> syntax, [NotNull] Func <Expression <Func <TSource, IBindingSyntaxContext <TTarget, TSource>, object> > > expression) where TTarget : class { return(syntax.ToInternal <TSource>(expression)); }
public static IBindingModeInfoBehaviorSyntax To <TTarget, TSource>( [NotNull] this IBindingToSyntax <TTarget, TSource> syntax, [NotNull] Expression <Func <TSource, object> > sourcePath) { Should.NotBeNull(sourcePath, "sourcePath"); return(syntax.To(BindingExtensions.GetMemberPath(sourcePath))); }
public static IBindingModeInfoBehaviorSyntax <TSource> ToAction <TTarget, TSource>( [NotNull] this IBindingToSyntax <TTarget> syntax, TSource source, [NotNull] Func <Expression <Action <TSource, IBindingSyntaxContext <TTarget, TSource> > > > expression) where TTarget : class { return(syntax.ToInternal(expression, source)); }
public static IBindingModeInfoBehaviorSyntax <TTarget> ToSelf <TTarget>([NotNull] this IBindingToSyntax <TTarget> syntax, [NotNull] string selfPath) where TTarget : class { Should.NotBeNull(syntax, "syntax"); return(syntax.To((TTarget)syntax.Builder.GetData(BindingBuilderConstants.Target, true), selfPath)); }
/// <summary> /// Used by Microdot hosts to initialize logging and tracing. /// </summary> /// <param name="logBinding"></param> /// <param name="eventPublisherBinding"></param> public void Bind(IBindingToSyntax <ILog> logBinding, IBindingToSyntax <IEventPublisher> eventPublisherBinding, IBindingToSyntax <Func <string, ILog> > funcLog) { // Bind microdot log that takes the caller name from class asking for the log logBinding .To <NLogLogger>() .InScope(GetTypeOfTarget) .WithConstructorArgument("receivingType", (context, target) => GetTypeOfTarget(context)); eventPublisherBinding .To <LogEventPublisher>() .InSingletonScope(); // Bind Orleans log with string context funcLog.ToMethod(c => { return(loggerName => { var dict = c.Kernel.Get <DisposableCollection <string, ILog> >(); return dict.GetOrAdd(loggerName , logName => { var caller = new ConstructorArgument("caller", logName); return c.Kernel.Get <NLogLogger>(caller); }); }); }) .InTransientScope(); }
/// <summary> /// Indicates that a service should be bound to the first available implementation. /// </summary> /// <typeparam name="TService">The implementation type.</typeparam> /// <typeparam name="T1">The first implementation type to try.</typeparam> /// <typeparam name="T2">The second implementation type to try.</typeparam> /// <typeparam name="T3">The third implementation type to try.</typeparam> /// <param name="syntax">The fluent syntax.</param> /// <returns>The fluent syntax.</returns> public static object ToFirst <TService, T1, T2, T3>(this IBindingToSyntax <TService> syntax) where T1 : TService where T2 : TService where T3 : TService { return(syntax.ToFirst(typeof(T1), typeof(T2), typeof(T3))); }
public override void Load() { IBindingToSyntax <IRepository <BankAccount> > bind = Bind <IRepository <BankAccount> >(); switch (_storageType.ToLower()) { case "ef": { bind.To <BankAccountEFRepository>().WithConstructorArgument("MyDefaultConnection"); break; } case "json": { bind.To <BankAccountJsonRepository>(); break; } case "xml": { bind.To <BankAccountXmlRepository>(); break; } default: { bind.To <BankAccountBinaryRepository>(); break; } } Bind <IUnitOfWork>().To <UnitOfWork>() .WithConstructorArgument(bind); Bind <IBankAccountService>().To <BankAccountService>(); }
/// <summary> /// Indicates that the service should be bound to a WCF service channel using the endpoint declared in the Web.config or App.config file with the given name. /// </summary> /// <typeparam name="TContract">The service contract interface type.</typeparam> /// <param name="bindingSyntax">The result from Bind<TContract>().</param> /// <param name="endpointConfigurationName">The configuration name used for the endpoint.</param> /// <exception cref="T:System.ArgumentNullException"><paramref name="endpointConfigurationName"/> is null.</exception> /// <returns>The fluent syntax;</returns> public static IBindingWhenInNamedWithOrOnSyntax <TContract> ToServiceChannel <TContract>( this IBindingToSyntax <TContract> bindingSyntax, string endpointConfigurationName) where TContract : class { ThrowIfNull(endpointConfigurationName, "endpointConfigurationName"); return(BindChannel(bindingSyntax, () => new ChannelFactory <TContract>(endpointConfigurationName))); }
private static IBindingWhenInNamedWithOrOnSyntax <TContract> BindChannel <TContract>( IBindingToSyntax <TContract> bindingSyntax, Func <ChannelFactory <TContract> > factoryFactory) where TContract : class { // Don't create the ChannelFactory at binding time, since it's an expensive operation var lazyFactory = new Lazy <ChannelFactory <TContract> >(factoryFactory); return(bindingSyntax.ToMethod(x => lazyFactory.Value.CreateChannel())); }
private static IBindingModeInfoBehaviorSyntax<TSource> ToInternal<TSource>(this IBindingToSyntax syntax, Func<LambdaExpression> expression, TSource source) { Should.NotBeNull(syntax, nameof(syntax)); syntax.Builder.AddOrUpdate(BindingBuilderConstants.Source, source); BindingServiceProvider.BindingProvider.BuildFromLambdaExpression(syntax.Builder, expression); return syntax.GetOrAddSyntaxBuilder<IBindingModeInfoBehaviorSyntax<TSource>, object, TSource>(); }
public static IBindingModeInfoBehaviorSyntax <TTarget> ToSelf <TTarget>( [NotNull] this IBindingToSyntax <TTarget> syntax, [NotNull] Func <Expression <Func <TTarget, IBindingSyntaxContext <TTarget, TTarget>, object> > > expression) where TTarget : class { Should.NotBeNull(syntax, "syntax"); return(syntax.ToInternal(expression, (TTarget)syntax.Builder.GetData(BindingBuilderConstants.Target, true))); }
private static IBindingModeInfoBehaviorSyntax <TSource> ToInternal <TSource>(this IBindingToSyntax syntax, Func <LambdaExpression> expression, TSource source) { Should.NotBeNull(syntax, "syntax"); syntax.Builder.AddOrUpdate(BindingBuilderConstants.Source, source); LambdaExpressionToBindingExpressionConverter.Convert(expression, syntax); return(syntax.GetOrAddSyntaxBuilder <IBindingModeInfoBehaviorSyntax <TSource>, object, TSource>()); }
public static IBindingModeInfoBehaviorSyntax <object> ToSource([NotNull] this IBindingToSyntax syntax, [NotNull] Func <IDataContext, IObserver> bindingSourceDelegate) { Should.NotBeNull(syntax, "syntax"); Should.NotBeNull(bindingSourceDelegate, "bindingSourceDelegate"); syntax.Builder.GetOrAddBindingSources().Add(bindingSourceDelegate); return(syntax.GetOrAddSyntaxBuilder <IBindingModeInfoBehaviorSyntax <object>, object, object>()); }
public static IBindingModeInfoBehaviorSyntax <TSource> To <TSource>([NotNull] this IBindingToSyntax syntax, [NotNull] TSource source, [NotNull] string sourcePath) { Should.NotBeNull(source, "source"); Should.NotBeNull(sourcePath, "sourcePath"); syntax.Builder.AddOrUpdate(BindingBuilderConstants.Source, source); syntax.Builder.GetOrAddBindingSources().Add(context => BindingExtensions.CreateBindingSource(context, sourcePath, source)); return(syntax.GetOrAddSyntaxBuilder <IBindingModeInfoBehaviorSyntax <TSource>, object, TSource>()); }
/// <summary> /// Indicates that the service should be bound to a WCF service channel using the given binding and the endpoint declared in the Web.config or App.config file. /// </summary> /// <typeparam name="TContract">The service contract interface type.</typeparam> /// <param name="bindingSyntax">The result from Bind<TContract>().</param> /// <param name="binding">The <see cref="T:System.ServiceModel.Channels.Binding"/> used to configure the endpoint.</param> /// <param name="remoteAddress">The <see cref="T:System.ServiceModel.EndpointAddress"/> that provides the location of the service.</param> /// <exception cref="T:System.ArgumentNullException"><paramref name="binding"/> or <paramref name="remoteAddress"/> is null.</exception> /// <returns>The fluent syntax;</returns> public static IBindingWhenInNamedWithOrOnSyntax <TContract> ToServiceChannel <TContract>( this IBindingToSyntax <TContract> bindingSyntax, Binding binding, EndpointAddress remoteAddress) where TContract : class { ThrowIfNull(binding, "binding"); ThrowIfNull(remoteAddress, "remoteAddress"); return(BindChannel(bindingSyntax, () => new ChannelFactory <TContract>(binding, remoteAddress))); }
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)); })); }
/// <summary> /// Indicates that the service should be mocked. The mock is activated in the singleton scope. /// </summary> /// <typeparam name="T">The service type.</typeparam> /// <param name="builder">The fluent syntax.</param> /// <returns>The fluent syntax.</returns> public static IBindingWhenInNamedWithOrOnSyntax <T> ToMock <T>(this IBindingToSyntax <T> builder) { return(ProfilerInterceptor.GuardInternal(() => { var result = builder.To <T>(); builder.BindingConfiguration.ScopeCallback = StandardScopeCallbacks.Singleton; builder.Kernel.Components.Get <IMockResolver>().AttachToBinding(builder.BindingConfiguration, typeof(T)); return result; })); }
public static void Convert(LambdaExpression expression, IBindingToSyntax syntax) { Should.NotBeNull(expression, "expression"); var callbacks = ConvertInternal(expression, syntax, true); for (int i = 0; i < callbacks.Length; i++) { callbacks[i].Invoke(syntax); } }
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); })); }
public FullBindingToSyntax ( IBindingToSyntax <T1> eager, IBindingToSyntax <Lazy <T1> > lazy, IKernel kernel ) { _eager = eager; _lazy = lazy; _kernel = kernel; }
/// <summary> /// Used by Microcore hosts to initialize logging and tracing. /// </summary> /// <param name="logBinding"></param> /// <param name="eventPublisherBinding"></param> public void Bind(IBindingToSyntax <ILog> logBinding, IBindingToSyntax <IEventPublisher> eventPublisherBinding) { logBinding .To <SerilogLogger>() .InScope(GetTypeOfTarget) .WithConstructorArgument("receivingType", (context, target) => GetTypeOfTarget(context)); eventPublisherBinding .To <LogEventPublisher>() .InSingletonScope(); }
protected override void OnBuild(IDependencyInfo info) { IBindingToSyntax <object> initial = Kernel.Bind(info.ResolvedTypes.ToArray()); IBindingWhenInNamedWithOrOnSyntax <object> binding = BuildTo(info, initial); BindScope(info, binding); BindNamedIfConfigured(info, binding); Definitions.Add(info); }
/// <summary> /// Tries to handle the ToProvider attribute. /// </summary> /// <param name="element">The element.</param> /// <param name="builder">The builder.</param> /// <returns>True if the attribute was found.</returns> private static IBindingWhenInNamedWithOrOnSyntax<object> HandleToProviderAttribute(XElement element, IBindingToSyntax<object> builder) { XAttribute providerAttribute = element.Attribute("toProvider"); if (providerAttribute == null) { return null; } Type provider = GetTypeFromAttributeValue(providerAttribute); return builder.ToProvider(provider); }
/// <summary> /// Tries to handle the to attribute. /// </summary> /// <param name="element">The element.</param> /// <param name="builder">The builder.</param> /// <returns>True if the To Attribute was found</returns> private static IBindingWhenInNamedWithOrOnSyntax<object> HandleToAttribute(XElement element, IBindingToSyntax<object> builder) { XAttribute toAttribute = element.Attribute("to"); if (toAttribute == null) { return null; } Type implementation = GetTypeFromAttributeValue(toAttribute); return builder.To(implementation); }
public void Bind(IBindingToSyntax <ILog> logBinding, IBindingToSyntax <IEventPublisher> eventPublisherBinding) { if (_useHttpLog) { logBinding.To <HttpLog>(); } else { logBinding.To <ConsoleLog>(); } eventPublisherBinding.To <NullEventPublisher>(); }
public static IBindingWithOrOnSyntax <TService> ToExtrnalService <TService>(this IBindingToSyntax <TService> syntax) { var serviceBinding = new ServiceBindingInfo { ServiceType = typeof(TService), IsExternal = true }; syntax.Kernel.Bind <ServiceBindingInfo>().ToConstant(serviceBinding); return(syntax.ToMethod(ThrowOnAttemptToResolve <TService>) .WithMetadata(nameof(ServiceBindingInfo), serviceBinding)); }
public void Bind(IBindingToSyntax <ILog> logBinding, IBindingToSyntax <IEventPublisher> eventPublisherBinding) { if (_useHttpLog) { logBinding.To <HttpLog>(); } else { logBinding.To <ConsoleLog>(); } eventPublisherBinding.To <SpyEventPublisher>().InSingletonScope(); }
//private readonly IBindingWhenInNamedWithOrOnSyntax<T2> _eager; //private readonly IBindingWhenInNamedWithOrOnSyntax<Lazy<T1>> _lazy; public FullBindingWhenInNamedWithOrOnSyntax ( IBindingToSyntax <T1> eager, IBindingToSyntax <Lazy <T1> > lazy, IKernel kernel ) { // we don't want to convert them via To or ToMethod just yet lest the resolver // fail due to multiple eligible bindings //_eager = eager.To<T2>(); //_lazy = lazy.ToMethod(ctx => new Lazy<T1>(() => Constants.NinjectKernel.Get<T1>())); _eager = eager; _lazy = lazy; _kernel = kernel; }