public void CreateFromFactory_executes_factory_with_resolved_parameters([Frozen] IFulfilsResolutionRequests resolver, InstanceCreator sut, IFactoryAdapter factory, ResolutionPath path, IServiceRegistration registration, object resolved, [MockParam(typeof(string), Name = "Foo")] ParameterInfo paramOne, object paramOneValue, [MockParam(typeof(int), Name = "Bar")] ParameterInfo paramTwo, object paramTwoValue) { // Arrange Mock.Get(factory).SetupGet(x => x.RequiresParameterResolution).Returns(true); Mock.Get(factory).Setup(x => x.GetParameters()).Returns(new [] { paramOne, paramTwo }); Mock.Get(resolver) .Setup(x => x.Resolve(It.Is <ResolutionRequest>(r => r.Name == paramOne.Name && r.ServiceType == paramOne.ParameterType))) .Returns(() => ResolutionResult.Success(path, paramOneValue)); Mock.Get(resolver) .Setup(x => x.Resolve(It.Is <ResolutionRequest>(r => r.Name == paramTwo.Name && r.ServiceType == paramTwo.ParameterType))) .Returns(() => ResolutionResult.Success(path, paramTwoValue)); Mock.Get(factory) .Setup(x => x.Execute(It.Is <object[]>(e => e.Length == 2 && e[0] == paramOneValue && e[1] == paramTwoValue))) .Returns(resolved); // Act var result = sut.CreateFromFactory(factory, path, registration); // Assert Mock.Get(factory) .Verify(x => x.Execute(It.Is <object[]>(e => e.Length == 2 && e[0] == paramOneValue && e[1] == paramTwoValue)), Times.Once); Assert.That(result, Is.SameAs(resolved)); }
private IList <MemberBinding> GetMemberBindings(IContainerContext containerContext, IServiceRegistration serviceRegistration, ResolutionContext resolutionContext) { var length = serviceRegistration.InjectionMembers.Length; var members = new List <MemberBinding>(); for (var i = 0; i < length; i++) { var info = serviceRegistration.InjectionMembers[i]; if (!info.CanInject(containerContext.ContainerConfigurator.ContainerConfiguration, serviceRegistration.RegistrationContext)) { continue; } var expression = containerContext.ResolutionStrategy .BuildResolutionExpression(containerContext, resolutionContext, info.TypeInformation, serviceRegistration.RegistrationContext.InjectionParameters); if (expression == null) { continue; } members.Add(info.MemberInfo.AssignTo(expression)); } return(members); }
protected override Expression GetExpressionInternal(IServiceRegistration serviceRegistration, ResolutionInfo resolutionInfo, Type resolveType) { if (this.expression != null) { return(this.expression); } lock (this.syncObject) { if (this.expression != null) { return(this.expression); } var expr = this.expressionBuilder.CreateFillExpression(serviceRegistration, Expression.Constant(serviceRegistration.RegistrationContext.ExistingInstance), resolutionInfo, serviceRegistration.ImplementationType); var factory = expr.CompileDelegate(Constants.ScopeExpression); var instance = factory(resolutionInfo.ResolutionScope); if (serviceRegistration.ShouldHandleDisposal && instance is IDisposable disposable) { resolutionInfo.RootScope.AddDisposableTracking(disposable); } if (serviceRegistration.RegistrationContext.Finalizer != null) { var finalizerExpression = base.HandleFinalizer(Expression.Constant(instance), serviceRegistration); return(this.expression = Expression.Constant(finalizerExpression.CompileDelegate(Constants.ScopeExpression)(resolutionInfo.ResolutionScope))); } return(this.expression = Expression.Constant(instance)); } }
private void CreateMethodExpressions(IContainerContext containerContext, IServiceRegistration serviceRegistration, ResolutionContext resolutionContext, Expression newExpression, Expression[] buffer) { var length = serviceRegistration.MetaInformation.InjectionMethods.Length; for (var i = 0; i < length; i++) { var info = serviceRegistration.MetaInformation.InjectionMethods[i]; var paramLength = info.Parameters.Length; if (paramLength == 0) { buffer[i] = newExpression.CallMethod(info.Method); } else { var parameters = new Expression[paramLength]; for (var j = 0; j < paramLength; j++) { parameters[j] = containerContext.ResolutionStrategy.BuildResolutionExpression(containerContext, resolutionContext, info.Parameters[j], serviceRegistration.RegistrationContext.InjectionParameters); } buffer[i] = newExpression.CallMethod(info.Method, parameters); } } }
public Expression CreateFillExpression(IContainerContext containerContext, IServiceRegistration serviceRegistration, Expression instance, ResolutionContext resolutionContext, Type serviceType) { var lines = new List <Expression>(); if (instance.Type != serviceType) { instance = instance.ConvertTo(serviceType); } var variable = serviceType.AsVariable(); var assign = variable.AssignTo(instance); lines.Add(assign); if (serviceRegistration.InjectionMembers.Length > 0) { lines.AddRange(this.FillMembersExpression(containerContext, serviceRegistration.InjectionMembers, serviceRegistration.RegistrationContext, resolutionContext, variable)); } if (serviceRegistration.InjectionMethods.Length > 0 || serviceRegistration.RegistrationContext.Initializer != null || this.containerExtensionManager.HasPostBuildExtensions) { lines.AddRange(this.CreatePostWorkExpressionIfAny(containerContext, serviceRegistration, resolutionContext, serviceType, variable)); } lines.Add(variable); //block returns with the variable return(lines.AsBlock(variable)); }
private IEnumerable <MemberBinding> GetMemberBindings(IServiceRegistration serviceRegistration, ResolutionInfo resolutionInfo) { var length = serviceRegistration.MetaInformation.InjectionMembers.Length; var members = new List <MemberBinding>(); for (var i = 0; i < length; i++) { var info = serviceRegistration.MetaInformation.InjectionMembers[i]; if (!this.CanInjectMember(info, serviceRegistration)) { continue; } var expression = this.containerContext.ResolutionStrategy .BuildResolutionExpression(this.containerContext, resolutionInfo, info.TypeInformation, serviceRegistration.RegistrationContext.InjectionParameters); if (expression == null) { continue; } members.Add(Expression.Bind(info.MemberInfo, expression)); } return(members); }
private async void MonitorServiceRegistration(CancellationToken _cancellationToken) { try { await Task.Delay(RegistrationCheckPeriodInSeconds * 1000, _cancellationToken); while (!_cancellationToken.IsCancellationRequested) { if (_registration != null) { var serviceInstanceInfo = await _discovery.FindServiceByInstanceName(_registration.InstanceName); if (serviceInstanceInfo == null) { _registration = await _discovery.RegisterService(); } } await Task.Delay(RegistrationCheckPeriodInSeconds * 1000, _cancellationToken); } _log.Info("Service registration monitor stopped."); } catch (OperationCanceledException) { _log.Info("Service registration monitor stopped."); } }
public Expression CreateFillExpression(IServiceRegistration serviceRegistration, Expression instance, ResolutionInfo resolutionInfo, Type serviceType) { var block = new List <Expression>(); if (instance.Type != serviceType) { instance = Expression.Convert(instance, serviceType); } var variable = Expression.Variable(serviceType); var assign = Expression.Assign(variable, instance); block.Add(assign); if (serviceRegistration.MetaInformation.InjectionMembers.Length > 0) { block.AddRange(this.FillMembersExpression(serviceRegistration, resolutionInfo, variable)); } if (serviceRegistration.MetaInformation.InjectionMethods.Length > 0 || this.containerExtensionManager.HasPostBuildExtensions) { return(this.CreatePostWorkExpressionIfAny(serviceRegistration, resolutionInfo, variable, serviceType, block, variable)); } block.Add(variable); //return return(Expression.Block(new[] { variable }, block)); }
private Expression[] CreateMethodExpressions(IServiceRegistration serviceRegistration, ResolutionInfo resolutionInfo, Expression newExpression) { var length = serviceRegistration.MetaInformation.InjectionMethods.Length; var methodExpressions = new Expression[length]; for (var i = 0; i < length; i++) { var info = serviceRegistration.MetaInformation.InjectionMethods[i]; var paramLength = info.Parameters.Length; if (paramLength == 0) { methodExpressions[i] = Expression.Call(newExpression, info.Method, new Expression[0]); } else { var parameters = new Expression[paramLength]; for (var j = 0; j < paramLength; j++) { parameters[j] = this.containerContext.ResolutionStrategy.BuildResolutionExpression(this.containerContext, resolutionInfo, info.Parameters[j], serviceRegistration.RegistrationContext.InjectionParameters); } methodExpressions[i] = Expression.Call(newExpression, info.Method, parameters); } } return(methodExpressions); }
private Expression CreatePostWorkExpressionIfAny(IServiceRegistration serviceRegistration, ResolutionInfo resolutionInfo, Expression initExpression, Type serviceType, List <Expression> block = null, ParameterExpression variable = null) { block = block ?? new List <Expression>(); var newVariable = variable ?? Expression.Variable(initExpression.Type); if (variable == null) { block.Add(Expression.Assign(newVariable, initExpression)); } if (serviceRegistration.MetaInformation.InjectionMethods.Length > 0) { block.AddRange(this.CreateMethodExpressions(serviceRegistration, resolutionInfo, newVariable)); } if (this.containerExtensionManager.HasPostBuildExtensions) { var call = Expression.Call(Expression.Constant(this.containerExtensionManager), Constants.BuildExtensionMethod, newVariable, Expression.Constant(this.containerContext), Expression.Constant(resolutionInfo), Expression.Constant(serviceRegistration), Expression.Constant(serviceType)); block.Add(Expression.Assign(newVariable, Expression.Convert(call, initExpression.Type))); } block.Add(newVariable); //return return(Expression.Block(new[] { newVariable }, block)); }
private bool TryBuildResolutionConstructor( ConstructorInformation constructor, ResolutionContext resolutionContext, IContainerContext containerContext, IServiceRegistration serviceRegistration, out TypeInformation failedParameter, out Expression[] parameterExpressions, bool skipUknownResolution = false) { var paramLength = constructor.Parameters.Length; parameterExpressions = new Expression[paramLength]; failedParameter = null; for (var i = 0; i < paramLength; i++) { var parameter = constructor.Parameters[i]; parameterExpressions[i] = containerContext.ResolutionStrategy.BuildResolutionExpression(containerContext, resolutionContext, parameter, serviceRegistration.RegistrationContext.InjectionParameters, skipUknownResolution); if (parameterExpressions[i] == null) { failedParameter = parameter; return(false); } } return(true); }
/// <inheritdoc /> public override Expression GetExpression(IContainerContext containerContext, IServiceRegistration serviceRegistration, IObjectBuilder objectBuilder, ResolutionContext resolutionContext, Type resolveType) { if (this.expression != null) { return(this.expression); } lock (this.syncObject) { if (this.expression != null) { return(this.expression); } var expr = base.GetExpression(containerContext, serviceRegistration, objectBuilder, resolutionContext, resolveType); if (expr == null) { return(null); } object instance; if (expr.NodeType == ExpressionType.New && ((NewExpression)expr).Arguments.Count == 0) { instance = Activator.CreateInstance(expr.Type); } else { instance = expr.CompileDelegate(resolutionContext)(resolutionContext.RootScope); } this.expression = instance.AsConstant(); } return(this.expression); }
protected override Expression GetExpressionInternal(IServiceRegistration serviceRegistration, ResolutionInfo resolutionInfo, Type resolveType) { var genericType = serviceRegistration.ImplementationType.MakeGenericType(resolveType.GetGenericArguments()); var registration = this.RegisterConcreteGenericType(serviceRegistration, resolveType, genericType); return(registration.GetExpression(resolutionInfo, resolveType)); }
private static void RegisterElasticsearchReadStore <TReadModel>( IServiceRegistration serviceRegistration) where TReadModel : class, IReadModel { serviceRegistration.Register <IElasticsearchReadModelStore <TReadModel>, ElasticsearchReadModelStore <TReadModel> >(); serviceRegistration.Register <IReadModelStore <TReadModel> >(r => r.Resolver.Resolve <IElasticsearchReadModelStore <TReadModel> >()); }
public IStashboxContainer ReMap(IServiceRegistration serviceRegistration, IRegistrationContext registrationContext) { if (serviceRegistration.IsDecorator) { this.containerContext.DecoratorRepository.AddDecorator(registrationContext.ServiceType, serviceRegistration, true, false); } else { if (registrationContext.AdditionalServiceTypes.Length > 0) { foreach (var additionalServiceType in registrationContext.AdditionalServiceTypes) { this.containerContext.RegistrationRepository.AddOrUpdateRegistration(serviceRegistration, additionalServiceType, true, false); } } this.containerContext.RegistrationRepository.AddOrUpdateRegistration(serviceRegistration, registrationContext.ServiceType, true, false); } this.containerContext.Container.RootScope.InvalidateDelegateCache(); this.containerExtensionManager.ExecuteOnRegistrationExtensions(this.containerContext, serviceRegistration); return(this.containerContext.Container); }
protected Expression HandleFinalizer(Expression instanceExpression, IServiceRegistration serviceRegistration) { var addFinalizerMethod = Constants.AddWithFinalizerMethod.MakeGenericMethod(instanceExpression.Type); return(Expression.Call(Constants.ScopeExpression, addFinalizerMethod, instanceExpression, Expression.Constant(serviceRegistration.RegistrationContext.Finalizer))); }
/// <summary> /// Resolves the given resolution request, using the given service registration. /// </summary> /// <param name="request">Request.</param> /// <param name="registration">Registration.</param> protected virtual ResolutionResult Resolve(ResolutionRequest request, IServiceRegistration registration) { if (request == null) { throw new ArgumentNullException(nameof(request)); } AssertIsValidRequest(request); if (registration == null) { return(ResolutionResult.Failure(request.ResolutionPath)); } var factory = registration.GetFactoryAdapter(request); if (factory == null) { return(ResolutionResult.Failure(request.ResolutionPath)); } var resolved = instanceCreator.CreateFromFactory(factory, request.ResolutionPath, registration); InvokeServiceResolved(registration, resolved); return(ResolutionResult.Success(request.ResolutionPath, resolved)); }
public void Register(IServiceRegistration services, IDictionary <string, object> data) { services.RegisterSingleton(r => r .Types(t => t.AssignableTo <IValidator>()) .As(s => s.Self().ImplementedInterfaces()) ); }
//private readonly IViewRenderService _viewRenderService; //readonly IConfiguration _configuration; //private readonly IEmailSender _emailSender; public CartController(IServiceRegistration serviceRegistration) { _serviceRegistration = serviceRegistration; //_viewRenderService = viewRenderService; //_configuration = configuration; //_emailSender = emailSender; }
/// <summary> /// Lookups the service references. /// </summary> /// <param name="context">The context.</param> /// <returns>IServiceReference[].</returns> /// Performs a lookup for ServiceReferences that are bound to this /// ServiceRegistry using the specified BundleContext. /// @param context The BundleContext to lookup the ServiceReferences on. /// @return An array of all matching ServiceReferences or null if none /// exist. public IServiceReference[] LookupServiceReferences(IBundleContext context) { int size; List <IServiceReference> references; List <IServiceRegistration> serviceRegs = (List <IServiceRegistration>)PublishedServicesByContext[context]; if (serviceRegs == null) { return(null); } size = serviceRegs.Count; if (size == 0) { return(null); } references = new List <IServiceReference>(); for (int i = 0; i < size; i++) { IServiceRegistration registration = (IServiceRegistration)serviceRegs[i]; IServiceReference reference = registration.GetReference(); references.Add(reference); } if (references.Count == 0) { return(null); } return((IServiceReference[])references.ToArray()); }
/// <summary> /// Unpublishes the services. /// </summary> /// <param name="context">The context.</param> /// Unpublishes all services from this ServiceRegistry that the /// specified BundleContext registered. /// @param context the BundleContext to unpublish all services for. public void UnpublishServices(IBundleContext context) { // Get all the Services published by the BundleContext. List <IServiceRegistration> serviceRegs = (List <IServiceRegistration>)PublishedServicesByContext[context]; if (serviceRegs != null) { // Remove this list for the BundleContext PublishedServicesByContext.Remove(context); int size = serviceRegs.Count(); for (int i = 0; i < size; i++) { IServiceRegistration serviceReg = (IServiceRegistration)serviceRegs[i]; // Remove each service from the list of all published Services AllPublishedServices.Remove(serviceReg); // Remove each service from the list of Services published by Class Name. string[] clazzes = ((ServiceRegistration)serviceReg).Classes; int numclazzes = clazzes.Length; for (int j = 0; j < numclazzes; j++) { string clazz = clazzes[j]; if (PublishedServicesByClass.ContainsKey(clazz)) { List <IServiceRegistration> services = (List <IServiceRegistration>)PublishedServicesByClass[clazz]; services.Remove(serviceReg); } } } } }
/// <summary> /// Scan and Register services using the specified <paramref name="builder"/> for the specified <paramref name="lifetime"/>. /// </summary> /// <param name="services">The <see cref="IServiceRegistration"/> to add the service to.</param> /// <param name="builder">The builder delegate used to scan and register services</param> /// <param name="lifetime">The service lifetime.</param> /// <returns>A reference to this instance after the operation has completed.</returns> public static IServiceRegistration Register(this IServiceRegistration services, Action <IServiceRegistrationBuilder> builder, ServiceLifetime lifetime) { if (services == null) { throw new ArgumentNullException(nameof(services)); } if (builder == null) { throw new ArgumentNullException(nameof(builder)); } var types = services.ServiceContext.Types; var serviceBuilder = new ServiceRegistrationBuilder(types); builder(serviceBuilder); var mapping = serviceBuilder.TypeMaps; foreach (var typeMap in mapping) { foreach (var serviceType in typeMap.ServiceTypes) { services.Register(serviceType, typeMap.ImplementationType, lifetime); } } return(services); }
/// <summary> /// Disposes of a single component instance, matching a given registration. /// </summary> /// <param name="registration">Registration.</param> /// <param name="instanceCache">Instance cache.</param> protected virtual void Dispose(IServiceRegistration registration, ICachesResolvedServiceInstances instanceCache) { if (registration == null) { throw new ArgumentNullException(nameof(registration)); } if (instanceCache == null) { throw new ArgumentNullException(nameof(instanceCache)); } object instance; if (!instanceCache.TryGet(registration, out instance)) { return; } if (!(instance is IDisposable)) { return; } ((IDisposable)instance).Dispose(); }
IDictionary <ServiceRegistrationKey, IServiceRegistration> GetNonConflictingRegistrations(IEnumerable <ServiceRegistrationKey> alreadyFound, IServiceRegistrationProvider provider, Type serviceTypeFilter) { if (alreadyFound == null) { throw new ArgumentNullException(nameof(alreadyFound)); } if (provider == null) { throw new ArgumentNullException(nameof(provider)); } var candidates = (serviceTypeFilter != null)? provider.GetAll(serviceTypeFilter) : provider.GetAll(); if (candidates == null) { candidates = new IServiceRegistration[0]; } return((from registration in candidates let key = ServiceRegistrationKey.ForRegistration(registration) where !alreadyFound.Contains(key) select new { Registration = registration, Key = key }) .ToDictionary(k => k.Key, v => v.Registration)); }
private ResolutionConstructor SelectConstructor(IServiceRegistration serviceRegistration, ResolutionInfo resolutionInfo, ConstructorInformation[] constructors) { var length = constructors.Length; var checkedConstructors = new Dictionary <ConstructorInfo, TypeInformation>(); for (var i = 0; i < length; i++) { var constructor = constructors[i]; var paramLength = constructor.Parameters.Length; var parameterExpressions = new Expression[paramLength]; var hasNullParameter = false; TypeInformation failedParameter = null; for (var j = 0; j < paramLength; j++) { var parameter = constructor.Parameters[j]; var expression = this.containerContext.ResolutionStrategy.BuildResolutionExpression(this.containerContext, resolutionInfo, parameter, serviceRegistration.RegistrationContext.InjectionParameters); if (expression == null) { hasNullParameter = true; failedParameter = parameter; break; } parameterExpressions[j] = expression; } if (hasNullParameter) { if (!resolutionInfo.NullResultAllowed) { checkedConstructors.Add(constructor.Constructor, failedParameter); } continue; } return(new ResolutionConstructor { Constructor = constructor.Constructor, Parameters = parameterExpressions }); } if (resolutionInfo.NullResultAllowed) { return(null); } var stringBuilder = new StringBuilder(); foreach (var checkedConstructor in checkedConstructors) { stringBuilder.AppendLine($"Checked constructor {checkedConstructor.Key}, unresolvable parameter: ({checkedConstructor.Value.Type}){checkedConstructor.Value.ParameterName}"); } throw new ResolutionFailedException(serviceRegistration.ImplementationType, stringBuilder.ToString()); }
private void RegisterDefaults(IServiceRegistration serviceRegistration) { serviceRegistration.Register <ILog, ConsoleLog>(); serviceRegistration.Register <IAggregateStoreResilienceStrategy, NoAggregateStoreResilienceStrategy>(); serviceRegistration.Register <IDispatchToReadStoresResilienceStrategy, NoDispatchToReadStoresResilienceStrategy>(); serviceRegistration.Register <ISagaUpdateResilienceStrategy, NoSagaUpdateResilienceStrategy>(); serviceRegistration.Register <IDispatchToSubscriberResilienceStrategy, NoDispatchToSubscriberResilienceStrategy>(); serviceRegistration.Register <IDispatchToReadStores, DispatchToReadStores>(); serviceRegistration.Register <IEventStore, EventStoreBase>(); serviceRegistration.Register <IEventPersistence, InMemoryEventPersistence>(Lifetime.Singleton); serviceRegistration.Register <ICommandBus, CommandBus>(); serviceRegistration.Register <IAggregateStore, AggregateStore>(); serviceRegistration.Register <ISnapshotStore, SnapshotStore>(); serviceRegistration.Register <ISnapshotSerilizer, SnapshotSerilizer>(); serviceRegistration.Register <ISnapshotPersistence, NullSnapshotPersistence>(); serviceRegistration.Register <ISnapshotUpgradeService, SnapshotUpgradeService>(); serviceRegistration.Register <ISnapshotDefinitionService, SnapshotDefinitionService>(Lifetime.Singleton); serviceRegistration.Register <IReadModelPopulator, ReadModelPopulator>(); serviceRegistration.Register <IEventJsonSerializer, EventJsonSerializer>(); serviceRegistration.Register <IEventDefinitionService, EventDefinitionService>(Lifetime.Singleton); serviceRegistration.Register <IQueryProcessor, QueryProcessor>(); serviceRegistration.Register <IJsonSerializer, JsonSerializer>(Lifetime.Singleton); serviceRegistration.Register <IJsonOptions, JsonOptions>(); serviceRegistration.Register <IJobScheduler, InstantJobScheduler>(); serviceRegistration.Register <IJobRunner, JobRunner>(); serviceRegistration.Register <IJobDefinitionService, JobDefinitionService>(Lifetime.Singleton); serviceRegistration.Register <IOptimisticConcurrencyRetryStrategy, OptimisticConcurrencyRetryStrategy>(); serviceRegistration.Register <IEventUpgradeManager, EventUpgradeManager>(Lifetime.Singleton); serviceRegistration.Register <IAggregateFactory, AggregateFactory>(); serviceRegistration.Register <IReadModelDomainEventApplier, ReadModelDomainEventApplier>(); serviceRegistration.Register <IDomainEventPublisher, DomainEventPublisher>(); serviceRegistration.Register <ISerializedCommandPublisher, SerializedCommandPublisher>(); serviceRegistration.Register <ICommandDefinitionService, CommandDefinitionService>(Lifetime.Singleton); serviceRegistration.Register <IDispatchToEventSubscribers, DispatchToEventSubscribers>(); serviceRegistration.Register <IDomainEventFactory, DomainEventFactory>(Lifetime.Singleton); serviceRegistration.Register <ISagaDefinitionService, SagaDefinitionService>(Lifetime.Singleton); serviceRegistration.Register <ISagaStore, SagaAggregateStore>(); serviceRegistration.Register <ISagaErrorHandler, SagaErrorHandler>(); serviceRegistration.Register <IDispatchToSagas, DispatchToSagas>(); #if NET452 serviceRegistration.Register <IMemoryCache, MemoryCache>(Lifetime.Singleton); #else serviceRegistration.Register <IMemoryCache, DictionaryMemoryCache>(Lifetime.Singleton); #endif serviceRegistration.RegisterGeneric(typeof(ISagaUpdater <, , ,>), typeof(SagaUpdater <, , ,>)); serviceRegistration.Register <IEventFlowConfiguration>(_ => _eventFlowConfiguration); serviceRegistration.Register <ICancellationConfiguration>(_ => _eventFlowConfiguration); serviceRegistration.RegisterGeneric(typeof(ITransientFaultHandler <>), typeof(TransientFaultHandler <>)); serviceRegistration.RegisterGeneric(typeof(IReadModelFactory <>), typeof(ReadModelFactory <>), Lifetime.Singleton); serviceRegistration.Register <IBootstrap, DefinitionServicesInitilizer>(); serviceRegistration.Register(_ => ModuleRegistration, Lifetime.Singleton); serviceRegistration.Register <ILoadedVersionedTypes>(r => new LoadedVersionedTypes( _jobTypes, _commandTypes, _aggregateEventTypes, _sagaTypes, _snapshotTypes), Lifetime.Singleton); }
private static void RegisterInMemoryReadStore <TReadModel>( IServiceRegistration serviceRegistration) where TReadModel : class, IReadModel { serviceRegistration.Register <IInMemoryReadStore <TReadModel>, InMemoryReadStore <TReadModel> >(Lifetime.Singleton); serviceRegistration.Register <IReadModelStore <TReadModel> >(r => r.Resolver.Resolve <IInMemoryReadStore <TReadModel> >()); serviceRegistration.Register <IQueryHandler <InMemoryQuery <TReadModel>, IReadOnlyCollection <TReadModel> >, InMemoryQueryHandler <TReadModel> >(); }
private static void RegisterMssqlReadStore <TReadModel>( IServiceRegistration serviceRegistration) where TReadModel : class, IReadModel { serviceRegistration.Register <IReadModelSqlGenerator, ReadModelSqlGenerator>(Lifetime.Singleton, true); serviceRegistration.Register <IMssqlReadModelStore <TReadModel>, MssqlReadModelStore <TReadModel> >(); serviceRegistration.Register <IReadModelStore <TReadModel> >(r => r.Resolver.Resolve <IMssqlReadModelStore <TReadModel> >()); }
/// <summary> /// /// </summary> /// <param name="context"></param> public void Start(IBundleContext context) { var serviceRef = context.GetServiceReference <IAttachContent>(); AttachContentService = context.GetService <IAttachContent>(serviceRef); serviceRegistration = context.RegisterService <IMenuItemEvent>(new MenuItemEvent()); }
/// <summary> /// Gets a value which indicates whether or not the current provider has a specified registrations. /// </summary> /// <returns> /// <c>true</c>, if the registration is contained within this provider, <c>false</c> otherwise.</returns> /// <param name="registration">A registration.</param> public bool HasRegistration(IServiceRegistration registration) { if (registration == null) { throw new ArgumentNullException(nameof(registration)); } return(providers.Any(x => x.HasRegistration(registration))); }
/// <summary> /// Adds or updates an element in the repository. /// </summary> /// <param name="typeKey">The key type.</param> /// <param name="registration">The registration.</param> /// <param name="nameKey">The name of the registration.</param> public void AddOrUpdateRegistration(Type typeKey, IServiceRegistration registration, string nameKey) { var immutableTree = ImmutableTree<IServiceRegistration>.Empty; var newTree = immutableTree.AddOrUpdate(nameKey.GetHashCode(), registration); lock (this.syncObject) { this.serviceRepository = this.serviceRepository.AddOrUpdate(typeKey.GetHashCode(), newTree, (oldValue, newValue) => newValue); } }
public override void Start(IBundleContext context) { TestIBll.IMessage message = new TestBll.MessageBll(); Message = message; TestIBll.ISayYear year = new TestBll.SayYearBll(); SayYear = year; messageReg = context.RegisterService<TestIBll.IMessage>(message, null); sayyear = context.RegisterService<TestIBll.ISayYear>(year, null); mcontext = context; }
public override void Start(IBundleContext context) { IBLL.IMyBll mybll = new BLL.MyBll(); mybllserver=context.RegisterService<IBLL.IMyBll>(mybll, null); mcontext = context; }
public void UnpublishService(IBundleContext context, IServiceRegistration serviceRegistration) { // Remove the ServiceRegistration from the list of Services published by BundleContext. List<IServiceRegistration> contextServices = (List<IServiceRegistration>)publishedServicesByContext[context]; if (contextServices != null) { contextServices.Remove(serviceRegistration); } // Remove the ServiceRegistration from the list of Services published by Class Name. string[] clazzes = ((ServiceRegistration)serviceRegistration).Classes; int size = clazzes.Length; for (int i = 0; i < size; i++) { string clazz = clazzes[i]; List<IServiceRegistration> services = (List<IServiceRegistration>)publishedServicesByClass[clazz]; services.Remove(serviceRegistration); } // Remove the ServiceRegistration from the list of all published Services. allPublishedServices.Remove(serviceRegistration); }
public void PublishService(IBundleContext context, IServiceRegistration serviceRegistration) { // Add the ServiceRegistration to the list of Services published by BundleContext. List<IServiceRegistration> contextServices = null; if (publishedServicesByContext.ContainsKey(context)) { contextServices = (List<IServiceRegistration>)publishedServicesByContext[context]; } if (contextServices == null) { contextServices = new List<IServiceRegistration>(); publishedServicesByContext.Add(context, contextServices); } contextServices.Add(serviceRegistration); // Add the ServiceRegistration to the list of Services published by Class Name. string[] clazzes = ((ServiceRegistration)serviceRegistration).Classes; int size = clazzes.Length; for (int i = 0; i < size; i++) { string clazz = clazzes[i]; List<IServiceRegistration> services = null; if (publishedServicesByClass.ContainsKey(clazz)) { services = (List<IServiceRegistration>)publishedServicesByClass[clazz]; } if (services == null) { services = new List<IServiceRegistration>(); publishedServicesByClass.Add(clazz, services); } services.Add(serviceRegistration); } // Add the ServiceRegistration to the list of all published Services. allPublishedServices.Add(serviceRegistration); }
private bool TryGetByTypeKeyWithConditionsWithoutGenericDefinitionExtraction(TypeInformation typeInfo, out IServiceRegistration registration) { ImmutableTree<IServiceRegistration> registrations; if (!this.TryGetRegistrationsByTypeWithoutGenericDefinitionExtraction(typeInfo.Type, out registrations)) { registration = null; return false; } var serviceRegistrations = registrations.Enumerate().Select(reg => reg.Value).ToArray(); if (serviceRegistrations.Any(reg => reg.HasCondition)) registration = serviceRegistrations.Where(reg => reg.HasCondition) .FirstOrDefault(reg => reg.IsUsableForCurrentContext(typeInfo)); else registration = serviceRegistrations.FirstOrDefault(reg => reg.IsUsableForCurrentContext(typeInfo)); return registration != null; }
private bool TryGetByTypeKey(TypeInformation typeInfo, out IServiceRegistration registration) { ImmutableTree<IServiceRegistration> registrations; if (!this.TryGetRegistrationsByType(typeInfo.Type, out registrations)) { registration = null; return false; } registration = registrations.Value; return true; }
private bool TryGetByNamedKeyWithoutGenericDefinitionExtraction(TypeInformation typeInfo, out IServiceRegistration registration) { ImmutableTree<IServiceRegistration> registrations; if (this.TryGetRegistrationsByTypeWithoutGenericDefinitionExtraction(typeInfo.Type, out registrations)) { registration = registrations.GetValueOrDefault(typeInfo.DependencyName.GetHashCode()); return registration != null; } registration = null; return false; }
/// <summary> /// Tries to retrieve all registrations for a type. /// </summary> /// <param name="typeInfo">The requested type information.</param> /// <param name="registrations">The retrieved registrations.</param> /// <returns>True if registrations were found, otherwise false.</returns> public bool TryGetTypedRepositoryRegistrations(TypeInformation typeInfo, out IServiceRegistration[] registrations) { var serviceRegistrations = this.serviceRepository.GetValueOrDefault(typeInfo.Type.GetHashCode()); if (serviceRegistrations == null) { Type genericTypeDefinition; if (this.TryHandleOpenGenericType(typeInfo.Type, out genericTypeDefinition)) { serviceRegistrations = this.genericDefinitionRepository.GetValueOrDefault(genericTypeDefinition.GetHashCode()); } else { registrations = null; return false; } } registrations = serviceRegistrations?.Enumerate().Select(reg => reg.Value).ToArray(); return registrations != null; }
/// <summary> /// Tries to retrieve a non generic definition registration with conditions. /// </summary> /// <param name="typeInfo">The requested type information.</param> /// <param name="registration">The retrieved registration.</param> /// <returns>True if a registration was found, otherwise false.</returns> public bool TryGetRegistrationWithConditionsWithoutGenericDefinitionExtraction(TypeInformation typeInfo, out IServiceRegistration registration) { return typeInfo.DependencyName == null ? this.TryGetByTypeKeyWithConditionsWithoutGenericDefinitionExtraction(typeInfo, out registration) : this.TryGetByNamedKeyWithoutGenericDefinitionExtraction(typeInfo, out registration); }
/// <summary> /// Tries to retrieve a registration with conditions. /// </summary> /// <param name="typeInfo">The requested type information.</param> /// <param name="registration">The retrieved registration.</param> /// <returns>True if a registration was found, otherwise false.</returns> public bool TryGetRegistrationWithConditions(TypeInformation typeInfo, out IServiceRegistration registration) { return typeInfo.DependencyName == null ? this.TryGetByTypeKeyWithConditions(typeInfo, out registration) : this.TryGetByNamedKey(typeInfo, out registration); }
public override void Start(IBundleContext context) { Log2Service.ITextLog log = new Log2Net.TextLog(); mybllserver = context.RegisterService<Log2Service.ITextLog>(log, null); mcontext = context; }