public Startup(IConfiguration configuration,
Microsoft.Extensions.Hosting.IHostingEnvironment environment) : base(() => new Never.ApplicationStartup(new Never.IoC.Providers.AppDomainAssemblyProvider(GetAssemblyName)))
{
this.Configuration = configuration;
this.Environment = environment;
this.OnStarting += this.Startup_OnStarting;
}
public Startup(Microsoft.Extensions.Hosting.IHostingEnvironment env)
{
var appsettings = new ConfigurationBuilder()
.SetBasePath(env.ContentRootPath)
.AddJsonFile("appsettings.json")
.Build();
Configuration = appsettings;
}
public static IServiceCollection AddDefaultJsonConfiguration(this IServiceCollection services)
{
return(services.AddSingleton(provider =>
{
IHostEnvironment env = provider.GetRequiredService <IHostEnvironment>();
IConfiguration config = new ConfigurationBuilder()
.AddDefaultJsonConfiguration(env)
.Build();
return config;
}));
}
public Startup(
IHostingEnvironment env,
StartupOptions startupOptions)
{
Environment = env;
StartupOptions = startupOptions;
var configurationBuilder = new ConfigurationBuilder()
.SetBasePath(env.ContentRootPath);
Configuration = configurationBuilder.Build();
}
public LinuxServiceHost(
Microsoft.Extensions.Configuration.IConfiguration configuration,
Microsoft.Extensions.Hosting.IHostingEnvironment environment,
Microsoft.Extensions.Logging.ILogger <LinuxServiceHost> logger,
Microsoft.Extensions.Hosting.IApplicationLifetime appLifetime,
ICommonService commonService)
{
this.configuration = configuration;
this.logger = logger;
this.appLifetime = appLifetime;
this.environment = environment;
this.commonService = commonService;
}
static void Main(string[] args)
{
HostingEnvironment = GetHostingEnvironment();
Configuration = GetConfiguration(HostingEnvironment, args);
var siloHostBuilder = new SiloHostBuilder()
.SetClusteringEnvironment()
.Configure <ClusterOptions>(options => {
options.ClusterId = Configuration["Orleans:ClusterId"];
options.ServiceId = Configuration["Orleans:ServiceId"];
})
.Configure <EndpointOptions>(options => {
options.AdvertisedIPAddress = IPAddress.Loopback;
})
.ConfigureApplicationParts(parts => {
parts.AddApplicationPart(typeof(Grains.Posts.BlogPostGrain).Assembly).WithReferences();
})
.ConfigureLogging(logging => {
logging
.AddConfiguration(Configuration)
.AddConsole();
})
.ConfigureServices(ConfigureServices);
if (Configuration.GetValue <bool>("OrleansDashboard:Enabled", false))
{
siloHostBuilder = siloHostBuilder.UseDashboard(options => {
options.Host = Configuration["OrleansDashboard:Host"];
options.Port = Configuration.GetValue <int>("OrleansDashboard:Port");
options.Username = Configuration["OrleansDashboard:Username"];
options.Password = Configuration["OrleansDashboard:Password"];
options.CounterUpdateIntervalMs = Configuration.GetValue <int>("OrleansDashboard:UpdateInterval", 1000);
});
}
var siloHost = siloHostBuilder.Build();
siloHost.StartAsync()
.ContinueWith(task => {
Console.WriteLine("CoreBlog SiloHost is running...");
return(task);
});
resetEvent.WaitOne();
}
static IConfiguration GetConfiguration(IHostingEnvironment hostingEnvironment, string[] args)
{
return(new ConfigurationBuilder()
.SetBasePath(hostingEnvironment.ContentRootPath)
.AddJsonFile(
provider: hostingEnvironment.ContentRootFileProvider,
path: "appsettings.json",
optional: false,
reloadOnChange: true)
.AddJsonFile(
provider: hostingEnvironment.ContentRootFileProvider,
path: $"appsettings.{hostingEnvironment.EnvironmentName}.json",
optional: true,
reloadOnChange: true)
.AddEnvironmentVariables(prefix: "ENVIRONMENT_")
.AddCommandLine(args)
.Build());
}
public AdminController(RoleManager <IdentityRole> roleManager,
UserManager <IdentityUser> userManager,
ICategoryRepository categoryRepository,
IGiftRepository giftRepository,
IOrderRepository orderRepository,
ICartRepository cartRepository,
ICartItemRepository cartItemRepository,
IEmailSender emailSender,
IHostingEnvironment appEnvironment)
{
_roleManager = roleManager;
_userManager = userManager;
_categoryRepository = categoryRepository;
_giftRepository = giftRepository;
_appEnvironment = appEnvironment;
_orderRepository = orderRepository;
_cartRepository = cartRepository;
_cartItemRepository = cartItemRepository;
_emailSender = emailSender;
}
private static void Main(string[] args)
{
_environment = new HostingEnvironment
{
EnvironmentName = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT"),
ApplicationName = AppDomain.CurrentDomain.FriendlyName,
ContentRootPath = AppDomain.CurrentDomain.BaseDirectory,
ContentRootFileProvider = new PhysicalFileProvider(AppDomain.CurrentDomain.BaseDirectory)
};
var builder = new ConfigurationBuilder()
.AddJsonFile($"appsettings.json", true, true)
.AddJsonFile($"appsettings.{_environment.EnvironmentName}.json", true, true)
.AddEnvironmentVariables();
var configuration = builder.Build();
var myConnString = configuration.GetConnectionString("SQLConn");
MainClientAsync().GetAwaiter().GetResult();
MainAsync().GetAwaiter().GetResult();
Console.ReadLine();
}
public void Configure(IApplicationBuilder app, Microsoft.Extensions.Hosting.IHostingEnvironment env)
{
// app.AddFastAndDependencySampler();
var config = app.ApplicationServices.GetService <TelemetryConfiguration>();
// app.UseSerilogRequestLogging(); // <-- Add this line
config.TelemetryProcessorChainBuilder.Use(next => new FixNameProcessor(next));
// config.TelemetryProcessorChainBuilder.Use(next => new AggressivelySampleFastDependencies(next));
config.TelemetryProcessorChainBuilder.Build();
app.Map("/api/test", builderinner => {
builderinner.Use((ctx, next) => {
var a = ctx.RequestServices.GetService <TelemetryConfiguration>();
throw new Exception("A");
});
});
app.Run(async ctx =>
{
var a = ctx.Features.Get <RequestTelemetry>();
a.Name = ctx.Request.Method + " " + ctx.Request.Path;
ctx.RequestServices.GetService <ILogger <Startup> >().LogWarning("TEST");
await ctx.Response.WriteAsync("Hello world");
});
}
public Startup(Microsoft.Extensions.Hosting.IHostingEnvironment hostEnv) //Конструктор для отримання рядка з файла dbSettings.json
{
_confString = new ConfigurationBuilder().SetBasePath(hostEnv.ContentRootPath).AddJsonFile("dbSettings.json").Build(); //SetBasePath-початковий путь до папки, в цій папці кажемо добав файл dbSettings.json через команду AddJsonFile і виконай отримання даного файлу Build
}
public static void ConfigureServices(IServiceCollection services, IConfiguration configuration, IHostingEnvironment environment)
{
services
.AddCustomApiVersioning()
.AddMvcCore()
.AddAuthorization()
.AddJsonFormatters()
.AddFluentValidations()
.AddApiExplorer()
.AddVersionedApiExplorer()
.Services
.AddCustomProblemDetails(environment);
DependencyResolutions.AddTo(services, configuration);
}
public TestStartup(IConfiguration configuration, ILoggerFactory loggerFactory, IHostingEnvironment hostingEnvironment)
: base(configuration, loggerFactory, hostingEnvironment)
{
}
/// <summary>
/// Adds the "Default" json file configuration to the <see cref="IConfigurationBuilder"/>.
/// This loads the files '.config/settings.json' and '.config/settings.<Environment>.json', and maps Key Vault secrets and Azure App Configuration keys into the configuration.
/// Key Vault:
/// Key Vault secrets are read from the Key Vault referenced by the '<see cref="ConfigurationConstants.KeyVaultUriConfigurationKey"/>' configuration value and used to replace any references of the form '[vault(my_special_secret_name)]' with the corresponding secret value
/// App Configuration:
/// App Configuration keys are retrieved from the '<see cref="ConfigurationConstants.AppConfigurationUriConfigurationKey"/>' configuration value and replace references matching '[config(my_app_config_key)]' with the key value
///
/// Authentication is handled by either MSI (optionally using the '<see cref="ConfigurationConstants.ManagedIdentityIdConfigurationKey"/>' configuration value for a user-assigned managed identity), or VS/az cli authentication.
/// Values will be refreshed every '<see cref="ConfigurationConstants.ReloadTimeSecondsConfigurationKey"/>' seconds.
/// </summary>
public static IConfigurationBuilder AddDefaultJsonConfiguration(this IConfigurationBuilder builder, IHostEnvironment hostEnvironment, string configPathFormat = ".config/settings{0}.json")
{
string rootConfigFile = string.Format(configPathFormat, "");
string envConfigFile = string.Format(configPathFormat, "." + hostEnvironment.EnvironmentName);
IConfiguration bootstrapConfig = new ConfigurationBuilder()
.SetBasePath(hostEnvironment.ContentRootPath)
.AddJsonFile(rootConfigFile)
.AddJsonFile(envConfigFile, optional: true)
.Build();
string reloadTimeString = bootstrapConfig[ConfigurationConstants.ReloadTimeSecondsConfigurationKey];
if (!int.TryParse(reloadTimeString, out int reloadTimeSeconds))
{
reloadTimeSeconds = 5 * 60;
}
var reloadTime = TimeSpan.FromSeconds(reloadTimeSeconds);
Func <string, string> keyVault = KeyVaultConfigMapper.Create(bootstrapConfig);
Func <string, string> appConfiguration = AppConfigurationConfigMapper.Create(bootstrapConfig);
string Mapper(string v) => keyVault(appConfiguration(v));
return(builder
.AddMappedJsonFile(rootConfigFile, reloadTime, Mapper)
.AddMappedJsonFile(envConfigFile, reloadTime, Mapper, optional: true));
}
/// <summary>
/// 注入服务
/// </summary>
/// <param name="services"></param>
/// <param name="env"></param>
static void ConfigureServices(IServiceCollection services, IHostingEnvironment env)
{
services.AddRabbitMQ(env.EnvironmentName);
}
public WebScriptJobHostEnvironment(IApplicationLifetime applicationLifetime, IScriptHostManager hostManager, ExtensionsHostingEnvironment hostingEnvironment)
{
_applicationLifetime = applicationLifetime ?? throw new ArgumentNullException(nameof(applicationLifetime));
_hostManager = hostManager ?? throw new ArgumentNullException(nameof(hostManager));
_hostingEnvironment = hostingEnvironment ?? throw new ArgumentNullException(nameof(hostingEnvironment));
}
public ServiceBaseLifetime(Microsoft.Extensions.Hosting.IHostingEnvironment environment, Microsoft.Extensions.Hosting.IApplicationLifetime applicationLifetime, Microsoft.Extensions.Logging.ILoggerFactory loggerFactory)
{
}
/// <summary>
/// Use for .NET Core Console applications.
/// </summary>
/// <param name="config"></param>
/// <param name="env"></param>
/// <returns></returns>
private static IConfigurationBuilder Configure(IConfigurationBuilder config, Microsoft.Extensions.Hosting.IHostingEnvironment env)
{
return(Configure(config, env.EnvironmentName));
}
public static bool IsEnvironment(this Microsoft.Extensions.Hosting.IHostingEnvironment hostingEnvironment, string environmentName)
{
throw null;
}
/// <summary>
/// 注入服务
/// </summary>
/// <param name="services"></param>
/// <param name="env"></param>
static void ConfigureServices(IServiceCollection services, IHostingEnvironment env)
{
services.AddSingleton <IAreaCrawlingHandler, AreaCrawlingHandler>();
}
public EnvPlugin(Microsoft.Extensions.Hosting.IHostingEnvironment environment)
{
this._environment = environment.EnvironmentName;
}
public static bool IsStaging(this Microsoft.Extensions.Hosting.IHostingEnvironment hostingEnvironment)
{
throw null;
}
public ConsoleLifetime(Microsoft.Extensions.Options.IOptions <Microsoft.Extensions.Hosting.ConsoleLifetimeOptions> options, Microsoft.Extensions.Hosting.IHostingEnvironment environment, Microsoft.Extensions.Hosting.IApplicationLifetime applicationLifetime)
{
}
public ConsoleLifetime(Microsoft.Extensions.Options.IOptions <Microsoft.Extensions.Hosting.ConsoleLifetimeOptions> options, Microsoft.Extensions.Hosting.IHostingEnvironment environment, Microsoft.Extensions.Hosting.IApplicationLifetime applicationLifetime, Microsoft.Extensions.Logging.ILoggerFactory loggerFactory)
{
}
public PlayersRepository(AppDBContent appDBContent, Microsoft.Extensions.Hosting.IHostingEnvironment appEnvironment)
{
this.appDBContent = appDBContent;
_appEnvironment = appEnvironment;
}
