Archivos estáticos en ASP.NET CoreStatic files in ASP.NET Core

Por Rick Anderson y Kirk LarkinBy Rick Anderson and Kirk Larkin

Los archivos estáticos, como HTML, CSS, imágenes y JavaScript, son activos que una aplicación de ASP.NET Core proporciona directamente a los clientes de forma predeterminada.Static files, such as HTML, CSS, images, and JavaScript, are assets an ASP.NET Core app serves directly to clients by default.

Vea o descargue el código de ejemplo (cómo descargarlo)View or download sample code (how to download)

Proporcionar archivos estáticosServe static files

Los archivos estáticos se almacenan en el directorio raíz web del proyecto.Static files are stored within the project's web root directory. El directorio predeterminado es {content root}/wwwroot, pero se puede cambiar con el método UseWebRoot.The default directory is {content root}/wwwroot, but it can be changed with the UseWebRoot method. Para más información, vea Raíz del contenido y Raíz web.For more information, see Content root and Web root.

El método CreateDefaultBuilder establece la raíz de contenido en el directorio actual:The CreateDefaultBuilder method sets the content root to the current directory:

public class Program
{
    public static void Main(string[] args)
    {
        CreateHostBuilder(args).Build().Run();
    }

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureWebHostDefaults(webBuilder =>
            {
                webBuilder.UseStartup<Startup>();
            });
}

El código anterior se creó con la plantilla de la aplicación web.The preceding code was created with the web app template.

Se puede acceder a los archivos estáticos a través de una ruta de acceso relativa a la raíz web.Static files are accessible via a path relative to the web root. Por ejemplo, las plantillas de proyecto Aplicación web contienen varias carpetas dentro de la carpeta wwwroot:For example, the Web Application project templates contain several folders within the wwwroot folder:

  • wwwroot
    • css
    • js
    • lib

Considere la posibilidad de crear la carpeta wwwroot/images y agregar el archivo wwwroot/images/MyImage.jpg.Consider creating the wwwroot/images folder and adding the wwwroot/images/MyImage.jpg file. El formato del URI para acceder a un archivo en la carpeta images es https://<hostname>/images/<image_file_name>.The URI format to access a file in the images folder is https://<hostname>/images/<image_file_name>. Por ejemplo, https://localhost:5001/images/MyImage.jpg.For example, https://localhost:5001/images/MyImage.jpg

Suministro de archivos en la raíz webServe files in web root

Las plantillas de aplicación web predeterminadas llaman al método UseStaticFiles en Startup.Configure, que permite proporcionar archivos estáticos:The default web app templates call the UseStaticFiles method in Startup.Configure, which enables static files to be served:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    else
    {
        app.UseExceptionHandler("/Home/Error");
        app.UseHsts();
    }

    app.UseHttpsRedirection();

    app.UseStaticFiles();

    app.UseRouting();

    app.UseAuthorization();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapDefaultControllerRoute();
    });
}

La sobrecarga del método UseStaticFiles sin parámetros marca los archivos en la raíz web como que se pueden proporcionar.The parameterless UseStaticFiles method overload marks the files in web root as servable. El siguiente marcado hace referencia a wwwroot/images/MyImage.jpg:The following markup references wwwroot/images/MyImage.jpg:

<img src="~/images/MyImage.jpg" class="img" alt="My image" />

En el código anterior, el carácter de tilde de la ñ ~/ apunta a la raíz web.In the preceding code, the tilde character ~/ points to the web root.

Proporcionar archivos fuera de la raíz webServe files outside of web root

Considere una jerarquía de directorios en la que residen fuera de la raíz web los archivos estáticos que se van a proporcionar:Consider a directory hierarchy in which the static files to be served reside outside of the web root:

  • wwwroot
    • css
    • images
    • js
  • MyStaticFiles
    • images
      • red-rose.jpg

Una solicitud puede acceder al archivo red-rose.jpg configurando el middleware de archivos estáticos como se muestra a continuación:A request can access the red-rose.jpg file by configuring the Static File Middleware as follows:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    else
    {
        app.UseExceptionHandler("/Home/Error");
        app.UseHsts();
    }

    app.UseHttpsRedirection();

    // using Microsoft.Extensions.FileProviders;
    // using System.IO;
    app.UseStaticFiles(new StaticFileOptions
    {
        FileProvider = new PhysicalFileProvider(
            Path.Combine(env.ContentRootPath, "MyStaticFiles")),
        RequestPath = "/StaticFiles"
    });

    app.UseRouting();

    app.UseAuthorization();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapDefaultControllerRoute();
    });
}

En el código anterior, la jerarquía del directorio MyStaticFiles se expone públicamente a través del segmento de URI StaticFiles.In the preceding code, the MyStaticFiles directory hierarchy is exposed publicly via the StaticFiles URI segment. Una solicitud a https://<hostname>/StaticFiles/images/red-rose.jpg sirve al archivo red-rose.jpg.A request to https://<hostname>/StaticFiles/images/red-rose.jpg serves the red-rose.jpg file.

El siguiente marcado hace referencia a MyStaticFiles/images/red-rose.jpg:The following markup references MyStaticFiles/images/red-rose.jpg:

<img src="~/StaticFiles/images/red-rose.jpg" class="img" alt="A red rose" />

Establecer encabezados de respuesta HTTPSet HTTP response headers

Se puede usar un objeto StaticFileOptions para establecer encabezados de respuesta HTTP.A StaticFileOptions object can be used to set HTTP response headers. Además de configurar el servicio de archivos estáticos desde la raíz web, el código siguiente establece el encabezado Cache-Control:In addition to configuring static file serving from the web root, the following code sets the Cache-Control header:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    else
    {
        app.UseExceptionHandler("/Home/Error");
        app.UseHsts();
    }

    app.UseHttpsRedirection();

    const string cacheMaxAge = "604800";
    app.UseStaticFiles(new StaticFileOptions
    {
        OnPrepareResponse = ctx =>
        {
            // using Microsoft.AspNetCore.Http;
            ctx.Context.Response.Headers.Append(
                 "Cache-Control", $"public, max-age={cacheMaxAge}");
        }
    });

    app.UseRouting();

    app.UseAuthorization();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapDefaultControllerRoute();
    });
}

