在MVC Controller中渲染.cshtml视图的Scripts节为字符串可行吗？

Absolutely, this is totally feasible! Let's break down two reliable approaches to grab the content of your @section Scripts {} from a view in your controller, so you can fetch it via AJAX and execute it after loading the view HTML.

方案1：前端提取法（简单直观，无需后端改动） #

This approach wraps your section content in a hidden container, so you can extract and execute it after the view HTML loads, avoiding the execution order issues you mentioned.

Steps: #

1. Modify your view to wrap the @section Scripts content in a hidden element:

<!-- Your regular view content -->
<div class="view-content">
    <!-- Your view's HTML markup here -->
</div>

<!-- Hide the script section content for later extraction -->
<div class="view-scripts" style="display: none;">
    @RenderSection("Scripts", false)
</div>

2. Update your front-end AJAX logic to separate content and scripts, then execute the scripts:

// Load the view HTML first
$.get('/YourController/YourAction', function(responseHtml) {
    const $response = $(responseHtml);
    // Insert the main view content into your container
    $('#content-container').html($response.find('.view-content'));
    // Extract and execute the script content
    const scriptContent = $response.find('.view-scripts').text().trim();
    if (scriptContent) {
        eval(scriptContent);
    }
});

Pros: No backend code changes needed, quick to implement, perfect for straightforward scenarios.
Notes: Ensure your @section Scripts only contains pure JavaScript (no mixed HTML) to avoid extraction errors.

方案2：后端 Controller 方法（灵活可控，适合复杂场景） #

If you prefer fetching scripts via a dedicated AJAX request, you can build a controller method that simulates view rendering to extract the Scripts section content directly.

Steps: #

1. Create an extension method to extract section content from Razor views:

using System.IO;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc.Razor;
using Microsoft.AspNetCore.Mvc.Rendering;

public static class ViewExtensions
{
    public static string GetSectionContent(this IView view, ViewContext viewContext, string sectionName)
    {
        if (view is RazorView razorView)
        {
            if (razorView.RazorPage is WebViewPage webPage)
            {
                webPage.ViewContext = viewContext;
                // Execute the Razor page to trigger section generation
                webPage.ExecuteAsync().Wait();
                
                if (webPage.Sections.TryGetValue(sectionName, out var sectionWriter))
                {
                    using var stringWriter = new StringWriter();
                    sectionWriter.Invoke(stringWriter);
                    return stringWriter.ToString();
                }
            }
        }
        return string.Empty;
    }
}

2. Add a method in your controller to return the script content:

public IActionResult GetScriptsForView(string action, string controller)
{
    // Build route data to target the correct view
    var routeData = new RouteData();
    routeData.Values["controller"] = controller;
    routeData.Values["action"] = action;

    // Create a controller context for the target view
    var controllerContext = new ControllerContext(HttpContext, routeData, this);

    // Locate the view
    var viewResult = ViewEngines.Engines.FindView(controllerContext, action, null);
    if (viewResult.View == null)
    {
        return Content(string.Empty, "text/javascript");
    }

    // Prepare view context with current ViewData/TempData
    var viewContext = new ViewContext(
        controllerContext,
        viewResult.View,
        ViewData,
        TempData,
        TextWriter.Null // No need to render the full view
    );

    // Extract the Scripts section content
    var scriptContent = viewResult.View.GetSectionContent(viewContext, "Scripts");
    
    // Return as pure JavaScript
    return Content(scriptContent, "text/javascript");
}

3. Update your front-end to load the view first, then fetch and execute the scripts:

// Load the view HTML
$.get('/YourController/YourAction', function(html) {
    $('#content-container').html(html);
    // Fetch the corresponding scripts
    $.get('/YourController/GetScriptsForView?action=YourAction&controller=YourController', function(scripts) {
        if (scripts.trim()) {
            eval(scripts);
        }
    });
});

Pros: No view modifications needed, full separation of content and scripts, great for caching or complex view scenarios.
Notes:

• Ensure the target view has a @section Scripts (returns empty string if not found).
• Add caching (e.g., with IMemoryCache) to avoid re-rendering views on every request for better performance.
• Be cautious with eval: only execute scripts you control to avoid XSS risks.

Quick note on HttpContext.Items #

You mentioned seeing references to HtmlHelper.ViewContext.HttpContext.Items — this is a temporary storage container for the current request cycle. You could use it like this:
In your view's @section Scripts:

@section Scripts {
    @{
        Context.Items["ViewScripts"] = RenderSection("Scripts", false).ToString();
    }
    // Your script content here
}

Then read it in your controller after rendering the view:

var scripts = HttpContext.Items["ViewScripts"] as string;

But this requires modifying every view, so it's less scalable than the two solutions above.

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