public static void Main(string[] args)
{
// This sample shows the current working prototype that fixes the application base on .NET Framework.
// This is important so that configuration files, static files and razor views can be found by libraries
// referenced by the application.
// In the other samples, the application base points to where the ".exe" is located. This is problematic
// at development time because it means static files, views and configuration files need to be copied (via compile)
// before running.
// The side effects are that anything above the call to ExecuteInChildAppDomain will be executed twice
// on .NET Framework and Mono.
#if NET451
Console.WriteLine($"AppDomain.Id = {AppDomain.CurrentDomain.Id}");
Console.WriteLine($"AppDomain.FriendlyName = {AppDomain.CurrentDomain.FriendlyName}");
Console.WriteLine($"AppDomain.BaseDirectory = {AppDomain.CurrentDomain.BaseDirectory}");
Console.WriteLine($"AppDomain.PrivateBinPath = {AppDomain.CurrentDomain.SetupInformation.PrivateBinPath}");
WebHost.ExecuteInChildAppDomain(args);
#endif
var configuration = WebApplicationConfiguration.GetDefault(args);
// The real application logic goes here
var application = new WebApplicationBuilder()
.UseConfiguration(configuration)
.UseStartup <Startup>()
.Build();
application.Run();
}
/// <summary>
/// Bootstrapping entry
/// </summary>
/// <param name="webBootstrapConfiguration"></param>
/// <param name="scanAssemblies"></param>
/// <returns></returns>
public static IServiceContainer BootstrapHelper(this IWebApplicationBootstrapConfiguration webBootstrapConfiguration, params Assembly[] scanAssemblies)
{
// Proc config validation
WebApplicationConfiguration config = null;
try
{
config = WebApplicationConfiguration.Instance;
}
catch { }
finally
{
if (config.IsNull())
{
throw new Exception("Signals.Core.Web.Configuration.WebApplicationConfiguration is not provided. Please use a configuration provider to provide configuration values!");
}
}
webBootstrapConfiguration.RegistrationService.Register <IHttpContextAccessor, HttpContextAccessor>();
webBootstrapConfiguration.RegistrationService.Register <IHttpContextWrapper, HttpContextWrapper>();
webBootstrapConfiguration.RegistrationService.Register <WebMediator>();
webBootstrapConfiguration.RegistrationService.Register(webBootstrapConfiguration.ResponseHeaders);
return(webBootstrapConfiguration.Resolve(scanAssemblies: scanAssemblies));
}
public static void Main(string[] args)
{
var application = new WebApplicationBuilder()
.UseConfiguration(WebApplicationConfiguration.GetDefault(args))
.UseStartup <Startup>()
.Build();
application.Run();
}
public static void Main(string[] args)
{
var configuration = WebApplicationConfiguration.GetDefault(args);
var host = new WebApplicationBuilder()
.UseStartup <Startup>()
.UseConfiguration(configuration)
.Build();
host.Run();
}
public static void Main(string[] args)
{
var app = new WebApplicationBuilder()
.UseServer("Microsoft.AspNet.Server.Kestrel")
.UseConfiguration(WebApplicationConfiguration.GetDefault(args))
.UseStartup <Startup>()
.Build();
app.Run();
}
public static void Main(string[] args)
{
var application = new WebApplicationBuilder()
.UseConfiguration(WebApplicationConfiguration.GetDefault(args))
.UseStartup <Startup>()
.Build();
// The following section should be used to demo sockets
//var addresses = application.GetAddresses();
//addresses.Clear();
//addresses.Add("http://unix:/tmp/kestrel-test.sock");
application.Run();
}
protected override IEnumerable <ServiceInstanceListener> CreateServiceInstanceListeners()
{
// Build an ASP.NET 5 web application that serves as the communication listener.
var webApp = new WebApplicationBuilder().UseConfiguration(WebApplicationConfiguration.GetDefault())
.UseStartup <Startup>()
.Build();
// Replace the address with the one dynamically allocated by Service Fabric.
var endpoint = ServiceInitializationParameters.CodePackageActivationContext.GetEndpoint("GatewayTypeEndpoint");
webApp.GetAddresses().Clear();
webApp.GetAddresses().Add($"{endpoint.Protocol}://+:{endpoint.Port}");
return(new[] { new ServiceInstanceListener(_ => new AspNetCommunicationListener(webApp)) });
}
/// <summary>
/// Loads configurations from files
/// </summary>
/// <returns></returns>
private static void AddConfiguration()
{
FileConfigurationProvider ConfigurationProviderForFile(string name) =>
new()
{
File = name,
Path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "configs"),
ReloadOnAccess = false
};
// Required by Signals
ApplicationConfiguration.UseProvider(ConfigurationProviderForFile("app.config.json"));
WebApplicationConfiguration.UseProvider(ConfigurationProviderForFile("web.config.json"));
}
}
/// <summary>
/// CTOR
/// </summary>
public WebMediatorTests()
{
ApplicationConfiguration.UseProvider(new FileConfigurationProvider
{
Path = Path.Combine(AppContext.BaseDirectory, "config"),
File = "app.json"
});
WebApplicationConfiguration.UseProvider(new FileConfigurationProvider
{
Path = Path.Combine(AppContext.BaseDirectory, "config"),
File = "webapp.json"
});
var config = new Config();
config.RegistrationService = new Aspects.DI.Autofac.RegistrationService();
config.CacheConfiguration = new InMemoryCacheConfiguration();
config.Bootstrap(typeof(MediatorTests).Assembly);
}
public static void Main(string[] args)
{
Console.WriteLine("Args:\n" + string.Join("\n", args));
var config = WebApplicationConfiguration.GetDefault(args);
var application = new WebApplicationBuilder()
.UseConfiguration(config)
.UseStartup <Startup>()
.Build();
var addresses = application.GetAddresses();
Console.WriteLine("Listening on " + string.Join(", ", addresses));
try
{
application.Run();
}
finally
{
Console.WriteLine("Exiting...");
}
}
/// <summary>
/// Load configuration from files
/// </summary>
/// <param name="services"></param>
/// <returns></returns>
private static void AddConfiguration(this IServiceCollection services)
{
string environment = null;
FileConfigurationProvider ProviderForFile(string name) => new FileConfigurationProvider
{
File = name,
Path = environment.IsNullOrEmpty() ? Path.Combine(AppContext.BaseDirectory, $"configs") : Path.Combine(AppContext.BaseDirectory, $"configs", environment),
ReloadOnAccess = false
};
// set active configuration
EnvironmentConfiguration.UseProvider(ProviderForFile("environment.config.json"));
environment = EnvironmentConfiguration.Instance.Environment;
// load custom configurations from file
// Signals core application configuration
ApplicationConfiguration.UseProvider(ProviderForFile("application.config.json"));
// Signals core web application configuration
WebApplicationConfiguration.UseProvider(ProviderForFile("web.application.config.json"));
// Application custom domain configuration
DomainConfiguration.UseProvider(ProviderForFile("domain.config.json"));
}
public IClientConnector Start(IApplication application, WebApplicationConfiguration additionalConfiguration)
{
return(Client);
}