Los archivos estáticos se almacenan en caché públicamente durante 600 segundos:Static files are publicly cacheable for 600 seconds:

Se han agregado encabezados de respuesta que muestran el encabezado Cache-Control

Autorización de archivos estáticosStatic file authorization

El middleware de archivos estáticos no proporciona comprobaciones de autorización.The Static File Middleware doesn't provide authorization checks. Los archivos que proporciona, incluidos los de wwwroot, están accesibles de forma pública.Any files served by it, including those under wwwroot, are publicly accessible. Para proporcionar archivos según su autorización:To serve files based on authorization:

  • Almacénelos fuera de wwwroot y cualquier directorio al que el middleware de archivos estáticos tenga acceso.Store them outside of wwwroot and any directory accessible to the Static File Middleware.

  • Proporciónelos a través de un método de acción al que se aplica la autorización y devuelva un objeto FileResult:Serve them via an action method to which authorization is applied and return a FileResult object:

    [Authorize]
    public IActionResult BannerImage()
    {
        var filePath = Path.Combine(
            _env.ContentRootPath, "MyStaticFiles", "images", "red-rose.jpg");
    
        return PhysicalFile(filePath, "image/jpeg");
    }
    

Examen de directoriosDirectory browsing

El examen de directorios permite enumerar directorios dentro de los directorios especificados.Directory browsing allows directory listing within specified directories.

Por motivos de seguridad, el examen de directorios está deshabilitado de forma predeterminada.Directory browsing is disabled by default for security reasons. Para más información, consulte Consideraciones.For more information, see Considerations.

Habilite el examen de directorios con:Enable directory browsing with:

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllersWithViews();
    services.AddDirectoryBrowser();
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    else
    {
        app.UseExceptionHandler("/Home/Error");
        app.UseHsts();
    }

    app.UseHttpsRedirection();

    // using Microsoft.Extensions.FileProviders;
    // using System.IO;
    app.UseStaticFiles(new StaticFileOptions
    {
        FileProvider = new PhysicalFileProvider(
            Path.Combine(env.WebRootPath, "images")),
        RequestPath = "/MyImages"
    });

    app.UseDirectoryBrowser(new DirectoryBrowserOptions
    {
        FileProvider = new PhysicalFileProvider(
            Path.Combine(env.WebRootPath, "images")),
        RequestPath = "/MyImages"
    });

    app.UseRouting();

    app.UseAuthorization();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapDefaultControllerRoute();
    });
}

El código anterior permite el examen de directorios de la carpeta wwwroot/images usando la dirección URL https://<hostname>/MyImages, con vínculos a cada archivo y carpeta:The preceding code allows directory browsing of the wwwroot/images folder using the URL https://<hostname>/MyImages, with links to each file and folder:

examen de directorios

Suministro de documentos predeterminadosServe default documents

El establecimiento de una página predeterminada proporciona a los visitantes un punto inicial en un sitio.Setting a default page provides visitors a starting point on a site. Para proporcionar una página predeterminada desde wwwroot sin un URI completo, llame al método UseDefaultFiles:To serve a default page from wwwroot without a fully qualified URI, call the UseDefaultFiles method:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    else
    {
        app.UseExceptionHandler("/Home/Error");
        app.UseHsts();
    }

    app.UseHttpsRedirection();

    app.UseDefaultFiles();
    app.UseStaticFiles();

    app.UseRouting();

    app.UseAuthorization();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapDefaultControllerRoute();
    });
}

Debe llamarse a UseDefaultFiles antes de a UseStaticFiles para proporcionar el archivo predeterminado.UseDefaultFiles must be called before UseStaticFiles to serve the default file. UseDefaultFiles es un sistema de reescritura de direcciones URL que no proporciona el archivo.UseDefaultFiles is a URL rewriter that doesn't serve the file.

Con UseDefaultFiles, las solicitudes a una carpeta en wwwroot buscan:With UseDefaultFiles, requests to a folder in wwwroot search for:

  • default.htmdefault.htm
  • default.htmldefault.html
  • index.htmindex.htm
  • index.htmlindex.html

El primer archivo que se encuentra en la lista se proporciona como si la solicitud fuera el URI completo.The first file found from the list is served as though the request were the fully qualified URI. La dirección URL del explorador sigue reflejando el URI solicitado.The browser URL continues to reflect the URI requested.

El código siguiente cambia el nombre de archivo predeterminado a mydefault.html:The following code changes the default file name to mydefault.html:

var options = new DefaultFilesOptions();
options.DefaultFileNames.Clear();
options.DefaultFileNames.Add("mydefault.html");
app.UseDefaultFiles(options);
app.UseStaticFiles();

El código siguiente muestra Startup.Configure con el código anterior:The following code shows Startup.Configure with the preceding code:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    else
    {
        app.UseExceptionHandler("/Home/Error");
        app.UseHsts();
    }

    app.UseHttpsRedirection();

    var options = new DefaultFilesOptions();
    options.DefaultFileNames.Clear();
    options.DefaultFileNames.Add("mydefault.html");
    app.UseDefaultFiles(options);
    app.UseStaticFiles();

    app.UseRouting();

    app.UseAuthorization();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapDefaultControllerRoute();
    });
}

UseFileServer para documentos predeterminadosUseFileServer for default documents

UseFileServer combina la funcionalidad de UseStaticFiles y UseDefaultFiles y, opcionalmente, la de UseDirectoryBrowser.UseFileServer combines the functionality of UseStaticFiles, UseDefaultFiles, and optionally UseDirectoryBrowser.

Llame a app.UseFileServer para poder proporcionar archivos estáticos y el archivo predeterminado.Call app.UseFileServer to enable the serving of static files and the default file. El examen de directorios no está habilitado.Directory browsing isn't enabled. El código siguiente muestra Startup.Configure con UseFileServer:The following code shows Startup.Configure with UseFileServer:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    else
    {
        app.UseExceptionHandler("/Home/Error");
        app.UseHsts();
    }

    app.UseHttpsRedirection();

    app.UseFileServer();

    app.UseRouting();

    app.UseAuthorization();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapDefaultControllerRoute();
    });
}

