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();
}
