public static IWebHost BuildWebHost(string[] args)
{
var config = new ConfigurationBuilder()
.AddCommandLine(args)
.Build();
var port = config.GetValue <string>("port");
var hostBuilder = new WebHostBuilder()
.UseConfiguration(config)
.UseKestrel()
.UseContentRoot(Directory.GetCurrentDirectory())
.UseStartup <Startup>();
if (!string.IsNullOrEmpty(port))
{
hostBuilder.UseUrls("http://0.0.0.0:" + port);
}
#if DEBUG
hostBuilder.UseSetting("detailedErrors", "true");
#endif
hostBuilder.UseIISIntegration();
#if DEBUG
hostBuilder.CaptureStartupErrors(true);
#endif
var host = hostBuilder.Build();
return(host);
}
public static void WebHostBuilder(WebHostBuilder webBuilder)
{
// <snippet_WebHostBuilderCaptureStartupErrors>
webBuilder.CaptureStartupErrors(true);
// </snippet_WebHostBuilderCaptureStartupErrors>
// <snippet_WebHostBuilderDetailedErrors>
webBuilder.UseSetting(WebHostDefaults.DetailedErrorsKey, "true");
// </snippet_WebHostBuilderDetailedErrors>
// <snippet_WebHostBuilderHostingStartupAssemblies>
webBuilder.UseSetting(
WebHostDefaults.HostingStartupAssembliesKey, "assembly1;assembly2");
// </snippet_WebHostBuilderHostingStartupAssemblies>
// <snippet_WebHostBuilderHostingStartupExcludeAssemblies>
webBuilder.UseSetting(
WebHostDefaults.HostingStartupExcludeAssembliesKey, "assembly1;assembly2");
// </snippet_WebHostBuilderHostingStartupExcludeAssemblies>
// <snippet_WebHostBuilderHttpsPort>
webBuilder.UseSetting("https_port", "8080");
// </snippet_WebHostBuilderHttpsPort>
// <snippet_WebHostBuilderPreferHostingUrls>
webBuilder.PreferHostingUrls(true);
// </snippet_WebHostBuilderPreferHostingUrls>
// <snippet_WebHostBuilderPreventHostingStartup>
webBuilder.UseSetting(WebHostDefaults.PreventHostingStartupKey, "true");
// </snippet_WebHostBuilderPreventHostingStartup>
// <snippet_WebHostBuilderUseStartup>
webBuilder.UseStartup("StartupAssemblyName");
// </snippet_WebHostBuilderUseStartup>
// <snippet_WebHostBuilderUseStartupGeneric>
webBuilder.UseStartup <Startup>();
// </snippet_WebHostBuilderUseStartupGeneric>
// <snippet_WebHostBuilderSuppressStatusMessages>
webBuilder.UseSetting(WebHostDefaults.SuppressStatusMessagesKey, "true");
// </snippet_WebHostBuilderSuppressStatusMessages>
// <snippet_WebHostBuilderUseUrls>
webBuilder.UseUrls("http://*:5000;http://localhost:5001;https://hostname:5002");
// </snippet_WebHostBuilderUseUrls>
// <snippet_WebHostBuilderUseWebRoot>
webBuilder.UseWebRoot("public");
// </snippet_WebHostBuilderUseWebRoot>
}
public static void Main(string[] args)
{
var host = new WebHostBuilder()
.UseKestrel()
.UseContentRoot(Directory.GetCurrentDirectory())
.UseIISIntegration()
.UseStartup <Startup>()
.UseApplicationInsights();
host.CaptureStartupErrors(true);
host.UseSetting("detailedErrors", "true");
host.Build().Run();
}
private static IWebHost BuildWebHostUsingWebHostBuilder()
{
var webHostBuilder = new WebHostBuilder();
return(webHostBuilder.
CaptureStartupErrors(true).
UseContentRoot(Directory.GetCurrentDirectory()).
UseUrls("http://localhost:3510"). //can not have https
//UseHttpSys().
UseKestrel(options: options => {
}). //overrides previous setting
UseIISIntegration().
UseStartup <Startup>().
UseSetting(WebHostDefaults.PreventHostingStartupKey, "true"). //could not see it working
Build());
}
public static IWebHostBuilder CreateWebHostBuilder(string[] args)
{
var webHostBuilder = new WebHostBuilder();
if (args?.Any() == true)
{
var config = new ConfigurationBuilder().AddCommandLine(args).Build();
webHostBuilder.UseConfiguration(config);
}
// Kestrel
webHostBuilder.UseKestrel((context, options) =>
{
options.AddServerHeader = false;
var listenUrls = webHostBuilder.GetSetting(WebHostDefaults.ServerUrlsKey);
if (string.IsNullOrWhiteSpace(listenUrls))
{
// Load Kestrel Endpoint config in app setting
options.Configure(context.Configuration.GetSection("Kestrel"));
}
});
// Content
var contentRoot = webHostBuilder.GetSetting(WebHostDefaults.ContentRootKey);
if (string.IsNullOrWhiteSpace(contentRoot))
{
webHostBuilder.UseContentRoot(Directory.GetCurrentDirectory());
}
// Capture Error
webHostBuilder.CaptureStartupErrors(true);
// DI Validate
webHostBuilder.UseDefaultServiceProvider((context, options) =>
{
options.ValidateScopes = context.HostingEnvironment.IsDevelopment();
});
// App Config
webHostBuilder.ConfigureAppConfiguration((context, configBuilder) =>
{
// Delete all default configuration providers
configBuilder.Sources.Clear();
configBuilder.SetBasePath(Directory.GetCurrentDirectory());
configBuilder.AddJsonFile(ConfigurationFileName.AppSettings, true, true);
var env = context.HostingEnvironment;
if (env.IsDevelopment())
{
var appAssembly = Assembly.Load(new AssemblyName(env.ApplicationName));
if (appAssembly != null)
{
configBuilder.AddUserSecrets(appAssembly, optional: true);
}
}
configBuilder.AddEnvironmentVariables();
if (args?.Any() == true)
{
configBuilder.AddCommandLine(args);
}
});
// Service Config
webHostBuilder.ConfigureServices((context, services) =>
{
// Hosting Filter
services.PostConfigure <HostFilteringOptions>(options =>
{
if (options.AllowedHosts != null && options.AllowedHosts.Count != 0)
{
return;
}
var hosts = context
.Configuration["AllowedHosts"]?
.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
options.AllowedHosts = (hosts?.Length > 0 ? hosts : new[] { "*" });
});
// Hosting Filter Notification
var hostingFilterOptions =
new ConfigurationChangeTokenSource <HostFilteringOptions>(context.Configuration);
services.AddSingleton <IOptionsChangeTokenSource <HostFilteringOptions> >(hostingFilterOptions);
services.AddTransient <IStartupFilter, HostFilteringStartupFilter>();
// IIS
var iisConfig = context.Configuration.GetSection("IIS");
var isUseIis = iisConfig?.GetValue("IsUseIIS", false) ?? false;
if (isUseIis)
{
webHostBuilder.UseIIS();
}
var isUseIisIntegration = iisConfig?.GetValue("IsUseIISIntegration", false) ?? false;
if (isUseIisIntegration)
{
webHostBuilder.UseIISIntegration();
}
});
// Startup
webHostBuilder.UseStartup(PlatformServices.Default.Application.ApplicationName);
return(webHostBuilder);
}