El código siguiente permite proporcionar archivos estáticos, el archivo predeterminado y el examen de directorios:The following code enables the serving of static files, the default file, and directory browsing:

app.UseFileServer(enableDirectoryBrowsing: true);

El código siguiente muestra Startup.Configure con el código anterior:The following code shows Startup.Configure with the preceding code:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    else
    {
        app.UseExceptionHandler("/Home/Error");
        app.UseHsts();
    }

    app.UseHttpsRedirection();

    app.UseFileServer(enableDirectoryBrowsing: true);

    app.UseRouting();

    app.UseAuthorization();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapDefaultControllerRoute();
    });
}

Tenga en cuenta la siguiente jerarquía de directorios:Consider the following directory hierarchy:

  • wwwroot
    • css
    • images
    • js
  • MyStaticFiles
    • images
      • MyImage.jpg
    • default.html

El código siguiente permite proporcionar archivos estáticos, el archivo predeterminado y el examen de directorios de MyStaticFiles:The following code enables the serving of static files, the default file, and directory browsing of MyStaticFiles:

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllersWithViews();
    services.AddDirectoryBrowser();
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    else
    {
        app.UseExceptionHandler("/Home/Error");
        app.UseHsts();
    }

    app.UseHttpsRedirection();

    app.UseStaticFiles(); // For the wwwroot folder.

    // using Microsoft.Extensions.FileProviders;
    // using System.IO;
    app.UseFileServer(new FileServerOptions
    {
        FileProvider = new PhysicalFileProvider(
            Path.Combine(env.ContentRootPath, "MyStaticFiles")),
        RequestPath = "/StaticFiles",
        EnableDirectoryBrowsing = true
    });

    app.UseRouting();

    app.UseAuthorization();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapDefaultControllerRoute();
    });
}

Se debe llamar a AddDirectoryBrowser cuando el valor de la propiedad EnableDirectoryBrowsing es true.AddDirectoryBrowser must be called when the EnableDirectoryBrowsing property value is true.

Al usar la jerarquía de archivos y el código anterior, las direcciones URL se resuelven como se indica a continuación:Using the file hierarchy and preceding code, URLs resolve as follows:

Identificador URIURI RespuestaResponse
https://<hostname>/StaticFiles/images/MyImage.jpg MyStaticFiles/images/MyImage.jpgMyStaticFiles/images/MyImage.jpg
https://<hostname>/StaticFiles MyStaticFiles/default.htmlMyStaticFiles/default.html

Si no existe ningún archivo con el nombre predeterminado en el directorio MyStaticFiles, https://<hostname>/StaticFiles devuelve la lista de directorios con vínculos activos:If no default-named file exists in the MyStaticFiles directory, https://<hostname>/StaticFiles returns the directory listing with clickable links:

Lista de archivos estáticos

UseDefaultFiles y UseDirectoryBrowser realizan un redireccionamiento del lado cliente desde el URI de destino sin una / final hasta el URI de destino una / final.UseDefaultFiles and UseDirectoryBrowser perform a client-side redirect from the target URI without a trailing / to the target URI with a trailing /. Por ejemplo, desde https://<hostname>/StaticFiles hasta https://<hostname>/StaticFiles/.For example, from https://<hostname>/StaticFiles to https://<hostname>/StaticFiles/. Las direcciones URL relativas dentro del directorio StaticFiles no son válidas sin una barra diagonal final (/).Relative URLs within the StaticFiles directory are invalid without a trailing slash (/).

FileExtensionContentTypeProviderFileExtensionContentTypeProvider

La clase FileExtensionContentTypeProvider contiene una propiedad Mappings que actúa como una asignación de extensiones de archivo para tipos de contenido MIME.The FileExtensionContentTypeProvider class contains a Mappings property that serves as a mapping of file extensions to MIME content types. En el ejemplo siguiente, se asignan varias extensiones de archivo a los tipos MIME conocidos.In the following sample, several file extensions are mapped to known MIME types. Se reemplaza la extensión .rtf y se quita .mp4:The .rtf extension is replaced, and .mp4 is removed:

// using Microsoft.AspNetCore.StaticFiles;
// using Microsoft.Extensions.FileProviders;
// using System.IO;

// Set up custom content types - associating file extension to MIME type
var provider = new FileExtensionContentTypeProvider();
// Add new mappings
provider.Mappings[".myapp"] = "application/x-msdownload";
provider.Mappings[".htm3"] = "text/html";
provider.Mappings[".image"] = "image/png";
// Replace an existing mapping
provider.Mappings[".rtf"] = "application/x-msdownload";
// Remove MP4 videos.
provider.Mappings.Remove(".mp4");

app.UseStaticFiles(new StaticFileOptions
{
    FileProvider = new PhysicalFileProvider(
        Path.Combine(env.WebRootPath, "images")),
    RequestPath = "/MyImages",
    ContentTypeProvider = provider
});

app.UseDirectoryBrowser(new DirectoryBrowserOptions
{
    FileProvider = new PhysicalFileProvider(
        Path.Combine(env.WebRootPath, "images")),
    RequestPath = "/MyImages"
});

El código siguiente muestra Startup.Configure con el código anterior:The following code shows Startup.Configure with the preceding code:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    else
    {
        app.UseExceptionHandler("/Home/Error");
        app.UseHsts();
    }

    app.UseHttpsRedirection();

    // using Microsoft.AspNetCore.StaticFiles;
    // using Microsoft.Extensions.FileProviders;
    // using System.IO;

    // Set up custom content types - associating file extension to MIME type
    var provider = new FileExtensionContentTypeProvider();
    // Add new mappings
    provider.Mappings[".myapp"] = "application/x-msdownload";
    provider.Mappings[".htm3"] = "text/html";
    provider.Mappings[".image"] = "image/png";
    // Replace an existing mapping
    provider.Mappings[".rtf"] = "application/x-msdownload";
    // Remove MP4 videos.
    provider.Mappings.Remove(".mp4");

    app.UseStaticFiles(new StaticFileOptions
    {
        FileProvider = new PhysicalFileProvider(
            Path.Combine(env.WebRootPath, "images")),
        RequestPath = "/MyImages",
        ContentTypeProvider = provider
    });

    app.UseDirectoryBrowser(new DirectoryBrowserOptions
    {
        FileProvider = new PhysicalFileProvider(
            Path.Combine(env.WebRootPath, "images")),
        RequestPath = "/MyImages"
    });

    app.UseRouting();

    app.UseAuthorization();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapDefaultControllerRoute();
    });
}

