internal Task Run()
{
SetStartupAssembly();
SetWebRoot();
ConfigureAppConfiguration();
ConfigureApp();
ConfigureServices();
ConfigureSerilog();
ConfigureHost();
return(_builder.Build().RunAsync());
}
public static IWebHost BuildWebHost(string[] args)
{
// IWebHostBuilder builder = new DefaultWebHostBuilderFactory().Build<Startup>(args);
IWebHostBuilder builder = WebHost.CreateDefaultBuilder(args).UseStartup <Startup>();
X509Certificate2 cert = Certificate.FromFile("local.pfx", "pencil");;
builder.UseKestrel(options => {
options.ConfigureHttpsDefaults(httpsOptions => {
httpsOptions.ServerCertificate = cert;
});
});
return(builder.Build());
}
public static IWebHost BuildWebHost(string[] args)
{
IWebHostBuilder webHostBuilder = WebHost
.CreateDefaultBuilder(args)
.ConfigureLogging(
(context, builder) =>
{
builder.AddFile("C:/Temp/Logs/log-{Date}.txt");
})
.UseStartup <Startup>();
return(webHostBuilder.Build());
}
/// <summary>
/// Starts a new function host using the given Uri and startup class.
/// </summary>
/// <typeparam name="TFunctionStartup">The type of the startup class. This should be the type of the class from the
/// function host project that is used to initialise the OpenApi services and dependencies.</typeparam>
/// <param name="baseUrl">The url that the function will be exposed on.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
public Task StartFunctionAsync <TFunctionStartup>(string baseUrl)
where TFunctionStartup : IWebJobsStartup, new()
{
IWebHostBuilder builder = WebHost.CreateDefaultBuilder();
builder.UseUrls(baseUrl);
builder.UseStartup <OpenApiWebHostStartup <TFunctionStartup> >();
IWebHost host = builder.Build();
this.webHosts.Add(host);
return(host.StartAsync());
}
/// <summary>
/// 此处是Web程序的入口
/// </summary>
/// <param name="args"></param>
public static void Main(string[] args)
{
//Kerstrel
IWebHostBuilder builder = WebHost.CreateDefaultBuilder(args)
.UseKestrel()
.UseIIS()
.UseIISIntegration() //作为反向代理
.UseEnvironment("Preview")
//.UseStartup<Startup>() //使用StartUp
.UseUrls("http://localhost:6500");
//在BUILDER上操作配置服务器
//自定义JSON配置文件
ConfigurationBuilder configurationBuilder = new ConfigurationBuilder();
configurationBuilder.SetBasePath(builder.GetSetting(WebHostDefaults.ContentRootKey));
configurationBuilder.AddJsonFile("appsettings.json");
IConfiguration config = configurationBuilder.Build();
var value = config["KEY"];
builder.UseConfiguration(configurationBuilder.Build());
//无StrartUp自定义congfig配置
builder.ConfigureServices(service =>
{
//Add Service
});
builder.Configure(app =>
{
app.Run(async context => { await context.Response.WriteAsync("Pipeline Break!"); });
});
var host = builder.Build();
using (IServiceScope scope = host.Services.CreateScope())
{
//此处获取服务的实例对象
IWebHostEnvironment environment = scope.ServiceProvider.GetRequiredService <IWebHostEnvironment>();
environment.ApplicationName = "我的新MVC服务APP";
}
host.Run();
}
public static void Run(string[] args, Action <ContainerBuilder> overrideDependencies = null)
{
if (overrideDependencies != null)
{
Startup.RegisterExternalTypes = overrideDependencies;
}
BaseUrl.Current = "http://localhost:5000";
IWebHostBuilder whb = WebHost.CreateDefaultBuilder(args)
.UseKestrel()
.UseStartup <Startup>();
ThreadPool.QueueUserWorkItem(state => { whb.Build().Run(); });
}
public static IWebHost Initialize(IEnumerable <ServiceDescriptor> services, FullNode fullNode,
SignalRSettings settings, IWebHostBuilder webHostBuilder)
{
Guard.NotNull(fullNode, nameof(fullNode));
Guard.NotNull(webHostBuilder, nameof(webHostBuilder));
Uri uri = settings.SignalRUri;
webHostBuilder
.UseKestrel()
.UseContentRoot(Directory.GetCurrentDirectory())
.UseIISIntegration()
.UseUrls(uri.ToString())
.ConfigureServices(collection =>
{
if (services == null)
{
return;
}
// copies all the services defined for the full node to the Api.
// also copies over singleton instances already defined
foreach (ServiceDescriptor service in services)
{
// open types can't be singletons
if (service.ServiceType.IsGenericType || service.Lifetime == ServiceLifetime.Scoped)
{
collection.Add(service);
continue;
}
object obj = fullNode.Services.ServiceProvider.GetService(service.ServiceType);
if (obj != null && service.Lifetime == ServiceLifetime.Singleton && service.ImplementationInstance == null)
{
collection.AddSingleton(service.ServiceType, obj);
}
else
{
collection.Add(service);
}
}
})
.UseStartup <Startup>();
IWebHost host = webHostBuilder.Build();
host.Start();
return(host);
}
public static IWebHost BuildWebHost(string[] args)
{
IWebHostBuilder builder = WebHost.CreateDefaultBuilder(args);
builder.ConfigureAppConfiguration((context, configurationBinder) =>
{
configurationBinder.AddJsonFile("appsettings.json", false, true);
}
);
builder = builder.UseStartup <Startup>();
return(builder.Build());
}
public static IWebHost BuildWebHost(string[] args)
{
IWebHostBuilder webHostBuilder = WebHost.CreateDefaultBuilder(args)
.UseStartup <Startup>();
string environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
if (environment == EnvironmentName.Development)
{
webHostBuilder.UseKestrel(options => options.ConfigureEndpoints());
}
return(webHostBuilder.Build());
}
public static void Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.MinimumLevel.Override("Microsoft", LogEventLevel.Information)
.Enrich.FromLogContext()
.WriteTo.Console()
.CreateLogger();
IWebHostBuilder builder = CreateWebHostBuilder(args);
IWebHost host = builder.Build();
host.Run();
}
public static IWebHost BuildWebHost(string[] args)
{
IWebHostBuilder builder = WebHost.CreateDefaultBuilder(args);
builder.ConfigureServices(s => s.AddSingleton(builder))
.ConfigureAppConfiguration(ic => ic.AddJsonFile(
path: Path.Combine(string.Empty, "appsettings.json")
, optional: false
, reloadOnChange: true))
.UseStartup <Startup>();
IWebHost host = builder.Build();
return(host);
}
static void Main(string[] args)
{
new ConfigurationBuilder()
.AddCommandLine(args)
.Build();
IWebHostBuilder builder = WebHost.CreateDefaultBuilder(args)
.UseStartup(typeof(Startup));
IWebHost webHost = builder.Build();
webHost.Start();
webHost.StopAsync(TimeSpan.Zero);
}
public static void Main(string[] args)
{
Thread.CurrentThread.CurrentCulture = new CultureInfo(ConfigurationConstants.APP_CULTURE);
IWebHostBuilder builder = CreateWebHostBuilder(args);
IWebHost host = builder.Build();
using IServiceScope scope = host.Services.CreateScope();
System.IServiceProvider services = scope.ServiceProvider;
DatabaseContext context = services.GetRequiredService <DatabaseContext>();
DatabaseInit.Execute(context);
host.Run();
}
/// <summary>
/// Build the web host
/// </summary>
/// <param name="kvUrl">URL of the Key Vault</param>
/// <param name="authType">MSI, CLI, VS</param>
/// <returns>Web Host ready to run</returns>
static async Task <IWebHost> BuildHost(string kvUrl, AuthenticationType authType)
{
// create the Key Vault Client
var kvClient = await GetKeyVaultClient(kvUrl, authType).ConfigureAwait(false);
if (kvClient == null)
{
return(null);
}
// build the config
// we need the key vault values for the DAL
config = BuildConfig(kvClient, kvUrl);
// configure the web host builder
IWebHostBuilder builder = WebHost.CreateDefaultBuilder()
.UseConfiguration(config)
.UseKestrel()
.UseUrls(string.Format(System.Globalization.CultureInfo.InvariantCulture, $"http://*:{Constants.Port}/"))
.UseStartup <Startup>()
.ConfigureServices(services =>
{
// add the data access layer via DI
services.AddDal(new Uri(config.GetValue <string>(Constants.CosmosUrl)),
config.GetValue <string>(Constants.CosmosKey),
config.GetValue <string>(Constants.CosmosDatabase),
config.GetValue <string>(Constants.CosmosCollection));
// add the KeyVaultConnection via DI
services.AddKeyVaultConnection(kvClient, new Uri(kvUrl));
// add IConfigurationRoot
services.AddSingleton <IConfigurationRoot>(config);
services.AddResponseCaching();
})
// configure logger based on command line
.ConfigureLogging(logger =>
{
logger.ClearProviders();
logger.AddConsole()
.AddFilter("Microsoft", HeliumLogLevel)
.AddFilter("System", HeliumLogLevel)
.AddFilter("Default", HeliumLogLevel);
});
// build the host
return(builder.Build());
}
protected override TestServer CreateServer(IWebHostBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
HostWeb = builder.Build();
HostWeb.Start();
// Fake Server
TestServer = new TestServer(new WebHostBuilder().UseStartup <MockStartup>());
return(TestServer);
}
public static IWebHost CreateWebHost2(string[] args)
{
var config = new ConfigurationBuilder().AddCommandLine(args).Build();
IWebHostBuilder builder = WebHost.CreateDefaultBuilder(args).UseStartup <Startup>();
string seeddata = config["init"];
string port = config["port"];
if (!string.IsNullOrWhiteSpace(port))
{
builder.UseUrls($"http://*:{port}");
}
var host = builder.Build();
return(host);
}
public static IWebHost BuildWebHost(string[] args)
{
IWebHostBuilder webHostBuilder = WebHost.CreateDefaultBuilder(args)
.UseKestrel(options =>
{
options.Listen(IPAddress.Any, 5000, listenOptions =>
{
listenOptions.UseHttps(@"..\..\certificates\localhost_ssl.pfx", "pass@word1");
listenOptions.NoDelay = true;
});
})
.UseStartup <Startup>();
return(webHostBuilder.Build());
}
protected override TestServer CreateServer(IWebHostBuilder builder)
{
//Real TCP port
this.host = builder.Build();
this.host.Start();
RootUri = this.host.ServerFeatures.Get <IServerAddressesFeature>().Addresses.LastOrDefault();
using (var scope = this.host.Services.CreateScope())
{
var services = scope.ServiceProvider;
ProductGenerator.Initialize(services);
}
//Fake Server we won't use...this is lame. Should be cleaner, or a utility class
return(new TestServer(new WebHostBuilder().UseStartup <Startup>()));
}
protected override TestServer CreateServer(IWebHostBuilder builder)
{
//Real TCP port
host = builder.Build();
// When running features in parallel, this line gets called twice leading to a port in use error.
// We disable parallelisation in xunit.runner.json, but if there was a way to only start up one host for the whole process
// that would be preferable. Cannot call this method from a BeforeTestRun binding (which would only be called once)
// as it only accepts static method and the ServerFactory cannot be DIed
host.Start();
RootUri = host.ServerFeatures.Get <IServerAddressesFeature>().Addresses.LastOrDefault(); //port 5001
// This is a 'fake' server, needed to be returned by the method but will not actually be used.
return(new TestServer(new WebHostBuilder().UseEnvironment("CI").UseStartup <TStartup>()));
}
private void GivenOcelotIsRunning()
{
_webHostBuilder = new WebHostBuilder()
.UseUrls(_ocelotBaseUrl)
.UseKestrel()
.UseContentRoot(Directory.GetCurrentDirectory())
.ConfigureServices(x => {
x.AddSingleton(_webHostBuilder);
})
.UseStartup <Startup>();
_builder = _webHostBuilder.Build();
_builder.Start();
}
public static void RunWebHost()
{
IWebHostBuilder webHostBuilder = WebHost.CreateDefaultBuilder()
.UseKestrel(options =>
{
options.Listen(IPAddress.Any, 5000);
})
.UseStartup <Startup>()
.ConfigureAppConfiguration(i =>
i.AddJsonFile("appsettings.overrides.json", true));
IWebHost webHost = webHostBuilder.Build();
webHost.Run();
}
/// <summary>
/// Build the web host
/// </summary>
/// <param name="useInMemory">Use in memory DB flag</param>
/// <returns>Web Host ready to run</returns>
private static IWebHost BuildHost()
{
// build the config
config = BuildConfig();
// configure the web host builder
IWebHostBuilder builder = WebHost.CreateDefaultBuilder()
.UseConfiguration(config)
.UseUrls(string.Format(System.Globalization.CultureInfo.InvariantCulture, $"http://*:{Constants.Port}/"))
.UseStartup <Startup>()
.UseShutdownTimeout(TimeSpan.FromSeconds(Constants.GracefulShutdownTimeout))
.ConfigureServices(services =>
{
// add the data access layer via DI
if (App.Secrets.UseInMemoryDb)
{
services.AddInMemoryDal();
}
else
{
services.AddDal(new Uri(Secrets.CosmosServer), Secrets.CosmosKey, Secrets.CosmosDatabase, Secrets.CosmosCollection);
}
// add IConfigurationRoot
services.AddSingleton <IConfigurationRoot>(config);
services.AddResponseCaching();
});
// configure logger based on command line
builder.ConfigureLogging(logger =>
{
logger.ClearProviders();
logger.AddConsole();
// if you specify the --log-level option, it will override the appsettings.json options
// remove any or all of the code below that you don't want to override
if (App.IsLogLevelSet)
{
logger.AddFilter("Microsoft", AppLogLevel)
.AddFilter("System", AppLogLevel)
.AddFilter("Default", AppLogLevel)
.AddFilter("CSE.NextGenSymmetricApp", AppLogLevel);
}
});
// build the host
return(builder.Build());
}
public static void Init(
this IWebHostBuilder hostBuilder,
string initMessage = "Starting Application",
string exceptionMessage = "Application terminated unexpectedly"
)
{
Log.Logger = CreateLogger();
try
{
Log.Information(initMessage);
var host = hostBuilder.Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService <AppDbContext>();
//DataSeeder seeder = services.GetRequiredService<DataSeeder>();
// todo: figure out the correct sequence
//context.Database.Migrate();
context.Database.EnsureCreated();
context.Database.Migrate();
//Log.Information($"Database created and seeded: {created}");
}
catch (Exception ex)
{
Log.Error(ex, "An error occurred seeding the DB.");
}
}
host.Run();
}
catch (Exception ex)
{
Log.Fatal(ex, exceptionMessage);
}
finally
{
Log.CloseAndFlush();
}
}
public static IWebHost BuildWebHost(string[] args)
{
var config = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("hosting.json", optional: true)
.Build();
IWebHostBuilder builder = WebHost.CreateDefaultBuilder(args)
.UseKestrel()
.UseConfiguration(config)
.UseContentRoot(Directory.GetCurrentDirectory())
.UseIISIntegration()
.UseStartup <Startup>();
return(builder.Build());
}
public static IWebHost BuildWebHost(string[] args)
{
IWebHostBuilder webHost = WebHost.CreateDefaultBuilder(args);
// SetingHeaderWebHost(webHost).ConfigureLogging((hostingContext, logging) =>
webHost.ConfigureLogging((hostingContext, logging) =>
{
logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
logging.AddConsole();
logging.AddDebug();
logging.AddEventSourceLogger();
})
.UseStartup <Startup>();
// SetingFooterWebHost(webHost);
return(webHost.Build());
}
protected sealed override TestServer CreateServer(IWebHostBuilder builder)
{
// Real TCP port
host = builder.Build();
host.Start();
RootUri = host.ServerFeatures.Get <IServerAddressesFeature>().Addresses.First();
// Fake Server to satisfy the return type
return(new TestServer(
new WebHostBuilder()
.UseStartup <TStartup>()
.UseSerilog()
.ConfigureAppConfiguration(
configBuilder => { configBuilder.AddConfiguration(GetConfigForUiTests()); }
)
));
}
private IWebHost BuildWebHost(string[] args)
{
var config = new ConfigurationBuilder()
.AddCommandLine(args)
.Build();
IWebHostBuilder builder = WebHost.CreateDefaultBuilder(args)
.UseStartup(typeof(TStartup));
string argUrls = config["urls"];
if (argUrls != null)
{
builder.UseUrls(argUrls);
}
return(builder.Build());
}
private void GivenAnotherOcelotIsRunning(string baseUrl)
{
_httpClientTwo.BaseAddress = new Uri(baseUrl);
_webHostBuilderTwo = new WebHostBuilder()
.UseUrls(baseUrl)
.UseKestrel()
.UseContentRoot(Directory.GetCurrentDirectory())
.ConfigureServices(x => {
x.AddSingleton(_webHostBuilderTwo);
})
.UseStartup <Startup>();
_builderTwo = _webHostBuilderTwo.Build();
_builderTwo.Start();
}
public static IWebHost BuildWebHost(string[] args)
{
IWebHostBuilder builder = WebHost.CreateDefaultBuilder(args);
builder.ConfigureServices(s => s.AddSingleton(builder))
.ConfigureAppConfiguration(ic => ic.AddJsonFile(Path.Combine("configuration", "configuration.json")))
.UseStartup <Startup>()
.UseSerilog((builderContext, config) =>
{
config
.MinimumLevel.Information()
.Enrich.FromLogContext()
.WriteTo.Console();
});
IWebHost host = builder.Build();
return(host);
}
public JSONServer()
{
string contentRoot = Directory.GetCurrentDirectory();
config = new ConfigurationBuilder()
.SetBasePath(contentRoot)
.Build();
hostBuilder = new WebHostBuilder()
.UseKestrel()
.UseUrls("http://localhost:7190")
.UseContentRoot(contentRoot)
.UseStartup <JSONServerStartup>()
.UseEnvironment("Development")
.UseConfiguration(config);
host = hostBuilder.Build();
}
