ASP.NET Core 2.0多Web项目全局强类型launchSettings.json最佳实践咨询

Great question—handling shared launch settings across multiple ASP.NET Core 2.0 projects (like your client/api/sts setup) can feel tricky at first, but there are a few solid, production-ready approaches to make this work smoothly. Let’s dive into the most reliable methods:

1. Shared Global JSON File + Strongly-Typed Model Binding #

This is my go-to approach because it’s cross-platform, git-friendly, and keeps all project URLs centralized in one place. Here’s how to set it up:

Step 1: Create a Global Configuration File #

In your solution root directory, add a new JSON file (e.g., global-launch-settings.json) with all your project URLs:

{
  "ProjectUrls": {
    "Api": "https://localhost:5001",
    "Sts": "https://localhost:5002",
    "Client": "https://localhost:5003"
  }
}

Step 2: Load the Global File in Each Project #

Update each project’s Program.cs to load this global file (note the path navigation to reach the solution root from the project directory):

public static IWebHost BuildWebHost(string[] args) =>
    WebHost.CreateDefaultBuilder(args)
        .ConfigureAppConfiguration((context, config) =>
        {
            // Navigate up two levels from project root to solution root
            var solutionRoot = Path.GetFullPath(Path.Combine(Directory.GetCurrentDirectory(), "..", ".."));
            config.AddJsonFile(
                Path.Combine(solutionRoot, "global-launch-settings.json"),
                optional: false, // Fail fast if file is missing
                reloadOnChange: true // Auto-reload when file is updated
            );
        })
        .UseStartup<Startup>()
        .Build();

Step 3: Create Strongly-Typed Models #

Add a shared class library (or duplicate in each project, though a shared library is cleaner) to hold your settings model:

public class GlobalLaunchSettings
{
    public string Api { get; set; }
    public string Sts { get; set; }
    public string Client { get; set; }
}

Step 4: Bind Configuration to the Model #

In each project’s Startup.cs, register the model with dependency injection:

public void ConfigureServices(IServiceCollection services)
{
    // Bind the "ProjectUrls" section to our strongly-typed model
    services.Configure<GlobalLaunchSettings>(Configuration.GetSection("ProjectUrls"));
    
    // Rest of your service configuration...
}

Step 5: Use the Settings Anywhere #

Inject IOptions<GlobalLaunchSettings> into controllers, services, or middleware to access other project URLs. For example, in your client project’s home controller:

private readonly GlobalLaunchSettings _launchSettings;

public HomeController(IOptions<GlobalLaunchSettings> launchSettings)
{
    _launchSettings = launchSettings.Value;
}

public IActionResult Index()
{
    // Use STS and API URLs in your view or business logic
    ViewData["StsUrl"] = _launchSettings.Sts;
    ViewData["ApiUrl"] = _launchSettings.Api;
    return View();
}

2. Environment Variables + Strongly-Typed Binding #

If you prefer not to manage an extra JSON file, using environment variables works well—especially if you need to override settings per environment. Here’s how:

Step 1: Define Global Environment Variables #

Create a .env file in your solution root (use the DotNetEnv NuGet package to load it, since ASP.NET Core 2.0 doesn’t natively support .env files):

API_APPLICATION_URL=https://localhost:5001
STS_APPLICATION_URL=https://localhost:5002
CLIENT_APPLICATION_URL=https://localhost:5003

Step 2: Install DotNetEnv and Load the File #

Install the package in each project:

Install-Package DotNetEnv

Then update Program.cs to load the .env file:

public static IWebHost BuildWebHost(string[] args)
{
    // Load environment variables from .env file
    var solutionRoot = Path.GetFullPath(Path.Combine(Directory.GetCurrentDirectory(), "..", ".."));
    DotNetEnv.Env.Load(Path.Combine(solutionRoot, ".env"));
    
    return WebHost.CreateDefaultBuilder(args)
        .UseStartup<Startup>()
        .Build();
}

Step 3: Bind Variables to the Model #

In Startup.cs, map environment variables to your strongly-typed model:

public void ConfigureServices(IServiceCollection services)
{
    services.Configure<GlobalLaunchSettings>(options =>
    {
        options.Api = Environment.GetEnvironmentVariable("API_APPLICATION_URL");
        options.Sts = Environment.GetEnvironmentVariable("STS_APPLICATION_URL");
        options.Client = Environment.GetEnvironmentVariable("CLIENT_APPLICATION_URL");
    });
    
    // Rest of your service setup...
}

Key Notes for Both Approaches #

• Git-Friendly: Add your global global-launch-settings.json or .env file to git (exclude .env if you have sensitive values, but for local dev URLs it’s safe).
• Cross-Platform: Both methods work on Windows, macOS, and Linux—no Visual Studio-specific hacks.
• Reload on Change: With the JSON approach, setting reloadOnChange: true lets you update URLs without restarting your apps.
• Production Overrides: For production, replace these local configs with environment variables or cloud-specific configuration (e.g., Azure App Service Configuration).

内容的提问来源于stack exchange，提问作者Bratollo