Vea Tipos de contenido MIME.See MIME content types.

Tipos de contenido no estándarNon-standard content types

El middleware de archivos estáticos entiende casi 400 tipos de contenido de archivo conocidos.The Static File Middleware understands almost 400 known file content types. Si el usuario solicita un archivo con un tipo de archivo desconocido, el middleware de archivos estáticos pasa la solicitud al siguiente middleware de la canalización.If the user requests a file with an unknown file type, the Static File Middleware passes the request to the next middleware in the pipeline. Si ningún middleware se ocupa de la solicitud, se devuelve una respuesta 404 No encontrado.If no middleware handles the request, a 404 Not Found response is returned. Si se habilita la exploración de directorios, se muestra un vínculo al archivo en una lista de directorios.If directory browsing is enabled, a link to the file is displayed in a directory listing.

El código siguiente permite proporcionar tipos desconocidos y procesa el archivo desconocido como una imagen:The following code enables serving unknown types and renders the unknown file as an image:

app.UseStaticFiles(new StaticFileOptions
{
    ServeUnknownFileTypes = true,
    DefaultContentType = "image/png"
});

El código siguiente muestra Startup.Configure con el código anterior:The following code shows Startup.Configure with the preceding code:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    else
    {
        app.UseExceptionHandler("/Home/Error");
        app.UseHsts();
    }

    app.UseHttpsRedirection();

    app.UseStaticFiles(new StaticFileOptions
    {
        ServeUnknownFileTypes = true,
        DefaultContentType = "image/png"
    });

    app.UseRouting();

    app.UseAuthorization();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapDefaultControllerRoute();
    });
}

Con el código anterior, una solicitud para un archivo con un tipo de contenido desconocido se devuelve como una imagen.With the preceding code, a request for a file with an unknown content type is returned as an image.

Advertencia

Habilitar ServeUnknownFileTypes supone un riesgo para la seguridad.Enabling ServeUnknownFileTypes is a security risk. Está deshabilitado de forma predeterminada y no se recomienda su uso.It's disabled by default, and its use is discouraged. FileExtensionContentTypeProvider proporciona una alternativa más segura a ofrecer archivos con extensiones no estándar.FileExtensionContentTypeProvider provides a safer alternative to serving files with non-standard extensions.

Entrega de archivos desde varias ubicacionesServe files from multiple locations

UseStaticFiles y UseFileServer tienen como valor predeterminado el proveedor de archivos que apunta a wwwroot.UseStaticFiles and UseFileServer default to the file provider pointing at wwwroot. Se pueden proporcionar instancias adicionales de UseStaticFiles y UseFileServer con otros proveedores de archivos para proporcionar archivos desde otras ubicaciones.Additional instances of UseStaticFiles and UseFileServer can be provided with other file providers to serve files from other locations. Para más información, consulte este problema de GitHub.For more information, see this GitHub issue.

Consideraciones de seguridad para archivos estáticosSecurity considerations for static files

Advertencia

UseDirectoryBrowser y UseStaticFiles pueden producir pérdidas de información confidencial.UseDirectoryBrowser and UseStaticFiles can leak secrets. Se recomienda deshabilitar el examen de directorios en producción.Disabling directory browsing in production is highly recommended. Revise cuidadosamente los directorios que se habilitan mediante UseStaticFiles o UseDirectoryBrowser.Carefully review which directories are enabled via UseStaticFiles or UseDirectoryBrowser. Todo el directorio y sus subdirectorios pasan a ser accesibles públicamente.The entire directory and its sub-directories become publicly accessible. Almacene los archivos adecuados para proporcionarlos al público en un directorio dedicado, como <content_root>/wwwroot.Store files suitable for serving to the public in a dedicated directory, such as <content_root>/wwwroot. Separe estos archivos de las vistas MVC, de Razor Pages, de los archivos de configuración, etc.Separate these files from MVC views, Razor Pages, configuration files, etc.

  • Las direcciones URL para el contenido que se expone a través de UseDirectoryBrowser y UseStaticFiles están sujetas a la distinción entre mayúsculas y minúsculas, y a restricciones de caracteres del sistema de archivos subyacente.The URLs for content exposed with UseDirectoryBrowser and UseStaticFiles are subject to the case sensitivity and character restrictions of the underlying file system. Por ejemplo, Windows no distingue entre mayúsculas y minúsculas, pero macOS y Linux sí.For example, Windows is case insensitive, but macOS and Linux aren't.

  • Las aplicaciones de ASP.NET Core hospedadas en IIS usan el módulo de ASP.NET Core para reenviar todas las solicitudes a la aplicación, incluidas las solicitudes de archivos estáticos.ASP.NET Core apps hosted in IIS use the ASP.NET Core Module to forward all requests to the app, including static file requests. No se utiliza el controlador de archivos estáticos de IIS y no tiene la posibilidad de controlar las solicitudes.The IIS static file handler isn't used and has no chance to handle requests.

  • Complete los pasos siguientes en el Administrador de IIS para quitar el controlador de archivos estáticos de IIS en el nivel de servidor o de sitio web:Complete the following steps in IIS Manager to remove the IIS static file handler at the server or website level:

    1. Navegue hasta la característica Módulos.Navigate to the Modules feature.
    2. En la lista, seleccione StaticFileModule.Select StaticFileModule in the list.
    3. Haga clic en Quitar en la barra lateral Acciones.Click Remove in the Actions sidebar.

