/// <summary> /// Retrieves the list of types available in the assemblies found by the <see cref="AssemblyFinder"/> specified in the constructor. /// </summary> /// <param name="baseType">The base type to match. Can be null.</param> /// <param name="excludeGlobalTypes">Indicates whether types from all referenced assemblies should be checked.</param> /// <returns> /// A collection of types that match the criteria specified by baseType and excludeGlobalTypes. /// </returns> public ICollection GetTypes(Type baseType, bool excludeGlobalTypes) { var nonNullBaseType = baseType ?? typeof(object); if (nonNullBaseType.IsSealed) // ValueTypes are also sealed { return new[] { nonNullBaseType } } ; if (!excludeGlobalTypes && AssemblyTypeCache.IsGacAssembly(nonNullBaseType.Assembly)) { return(_globalTypesCache.GetOrAdd( nonNullBaseType, key => { s_log.Value.DebugFormat("Discovering types derived from '{0}', including GAC...", key); using (StopwatchScope.CreateScope( s_log.Value, LogLevel.Info, string.Format("Discovered types derived from '{0}', including GAC. Time taken: {{elapsed}}", key))) { return GetTypesFromAllAssemblies(key, false).ToList().AsReadOnly(); } })); } var baseTypeCache = _baseTypeCache.Value; Assertion.IsTrue(_baseTypeCache.IsValueCreated); return(baseTypeCache.GetTypes(nonNullBaseType)); }
public List <EnumValueInfo> GetAccessTypesFromAssembly(Assembly assembly, MetadataCache cache) { ArgumentUtility.CheckNotNull("assembly", assembly); ArgumentUtility.CheckNotNull("cache", cache); List <EnumValueInfo> accessTypes = new List <EnumValueInfo> (); foreach (var type in AssemblyTypeCache.GetTypes(assembly)) { if (type.IsEnum && Attribute.IsDefined(type, typeof(AccessTypeAttribute), false)) { Dictionary <Enum, EnumValueInfo> values = _enumerationReflector.GetValues(type, cache); foreach (KeyValuePair <Enum, EnumValueInfo> entry in values) { if (!cache.ContainsAccessType(entry.Key)) { cache.AddAccessType(entry.Key, entry.Value); } accessTypes.Add(entry.Value); } } } return(accessTypes); }
private IEnumerable <Type> GetTypesFromBaseType(_Assembly assembly, Type baseType) { ReadOnlyCollection <Type> allTypesInAssembly; try { allTypesInAssembly = AssemblyTypeCache.GetTypes(assembly); } catch (ReflectionTypeLoadException ex) { string message = string.Format( "The types from assembly '{0}' could not be loaded.{1}{2}", assembly.GetName(), Environment.NewLine, string.Join(Environment.NewLine, ex.LoaderExceptions.Select(e => e.Message))); throw new TypeLoadException(message, ex); } if (baseType == null) { return(allTypesInAssembly); } return(GetFilteredTypes(allTypesInAssembly, baseType)); }
private static void InstallDefaultRules(ValidatingVisitor visitor) { foreach (Type t in AssemblyTypeCache.GetTypes(Assembly.GetExecutingAssembly())) { if (!t.IsAbstract && typeof(IRuleSet).IsAssignableFrom(t) && t.Namespace == typeof(IRuleSet).Namespace) { IRuleSet ruleSet = (IRuleSet)Activator.CreateInstance(t); ruleSet.Install(visitor); } } }
/// <summary> /// Adds all consumers in the specified assemblies /// </summary> /// <param name="configurator"></param> /// <param name="assemblies">The assemblies to scan for consumers</param> public static void AddConsumers(this IRegistrationConfigurator configurator, params Assembly[] assemblies) { if (assemblies.Length == 0) { assemblies = AppDomain.CurrentDomain.GetAssemblies(); } var types = AssemblyTypeCache.FindTypes(assemblies, IsConsumerOrDefinition).GetAwaiter().GetResult(); AddConsumers(configurator, types.FindTypes(TypeClassification.Concrete | TypeClassification.Closed).ToArray()); }
/// <summary> /// Adds SagaStateMachines to the registry, using the factory method, and updates the registrar prior to registering so that the default /// saga registrar isn't notified. /// </summary> /// <param name="configurator"></param> /// <param name="registrar"></param> /// <param name="assemblies">The assemblies to scan for state machines</param> public static void AddSagaStateMachines(this IRegistrationConfigurator configurator, ISagaStateMachineRegistrar registrar, params Assembly[] assemblies) { if (assemblies.Length == 0) { assemblies = AppDomain.CurrentDomain.GetAssemblies(); } var types = AssemblyTypeCache.FindTypes(assemblies, IsSagaStateMachineOrDefinition).GetAwaiter().GetResult(); configurator.AddSagaStateMachines(registrar, types.FindTypes(TypeClassification.Concrete).ToArray()); }
public static void RegisterSagaStateMachines(this IContainerRegistrar registrar, params Assembly[] assemblies) { if (assemblies.Length == 0) { assemblies = AppDomain.CurrentDomain.GetAssemblies(); } var types = AssemblyTypeCache.FindTypes(assemblies, x => x.HasInterface(typeof(SagaStateMachine <>))).GetAwaiter().GetResult(); registrar.RegisterSagaStateMachines(types.FindTypes(TypeClassification.Concrete | TypeClassification.Closed).ToArray()); }
/// <summary> /// Adds all futures that match the given filter in the specified assemblies /// </summary> /// <param name="configurator"></param> /// <param name="filter"></param> /// <param name="assemblies">The assemblies to scan for futures</param> public static void AddFutures(this IRegistrationConfigurator configurator, Func <Type, bool> filter, params Assembly[] assemblies) { if (assemblies.Length == 0) { assemblies = AppDomain.CurrentDomain.GetAssemblies(); } var types = AssemblyTypeCache.FindTypes(assemblies, TypeMetadataCache.IsFutureOrDefinition).GetAwaiter().GetResult(); AddFutures(configurator, filter, types.FindTypes(TypeClassification.Concrete | TypeClassification.Closed).ToArray()); }
static IEnumerable <Type> FindTypesInNamespace(Type type, Func <Type, bool> typeFilter) { bool Filter(Type candidate) { return(typeFilter(candidate) && candidate.Namespace != null && candidate.Namespace.StartsWith(type.Namespace, StringComparison.OrdinalIgnoreCase)); } return(AssemblyTypeCache.FindTypes(type.Assembly, TypeClassification.Concrete, Filter).GetAwaiter().GetResult()); }
/// <summary> /// Adds SagaStateMachines to the registry, using the factory method, and updates the registrar prior to registering so that the default /// saga registrar isn't notified. /// </summary> /// <param name="configurator"></param> /// <param name="assemblies">The assemblies to scan for state machines</param> public static void AddSagaStateMachines(this IRegistrationConfigurator configurator, params Assembly[] assemblies) { if (assemblies.Length == 0) { assemblies = AppDomain.CurrentDomain.GetAssemblies(); } var types = AssemblyTypeCache.FindTypes(assemblies, type => TypeMetadataCache.IsSagaStateMachineOrDefinition(type) && !TypeMetadataCache.IsFutureOrDefinition(type)) .GetAwaiter().GetResult(); configurator.AddSagaStateMachines(types.FindTypes(TypeClassification.Concrete | TypeClassification.Closed).ToArray()); }
static IList <Type> FindTypes <T>(IKernel kernel, Func <Type, bool> filter) { Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies(); TypeSet types = AssemblyTypeCache.FindTypes(assemblies, typeof(T).IsAssignableFrom).Result; return(types.AllTypes() .SelectMany(kernel.GetBindings) .Select(x => x.Service) .Distinct() .Where(filter) .ToList()); }
/// <summary> /// Scans the given assembly for declarative mixin configuration information and stores the information for a later call to <see cref="BuildConfiguration"/>. /// The mixin configuration information of types marked with the <see cref="IgnoreForMixinConfigurationAttribute"/> will be ignored. /// </summary> /// <param name="assembly">The assembly to be scanned.</param> /// <returns>A reference to this <see cref="DeclarativeConfigurationBuilder"/> object.</returns> /// <exception cref="ArgumentNullException">The <paramref name="assembly"/> parameter is <see langword="null"/>.</exception> public DeclarativeConfigurationBuilder AddAssembly(Assembly assembly) { ArgumentUtility.CheckNotNull("assembly", assembly); s_log.DebugFormat("Adding assembly {0} to DeclarativeConfigurationBuilder.", assembly); foreach (var t in AssemblyTypeCache.GetTypes(assembly)) { if (!t.IsDefined(typeof(IgnoreForMixinConfigurationAttribute), false) && !MixinTypeUtility.IsGeneratedByMixinEngine(t)) { AddType(t); } } return(this); }
static IServiceInstanceTransportConfigurator <TEndpointConfigurator> GetServiceInstanceTransportConfigurator() { var assembly = typeof(TEndpointConfigurator).Assembly; var transportConfiguratorType = AssemblyTypeCache .FindTypes(assembly, TypeClassification.Concrete, x => x.HasInterface <IServiceInstanceTransportConfigurator <TEndpointConfigurator> >()) .GetAwaiter().GetResult().FirstOrDefault(); if (transportConfiguratorType == null) { throw new ArgumentException($"Type not found: {TypeMetadataCache<IServiceInstanceTransportConfigurator<TEndpointConfigurator>>.ShortName}"); } return((IServiceInstanceTransportConfigurator <TEndpointConfigurator>)Activator.CreateInstance(transportConfiguratorType)); }
TypeConverterCache() { _typeConverters = new ConcurrentDictionary <Type, object>(); _converters = new List <object>(); var assembly = typeof(BooleanTypeConverter).Assembly; var ns = typeof(BooleanTypeConverter).Namespace; var converterTypes = AssemblyTypeCache.FindTypes(assembly, TypeClassification.Concrete | TypeClassification.Closed, x => x.Namespace.StartsWith(ns) && x.HasInterface(typeof(ITypeConverter <,>))).GetAwaiter().GetResult().ToArray(); foreach (var converterType in converterTypes) { AddSupportedTypes(converterType); } }
private void ConfigureLogging() { if (_parameters.Verbose) { LogManager.InitializeConsole(); } else { var mixerLoggers = from t in AssemblyTypeCache.GetTypes(typeof(Mixer).Assembly) where t.Namespace == typeof(Mixer).Namespace select LogManager.GetLogger(t); var logThresholds = from l in mixerLoggers select new LogThreshold(l, LogLevel.Info); LogManager.InitializeConsole(LogLevel.Warn, logThresholds.ToArray()); } }
static IEnumerable <Type> FindTypesInNamespace(Type type, Func <Type, bool> typeFilter) { if (type.Namespace == null) { throw new ArgumentException("The type must have a valid namespace", nameof(type)); } var dottedNamespace = type.Namespace + "."; bool Filter(Type candidate) { return(typeFilter(candidate) && candidate.Namespace != null && (candidate.Namespace.StartsWith(dottedNamespace, StringComparison.OrdinalIgnoreCase) || candidate.Namespace.Equals(type.Namespace, StringComparison.OrdinalIgnoreCase))); } return(AssemblyTypeCache.FindTypes(type.Assembly, TypeClassification.Concrete | TypeClassification.Closed, Filter).GetAwaiter().GetResult()); }
public static async Task MapEndpointConventions(this IBusFactoryConfigurator cfg, params Assembly[] assemblies) { var types = await AssemblyTypeCache.FindTypes(assemblies, t => { var info = t.GetTypeInfo(); return(!info.IsAbstract && !info.IsInterface && typeof(ICommand).IsAssignableFrom(t)); }); var allTypes = types.AllTypes(); var mapMethod = typeof(EndpointConvention) .GetMethod("Map", BindingFlags.Static | BindingFlags.Public, null, new Type[] { typeof(Uri) }, null); foreach (var type in allTypes) { var generic = mapMethod.MakeGenericMethod(type); generic.Invoke(null, new object[] { new Uri($"queue:{type.Name}") }); } }
public void GetMetadata(Assembly assembly, MetadataCache cache) { ArgumentUtility.CheckNotNull("assembly", assembly); ArgumentUtility.CheckNotNull("cache", cache); Assembly securityAssembly = GetType().Assembly; _accessTypeReflector.GetAccessTypesFromAssembly(securityAssembly, cache); _accessTypeReflector.GetAccessTypesFromAssembly(assembly, cache); _abstractRoleReflector.GetAbstractRoles(securityAssembly, cache); _abstractRoleReflector.GetAbstractRoles(assembly, cache); foreach (Type type in AssemblyTypeCache.GetTypes(assembly)) { if (typeof(ISecurableObject).IsAssignableFrom(type)) { _classReflector.GetMetadata(type, cache); } } }
public Task <TypeSet> ScanForTypes() { return(AssemblyTypeCache.FindTypes(_assemblies, _filter.Matches)); }
public static IServiceCollection ConfigureBus(this IServiceCollection services, IConfiguration configuration, string apiResourceName, Assembly assembly, Action <IServiceCollectionConfigurator <IExternalBus> > postAction = null) { var config = new MassTransitConfig(); configuration.Bind("MassTransitConfig", config); // get referenced assemblies var assemblies = new List <Assembly> { assembly }; assemblies.AddRange(assembly.GetProjectReferencedAssemblies()); // find consumers var types = AssemblyTypeCache.FindTypes(assemblies, TypeMetadataCache.IsConsumerOrDefinition).GetAwaiter() .GetResult(); var consumers = types.FindTypes(TypeClassification.Concrete | TypeClassification.Closed).ToArray(); var internals = new List <Type>(); var externals = new List <Type>(); foreach (var type in consumers) { if (type.HasInterface <IExternalConsumer>()) { externals.Add(type); Console.ForegroundColor = ConsoleColor.Yellow; Console.WriteLine($"{type.FullName} registered into External Bus"); } else { internals.Add(type); Console.ForegroundColor = ConsoleColor.Magenta; Console.WriteLine($"{type.FullName} registered into Mediator"); } } services.AddMediator(x => { x.AddConsumers(internals.ToArray()); }); //services.AddMassTransit(x => //{ // x.AddConsumers(internals.ToArray()); // x.AddMediator((provider, cfg) => { cfg.UseFluentValidation(); }); //}); services.AddMassTransit <IExternalBus>(x => { x.AddConsumers(externals.ToArray()); x.AddBus(provider => { switch (config.BusType) { case BusType.AzureServiceBus: case BusType.ActiveMQ: case BusType.AmazonSQS: throw new NotImplementedException(); default: var busControl = Bus.Factory.CreateUsingRabbitMq(cfg => { cfg.Host(new Uri(config.RabbitMQ.Address), h => { h.Username(config.RabbitMQ.Username); h.Password(config.RabbitMQ.Password); }); cfg.ReceiveEndpoint(apiResourceName, ep => { ep.ConfigureConsumers(provider); }); cfg.ConnectConsumerConfigurationObserver( new FluentValidationConsumerConfigurationObserver(provider)); //cfg.UseFluentValidation(); }); return(busControl); } }); postAction?.Invoke(x); }); services.AddMassTransitHostedService(); return(services); }
/// <summary> /// Gets the default service configuration for the types in the given assemblies. /// </summary> /// <param name="assemblies">The assemblies for whose types to get the default service configuration.</param> /// <returns>A <see cref="ServiceConfigurationEntry"/> for each type that has the <see cref="ImplementationForAttribute"/> applied. /// Types without the attribute are ignored.</returns> public IEnumerable <ServiceConfigurationEntry> GetDefaultConfiguration(IEnumerable <Assembly> assemblies) { ArgumentUtility.CheckNotNull("assemblies", assemblies); return(assemblies.SelectMany(a => GetDefaultConfiguration(AssemblyTypeCache.GetTypes(a)))); }
/// <summary> /// Gets the default service configuration for the given types. /// </summary> /// <param name="serviceType">The type to get the default service configuration for.</param> /// <returns>A <see cref="ServiceConfigurationEntry"/> for each serviceType that has implementations with a <see cref="ImplementationForAttribute"/> applied. /// Types without the attribute are ignored.</returns> public ServiceConfigurationEntry GetDefaultConfiguration(Type serviceType) { ArgumentUtility.CheckNotNull("serviceType", serviceType); try { var excludeGlobalTypes = _excludeGlobalTypesForDefaultConfiguration || !AssemblyTypeCache.IsGacAssembly(serviceType.Assembly); var implementingTypes = GetImplementingTypes(serviceType, excludeGlobalTypes); var attributes = implementingTypes .SelectMany( implementingType => GetImplementationForAttributesFromCache(implementingType) .Where(attribute => attribute.ServiceType == serviceType) .Select(CloneAttribute) .Select(attribute => Tuple.Create(implementingType, attribute))) .ToLookup(a => a.Item2.RegistrationType); if (attributes.Contains(RegistrationType.Compound) && attributes.Contains(RegistrationType.Single)) { throw new InvalidOperationException("Registration types 'Compound' and 'Single' cannot be used together."); } if (attributes.Contains(RegistrationType.Single) && attributes.Contains(RegistrationType.Multiple)) { throw new InvalidOperationException("Registration types 'Single' and 'Multiple' cannot be used together."); } return(ServiceConfigurationEntry.CreateFromAttributes(serviceType, FilterAttributes(attributes))); } catch (Exception ex) { var message = string.Format("Invalid configuration of service type '{0}'. {1}", serviceType, ex.Message); throw new InvalidOperationException(message, ex); } }