public void Initialize(INotificationQueue notificationQueue, IRegistrator registrator) { _registrator = registrator; _notificationQueue = notificationQueue; _registrator.ClientExtraInfoUpdated += (a, e) => SendTile(e.UniqueId); }
public RdapConnectionListener() { sessionRegister = new SessionRegistrator(); publisherRegistrator = new PublisherRegistrator(); connectionFactory = new RdapConnectionFactory(sessionRegister, publisherRegistrator); connectionListener = new TcpConnectionListener(connectionFactory, sessionRegister); }
/// <summary> /// Sets the default implementations. /// </summary> /// <param name="container">The container.</param> private static void SetDefaultImplementations(IRegistrator container) { // TODO auto-register at least from Controllers and NSI WS container.Register<IStructureWriterFactory, SdmxStructureXmlFactory>(Reuse.Singleton, ifAlreadyRegistered: IfAlreadyRegistered.Keep); container.Register<IRetrieverManager, RetrieverManager>(Reuse.Singleton, ifAlreadyRegistered: IfAlreadyRegistered.Keep); container.Register<IStructureWriterFactory, SdmxStructureXmlFactory>(Reuse.Singleton, ifAlreadyRegistered: IfAlreadyRegistered.Keep); container.Register<IStructureWriterManager, StructureWriterManager>(Reuse.Singleton, ifAlreadyRegistered: IfAlreadyRegistered.Keep, made: FactoryMethod.ConstructorWithResolvableArguments); container.Register<IDataWriterFactory, LazyDataWriterFactory>(Reuse.Singleton, ifAlreadyRegistered: IfAlreadyRegistered.Keep); container.Register<IDataWriterManager, DataWriterManager>(Reuse.Singleton, ifAlreadyRegistered: IfAlreadyRegistered.Keep); container.Register<IDataRequestController, DataRequestController>(Reuse.Singleton, ifAlreadyRegistered: IfAlreadyRegistered.Keep); container.Register<IStructureRequestController, StructureRequestController>(Reuse.Singleton, ifAlreadyRegistered: IfAlreadyRegistered.Keep); container.Register<IMessageBuilderManager, MessageBuilderManager>(Reuse.Singleton, ifAlreadyRegistered: IfAlreadyRegistered.Keep); container.Register<INSIStdV21Service, NSIStdV21Service>(Reuse.Singleton, ifAlreadyRegistered: IfAlreadyRegistered.Keep); container.Register<INSIEstatV20Service, NsiEstatV20Service>(Reuse.Singleton, ifAlreadyRegistered: IfAlreadyRegistered.Keep); container.Register<INSIStdV20Service, NsiStdV20Service>(Reuse.Singleton, ifAlreadyRegistered: IfAlreadyRegistered.Keep); container.Register<IWadlProvider, WadlProvider>(Reuse.Singleton, ifAlreadyRegistered: IfAlreadyRegistered.Keep); container.Register<IStaticWsdlService, StaticWsdlService>(Reuse.Singleton, ifAlreadyRegistered: IfAlreadyRegistered.Keep); container.Register<IDataResource, DataResource>(Reuse.Singleton, ifAlreadyRegistered: IfAlreadyRegistered.Keep); container.Register<IStructureResource, StructureResource>(Reuse.Singleton, ifAlreadyRegistered: IfAlreadyRegistered.Keep); container.Register<IMessageFaultSoapBuilderFactory, MessageFaultSoapBuilderFactory>(Reuse.Singleton, ifAlreadyRegistered: IfAlreadyRegistered.Keep); container.Register<IDataQueryVisitorFactory, DataQueryVisitorFactory>(Reuse.Singleton, ifAlreadyRegistered: IfAlreadyRegistered.Keep); container.Register<IDataflowPrincipalManager, DataflowPrincipalManager>(Reuse.Singleton, ifAlreadyRegistered: IfAlreadyRegistered.Keep); container.Register<WsdlRegistry>(Reuse.Singleton); }
public CompositionRoot(IRegistrator container) { container.Register <IDatastoreDbFactory, DatastoreDbFactory>(Reuse.Singleton); container.Register(reuse: Reuse.Singleton, made: Made.Of(r => ServiceInfo.Of <IDatastoreDbFactory>(), f => f.CreateDatastoreDb())); container.RegisterDelegate <ServiceFactory>(r => r.Resolve); container.RegisterMany(new[] { typeof(IMediator).GetAssembly(), typeof(DatastoreDbFactory).GetAssembly() }, Registrator.Interfaces); }
public static IRegistrator Component(this IRegistrator registrator, Action <IConfigurator <IRegistrator> > setup) { var configurator = new Configurator <IRegistrator>(); configurator.Setup(c => c(registrator)); setup(configurator); return(configurator.Build()); }
private static void RegisterTransientDisposablesTracker(IRegistrator registrator) { registrator.Register <TransientDisposablesTracker>(Reuse.InCurrentScope); registrator.RegisterInitializer <object>( (service, r) => r.Resolve <TransientDisposablesTracker>().Track((IDisposable)service), r => r.ReuseLifespan == 0 && r.GetKnownImplementationOrServiceType().IsAssignableTo <IDisposable>()); }
/// <summary>Adds to application builder the registered OWIN middlewares /// wrapped in <see cref="DryIocWrapperMiddleware{TServiceMiddleware}"/>.</summary> /// <param name="app">App builder to use.</param> /// <param name="registry">Container registry to find registered <see cref="OwinMiddleware"/>.</param> /// <returns>App builder to enable method chaining.</returns> public static IAppBuilder UseRegisteredMiddlewares(this IAppBuilder app, IRegistrator registry) { foreach (var middlewareType in registry.DiscoverRegisteredMiddlewares()) { app = app.Use(middlewareType); } return(app); }
public override void Load(IRegistrator registrar) { var navigationView = new NavigationView(); registrar.RegisterInstance <IView>(navigationView, IfAlreadyRegistered.Replace, Setup.Default, nameof(NavigationView)); registrar.RegisterInstance <IParameterViewStackService>(new ParameterViewStackService(navigationView)); registrar.RegisterInstance <IViewModelFactory>(new DefaultViewModelFactory()); }
public TcpConnection(TcpSocketClient socketClient, ISessionContext sessionContext, IRegistrator<string, IConnection> registrator) { this.socketClient = socketClient; this.sessionContext = sessionContext; this.registrator = registrator; this.socketClient.OnDataRecieved += OnDataRecieved; this.socketClient.OnExceptionThrown += OnSocketClientExceptionThrown; }
public static IRegistrator SetupViewModels(this IRegistrator registrator) { registrator.Register <ILightsOutGameViewModel, LightsOutGameViewModel>(); registrator.Register <ISwitchViewModel, SwitchViewModel>(); registrator.Register <ILevelsLoader, LevelsLoader>(); registrator.RegisterDelegate <Func <HttpClient> >(r => () => new HttpClient()); registrator.RegisterDelegate <Func <ISwitchViewModel> >(r => () => r.Resolve <ISwitchViewModel>()); return(registrator); }
protected override void Load(IRegistrator builder, ITypeFinder typeFinder, SiteConfig config) { //Register for Data Repositories builder.Register <IProjectTypeRepository, ProjectTypeRepository>(Reuse.InWebRequest); builder.Register <IProjectRepository, ProjectRepository>(Reuse.InWebRequest); //Register for Data Services builder.Register <ITmcMainService, TmcMainService>(Reuse.InWebRequest); }
/// <summary> /// Ensures that a service always resolves as lazy proxy (uses ProxyGenerator, a bit easier to understand). /// </summary> /// <param name="registrator">The registrator.</param> /// <param name="interfaceType">The type of the interface.</param> /// <param name="serviceKey">Optional service key.</param> public static IRegistrator ResolveAsLazy(this IRegistrator registrator, Type interfaceType, object serviceKey = null) { var method = typeof(WrapAsLazy).SingleMethod(nameof(CreateLazyProxy), includeNonPublic: true) .MakeGenericMethod(interfaceType); var decoratorSetup = GetDecoratorSetup(serviceKey); registrator.Register(interfaceType, Reuse.Transient, Made.Of(method), decoratorSetup); return(registrator); }
public User(IServiceProvider serviceProvider, IResolver resolver, IResolverContext resolverContext, IRegistrator registrator, IContainer container) { ServiceProvider = serviceProvider; Resolver = resolver; ResolverContext = resolverContext; Registrator = registrator; Container = container; }
private static IEnumerable <Type> DiscoverRegisteredMiddlewares(this IRegistrator registry) { return(registry.GetServiceRegistrations() .Where(r => r.ServiceType.IsAssignableTo(typeof(OwinMiddleware))) // note: ordering is important and set to registration order by default .OrderBy(r => r.FactoryRegistrationOrder) .Select(r => typeof(DryIocWrapperMiddleware <>) .MakeGenericType(r.Factory.ImplementationType ?? r.ServiceType))); }
public static IRegistrator SetupMappings(this IRegistrator registrator) { registrator.RegisterDelegate(r => new MapperConfiguration(cfg => { cfg.AddProfile <MappingProfile>(); })); registrator.RegisterDelegate <IMapper>(r => new Mapper(r.Resolve <MapperConfiguration>()), Reuse.Singleton); return(registrator); }
public void Compose(IRegistrator registrator) { registrator .Register <IFoo>(Lifetime.PerContainer) .Register <IBar>(Lifetime.PerContainer) .Register <IBuzzy>(Lifetime.PerContainer) .Register <IEnumerableDependencyFoo>() .Register <IReadOnlyCollectionDependencyFoo>(Lifetime.PerContainer); }
public static void RegisterForAllImplementedInterfaces(this IRegistrator registrator, Type type, IReuse reuse = null) { var implementedTypes = type.GetImplementedTypes(); foreach (var implementedType in implementedTypes) { registrator.Register(implementedType, type, reuse); } }
// If you need the whole container then change parameter type from IRegistrator to IContainer public CompositionRoot(IRegistrator r) { r.Register <IHotelServices, HotelServices>(Reuse.Singleton); r.Register <IDataServices, DataServices>(Reuse.Transient); // r.Register<IScopedService, ScopedService>(Reuse.InCurrentScope); var assemblies = new[] { typeof(DataServices).GetAssembly() }; r.RegisterExports(assemblies); }
public CompositionRoot(IRegistrator registrator) { registrator.Register <IUserService, UserService>(); registrator.Register <IGameService, GameService>(); registrator.Register <IEmailService, EmailService>(); registrator.Register <ISmtpHelper, SmtpHelper>(); registrator.Register <IGameRepository, GameRepository>(); registrator.Register <IAuthorizationHandler, IsUserInvolvedAuthorizationHandler>(); registrator.RegisterInstance(new TicTacToeHelper()); }
public CompositionRoot(IRegistrator registrator) { registrator.Register <IUnitOfWorkManager, UnitOfWorkManager>(Reuse.InWebRequest); registrator.Register <IClaimService, ClaimService>(Reuse.InWebRequest); //UnitOfWork will be disposed each time, so it should get a new instance each time registrator.Register <IUnitOfWork, UnitOfWork>(setup: Setup.With(allowDisposableTransient: true)); registrator.Register <IRepository <ClaimDTO, int>, GeneralRepository <ClaimDTO, int> >(setup: Setup.With(allowDisposableTransient: true)); registrator.Register <DbContext, ApplicationDbContext>(setup: Setup.With(allowDisposableTransient: true)); }
static void RegisterRepositories(IRegistrator container) { var ns = typeof(CUsers.Domain.UserEventRepository).Namespace; var types = typeof(CUsers.Domain.UserEventRepository).Assembly.GetLoadedTypes().Where( (i) => i.Namespace == ns && !i.IsInterface && !i.IsAbstract && i.Name.EndsWith("Repository") ); container.RegisterMany(types, Reuse.Singleton, serviceTypeCondition: (s) => s.IsInterface, ifAlreadyRegistered: IfAlreadyRegistered.Throw); }
// If you need the whole container then change parameter type from IRegistrator to IContainer public CompositionRoot(IRegistrator r) { // TODO: register services here ////r.Register<ISingletonService, SingletonService>(Reuse.Singleton); ////r.Register<ITransientService, TransientService>(Reuse.Transient); ////r.Register<IScopedService, ScopedService>(Reuse.InCurrentScope); ////var assemblies = new[] { typeof(ExportedService).GetAssembly() }; ////r.RegisterExports(assemblies); }
private static bool ExampleOfCustomRegisterDescriptor(IRegistrator registrator, ServiceDescriptor descriptor) { #if DEBUG if (descriptor.ServiceType == typeof(ILoggerFactory)) { Console.WriteLine($"{descriptor.ServiceType.Name} is registered as instance: {descriptor}"); } #endif return(false); // fallback to the default registration logic }
/// <summary> /// Registers a service that is always resolved as lazy wrapper. /// </summary> /// <typeparam name="TInterface">The type of the interface.</typeparam> /// <typeparam name="TClass">The type of the class.</typeparam> /// <param name="registrator">The registrator.</param> /// <param name="serviceKey">Optional service key.</param> public static IRegistrator RegisterAsLazy <TInterface, TClass>(this IRegistrator registrator, object serviceKey = null) where TInterface : class where TClass : TInterface { // perform normal registration registrator.Register <TInterface, TClass>(serviceKey: serviceKey); // register the interface for lazy interception return(registrator.ResolveAsLazy <TInterface>(serviceKey)); }
public void RegisterTypes(IRegistrator registrator) { // Navigation registrator.Register <IStackAlgorithm, NavigationStackAlgorithm>(Reuse.Singleton, serviceKey: typeof(NavigationStack)); registrator.Register <IStackAlgorithm, ModalStackAlgorithm>(Reuse.Singleton, serviceKey: typeof(ModalStack)); registrator.Register <IViewModelWrapperStorage, ViewModelWrapperStorage>(Reuse.Singleton); registrator.Register <INavigationViewProvider, NavigationViewProvider>(Reuse.Singleton); registrator.Register <INavigationPageFactory, DefaultNavigationPageFactory>(Reuse.Singleton); registrator.Register <INavigationMapper, NavigationMapper>(Reuse.Singleton); registrator.Register <INavigationService, NavigationService>(Reuse.Singleton); }
private static void RegisterComponents(this IRegistrator container) { container.Register( Made.Of( () => Arg.Of <ILoggerFactory>().CreateLogger(Arg.Index <Type>(0)), request => request.Parent.ImplementationType ) ); container.Register <INHibernateInstaller, NHibInstaller>(Reuse.Singleton); }
public void Compose(IRegistrator registrator) { foreach (var attribute in _registerAttributes) { registrator.Register(attribute.ServiceType, attribute.Lifetime); } foreach (var attribute in _registerByAttributes) { registrator.RegisterBy(attribute.RegistrationAttributeType, attribute.Lifetime); } }
public CompositionRoot(IRegistrator r) { // Services r.Register <BroadcastService, BroadcastService>(Reuse.Singleton); r.Register <GameService, GameService>(Reuse.Singleton); r.Register <UserService, UserService>(Reuse.Singleton); // Repositories r.Register <IApiRepository, ApiRepository>(Reuse.Singleton); r.Register <ICommunityRepository, CommunityRepository>(Reuse.Singleton); }
public void Initialize(INotificationQueue notificationQueue, IRegistrator registrator) { _notificationQueue = notificationQueue; _registrator = registrator; // As soon as the client is registered, let's send it the Live Tile! _registrator.ClientRegistered += (sender, args) => { SendWeekNumberTile(args.UniqueId); }; }
static void RegisterApplicationServices(IRegistrator container) { var ns = typeof(CUsers.ApplicationServices.IUserService).Namespace; var types = typeof(CUsers.ApplicationServices.IUserService).Assembly.GetLoadedTypes().Where( (i) => i.Namespace == ns && !i.IsInterface && !i.IsAbstract && (i.Name.EndsWith("Service") || i.Name.EndsWith("Handler") || i.Name.EndsWith("Reader")) ); container.RegisterMany(types, Reuse.Singleton, serviceTypeCondition: (s) => s.IsInterface, ifAlreadyRegistered: IfAlreadyRegistered.Throw); }
public SessionContext(string sessionId, IRequestHandler requestHandler, IRegistrator<string, ISessionContext> publisherRegistrator) { this.publisherRegistrator = publisherRegistrator; SessionId = sessionId; RequestHandler = requestHandler; sessionStateEngine = SessionStateEngineFactory.Create(this); SessionTimeoutContext = new ElapsedTimerContext(SessionTimerConstants.SESSION_TIME_OUT); ResponseTimeoutContext = new ElapsedTimerContext(SessionTimerConstants.RESPONSE_TIME_OUT); sessionElapsedTimer = new SessionElaspedTimer(sessionStateEngine, this); UnRegister(); }
// If you need the whole container then change parameter type from IRegistrator to IContainer public CompositionRoot(IRegistrator r) { r.Register <ISingletonService, SingletonService>(Reuse.Singleton); r.Register <ITransientService, TransientService>(Reuse.Transient); r.Register <IScopedService, ScopedService>(Reuse.InCurrentScope); // optional: MEF based auto-wiring var assemblies = new[] { typeof(ExportedService).GetAssembly() }; r.RegisterExports(assemblies); }
public CompositionRoot(IRegistrator registrator) { // General registrator.Register <Lazy <HttpClient> >(Reuse.InWebRequest); registrator.Register <IDbContext, ApplicationDbContext>(Reuse.InWebRequest); registrator.Register(typeof(IRepository <>), typeof(EfRepository <>), Reuse.InWebRequest); // Menu Business registrator.Register <IGetMenuesQuery, GetMenuesQuery>(Reuse.InWebRequest); registrator.Register <ISaveMenuCommand, SaveMenuCommand>(Reuse.InWebRequest); registrator.Register <IDeleteMenuCommand, DeleteMenuCommand>(Reuse.InWebRequest); }
// If you need the whole container then change the parameter type from IRegistrator to IContainer public static void RegisterMyBusinessLogic(this IRegistrator r) { r.Register <ISingletonService, SingletonService>(Reuse.Singleton); r.Register <ITransientService, TransientService>(Reuse.Transient); r.Register <IScopedService, ScopedService>(Reuse.InCurrentScope); r.Register <IExportedService, ExportedService>(); // optional: registering MEF Exported services //var assemblies = new[] { typeof(ExportedService).GetAssembly() }; //r.RegisterExports(assemblies); }
/// <inheritdoc /> public override void Load(IRegistrator registrar) { var funcLogManager = new FuncLogManager(type => { var actualLogger = Log.ForContext(type); return(new SerilogFullLogger(actualLogger)); }); registrar.RegisterInstance(Log.Logger); registrar.Register <IFullLogger, SerilogFullLogger>(Reuse.Singleton); registrar.RegisterInstance(funcLogManager); }
public static void Intercept <TInterceptor>(this IRegistrator registrator, Type serviceType, Type proxyType, object serviceKey = null) where TInterceptor : class, IInterceptor { var decoratorSetup = serviceKey == null ? Setup.DecoratorWith(useDecorateeReuse : true) : Setup.DecoratorWith(r => serviceKey.Equals(r.ServiceKey), useDecorateeReuse: true); registrator.Register(serviceType, proxyType, made: Made.Of(type => type.PublicConstructors().SingleOrDefault(c => c.GetParameters().Length != 0), Parameters.Of.Type <IInterceptor[]>(typeof(TInterceptor[]))), setup: decoratorSetup); }
public EntileInstanceBehavior(IRegistrator registrator, INotificationQueue notificationQueue) { _registrator = registrator; _notificationQueue = notificationQueue; }
public EntileServiceHost(IRegistrator registrator, INotificationQueue notificationQueue, Type serviceType, params Uri[] baseAddresses) : base(serviceType, baseAddresses) { _registrator = registrator; _notificationQueue = notificationQueue; }
public EntileRegistrationServiceFactory(IRegistrator registrator, INotificationQueue notificationQueue) { _registrator = registrator; _notificationQueue = notificationQueue; }
public RdapResponseHandler(string connectionId, IRegistrator<string, IConnection> registrator) { this.connectionId = connectionId; this.registrator = registrator; }
public RegistrationService(IRegistrator registrator) { _registrator = registrator; }
public TcpConnectionListener(IConnectionFactory<TcpSocketClient> connectionFactory, IRegistrator<string, IConnection> registrator) { this.registrator = registrator; this.connectionFactory = connectionFactory; tcpListener = new TcpSocketServer(2048); }
public WeekNumberService(IRegistrator registrator) { _registrator = registrator; }
public void Initialize(INotificationQueue notificationQueue, IRegistrator registrator) { }
public EntileInstanceProvider(Type serviceType, IRegistrator registrator, INotificationQueue notificationQueue) { _serviceType = serviceType; _registrator = registrator; _notificationQueue = notificationQueue; }
public SampleService(IRegistrator registrator, INotificationQueue notificationQueue) { _registrator = registrator; _notificationQueue = notificationQueue; }
public ManualNotificationService(IRegistrator registrator, INotificationQueue notificationQueue) { _registrator = registrator; _notificationQueue = notificationQueue; }
public Notifier(IRegistrator registrator, INotificationQueue queue) { _registrator = registrator; _queue = queue; _notificationAgent = new NotificationAgent(); }