Advertencia

Si el controlador de archivos estáticos de IIS está habilitado y el módulo de ASP.NET Core no está configurado correctamente, se proporcionan archivos estáticos.If the IIS static file handler is enabled and the ASP.NET Core Module is configured incorrectly, static files are served. Esto sucede, por ejemplo, si el archivo web.config no está implementado.This happens, for example, if the web.config file isn't deployed.

  • Coloque los archivos de código (incluidos .cs y .cshtml) fuera de la raíz web del proyecto de la aplicación.Place code files, including .cs and .cshtml, outside of the app project's web root. Por lo tanto, se crea una separación lógica entre el contenido del lado cliente de la aplicación y el código basado en servidor.A logical separation is therefore created between the app's client-side content and server-based code. Esto impide que se filtre el código del lado servidor.This prevents server-side code from being leaked.

Recursos adicionalesAdditional resources

Por Rick Anderson y Scott AddieBy Rick Anderson and Scott Addie

Los archivos estáticos, como HTML, CSS, imágenes y JavaScript, son activos que una aplicación de ASP.NET Core proporciona directamente a los clientes.Static files, such as HTML, CSS, images, and JavaScript, are assets an ASP.NET Core app serves directly to clients. Se necesita alguna configuración para habilitar el servicio de estos archivos.Some configuration is required to enable serving of these files.

Vea o descargue el código de ejemplo (cómo descargarlo)View or download sample code (how to download)

Proporcionar archivos estáticosServe static files

Los archivos estáticos se almacenan en el directorio raíz web del proyecto.Static files are stored within the project's web root directory. El directorio predeterminado es {raíz del contenido}/wwwroot, pero se puede cambiar con el método UseWebRoot.The default directory is {content root}/wwwroot, but it can be changed via the UseWebRoot method. Vea Raíz del contenido y Raíz web para obtener más información.See Content root and Web root for more information.

El host de web de la aplicación debe tener conocimiento del directorio raíz del contenido.The app's web host must be made aware of the content root directory.

El método WebHost.CreateDefaultBuilder establece la raíz de contenido en el directorio actual:The WebHost.CreateDefaultBuilder method sets the content root to the current directory:

public class Program
{
    public static void Main(string[] args)
    {
        CreateWebHostBuilder(args).Build().Run();
    }

    public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
        WebHost.CreateDefaultBuilder(args)
            .UseStartup<Startup>();
}

Se puede acceder a los archivos estáticos a través de una ruta de acceso relativa a la raíz web.Static files are accessible via a path relative to the web root. Por ejemplo, la plantilla de proyecto Aplicación web contiene varias carpetas dentro de la carpeta wwwroot:For example, the Web Application project template contains several folders within the wwwroot folder:

  • wwwroot
    • css
    • images
    • js

El formato de URI para acceder a un archivo en la subcarpeta images es http://<server_address>/images/<image_file_name> .The URI format to access a file in the images subfolder is http://<server_address>/images/<image_file_name>. Por ejemplo, http://localhost:9189/images/banner3.svg .For example, http://localhost:9189/images/banner3.svg.

Si el destino es .NET Framework, agregue el paquete Microsoft.AspNetCore.StaticFiles al proyecto.If targeting .NET Framework, add the Microsoft.AspNetCore.StaticFiles package to the project. Si el destino es .NET Core, el metapaquete Microsoft.AspNetCore.App incluye este paquete.If targeting .NET Core, the Microsoft.AspNetCore.App metapackage includes this package.

Configure el middleware, que permite proporcionar archivos estáticos.Configure the middleware, which enables the serving of static files.

Proporcionar archivos dentro de la raíz webServe files inside of web root

Invoque al método UseStaticFiles en Startup.Configure:Invoke the UseStaticFiles method within Startup.Configure:

public void Configure(IApplicationBuilder app)
{
    app.UseStaticFiles();
}

La sobrecarga del método UseStaticFiles sin parámetros marca los archivos en la raíz web como que se pueden proporcionar.The parameterless UseStaticFiles method overload marks the files in web root as servable. El siguiente marcado hace referencia a wwwroot/images/banner1.svg:The following markup references wwwroot/images/banner1.svg:

<img src="~/images/banner1.svg" alt="ASP.NET" class="img-responsive" />

En el código anterior, el carácter de tilde de la ñ ~/ apunta a la raíz web.In the preceding code, the tilde character ~/ points to the web root.

Proporcionar archivos fuera de la raíz webServe files outside of web root

Considere una jerarquía de directorios en la que residen fuera de la raíz web los archivos estáticos que se van a proporcionar:Consider a directory hierarchy in which the static files to be served reside outside of the web root:

  • wwwroot
    • css
    • images
    • js
  • MyStaticFiles
    • images
      • banner1.svg

Una solicitud puede acceder al archivo banner1.svg configurando el middleware de archivos estáticos como se muestra a continuación:A request can access the banner1.svg file by configuring the Static File Middleware as follows:

public void Configure(IApplicationBuilder app)
{
    app.UseStaticFiles(); // For the wwwroot folder

    app.UseStaticFiles(new StaticFileOptions
    {
        FileProvider = new PhysicalFileProvider(
            Path.Combine(Directory.GetCurrentDirectory(), "MyStaticFiles")),
        RequestPath = "/StaticFiles"
    });
}

En el código anterior, la jerarquía del directorio MyStaticFiles se expone públicamente a través del segmento de URI StaticFiles.In the preceding code, the MyStaticFiles directory hierarchy is exposed publicly via the StaticFiles URI segment. Una solicitud a http://<server_address>/StaticFiles/images/banner1.svg proporciona el archivo banner1.svg.A request to http://<server_address>/StaticFiles/images/banner1.svg serves the banner1.svg file.

El siguiente marcado hace referencia a MyStaticFiles/images/banner1.svg:The following markup references MyStaticFiles/images/banner1.svg:

<img src="~/StaticFiles/images/banner1.svg" alt="ASP.NET" class="img-responsive" />

Establecer encabezados de respuesta HTTPSet HTTP response headers

