public StorageBuilder Register(Type type) { return(Update(x => { AssemblyRegistrar.RegisterIfNotExist(x.Assemblies, type.Assembly); IEnumerable <IService> services = ServicesGenerator.GenerateServices(type, Object.Assemblies, null); ServiceRegistrar.Register(Object.Services, services); })); }
public MyClass(IServiceRegistrar registrar) { // register as a type mapping registrar.Register <IMyService, MyService>(); // register as a single instance registrar.RegisterInstance <IMyService>(new MyService { Value = "Value" }); // register as a delegate registrar.Register <IMyService>(locator => new MyService { Value = "Value" }); }
public void Bootstrap(IServiceRegistrar registrar) { registrar.Register <ITextLogFormatter, TextLogFormatter>(); registrar.RegisterSingleton <IClock, SystemClock>(); registrar.RegisterSingleton <IApplicationOptions, ApplicationOptions>(); registrar.RegisterSingleton <ILogger, Logger>(); if (Debugger.IsAttached) { registrar.RegisterSingleton <ILogDestination, DebugLogDestination>(); } }
public void Bootstrap(IServiceRegistrar registrar) { registrar.Register <IGameEngine, GameEngine>(); registrar.Register <IDeckCreator, DeckCreator>(); registrar.Register <ISystem, CardDetailsProviderSystem>(); registrar.Register <ISystem, CardPreparationSystem>(); registrar.Register <ISystem, PowerSystem>(); registrar.Register <ISystem, ToughnessSystem>(); registrar.Register <ISystem, ZombiesGainsPlusOnePlusOneCounterSystem>(); registrar.Register <ISystem, CreatureKilledSystem>(); }
private static void AddConcretionsThatCouldBeClosed(this IServiceRegistrar serviceRegistrar, RegistrationScope registrationScope, Type @interface, List <Type> concretions) { foreach (var type in concretions .Where(x => x.IsOpenGeneric() && x.CouldCloseTo(@interface))) { try { serviceRegistrar.Register(@interface, type.MakeGenericType(@interface.GenericTypeArguments), registrationScope); } catch (Exception) { } } }
public static void RegisterBuilders(IServiceRegistrar serviceRegistrar, params Assembly[] assemblies) { var queryBuilderType = typeof(QueryBuilder <>); var assemblyTypes = assemblies.SelectMany(a => a.GetTypes()).ToList(); var queryBuilderTypes = assemblyTypes .Where(t => !t.IsAbstract && !t.IsInterface) .Where(t => t.BaseType.IsGenericType && t.BaseType.GetGenericTypeDefinition() == queryBuilderType) .ToList(); foreach (var builderType in queryBuilderTypes) { serviceRegistrar.Register(typeof(IQueryBuilder <>).MakeGenericType(builderType.BaseType.GetGenericArguments().First()), builderType); } }
public static void RegisterListeners(IServiceRegistrar serviceRegistrar, params Assembly[] assemblies) { var eventListenerType = typeof(EventListener <>); var assemblyTypes = assemblies.SelectMany(a => a.GetTypes()).ToList(); var eventListenerTypes = assemblyTypes .Where(t => !t.IsAbstract && !t.IsInterface) .Where(t => t.BaseType.IsGenericType && t.BaseType.GetGenericTypeDefinition() == eventListenerType) .GroupBy(t => t.BaseType.GetGenericArguments().First()) .ToList(); foreach (var events in eventListenerTypes) { foreach (var listener in events) { serviceRegistrar.Register(typeof(IEventListener <>).MakeGenericType(events.Key), listener); } } }
public static void RegisterRepositories(IServiceRegistrar serviceRegistrar, params Assembly[] assemblies) { var assemblyTypes = assemblies.SelectMany(a => a.GetTypes()).ToList(); var repositoryTypes = assemblyTypes .Where(t => t.IsInterface) .Where(t => t.GetInterfaces() .Any(i => i == typeof(IReadRepository) || (i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IWriteRepository <>))) ) .ToList(); var repositories = assemblyTypes .Where(t => !t.IsAbstract && !t.IsInterface && t.GetInterfaces().Any(i => repositoryTypes.Contains(i))) .ToList(); foreach (var repositoryType in repositories) { var implementedRepositories = repositoryType.GetInterfaces().Where(i => repositoryTypes.Contains(i)); foreach (var implementedRepository in implementedRepositories) { serviceRegistrar.Register(implementedRepository, repositoryType); } } }
public static void RegisterHandlers(IServiceRegistrar serviceRegistrar, params Assembly[] assemblies) { var commandHandlerTypes = new[] { typeof(CommandHandler <>), typeof(CommandHandler <,>), typeof(CommandHandler <, ,>), typeof(CommandHandler <, , ,>) }; var assemblyTypes = assemblies.SelectMany(a => a.GetTypes()).ToList(); var commandHandlers = assemblyTypes .Where(t => !t.IsAbstract && !t.IsInterface) .Where(t => t.BaseType.IsGenericType && commandHandlerTypes.Any(ct => t.BaseType.GetGenericTypeDefinition() == ct)) .ToList(); foreach (var handlerType in commandHandlers) { var commandTypes = handlerType.BaseType.GenericTypeArguments.ToList(); foreach (var commandType in commandTypes) { serviceRegistrar.Register(typeof(ICommandHandler <>).MakeGenericType(commandType), handlerType); } } }
private static IServiceRegistrar Register <TService, TImplementation>(this IServiceRegistrar serviceRegistrar, RegistrationScope registrationScope) where TImplementation : TService => serviceRegistrar.Register(typeof(TService), typeof(TImplementation), registrationScope);
/// <summary> /// Helper method use to differentiate behavior between request handlers and notification /// handlers. Request handlers should only be added once (so set addIfAlreadyExists to false) /// Notification handlers should all be added (set addIfAlreadyExists to true) /// </summary> /// <param name="serviceRegistrar"> </param> /// <param name="registrationScope"> </param> /// <param name="openRequestInterface"> </param> /// <param name="assembliesToScan"> </param> /// <param name="addIfAlreadyExists"> </param> private static IServiceRegistrar ConnectImplementationsToTypesClosing(this IServiceRegistrar serviceRegistrar, RegistrationScope registrationScope, Type openRequestInterface, IEnumerable <Assembly> assembliesToScan, bool addIfAlreadyExists) { if (!assembliesToScan.Any()) { assembliesToScan = AppDomain.CurrentDomain.GetAssemblies(); } var concretions = new List <Type>(); var interfaces = new List <Type>(); foreach (var type in assembliesToScan.SelectMany(a => a.DefinedTypes).Where(t => !t.IsOpenGeneric())) { var interfaceTypes = Enumerable.ToArray <Type>(type.FindInterfacesThatClose(openRequestInterface)); if (!interfaceTypes.Any()) { continue; } if (type.IsConcrete()) { concretions.Add(type); } foreach (var interfaceType in interfaceTypes) { interfaces.Fill(interfaceType); } } foreach (var @interface in interfaces) { var exactMatches = concretions.Where(x => x.CanBeCastTo(@interface)).ToList(); if (addIfAlreadyExists) { foreach (var type in exactMatches) { serviceRegistrar.Register(@interface, type, registrationScope); } } else { if (exactMatches.Count > 1) { exactMatches.RemoveAll(m => !IsMatchingWithInterface(m, @interface)); } foreach (var type in exactMatches) { serviceRegistrar.Register(@interface, type, registrationScope); } } if ([email protected]()) { serviceRegistrar.AddConcretionsThatCouldBeClosed(registrationScope, @interface, concretions); } } return(serviceRegistrar); }
/// <summary> /// Registers the by naming convention. /// </summary> /// <param name="registrar">The registrar.</param> /// <param name="predicate">The predicate.</param> /// <param name="assemblies">The assemblies.</param> public static void RegisterByNamingConvention(this IServiceRegistrar registrar, Predicate <Type> predicate, params Assembly[] assemblies) { RegisterByNamingConvention((serviceType, implementationType) => registrar.Register(serviceType, implementationType), predicate, assemblies); }
public static void RegisterDependencies(IServiceRegistrar registrar) { var bootstrapper = BootstrapperLocator.FindBootstrapper(); var typeCatalogue = new TypeCatalogue(); var assemblyFilesNames = bootstrapper.GetAssemblyFileNamesToScanForExtensions() ?? throw new InvalidOperationException(ExceptionMessages.GetAssemblyFileNamesToScanForExtensionsShouldntReturnNull); typeCatalogue.Load(assemblyFilesNames); var typeCatalogueInstanceProvider = new TypeCatalogueInstanceProvider(typeCatalogue); var argumentValueFormatters = typeCatalogueInstanceProvider.InstantiateAllOfType <IArgumentValueFormatter>(); var dummyFactories = typeCatalogueInstanceProvider.InstantiateAllOfType <IDummyFactory>(); var fakeOptionsBuilders = typeCatalogueInstanceProvider.InstantiateAllOfType <IFakeOptionsBuilder>(); var implicitOptionsBuilderCatalogue = new ImplicitOptionsBuilderCatalogue(fakeOptionsBuilders); var methodInfoManager = new MethodInfoManager(); var argumentConstraintTrap = new ArgumentConstraintTrap(); var expressionArgumentConstraintFactory = new ExpressionArgumentConstraintFactory(argumentConstraintTrap); var fakeManagerAccessor = new DefaultFakeManagerAccessor(); var fakeObjectCreator = new FakeObjectCreator( FakeCallProcessorProviderFactory, new CastleDynamicProxyInterceptionValidator(methodInfoManager), new DelegateProxyInterceptionValidator()); var callExpressionParser = new CallExpressionParser(); var interceptionAsserter = new DefaultInterceptionAsserter(fakeObjectCreator); var argumentValueFormatter = new ArgumentValueFormatter(argumentValueFormatters); var fakeObjectCallFormatter = new DefaultFakeObjectCallFormatter(argumentValueFormatter, fakeManagerAccessor); var callWriter = new CallWriter(fakeObjectCallFormatter, new FakeCallEqualityComparer()); var configurationFactory = new ConfigurationFactory(RuleBuilderFactory); registrar.Register <IExpressionCallMatcherFactory>(new ExpressionCallMatcherFactory(expressionArgumentConstraintFactory, methodInfoManager)); registrar.Register(expressionArgumentConstraintFactory); registrar.Register <FakeAndDummyManager>( new FakeAndDummyManager( new DummyValueResolver(new DynamicDummyFactory(dummyFactories), fakeObjectCreator), fakeObjectCreator, implicitOptionsBuilderCatalogue)); registrar.Register <IArgumentConstraintManagerFactory>(new ArgumentConstraintManagerFactory()); registrar.Register(new EventHandlerArgumentProviderMap()); registrar.Register <SequentialCallContext.Factory>(SequentialCallContextFactory); registrar.Register <IStartConfigurationFactory>( new StartConfigurationFactory(ExpressionCallRuleFactory, configurationFactory, callExpressionParser, interceptionAsserter)); registrar.Register <IFakeConfigurationManager>( new FakeConfigurationManager(configurationFactory, ExpressionCallRuleFactory, callExpressionParser, interceptionAsserter)); registrar.Register <IFakeManagerAccessor>(fakeManagerAccessor); registrar.Register <ICallExpressionParser>(callExpressionParser); registrar.Register((StringBuilderOutputWriter.Factory)StringBuilderOutputWriterFactory); registrar.Register <IFakeObjectCallFormatter>(fakeObjectCallFormatter); StringBuilderOutputWriter StringBuilderOutputWriterFactory() => new StringBuilderOutputWriter(argumentValueFormatter !); FakeManager FakeManagerFactory(Type fakeObjectType, object proxy, string?name) => new FakeManager(fakeObjectType, proxy, name); IFakeCallProcessorProvider FakeCallProcessorProviderFactory(Type typeOfFake, IProxyOptions proxyOptions) => new FakeManagerProvider(FakeManagerFactory, fakeManagerAccessor, typeOfFake, proxyOptions); ExpressionCallRule ExpressionCallRuleFactory(ParsedCallExpression callSpecification) => new ExpressionCallRule(new ExpressionCallMatcher(callSpecification, expressionArgumentConstraintFactory, methodInfoManager)); IFakeAsserter FakeAsserterFactory(IEnumerable <CompletedFakeObjectCall> calls, int lastSequenceNumber) => new FakeAsserter(calls, lastSequenceNumber, callWriter, StringBuilderOutputWriterFactory); SequentialCallContext SequentialCallContextFactory() => new SequentialCallContext(callWriter, StringBuilderOutputWriterFactory); RuleBuilder RuleBuilderFactory(BuildableCallRule rule, FakeManager fake) => new RuleBuilder(rule, fake, FakeAsserterFactory); }
/// <summary> /// Registers the by type match. /// </summary> /// <param name="registrar">The registrar.</param> /// <param name="basedOnType">Type of the based on.</param> /// <param name="predicate">The predicate.</param> /// <param name="assemblies">The assemblies.</param> public static void RegisterByTypeMatch(this IServiceRegistrar registrar, Type basedOnType, Predicate <Type> predicate, params Assembly[] assemblies) { RegisterByTypeMatch((serviceType, implementationType, name) => registrar.Register(serviceType, implementationType, name), basedOnType, predicate, assemblies); }
/// <summary> /// Configures the consumer. /// </summary> /// <param name="r">The r.</param> /// <param name="type">The type.</param> protected virtual void ConfigureConsumer(IServiceRegistrar r, Type type) { r.Register <IMessageConsumer>(type, type.FullName); }
public void Bootstrap(IServiceRegistrar registrar) { registrar.Register <ILogDestination, ConsoleLogDestination>(); }
/// <summary> /// Registers the by naming convention. /// </summary> /// <param name="registrar">The registrar.</param> /// <param name="predicate">The predicate.</param> public static void RegisterByNamingConvention(this IServiceRegistrar registrar, Predicate <Type> predicate) { RegisterByNamingConvention((serviceType, implementationType) => registrar.Register(serviceType, implementationType), predicate, new[] { GetPreviousCallingMethodAssembly() }); }
/// <summary> /// Registers the by type match. /// </summary> /// <typeparam name="TBasedOn">The type of the based on.</typeparam> /// <param name="registrar">The registrar.</param> /// <param name="assemblies">The assemblies.</param> public static void RegisterByTypeMatch <TBasedOn>(this IServiceRegistrar registrar, params Assembly[] assemblies) { RegisterByTypeMatch((serviceType, implementationType, name) => registrar.Register(serviceType, implementationType, name), typeof(TBasedOn), x => DefaultPredicate(registrar, x), assemblies); }
public void Bootstrap(IServiceRegistrar registrar) { registrar.Register <IApplicationEntryPoint, ApplicationEntryPoint>(); }
/// <summary> /// Registers the default mediator. /// </summary> /// <param name="serviceRegistrar"> The service registrar. </param> /// <param name="registrationScope"> The registration scope. </param> /// <returns> The <see cref="IServiceRegistrar" /> </returns> public static IServiceRegistrar RegisterDefaultMediator(this IServiceRegistrar serviceRegistrar, RegistrationScope registrationScope) { registrationScope = RegistrationScope.Singleton.Restricted(registrationScope); return(serviceRegistrar .Register <IMediator, Mediator>(registrationScope)); }
/// <summary> /// Registers the by type match. /// </summary> /// <typeparam name="TBasedOn">The type of the based on.</typeparam> /// <param name="registrar">The registrar.</param> public static void RegisterByTypeMatch <TBasedOn>(this IServiceRegistrar registrar) { RegisterByTypeMatch((serviceType, implementationType, name) => registrar.Register(serviceType, implementationType, name), typeof(TBasedOn), x => DefaultPredicate(registrar, x), new[] { GetPreviousCallingMethodAssembly() }); }
/// <summary> /// Registers the by naming convention. /// </summary> /// <param name="registrar">The registrar.</param> /// <param name="assemblies">The assemblies.</param> public static void RegisterByNamingConvention(this IServiceRegistrar registrar, params Assembly[] assemblies) { RegisterByNamingConvention((serviceType, implementationType) => registrar.Register(serviceType, implementationType), x => DefaultPredicate(registrar, x), assemblies); }
/// <summary> /// Registers the by type match. /// </summary> /// <param name="registrar">The registrar.</param> /// <param name="basedOnType">Type of the based on.</param> /// <param name="predicate">The predicate.</param> public static void RegisterByTypeMatch(this IServiceRegistrar registrar, Type basedOnType, Predicate <Type> predicate) { RegisterByTypeMatch((serviceType, implementationType, name) => registrar.Register(serviceType, implementationType, name), basedOnType, predicate, new[] { GetPreviousCallingMethodAssembly() }); }