/// <summary> /// Initializes an instance of <see cref="EventMigratorManager">EventMigratorManager</see> /// </summary> /// <param name="typeDiscoverer"><see cref="ITypeDiscoverer"/> to use for discovering <see cref="IEventMigrator">Event migrators</see></param> /// <param name="container"><see cref="IContainer"/> to use for instantiation of <see cref="IEventMigrator">Event migrators</see></param> public EventMigratorManager(ITypeDiscoverer typeDiscoverer, IContainer container) { _typeDiscoverer = typeDiscoverer; _container = container; _migratorTypes = new Dictionary<Type, Type>(); Initialize(); }
/// <summary> /// Initializes an instance of <see cref="ChapterValidatorProvider"/> ChapterValidatorProvider /// </summary> /// <param name="typeDiscoverer">An instance of ITypeDiscoverer to help identify and register <see cref="IChapterValidator"> IChapterValidator</see> implementations /// </param> /// <param name="container">An instance of <see cref="IContainer"/> to create concrete instances of validators</param> public ChapterValidatorProvider(ITypeDiscoverer typeDiscoverer, IContainer container) { _typeDiscoverer = typeDiscoverer; _container = container; Initialize(); }
/// <summary> /// Initializes a new instance of <see cref="SecurityManager"/> /// </summary> /// <param name="typeDiscoverer"><see cref="ITypeDiscoverer"/> to discover any <see cref="BaseSecurityDescriptor">security descriptors</see></param> /// <param name="container"><see cref="IContainer"/> to instantiate instances of <see cref="ISecurityDescriptor"/></param> public SecurityManager(ITypeDiscoverer typeDiscoverer, IContainer container) { _typeDiscoverer = typeDiscoverer; _container = container; PopulateSecurityDescriptors(); }
public EntityContextConnection(ITypeDiscoverer typeDiscoverer) { _typeDiscoverer = typeDiscoverer; FluentConfiguration = Fluently.Configure(). Mappings(m => DiscoverClassMapsAndAddAssemblies(m)); }
/// <summary> /// Initializes an instance of <see cref="EventMigratorManager">EventMigratorManager</see> /// </summary> /// <param name="typeDiscoverer"></param> /// <param name="serviceLocator"></param> public EventMigratorManager(ITypeDiscoverer typeDiscoverer, IServiceLocator serviceLocator) { _typeDiscoverer = typeDiscoverer; _serviceLocator = serviceLocator; _migratorTypes = new Dictionary<Type, Type>(); Initialize(); }
/// <summary> /// Initializes a new instance of <see cref="DefaultValidatorFactory"/> /// </summary> /// <param name="typeDiscoverer">A <see cref="ITypeDiscoverer"/> used for discovering validators</param> /// <param name="container">A <see cref="IContainer"/> to use for creating instances of the different validators</param> public DefaultValidatorFactory(ITypeDiscoverer typeDiscoverer, IContainer container) { _container = container; _validatorsByType = new Dictionary <Type, Type>(); _typeDiscoverer = typeDiscoverer; Populate(); }
/// <summary> /// Initializes an instance of <see cref="ChapterValidatorProvider"/> ChapterValidatorProvider /// </summary> /// <param name="typeDiscoverer">An instance of ITypeDiscoverer to help identify and register <see cref="IChapterValidator"> IChapterValidator</see> implementations /// </param> /// <param name="serviceLocator">An instance of IServiceLocator to return concrete instances of validators</param> public ChapterValidatorProvider(ITypeDiscoverer typeDiscoverer, IServiceLocator serviceLocator) { _typeDiscoverer = typeDiscoverer; _serviceLocator = serviceLocator; Initialize(); }
/// <summary> /// Initializes an instance of <see cref="EventMigratorManager">EventMigratorManager</see> /// </summary> /// <param name="typeDiscoverer"><see cref="ITypeDiscoverer"/> to use for discovering <see cref="IEventMigrator">Event migrators</see></param> /// <param name="container"><see cref="IContainer"/> to use for instantiation of <see cref="IEventMigrator">Event migrators</see></param> public EventMigratorManager(ITypeDiscoverer typeDiscoverer, IContainer container) { _typeDiscoverer = typeDiscoverer; _container = container; _migratorTypes = new Dictionary <Type, Type>(); Initialize(); }
public GeneratedProxies( CommandProxies commandProxies, CommandSecurityProxies commandSecurityProxies, QueryProxies queryProxies, ReadModelProxies readModelProxies, ServiceProxies serviceProxies, NamespaceConfigurationProxies namespaceConfigurationProxies, ITypeDiscoverer typeDiscoverer, IContainer container) { var builder = new StringBuilder(); builder.Append(commandProxies.Generate()); builder.Append(commandSecurityProxies.Generate()); builder.Append(readModelProxies.Generate()); builder.Append(queryProxies.Generate()); builder.Append(serviceProxies.Generate()); builder.Append(namespaceConfigurationProxies.Generate()); var generatorTypes = typeDiscoverer.FindMultiple<IProxyGenerator>().Where(t => !t.Namespace.StartsWith("Bifrost")); foreach (var generatorType in generatorTypes) { var generator = container.Get(generatorType) as IProxyGenerator; builder.Append(generator.Generate()); } All = builder.ToString(); }
public QueryService(ITypeDiscoverer typeDiscoverer, IContainer container, IQueryCoordinator queryCoordinator, WebConfiguration configuration) { _typeDiscoverer = typeDiscoverer; _container = container; _queryCoordinator = queryCoordinator; _configuration = configuration; }
public GeneratedProxies( CommandProxies commandProxies, CommandSecurityProxies commandSecurityProxies, QueryProxies queryProxies, ReadModelProxies readModelProxies, ServiceProxies serviceProxies, NamespaceConfigurationProxies namespaceConfigurationProxies, #if (NET461) HubProxies hubProxies, #endif ITypeDiscoverer typeDiscoverer, IContainer container) { var builder = new StringBuilder(); builder.Append(commandProxies.Generate()); builder.Append(commandSecurityProxies.Generate()); builder.Append(readModelProxies.Generate()); builder.Append(queryProxies.Generate()); builder.Append(serviceProxies.Generate()); builder.Append(namespaceConfigurationProxies.Generate()); #if (NET461) builder.Append(hubProxies.Generate()); #endif var generatorTypes = typeDiscoverer.FindMultiple <IProxyGenerator>().Where(t => !t.Namespace.StartsWith("Bifrost")); foreach (var generatorType in generatorTypes) { var generator = container.Get(generatorType) as IProxyGenerator; builder.Append(generator.Generate()); } All = builder.ToString(); }
/// <summary> /// Initializes a new instance of <see cref="ApplicationResourceResolver"/> /// </summary> /// <param name="application">Current <see cref="IApplication">Application</see></param> /// <param name="types"><see cref="IApplicationResourceTypes">Resource types</see> available</param> /// <param name="resolvers">Instances of <see cref="ICanResolveApplicationResources"/> for specialized resolving</param> /// <param name="typeDiscoverer"><see cref="ITypeDiscoverer"/> for discovering types needed</param> public ApplicationResourceResolver(IApplication application, IApplicationResourceTypes types, IInstancesOf <ICanResolveApplicationResources> resolvers, ITypeDiscoverer typeDiscoverer) { _application = application; _types = types; _resolversByType = resolvers.ToDictionary(r => r.ApplicationResourceType.Identifier, r => r); _typeDiscoverer = typeDiscoverer; }
/// <summary> /// Initializes a new instance of <see cref="EntityTypeConfigurations"/> /// </summary> /// <param name="typeDiscoverer"></param> /// <param name="container"></param> public EntityTypeConfigurations(ITypeDiscoverer typeDiscoverer, IContainer container) { // Todo: The filtering should not be here when we have a way of excluding assemblies from discovery from extensions var configurationTypes = typeDiscoverer.FindMultiple(typeof(EntityTypeConfiguration <>)).Where(t => !t.FullName.Contains("System.")); _configurations = configurationTypes.ToDictionary(c => c, c => container.Get(c)); }
/// <summary> /// Initializes an instance of <see cref="CommandValidatorProvider"/> CommandValidatorProvider /// </summary> /// <param name="typeDiscoverer"> /// An instance of ITypeDiscoverer to help identify and register <see cref="ICommandInputValidator"/> implementations /// and <see cref="ICommandBusinessValidator"/> implementations /// </param> /// <param name="container">An instance of <see cref="IContainer"/> to manage instances of any <see cref="ICommandInputValidator"/></param> public CommandValidatorProvider(ITypeDiscoverer typeDiscoverer, IContainer container) { _typeDiscoverer = typeDiscoverer; _container = container; InitializeCommandValidators(); InitializeDynamicValidators(); }
public CommandProxies(ITypeDiscoverer typeDiscoverer, ITypeImporter typeImporter, ICodeGenerator codeGenerator, WebConfiguration configuration) { _typeDiscoverer = typeDiscoverer; _typeImporter = typeImporter; _codeGenerator = codeGenerator; _configuration = configuration; }
/// <summary> /// Initializes an instance of <see cref="CommandValidatorProvider"/> CommandValidatorProvider /// </summary> /// <param name="typeDiscoverer"> /// An instance of ITypeDiscoverer to help identify and register <see cref="ICommandInputValidator"/> implementations /// and <see cref="ICommandBusinessValidator"/> implementations /// </param> /// <param name="container">An instance of <see cref="IContainer"/> to manage instances of any <see cref="ICommandInputValidator"/></param> /// <param name="configuration">An instance of <see cref="IConfigure"/> that holds the current configuration</param> public CommandValidatorProvider(ITypeDiscoverer typeDiscoverer, IContainer container, IConfigure configuration) { _typeDiscoverer = typeDiscoverer; _container = container; _configuration = configuration; Initialize(); }
/// <summary> /// Initializes an instance of <see cref="EventSubscriptionManager"/> /// </summary> /// <param name="repository">A <see cref="IEventSubscriptionRepository"/> that will be used to maintain subscriptions from a datasource</param> /// <param name="typeDiscoverer">A <see cref="ITypeDiscoverer"/> for discovering <see cref="IEventSubscriber"/>s in current process</param> /// <param name="container">A <see cref="IContainer"/> for creating instances of objects/services</param> public EventSubscriptionManager(IEventSubscriptionRepository repository, ITypeDiscoverer typeDiscoverer, IContainer container) { _repository = repository; _typeDiscoverer = typeDiscoverer; _container = container; Initialize(); }
public QueryProxies( ITypeDiscoverer typeDiscoverer, ICodeGenerator codeGenerator, WebConfiguration configuration) { _typeDiscoverer = typeDiscoverer; _codeGenerator = codeGenerator; _configuration = configuration; }
/// <summary> /// Initializes a new instance of <see cref="QueryCoordinator"/> /// </summary> /// <param name="typeDiscoverer"><see cref="ITypeDiscoverer"/> to use for discovering <see cref="IQueryProviderFor{T}"/> implementations</param> /// <param name="container"><see cref="IContainer"/> for getting instances of <see cref="IQueryProviderFor{T}">query providers</see></param> public QueryCoordinator(ITypeDiscoverer typeDiscoverer, IContainer container) { _container = container; var queryTypes = typeDiscoverer.FindMultiple(typeof(IQueryProviderFor<>)); _queryProviderTypesPerTargetType = queryTypes.Select(t => new { TargetType = GetQueryTypeFrom(t), QueryProviderType = t }).ToDictionary(t => t.TargetType, t => t.QueryProviderType); }
public CommandCoordinatorService( ICommandCoordinator commandCoordinator, ISerializer serializer, ITypeDiscoverer typeDiscoverer) { _commandCoordinator = commandCoordinator; _serializer = serializer; _typeDiscoverer = typeDiscoverer; }
public ValidationService( ICommandValidatorProvider commandValidatorProvider, IValidationMetaDataGenerator validationMetaDataGenerator, ITypeDiscoverer discoverer) { _commandValidatorProvider = commandValidatorProvider; _validationMetaDataGenerator = validationMetaDataGenerator; _discoverer = discoverer; }
void DiscoverClassMapsAndAddAssemblies(ITypeDiscoverer typeDiscoverer, MappingConfiguration mappings) { var assemblies = typeDiscoverer.FindMultiple(typeof(IMappingProvider)).Select(t => t.Assembly).Distinct(); foreach (var assembly in assemblies) { mappings.FluentMappings.AddFromAssembly(assembly).Conventions.Add(DefaultLazy.Never(), AutoImport.Never()); mappings.HbmMappings.AddFromAssembly(assembly); } }
/// <summary> /// Initializes an instance of <see cref="QueryValidationDescriptors"/> /// </summary> public QueryValidationDescriptors(ITypeDiscoverer typeDiscoverer, IContainer container) { var descriptors = typeDiscoverer.FindMultiple(typeof(QueryValidationDescriptorFor <>)).Where(d => d != typeof(QueryValidationDescriptorFor <>)); descriptors.ForEach(d => { var queryType = d.BaseType.GetGenericArguments()[0]; var descriptor = container.Get(d) as IQueryValidationDescriptor; _descriptors[queryType] = descriptor; }); }
public CommandCoordinator( ICommandCoordinator commandCoordinator, ITypeDiscoverer typeDiscoverer, ICommandContextConnectionManager commandContextConnectionManager, ISerializer serializer) { _commandCoordinator = commandCoordinator; _typeDiscoverer = typeDiscoverer; _commandContextConnectionManager = commandContextConnectionManager; _serializer = serializer; }
public CommandCoordinatorService( ICommandCoordinator commandCoordinator, ISerializer serializer, ITypeDiscoverer typeDiscoverer, ISagaLibrarian sagaLibrarian) { _commandCoordinator = commandCoordinator; _serializer = serializer; _typeDiscoverer = typeDiscoverer; _sagaLibrarian = sagaLibrarian; }
/// <summary> /// Get the type of the command matching the fullname. This can be in any loaded assembly and does not require the /// </summary> /// <param name="typeDiscoverer">instance of <see cref="ITypeDiscoverer"/> being extended</param> /// <param name="fullName">The full name of the type</param> /// <returns>the type if found, <see cref="UnknownCommandException" /> if not found or type is not a command</returns> public static Type GetCommandTypeByName(this ITypeDiscoverer typeDiscoverer, string fullName) { var commandType = typeDiscoverer.FindTypeByFullName(fullName); if (commandType == null || !commandType.HasInterface(typeof(ICommand))) { throw new UnknownCommandException(fullName); } return(commandType); }
public CommandSecurityProxies( ITypeDiscoverer typeDiscoverer, ICodeGenerator codeGenerator, ICommandSecurityManager commandSecurityManager, WebConfiguration configuration) { _typeDiscoverer = typeDiscoverer; _codeGenerator = codeGenerator; _configuration = configuration; _commandSecurityManager = commandSecurityManager; }
public ViewService( ITypeDiscoverer typeDiscoverer, ISerializer serializer, IContainer container) { _typeDiscoverer = typeDiscoverer; _serializer = serializer; _container = container; PopulateViewTypes(); }
/// <summary> /// Initializes a new instance of <see cref="QueryCoordinator"/> /// </summary> /// <param name="typeDiscoverer"><see cref="ITypeDiscoverer"/> to use for discovering <see cref="IQueryProviderFor{T}"/> implementations</param> /// <param name="container"><see cref="IContainer"/> for getting instances of <see cref="IQueryProviderFor{T}">query providers</see></param> /// <param name="fetchingSecurityManager"><see cref="IFetchingSecurityManager"/> to use for securing <see cref="IQuery">queries</see></param> /// <param name="filters"><see cref="IReadModelFilters">Filters</see> used to filter any of the read models coming back after a query</param> public QueryCoordinator(ITypeDiscoverer typeDiscoverer, IContainer container, IFetchingSecurityManager fetchingSecurityManager, IReadModelFilters filters) { _container = container; _filters = filters; _fetchingSecurityManager = fetchingSecurityManager; var queryTypes = typeDiscoverer.FindMultiple(typeof(IQueryProviderFor<>)); _queryProviderTypesPerTargetType = queryTypes.Select(t => new { TargetType = GetQueryTypeFrom(t), QueryProviderType = t }).ToDictionary(t => t.TargetType, t => t.QueryProviderType); }
/// <summary> /// Initializes a new instance of <see cref="TypeRules"/> /// </summary> /// <param name="typeDiscoverer"><see cref="ITypeDiscoverer"/> used for discovering rules</param> /// <param name="container"><see cref="IContainer"/> used for getting instances</param> /// <param name="problemsFactory"><see cref="IProblemsFactory"/> used for creating problems</param> /// <param name="problemsReporter"><see cref="IProblemsReporter">Reporter</see> to use for reporting back any problems</param> public TypeRules( ITypeDiscoverer typeDiscoverer, IContainer container, IProblemsFactory problemsFactory, IProblemsReporter problemsReporter) { _typeDiscoverer = typeDiscoverer; _container = container; _problemsFactory = problemsFactory; _problemsReporter = problemsReporter; }
/// <summary> /// Get the type of the query matching the fullname. This can be in any loaded assembly and does not require the assmebly qualified name. /// </summary> /// <param name="typeDiscoverer">instance of <see cref="ITypeDiscoverer"/> being extended</param> /// <param name="fullName">The full name of the type</param> /// <returns>the type if found, <see cref="UnknownQueryException" /> if not found or type is not a query</returns> public static Type GetQueryTypeByName(this ITypeDiscoverer typeDiscoverer, string fullName) { var queryType = typeDiscoverer.FindTypeByFullName(fullName); if (queryType == null || !queryType.HasInterface(typeof(IQuery))) { throw new UnknownQueryException(fullName); } return(queryType); }
/// <summary> /// Get the type of the <see cref="IReadModelOf{T}"/> matching the fullname. This can be in any loaded assembly and does not require the assmebly qualified name. /// </summary> /// <param name="typeDiscoverer">instance of <see cref="ITypeDiscoverer"/> being extended</param> /// <param name="fullName">The full name of the type</param> /// <returns>the type if found, <see cref="UnknownReadModelOfException" /> if not found or type is not a readmodelof</returns> public static Type GetReadModelOfTypeByName(this ITypeDiscoverer typeDiscoverer, string fullName) { var readModelOfType = typeDiscoverer.FindTypeByFullName(fullName); if (readModelOfType == null || !readModelOfType.HasInterface(typeof(IReadModelOf <>))) { throw new UnknownReadModelOfException(fullName); } return(readModelOfType); }
public ReadModelService(ITypeDiscoverer typeDiscoverer, IContainer container, IFetchingSecurityManager fetchingSecurityManager, IReadModelFilters readModelFilters) { _typeDiscoverer = typeDiscoverer; _container = container; _fetchingSecurityManager = fetchingSecurityManager; _readModelFilters = readModelFilters; _authorizeMethod = fetchingSecurityManager.GetType().GetMethods() .Where(m => m.Name == "Authorize" && m.GetParameters()[0].ParameterType.Name.StartsWith("IReadModelOf")).Single(); }
/// <summary> /// Initializes an instance of <see cref="EventSubscriptionManager"/> /// </summary> /// <param name="subscriptions">A <see cref="IEventSubscriptions"/> that will be used to maintain subscriptions from a datasource</param> /// <param name="typeDiscoverer">A <see cref="ITypeDiscoverer"/> for discovering <see cref="IProcessEvents"/>s in current process</param> /// <param name="container">A <see cref="IContainer"/> for creating instances of objects/services</param> /// <param name="localizer">A <see cref="ILocalizer"/> for controlling localization while executing subscriptions</param> public EventSubscriptionManager( IEventSubscriptions subscriptions, ITypeDiscoverer typeDiscoverer, IContainer container, ILocalizer localizer) { _subscriptions = subscriptions; _typeDiscoverer = typeDiscoverer; _container = container; _localizer = localizer; RefreshAndMergeSubscriptionsFromRepository(); }
/// <inheritdoc /> public void Initialize(ITypeDiscoverer typeDiscoverer) { if (typeDiscoverer is null) { throw new ArgumentNullException( nameof(typeDiscoverer), $"{nameof(typeDiscoverer)} passed to {GetType().FullName} was null."); } /* NOTE: although the IUnityContainer is disposable, this should be * the global instance and it should not be disposed of at this point. */ typeDiscoverer.Discover(_lazyContainer.Value); }
/// <summary> /// Initializes a new instance of <see cref="QueryCoordinator"/> /// </summary> /// <param name="typeDiscoverer"><see cref="ITypeDiscoverer"/> to use for discovering <see cref="IQueryProviderFor{T}"/> implementations</param> /// <param name="container"><see cref="IContainer"/> for getting instances of <see cref="IQueryProviderFor{T}">query providers</see></param> /// <param name="fetchingSecurityManager"><see cref="IFetchingSecurityManager"/> to use for securing <see cref="IQuery">queries</see></param> /// <param name="validator"><see cref="IQueryValidator"/> to use for validating <see cref="IQuery">queries</see></param> /// <param name="filters"><see cref="IReadModelFilters">Filters</see> used to filter any of the read models coming back after a query</param> public QueryCoordinator( ITypeDiscoverer typeDiscoverer, IContainer container, IFetchingSecurityManager fetchingSecurityManager, IQueryValidator validator, IReadModelFilters filters) { _typeDiscoverer = typeDiscoverer; _container = container; _validator = validator; _filters = filters; _fetchingSecurityManager = fetchingSecurityManager; DiscoverQueryTypesPerTargetType(); }
/// <summary> /// Initializes a new instance of <see cref="ProcessMethodEventProcessors"/> /// </summary> /// <param name="applicationResources"><see cref="IApplicationResources"/> for identifying <see cref="IEvent">events</see> </param> /// <param name="applicationResourcesIdentifierConverter"><see cref="IApplicationResourceIdentifierConverter"/> for converting <see cref="IApplicationResourceIdentifier"/> to and from different formats</param> /// <param name="typeDiscoverer"><see cref="ITypeDiscoverer"/> for discovering implementations of <see cref="IProcessEvents"/></param> /// <param name="container"><see cref="IContainer"/> for the implementation <see cref="ProcessMethodEventProcessor"/> when acquiring instances of implementations of <see cref="IProcessEvents"/></param> /// <param name="systemClock"><see cref="ISystemClock"/> for timing <see cref="IEventProcessors"/></param> public ProcessMethodEventProcessors( IApplicationResources applicationResources, IApplicationResourceIdentifierConverter applicationResourcesIdentifierConverter, ITypeDiscoverer typeDiscoverer, IContainer container, ISystemClock systemClock) { _applicationResources = applicationResources; _applicationResourcesIdentifierConverter = applicationResourcesIdentifierConverter; _typeDiscoverer = typeDiscoverer; _container = container; _systemClock = systemClock; PopulateEventProcessors(); }
/// <summary> /// Initializes a new instance of <see cref="ValidationMetaDataGenerator"/> /// </summary> /// <param name="typeDiscoverer"><see cref="ITypeDiscoverer"/> to use for discovering generators</param> /// <param name="container"><see cref="IContainer"/> to use for activation of generators</param> public ValidationMetaDataGenerator(ITypeDiscoverer typeDiscoverer, IContainer container) { _typeDiscoverer = typeDiscoverer; _container = container; var inputValidatorsByType = typeDiscoverer.FindMultiple(typeof(IValidateInput <>)) .Where(t => typeof(IValidator).IsAssignableFrom(t)) .GroupBy(t => t.BaseType.GetGenericArguments()[0]); foreach (var inputValidatorByType in inputValidatorsByType) { _inputValidatorsByType[inputValidatorByType.Key] = inputValidatorByType.ToList(); } PopulateGenerators(); }
/// <summary> /// Initializes a new instance of <see cref="ValidationMetaDataGenerator"/> /// </summary> /// <param name="typeDiscoverer"><see cref="ITypeDiscoverer"/> to use for discovering generators</param> /// <param name="container"><see cref="IContainer"/> to use for activation of generators</param> public ValidationMetaDataGenerator(ITypeDiscoverer typeDiscoverer, IContainer container) { _typeDiscoverer = typeDiscoverer; _container = container; var inputValidatorsByType = typeDiscoverer.FindMultiple(typeof(IValidateInput<>)) .Where(t => typeof(IValidator).IsAssignableFrom(t)) .GroupBy(t=>t.BaseType.GetGenericArguments()[0]); foreach (var inputValidatorByType in inputValidatorsByType) { _inputValidatorsByType[inputValidatorByType.Key] = inputValidatorByType.ToList(); } PopulateGenerators(); }
public MessageBroker(ITypeDiscoverer typeDiscoverer, IContainer container) { var consumerTypes = typeDiscoverer.FindMultiple(typeof(IMessageConsumer <>)); consumerTypes.ForEach(t => { var messageType = t.GetInterface(typeof(IMessageConsumer <>).Name).GetGenericArguments()[0]; List <object> consumers; if (!_consumersByMessageType.ContainsKey(messageType)) { consumers = new List <object>(); _consumersByMessageType[messageType] = consumers; } else { consumers = _consumersByMessageType[messageType]; } consumers.Add(container.Get(t)); }); _messageTypesByName = typeDiscoverer.FindMultiple(typeof(Message)).ToDictionary(t => t.Name, t => t); _topicName = ConfigurationManager.AppSettings["RabbitMQTopic"]; _consumerName = ConfigurationManager.AppSettings["RabbitMQQueue"]; _connectionFactory = new ConnectionFactory() { HostName = ConfigurationManager.AppSettings["RabbitMQServer"], UserName = ConfigurationManager.AppSettings["RabbitMQUsername"], Password = ConfigurationManager.AppSettings["RabbitMQPassword"] }; _connection = _connectionFactory.CreateConnection(); _channel = _connection.CreateModel(); _channel.ExchangeDeclare(_topicName, "topic"); _channel.QueueDeclare(_consumerName, true, false, false, null); _channel.QueueBind(_consumerName, _topicName, "*"); _consumer = new QueueingBasicConsumer(_channel); _channel.BasicConsume(_consumerName, true, _consumer); ThreadPool.QueueUserWorkItem(Receiver); }
static void DiscoverClassMapsAndAddAssemblies( IAssemblies assemblies, ITypeDiscoverer typeDiscoverer, MappingConfiguration mappings) { var assembliesWithFluentMappings = typeDiscoverer .FindMultiple(typeof(IMappingProvider)) .Select(t => t.Assembly) .Distinct(); foreach (var assembly in assembliesWithFluentMappings) { mappings.FluentMappings.AddFromAssembly(assembly).Conventions.Add(DefaultLazy.Never(), AutoImport.Never()); } var assembliesWithHbmMappings = assemblies .GetAll() .Where(a => a.GetManifestResourceNames().Any(s => s.EndsWith(".hbm.xml"))); foreach (var assembly in assembliesWithHbmMappings) { mappings.HbmMappings.AddFromAssembly(assembly); } }
public QueryProxies(ITypeDiscoverer typeDiscoverer, ICodeGenerator codeGenerator, WebConfiguration configuration) { _typeDiscoverer = typeDiscoverer; _codeGenerator = codeGenerator; _configuration = configuration; }
public JsonInterceptor(ITypeDiscoverer typeDiscoverer, IContainer container) { _container = container; _valueInterceptors = typeDiscoverer.FindMultiple(typeof(ICanInterceptValue<>)); }
/// <summary> /// Initializes a new instance of <see cref="CommandHandlerInvoker">CommandHandlerInvoker</see> /// </summary> /// <param name="discoverer">A <see cref="ITypeDiscoverer"/> to use for discovering <see cref="ICommandHandler">command handlers</see></param> /// <param name="serviceLocator">A <see cref="IServiceLocator"/> to use for getting instances of objects</param> public CommandHandlerInvoker(ITypeDiscoverer discoverer, IServiceLocator serviceLocator) { _discoverer = discoverer; _serviceLocator = serviceLocator; _initialized = false; }
/// <summary> /// Initializes an instance of <see cref="EventMigrationHierarchyDiscoverer"/> /// </summary> /// <param name="typeDiscoverer"></param> public EventMigrationHierarchyDiscoverer(ITypeDiscoverer typeDiscoverer) { _typeDiscoverer = typeDiscoverer; }
/// <summary> /// Initializes a new instance of <see cref="ValidationMetaDataGenerator"/> /// </summary> /// <param name="typeDiscoverer"><see cref="ITypeDiscoverer"/> to use for discovering generators</param> /// <param name="container"><see cref="IContainer"/> to use for activation of generators</param> public ValidationMetaDataGenerator(ITypeDiscoverer typeDiscoverer, IContainer container) { _typeDiscoverer = typeDiscoverer; _container = container; PopulateGenerators(); }
/// <summary> /// Initializes an instance of <see cref="ReadModelFilters"/> /// </summary> /// <param name="typeDiscoverer"><see cref="ITypeDiscoverer"/> to use for discovering filters</param> /// <param name="container"><see cref="IContainer"/> for instantiating filters</param> public ReadModelFilters(ITypeDiscoverer typeDiscoverer, IContainer container) { _container = container; _filterTypes = typeDiscoverer.FindMultiple<ICanFilterReadModels>(); }