Se puede usar un objeto StaticFileOptions para establecer encabezados de respuesta HTTP.A StaticFileOptions object can be used to set HTTP response headers. Además de configurar el servicio de archivos estáticos desde la raíz web, el código siguiente establece el encabezado Cache-Control:In addition to configuring static file serving from the web root, the following code sets the Cache-Control header:

public void Configure(IApplicationBuilder app)
{
    var cachePeriod =  "604800";
    app.UseStaticFiles(new StaticFileOptions
    {
        OnPrepareResponse = ctx =>
        {
            // Requires the following import:
            // using Microsoft.AspNetCore.Http;
            ctx.Context.Response.Headers.Append("Cache-Control", $"public, max-age={cachePeriod}");
        }
    });
}

Si quiere que los comentarios de código se traduzcan en más idiomas además del inglés, háganoslo saber en este problema de debate de GitHub.If you would like to see code comments translated to languages other than English, let us know in this GitHub discussion issue.

El método HeaderDictionaryExtensions.Append existe en el paquete Microsoft.AspNetCore.Http.The HeaderDictionaryExtensions.Append method exists in the Microsoft.AspNetCore.Http package.

Los archivos se han hecho públicamente almacenables en caché durante 10 minutos (600 segundos) en el entorno de desarrollo:The files have been made publicly cacheable for 10 minutes (600 seconds) in the Development environment:

Se han agregado encabezados de respuesta que muestran el encabezado Cache-Control

Autorización de archivos estáticosStatic file authorization

El middleware de archivos estáticos no proporciona comprobaciones de autorización.The Static File Middleware doesn't provide authorization checks. Los archivos que proporciona, incluidos los de wwwroot, están accesibles de forma pública.Any files served by it, including those under wwwroot, are publicly accessible. Para proporcionar archivos según su autorización:To serve files based on authorization:

  • Almacénelos fuera de wwwroot y cualquier directorio al que el middleware de archivos estáticos tenga acceso.Store them outside of wwwroot and any directory accessible to the Static File Middleware.

  • Proporciónelos a través de un método de acción al que se aplica la autorización.Serve them via an action method to which authorization is applied. Devuelva un objeto FileResult:Return a FileResult object:

    [Authorize]
    public IActionResult BannerImage()
    {
        var file = Path.Combine(Directory.GetCurrentDirectory(), 
                                "MyStaticFiles", "images", "banner1.svg");
    
        return PhysicalFile(file, "image/svg+xml");
    }
    

Habilite el examen de directoriosEnable directory browsing

El examen de directorios permite a los usuarios de su aplicación web ver una lista de directorios y archivos contenidos en un directorio especificado.Directory browsing allows users of your web app to see a directory listing and files within a specified directory. Por motivos de seguridad, el examen de directorios está deshabilitado de forma predeterminada (consulte Consideraciones).Directory browsing is disabled by default for security reasons (see Considerations). Habilite el examen de directorios invocando el método UseDirectoryBrowser en Startup.Configure:Enable directory browsing by invoking the UseDirectoryBrowser method in Startup.Configure:

public void Configure(IApplicationBuilder app)
{
    app.UseStaticFiles(); // For the wwwroot folder

    app.UseStaticFiles(new StaticFileOptions
    {
        FileProvider = new PhysicalFileProvider(
            Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "images")),
        RequestPath = "/MyImages"
    });

    app.UseDirectoryBrowser(new DirectoryBrowserOptions
    {
        FileProvider = new PhysicalFileProvider(
            Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "images")),
        RequestPath = "/MyImages"
    });
}

Agregar servicios requeridos invocando el método AddDirectoryBrowser desde Startup.ConfigureServices:Add required services by invoking the AddDirectoryBrowser method from Startup.ConfigureServices:

public void ConfigureServices(IServiceCollection services)
{
    services.AddDirectoryBrowser();
}

El código anterior permite el examen de directorios de la carpeta wwwroot/images usando la dirección URL http://<server_address>/MyImages, con vínculos a cada archivo y carpeta:The preceding code allows directory browsing of the wwwroot/images folder using the URL http://<server_address>/MyImages, with links to each file and folder:

examen de directorios

Vea consideraciones sobre los riesgos de seguridad al habilitar el examen.See Considerations on the security risks when enabling browsing.

Tenga en cuenta las dos llamadas a UseStaticFiles en el ejemplo siguiente.Note the two UseStaticFiles calls in the following example. La primera llamada permite proporcionar archivos estáticos en la carpeta wwwroot.The first call enables the serving of static files in the wwwroot folder. La segunda llamada habilita el examen de directorios de la carpeta wwwroot/images usando la dirección URL http://<server_address>/MyImages:The second call enables directory browsing of the wwwroot/images folder using the URL http://<server_address>/MyImages:

public void Configure(IApplicationBuilder app)
{
    app.UseStaticFiles(); // For the wwwroot folder

    app.UseStaticFiles(new StaticFileOptions
    {
        FileProvider = new PhysicalFileProvider(
            Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "images")),
        RequestPath = "/MyImages"
    });

    app.UseDirectoryBrowser(new DirectoryBrowserOptions
    {
        FileProvider = new PhysicalFileProvider(
            Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "images")),
        RequestPath = "/MyImages"
    });
}

Proporcionar un documento predeterminadoServe a default document

Establecer una página principal predeterminada proporciona a los visitantes un punto de partida lógico cuando visitan su sitio.Setting a default home page provides visitors a logical starting point when visiting your site. Para proporcionar una página predeterminada sin que el usuario cumpla por completo los requisitos del URI, llame al método UseDefaultFiles desde Startup.Configure:To serve a default page without the user fully qualifying the URI, call the UseDefaultFiles method from Startup.Configure:

public void Configure(IApplicationBuilder app)
{
    app.UseDefaultFiles();
    app.UseStaticFiles();
}

Importante

