能否将编译为.NET Framework的.NET Core WebAPI与现有ERP应用同池运行？

Great question—this is a super common approach for modernizing legacy .NET Framework systems incrementally, and yes, this is absolutely feasible with some careful configuration. Let’s break down the details:

1. Compiling .NET Core WebAPI for .NET Framework #

You absolutely can target .NET Framework when building your .NET Core WebAPI. Here’s how:

• In your WebAPI project’s .csproj file, set the target framework to match your existing ERP’s .NET Framework version (e.g., net48 if you’re on 4.8):

  <TargetFramework>net48</TargetFramework>
  

• Ensure all NuGet packages you use in the WebAPI are compatible with your target .NET Framework version. Most modern ASP.NET Core packages support .NET Framework 4.6.2 and above, but double-check for any legacy dependencies that might cause conflicts.

2. Hosting in the Same IIS Environment (and Handling App Pools) #

While you can’t run both the legacy VB.NET app and the .NET Core WebAPI in the exact same application pool (here’s why: legacy .NET Framework apps require an app pool with a managed CLR version set, like v4.0, while .NET Core apps—even those targeting .NET Framework—use the AspNetCoreModule and require an app pool set to No Managed Code), you can host them under the same IIS site with separate app pools, and route requests between them seamlessly.

This is still a clean setup that feels like a single system to end-users:

• Deploy your legacy app as the root of the IIS site (e.g., https://yourapp.com/)
• Deploy the .NET Core WebAPI as a sub-application under the same site (e.g., https://yourapp.com/api/), using its own app pool configured for No Managed Code
• IIS will automatically route requests based on the URL path, so your Angular UI can call /api/* endpoints while legacy pages use the root path.

If you’re dead-set on using the same app pool (though not recommended for stability), you could technically self-host the .NET Core WebAPI within the legacy app using OWIN, but this adds more complexity and negates some of the benefits of using .NET Core’s modern hosting model.

3. Routing Configuration to Avoid Conflicts #

Your plan to use route prefixes is spot-on—this is the key to keeping requests separated:

• In your .NET Core WebAPI, configure a global route prefix for all API endpoints. For .NET 6+ (Minimal API or Controllers), you can do this in Program.cs:

  // For controller-based APIs
  app.MapControllers().WithRoutePrefix("api");
  
  // For Minimal APIs
  app.MapGroup("/api")
     .MapGet("/products", () => /* your logic */)
     .MapPost("/orders", () => /* your logic */);
  

• Ensure your legacy VB.NET app doesn’t use the /api prefix for any existing endpoints. If it does, pick a different prefix (like /modern-api) to avoid clashes.

4. Key Considerations for a Smooth Migration #

• Version Alignment: Match the target .NET Framework version of your WebAPI exactly to your legacy system to avoid runtime compatibility issues (e.g., if your ERP uses 4.7.2, don’t target 4.8 for the WebAPI).
• Dependency Conflicts: Legacy VB.NET apps often have outdated NuGet packages or third-party components. Test the WebAPI alongside the legacy app to catch any assembly version conflicts early.
• Shared State: If you need to share user sessions between the legacy app and the new Angular/API layer, use a distributed cache like Redis instead of in-memory session state. This works across both .NET Framework and .NET Core.
• Incremental Rollout: Start with isolated, low-risk features (like a reporting module or user profile editor) to validate the setup before migrating critical ERP functionality.

This approach lets you modernize piecemeal without overhauling your entire system at once—smart move!

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