/// <summary> /// /// </summary> /// <typeparam name="TProfile"></typeparam> /// <param name="validate"></param> public void AddProfile <TProfile>(bool validate = false) where TProfile : Profile, new() { Configurators.Add(context => context.MapperConfiguration.AddProfile <TProfile>()); if (validate) { ValidateProfile(typeof(TProfile)); } }
public void AddProfiles(Assembly assembly) { var profileTypes = assembly .GetTypes() .Where(type => typeof(Profile).IsAssignableFrom(type) && !type.IsAbstract && !type.IsGenericType); foreach (var profileType in profileTypes) { Configurators.Add(mapper => mapper.AddProfile(profileType)); } }
/// <summary> /// 添加模块 /// </summary> /// <typeparam name="TModule"></typeparam> /// <param name="func">委托返回所有的枚举项值</param> /// <param name="func2">委托返回所有的枚举类型</param> public void Add <TModule>(Func <Assembly, Dictionary <string, Dictionary <int, string> > > func, Func <Assembly, Dictionary <string, string> > func2) { var assembly = typeof(TModule).Assembly; Configurators.Add(context => { Dictionary <string, Dictionary <int, string> > dic = new Dictionary <string, Dictionary <int, string> >(); Dictionary <string, string> dicType = new Dictionary <string, string>(); if (func != null) { dic = func(assembly); if (func2 == null) { throw new Exception("返回枚举类型的委托不能为空"); } dicType = func2(assembly); } else { var types = assembly.GetTypes().Where(p => p.IsEnum); foreach (var enumType in types) { FieldInfo[] fields = enumType.GetFields(BindingFlags.Static | BindingFlags.Public); var rs = new Dictionary <int, string>(); foreach (var item in fields) { var fieldValue = item.GetRawConstantValue(); var fieldDescription = item.GetDescription(); rs.Add((int)fieldValue, fieldDescription); } dic.Add(enumType.Name, rs); dicType.Add(enumType.Name, enumType.GetDescription()); } } foreach (var item in dic) { if (!context.Enums.ContainsKey(item.Key)) { context.Enums.Add(item.Key, item.Value); } } foreach (var item in dicType) { if (!context.EnumTypes.ContainsKey(item.Key)) { context.EnumTypes.Add(item.Key, item.Value); } } }); }
public void AddProfile <TProfile>(bool validate = false) where TProfile : Profile, new() { Configurators.Add(context => { context.MapperConfiguration.AddProfile <TProfile>(); }); if (validate) { ValidatingProfiles.Add <TProfile>(); } }
/// <summary> /// /// </summary> /// <typeparam name="TModule"></typeparam> /// <param name="validate"></param> public void AddMaps <TModule>(bool validate = false) { var assembly = typeof(TModule).Assembly; Configurators.Add(context => context.MapperConfiguration.AddMaps(assembly)); if (validate) { var profileTypes = assembly .DefinedTypes .Where(type => typeof(Profile).IsAssignableFrom(type) && !type.IsAbstract && !type.IsGenericType); foreach (var profileType in profileTypes) { ValidatingProfiles.Add(profileType); } } }
/// <inheritdoc/> public async Task <int> RunAsync() { // Remove the synchronization context await default(SynchronizationContextRemover); // Populate the class catalog (if we haven't already) _classCatalog.Populate(); // Run bootstrapper configurators first Configurators.Configure <IConfigurableBootstrapper>(this); Configurators.Configure <IBootstrapper>(this); // Create the service collection IServiceCollection serviceCollection = CreateServiceCollection() ?? new ServiceCollection(); serviceCollection.TryAddSingleton <IConfigurableBootstrapper>(this); serviceCollection.TryAddSingleton <IBootstrapper>(this); serviceCollection.TryAddSingleton(_classCatalog); // The class catalog is retrieved later for deferred logging once a service provider is built // Run configurators on the service collection ConfigurableServices configurableServices = new ConfigurableServices(serviceCollection); Configurators.Configure(configurableServices); // Add simple logging to make sure it's available in commands before the engine adds in serviceCollection.AddLogging(); // Create the stand-alone command line service container and register a few types needed for the CLI CommandServiceTypeRegistrar registrar = new CommandServiceTypeRegistrar(); registrar.RegisterInstance(typeof(IServiceCollection), serviceCollection); registrar.RegisterInstance(typeof(IConfiguratorCollection), Configurators); // Create the command line parser and run the command ICommandApp app = _getCommandApp(registrar); app.Configure(x => { x.ValidateExamples(); ConfigurableCommands configurableCommands = new ConfigurableCommands(x); Configurators.Configure(configurableCommands); }); return(await app.RunAsync(Args)); }
public sealed override async Task <int> ExecuteAsync(CommandContext context, TSettings commandSettings) { // Set verbose tracing if (commandSettings.LogLevel != LogLevel.Information) { ServiceCollection.Configure <LoggerFilterOptions>(options => options.MinLevel = commandSettings.LogLevel); } // File logging if (!string.IsNullOrEmpty(commandSettings.LogFile)) { // Add the log provider (adding it to the service collection will get picked up by the logger factory) ServiceCollection.AddSingleton <ILoggerProvider, FileLoggerProvider>(); ServiceCollection.Configure <FileLoggerOptions>(options => { options.FileName = commandSettings.LogFile; options.LogDirectory = string.Empty; }); } // Build a temporary service provider so we can log // Make sure to place it in it's own scope so transient services get correctly disposed IServiceProvider services = ServiceCollection.BuildServiceProvider(); ClassCatalog classCatalog = services.GetService <ClassCatalog>(); using (IServiceScope serviceScope = services.CreateScope()) { // Log pending messages ILogger logger = serviceScope.ServiceProvider.GetRequiredService <ILogger <Bootstrapper> >(); logger.LogInformation($"Statiq version {Engine.Version}"); classCatalog?.LogDebugMessages(logger); // Attach if (commandSettings.Attach) { logger.LogInformation($"Waiting for a debugger to attach to process {Process.GetCurrentProcess().Id} (or press a key to continue)..."); while (!Debugger.IsAttached && !Console.KeyAvailable) { Thread.Sleep(100); } if (Console.KeyAvailable) { Console.ReadKey(true); logger.LogInformation("Key pressed, continuing execution"); } else { logger.LogInformation("Debugger attached, continuing execution"); } } } // Add settings if (commandSettings.Settings?.Length > 0) { foreach (KeyValuePair <string, string> setting in SettingsParser.Parse(commandSettings.Settings)) { ConfigurationSettings[setting.Key] = setting.Value; } } // Configure settings after other configuration so they can use the values ConfigurableSettings configurableSettings = new ConfigurableSettings(ConfigurationSettings); Configurators.Configure(configurableSettings); return(await ExecuteCommandAsync(context, commandSettings)); }
/// <inheritdoc/> public async Task <int> RunAsync() { // Remove the synchronization context await default(SynchronizationContextRemover); // Populate the class catalog (if we haven't already) _classCatalog.Populate(); // Run bootstrapper configurators first Configurators.Configure <IConfigurableBootstrapper>(this); Configurators.Configure <IBootstrapper>(this); // Run the configuration configurator and get the configuration root SettingsConfigurationProvider settingsProvider = new SettingsConfigurationProvider(); IConfigurationBuilder configurationBuilder = new ConfigurationBuilder(); ConfigurableConfiguration configurableConfiguration = new ConfigurableConfiguration(configurationBuilder); Configurators.Configure(configurableConfiguration); configurationBuilder.Add(settingsProvider); IConfigurationRoot configurationRoot = configurationBuilder.Build(); ConfigurationSettings configurationSettings = new ConfigurationSettings(settingsProvider, configurationRoot); // Create the service collection IServiceCollection serviceCollection = CreateServiceCollection() ?? new ServiceCollection(); serviceCollection.TryAddSingleton <IConfigurableBootstrapper>(this); serviceCollection.TryAddSingleton <IBootstrapper>(this); serviceCollection.TryAddSingleton(_classCatalog); // The class catalog is retrieved later for deferred logging once a service provider is built serviceCollection.TryAddSingleton <IConfiguration>(configurationRoot); // Run configurators on the service collection ConfigurableServices configurableServices = new ConfigurableServices(serviceCollection, configurationRoot); Configurators.Configure(configurableServices); // Add simple logging to make sure it's available in commands before the engine adds in, // but add it after the configurators have a chance to configure logging serviceCollection.AddLogging(); // Create the stand-alone command line service container and register a few types needed for the CLI CommandServiceTypeRegistrar registrar = new CommandServiceTypeRegistrar(); registrar.RegisterInstance(typeof(IConfigurationSettings), configurationSettings); registrar.RegisterInstance(typeof(IConfigurationRoot), configurationRoot); registrar.RegisterInstance(typeof(IServiceCollection), serviceCollection); registrar.RegisterInstance(typeof(IConfiguratorCollection), Configurators); registrar.RegisterInstance(typeof(IBootstrapper), this); // Create the command line parser and run the command ICommandApp app = _getCommandApp(registrar); app.Configure(commandConfigurator => { commandConfigurator.ValidateExamples(); ConfigurableCommands configurableCommands = new ConfigurableCommands(commandConfigurator); Configurators.Configure(configurableCommands); }); int exitCode = await app.RunAsync(Arguments); // Dispose all instances of the console logger to flush the message queue and stop the listening thread ConsoleLoggerProvider.DisposeAll(); return(exitCode); }
public void AddConfigurator(Action <IMapperConfigurationExpression> action) { Configurators.Add(action); }