Debe llamarse a UseDefaultFiles antes de a UseStaticFiles para proporcionar el archivo predeterminado.UseDefaultFiles must be called before UseStaticFiles to serve the default file. UseDefaultFiles es un sistema de reescritura de direcciones URL que no proporciona realmente el archivo.UseDefaultFiles is a URL rewriter that doesn't actually serve the file. Habilite el middleware de archivos estáticos a través de UseStaticFiles para proporcionar el archivo.Enable Static File Middleware via UseStaticFiles to serve the file.

Con UseDefaultFiles, las solicitudes a una carpeta buscan:With UseDefaultFiles, requests to a folder search for:

  • default.htmdefault.htm
  • default.htmldefault.html
  • index.htmindex.htm
  • index.htmlindex.html

El primer archivo que se encuentra en la lista se proporciona como si la solicitud fuera el URI completo.The first file found from the list is served as though the request were the fully qualified URI. La dirección URL del explorador sigue reflejando el URI solicitado.The browser URL continues to reflect the URI requested.

El código siguiente cambia el nombre de archivo predeterminado a mydefault.html:The following code changes the default file name to mydefault.html:

public void Configure(IApplicationBuilder app)
{
    // Serve my app-specific default file, if present.
    DefaultFilesOptions options = new DefaultFilesOptions();
    options.DefaultFileNames.Clear();
    options.DefaultFileNames.Add("mydefault.html");
    app.UseDefaultFiles(options);
    app.UseStaticFiles();
}

UseFileServerUseFileServer

UseFileServer combina la funcionalidad de UseStaticFiles y UseDefaultFiles y, opcionalmente, la de UseDirectoryBrowser.UseFileServer combines the functionality of UseStaticFiles, UseDefaultFiles, and optionally UseDirectoryBrowser.

El código siguiente permite proporcionar archivos estáticos y el archivo predeterminado.The following code enables the serving of static files and the default file. El examen de directorios no está habilitado.Directory browsing isn't enabled.

app.UseFileServer();

El código siguiente refuerza la sobrecarga sin parámetros habilitando el examen de directorios:The following code builds upon the parameterless overload by enabling directory browsing:

app.UseFileServer(enableDirectoryBrowsing: true);

Tenga en cuenta la siguiente jerarquía de directorios:Consider the following directory hierarchy:

  • wwwrootwwwroot
    • csscss
    • imagesimages
    • jsjs
  • MyStaticFilesMyStaticFiles
    • imagesimages
      • banner1.svgbanner1.svg
    • default.htmldefault.html

El código siguiente permite los archivos estáticos, los archivos predeterminados y el examen de directorios de MyStaticFiles:The following code enables static files, default files, and directory browsing of MyStaticFiles:

public void Configure(IApplicationBuilder app)
{
    app.UseStaticFiles(); // For the wwwroot folder

    app.UseFileServer(new FileServerOptions
    {
        FileProvider = new PhysicalFileProvider(
            Path.Combine(Directory.GetCurrentDirectory(), "MyStaticFiles")),
        RequestPath = "/StaticFiles",
        EnableDirectoryBrowsing = true
    });
}

Se debe llamar a AddDirectoryBrowser cuando el valor de la propiedad EnableDirectoryBrowsing es true:AddDirectoryBrowser must be called when the EnableDirectoryBrowsing property value is true:

public void ConfigureServices(IServiceCollection services)
{
    services.AddDirectoryBrowser();
}

Al usar la jerarquía de archivos y el código anterior, las direcciones URL se resuelven como se indica a continuación:Using the file hierarchy and preceding code, URLs resolve as follows:

Identificador URIURI RespuestaResponse
http://<server_address>/StaticFiles/images/banner1.svghttp://<server_address>/StaticFiles/images/banner1.svg MyStaticFiles/images/banner1.svgMyStaticFiles/images/banner1.svg
http://<server_address>/StaticFileshttp://<server_address>/StaticFiles MyStaticFiles/default.htmlMyStaticFiles/default.html

Si no existe ningún archivo con el nombre predeterminado en el directorio MyStaticFiles, http://<server_address>/StaticFiles devuelve la lista de directorios con vínculos activos:If no default-named file exists in the MyStaticFiles directory, http://<server_address>/StaticFiles returns the directory listing with clickable links:

Lista de archivos estáticos

Nota

UseDefaultFiles y UseDirectoryBrowser realizan un redireccionamiento del lado cliente desde http://{SERVER ADDRESS}/StaticFiles (sin una barra diagonal final) hasta http://{SERVER ADDRESS}/StaticFiles/ (con una barra diagonal final).UseDefaultFiles and UseDirectoryBrowser perform a client-side redirect from http://{SERVER ADDRESS}/StaticFiles (without a trailing slash) to http://{SERVER ADDRESS}/StaticFiles/ (with a trailing slash). Las direcciones URL relativas dentro del directorio StaticFiles no son válidas sin una barra diagonal final.Relative URLs within the StaticFiles directory are invalid without a trailing slash.

FileExtensionContentTypeProviderFileExtensionContentTypeProvider

La clase FileExtensionContentTypeProvider contiene una propiedad Mappings que actúa como una asignación de extensiones de archivo para tipos de contenido MIME.The FileExtensionContentTypeProvider class contains a Mappings property serving as a mapping of file extensions to MIME content types. En el ejemplo siguiente, se registran varias extensiones de archivo a los tipos MIME conocidos.In the following sample, several file extensions are registered to known MIME types. Se reemplaza la extensión .rtf y se quita .mp4.The .rtf extension is replaced, and .mp4 is removed.

public void Configure(IApplicationBuilder app)
{
    // Set up custom content types - associating file extension to MIME type
    var provider = new FileExtensionContentTypeProvider();
    // Add new mappings
    provider.Mappings[".myapp"] = "application/x-msdownload";
    provider.Mappings[".htm3"] = "text/html";
    provider.Mappings[".image"] = "image/png";
    // Replace an existing mapping
    provider.Mappings[".rtf"] = "application/x-msdownload";
    // Remove MP4 videos.
    provider.Mappings.Remove(".mp4");

    app.UseStaticFiles(new StaticFileOptions
    {
        FileProvider = new PhysicalFileProvider(
            Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "images")),
        RequestPath = "/MyImages",
        ContentTypeProvider = provider
    });

    app.UseDirectoryBrowser(new DirectoryBrowserOptions
    {
        FileProvider = new PhysicalFileProvider(
            Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "images")),
        RequestPath = "/MyImages"
    });
}

Vea Tipos de contenido MIME.See MIME content types.

Tipos de contenido no estándarNon-standard content types

El middleware de archivos estáticos entiende casi 400 tipos de contenido de archivo conocidos.Static File Middleware understands almost 400 known file content types. Si el usuario solicita un archivo con un tipo de archivo desconocido, el middleware de archivos estáticos pasa la solicitud al siguiente middleware de la canalización.If the user requests a file with an unknown file type, Static File Middleware passes the request to the next middleware in the pipeline. Si ningún middleware se ocupa de la solicitud, se devuelve una respuesta 404 No encontrado.If no middleware handles the request, a 404 Not Found response is returned. Si se habilita la exploración de directorios, se muestra un vínculo al archivo en una lista de directorios.If directory browsing is enabled, a link to the file is displayed in a directory listing.

El código siguiente permite proporcionar tipos desconocidos y procesa el archivo desconocido como una imagen:The following code enables serving unknown types and renders the unknown file as an image:

public void Configure(IApplicationBuilder app)
{
    app.UseStaticFiles(new StaticFileOptions
    {
        ServeUnknownFileTypes = true,
        DefaultContentType = "image/png"
    });
}

Con el código anterior, una solicitud para un archivo con un tipo de contenido desconocido se devuelve como una imagen.With the preceding code, a request for a file with an unknown content type is returned as an image.

Advertencia

Habilitar ServeUnknownFileTypes supone un riesgo para la seguridad.Enabling ServeUnknownFileTypes is a security risk. Está deshabilitado de forma predeterminada y no se recomienda su uso.It's disabled by default, and its use is discouraged. FileExtensionContentTypeProvider proporciona una alternativa más segura a ofrecer archivos con extensiones no estándar.FileExtensionContentTypeProvider provides a safer alternative to serving files with non-standard extensions.

Entrega de archivos desde varias ubicacionesServe files from multiple locations

UseStaticFiles y UseFileServer tienen como valor predeterminado el proveedor de archivos que apunta a wwwroot.UseStaticFiles and UseFileServer defaults to the file provider pointing at wwwroot. Puede proporcionar instancias adicionales de UseStaticFiles y UseFileServer con otros proveedores de archivos para proporcionar archivos desde otras ubicaciones.You can provide additional instances of UseStaticFiles and UseFileServer with other file providers to serve files from other locations. Para más información, consulte este problema de GitHub.For more information, see this GitHub issue.

ConsideracionesConsiderations

Advertencia

UseDirectoryBrowser y UseStaticFiles pueden producir pérdidas de información confidencial.UseDirectoryBrowser and UseStaticFiles can leak secrets. Se recomienda deshabilitar el examen de directorios en producción.Disabling directory browsing in production is highly recommended. Revise cuidadosamente los directorios que se habilitan mediante UseStaticFiles o UseDirectoryBrowser.Carefully review which directories are enabled via UseStaticFiles or UseDirectoryBrowser. Todo el directorio y sus subdirectorios pasan a ser accesibles públicamente.The entire directory and its sub-directories become publicly accessible. Almacene los archivos adecuados para proporcionarlos al público en un directorio dedicado, como <content_root>/wwwroot.Store files suitable for serving to the public in a dedicated directory, such as <content_root>/wwwroot. Separe estos archivos de las vistas MVC, las instancias de Razor Pages (solo 2.x), los archivos de configuración, etc.Separate these files from MVC views, Razor Pages (2.x only), configuration files, etc.

  • Las direcciones URL para el contenido que se expone a través de UseDirectoryBrowser y UseStaticFiles están sujetas a la distinción entre mayúsculas y minúsculas, y a restricciones de caracteres del sistema de archivos subyacente.The URLs for content exposed with UseDirectoryBrowser and UseStaticFiles are subject to the case sensitivity and character restrictions of the underlying file system. Por ejemplo, Windows no distingue entre mayúsculas y minúsculas, pero macOS y Linux sí.For example, Windows is case insensitive—macOS and Linux aren't.

  • Las aplicaciones de ASP.NET Core hospedadas en IIS usan el módulo de ASP.NET Core para reenviar todas las solicitudes a la aplicación, incluidas las solicitudes de archivos estáticos.ASP.NET Core apps hosted in IIS use the ASP.NET Core Module to forward all requests to the app, including static file requests. No se usa el controlador de archivos estáticos de IIS.The IIS static file handler isn't used. No tiene ninguna posibilidad de controlar las solicitudes antes de que las controle el módulo.It has no chance to handle requests before they're handled by the module.

  • Complete los pasos siguientes en el Administrador de IIS para quitar el controlador de archivos estáticos de IIS en el nivel de servidor o de sitio web:Complete the following steps in IIS Manager to remove the IIS static file handler at the server or website level:

    1. Navegue hasta la característica Módulos.Navigate to the Modules feature.
    2. En la lista, seleccione StaticFileModule.Select StaticFileModule in the list.
    3. Haga clic en Quitar en la barra lateral Acciones.Click Remove in the Actions sidebar.

Advertencia

Si el controlador de archivos estáticos de IIS está habilitado y el módulo de ASP.NET Core no está configurado correctamente, se proporcionan archivos estáticos.If the IIS static file handler is enabled and the ASP.NET Core Module is configured incorrectly, static files are served. Esto sucede, por ejemplo, si el archivo web.config no está implementado.This happens, for example, if the web.config file isn't deployed.

  • Coloque los archivos de código (incluidos .cs y .cshtml) fuera de la raíz web del proyecto de la aplicación.Place code files (including .cs and .cshtml) outside of the app project's web root. Por lo tanto, se crea una separación lógica entre el contenido del lado cliente de la aplicación y el código basado en servidor.A logical separation is therefore created between the app's client-side content and server-based code. Esto impide que se filtre el código del lado servidor.This prevents server-side code from being leaked.

Recursos adicionalesAdditional resources