Statické soubory v ASP.NET Core

Od Ricka Andersona a Vychytáka Přichytáka

Statické soubory, jako je HTML, CSS, obrázky a JavaScript, jsou prostředky, ASP.NET Core aplikace ve výchozím nastavení slouží přímo klientům.

Zobrazení nebo stažení ukázkového kódu (stažení)

Zobrazování statických souborů

Statické soubory se ukládají v kořenovém adresáři projektu. Výchozí adresář je {content root}/wwwroot , ale můžete ho změnit pomocí metody UseWebRoot . Další informace najdete v tématu Kořenový adresář obsahu a Kořenový adresář webu.

Metoda CreateDefaultBuilder nastaví kořen obsahu na aktuální adresář:

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>();
            });
}

Předchozí kód byl vytvořen pomocí šablony webové aplikace.

Statické soubory jsou přístupné prostřednictvím cesty relativní k webovému kořenovému adresáři. Například šablony projektů webové aplikace obsahují několik složek ve wwwroot složce :

• wwwroot
  • css
  • js
  • lib

Zvažte vytvoření složky wwwroot/images a přidání souboru wwwroot/images/MyImage.jpg souborů. Formát identifikátoru URI pro přístup k souboru ve images složce je https://<hostname>/images/<image_file_name> . Například https://localhost:5001/images/MyImage.jpg.

Zobrazování souborů ve webovém kořenovém adresáři

Výchozí šablony webové aplikace volají metodu v , která umožňuje obsluhovat UseStaticFiles Startup.Configure statické soubory:

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();
    });
}

Přetížení metody UseStaticFiles bez parametrů označuje soubory v kořenovém adresáři webu jako záložní. Následující kód odkazuje na wwwroot/images/MyImage.jpg:

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

Znak tildy v předchozím kódu ~/ odkazuje na kořenový webový adresář.

Zobrazování souborů mimo kořenový web

Zvažte hierarchii adresářů, ve které se statické soubory, které se mají zhostovat, umístěny mimo kořenový webový adresář:

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

Požadavek má k souboru red-rose.jpg přístup tak, že nakonfiguruje middleware statického souboru následujícím způsobem:

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();
    });
}

V předchozím kódu je hierarchie adresářů MyStaticFiles veřejně zpřístupněna prostřednictvím segmentu identifikátoru URI StaticFiles. Požadavek na https://<hostname>/StaticFiles/images/red-rose.jpg zpracování red-rose.jpg souboru.

Následující kód odkazuje na MyStaticFiles/images/red-rose.jpg:

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

Nastavení hlaviček odpovědi HTTP

Objekt StaticFileOptions lze použít k nastavení hlaviček odpovědi HTTP. Kromě konfigurace statického souboru obsluhujícího z kořenového adresáře webunastaví hlavičku následující Cache-Control kód:

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();
    });
}

Statické soubory je možné veřejně ukládat do mezipaměti po dobu 600 sekund:

Autorizace statického souboru

Šablony ASP.NET Core volají UseStaticFiles před voláním UseAuthorization metody . Většina aplikací tento model dodržuje. Při volání middlewaru static file před autorizačním middlewarem:

• U statických souborů nejsou provedeny žádné kontroly autorizace.
• Statické soubory obsluhoované middlewarem statického souboru, například soubory v systému wwwroot , jsou veřejně přístupné.

Obsluhu statických souborů na základě autorizace:

• Uložte je mimo wwwroot .
• Po UseStaticFiles zavolání volejte a zadejte cestu UseAuthorization .
• Nastavte zásadu pro záložní autorizaci.

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

    app.UseHttpsRedirection();

    // wwwroot css, JavaScript, and images don't require authentication.
    app.UseStaticFiles();   

    app.UseRouting();

    app.UseAuthentication();
    app.UseAuthorization();

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

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

public class Startup
{
    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    public IConfiguration Configuration { get; }

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddDbContext<ApplicationDbContext>(options =>
            options.UseSqlServer(
                Configuration.GetConnectionString("DefaultConnection")));
        services.AddDefaultIdentity<IdentityUser>(options => options.SignIn.RequireConfirmedAccount = true)
            .AddEntityFrameworkStores<ApplicationDbContext>();

        services.AddRazorPages();

        services.AddAuthorization(options =>
        {
            options.FallbackPolicy = new AuthorizationPolicyBuilder()
                .RequireAuthenticatedUser()
                .Build();
        });
    }

    // Remaining code ommitted for brevity.

V předchozím kódu vyžadují zásady záložní autorizace ověření všech uživatelů. Koncové body, jako jsou kontrolery, stránky atd., které určují vlastní požadavky na autorizaci, zásady Razor základní autorizace nepoužívejte. Například Stránky, kontrolery nebo metody akcí s použitým atributem autorizace Razor [AllowAnonymous] místo [Authorize(PolicyName="MyPolicy")] záložních zásad autorizace.

RequireAuthenticatedUser přidá DenyAnonymousAuthorizationRequirement k aktuální instanci , která vynucuje, aby byl aktuální uživatel ověřen.

Statické prostředky v části jsou veřejně přístupné, protože před se volá wwwroot výchozí middleware statického souboru ( app.UseStaticFiles(); UseAuthentication ). Statické prostředky ve složce MyStaticFiles vyžadují ověření. Ukázkový kód to demonstruje.

Alternativním přístupem k zobrazování souborů na základě autorizace je:

• Uložte je mimo wwwroot a libovolný adresář přístupný middlewaru statického souboru.
• Předávejte je prostřednictvím metody akce, u které se použije autorizace, a vrácení FileResult objektu:

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

    return PhysicalFile(filePath, "image/jpeg");
}

Procházení adresářů

Procházení adresářů umožňuje výpis adresářů v zadaných adresářích.

Procházení adresářů je z bezpečnostních důvodů ve výchozím nastavení zakázané. Další informace najdete v tématu Důležité informace o zabezpečení statických souborů.

Povolte procházení adresářů pomocí:

• AddDirectoryBrowser v Startup.ConfigureServices souboru .
• UseDirectoryBrowser v Startup.Configure souboru .

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();
    });
}

Předchozí kód umožňuje procházení adresáře složky wwwroot/images pomocí adresy URL s odkazy na jednotlivé soubory a https://<hostname>/MyImages složky:

Zobrazení výchozích dokumentů

Nastavení výchozí stránky poskytuje návštěvníkům výchozí bod v lokalitě. Pokud chcete zobrazit výchozí soubor z bez vyžadování adresy URL požadavku, aby zahrnoval název wwwroot souboru, zavolejte UseDefaultFiles metodu :

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();
    });
}

UseDefaultFiles Před zobrazením výchozího UseStaticFiles souboru musí být volána metoda . UseDefaultFiles je rewriter adresy URL, který soubor nenaslouchá.

V UseDefaultFiles systému požadavky na složku ve wwwroot vyhledávání:

• default.htm
• default.html
• index.htm
• index.html

První soubor nalezený v seznamu se zobrazí, jako by požadavek obsahoval název souboru. Adresa URL prohlížeče bude dál odrážet požadovaný identifikátor URI.

Následující kód změní výchozí název souboru na mydefault.html:

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

Následující kód ukazuje Startup.Configure předchozí kód:

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 pro výchozí dokumenty

UseFileServer kombinuje funkce UseStaticFiles UseDefaultFiles , a volitelně UseDirectoryBrowser .

Voláním app.UseFileServer metody povolíte obsluhu statických souborů a výchozí soubor. Procházení adresářů není povolené. Následující kód ukazuje s Startup.Configure 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();
    });
}

Následující kód umožňuje obsluhu statických souborů, výchozího souboru a procházení adresářů:

app.UseFileServer(enableDirectoryBrowsing: true);

Následující kód ukazuje Startup.Configure předchozí kód:

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();
    });
}

Zvažte následující hierarchii adresářů:

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

Následující kód umožňuje obsluhu statických souborů, výchozího souboru a procházení adresářů 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();
    });
}

AddDirectoryBrowser musí být volána, EnableDirectoryBrowsing když je hodnota vlastnosti true .

Pomocí hierarchie souborů a předchozího kódu se adresy URL překládaly takto:

Identifikátor URI	Odpověď
https://<hostname>/StaticFiles/images/MyImage.jpg	Soubory MyStaticFiles/images/MyImage.jpg
https://<hostname>/StaticFiles	MyStaticFiles/default.html

Pokud v adresáři MyStaticFiles neexistuje žádný výchozí soubor s názvem , vrátí seznam adresářů s odkazy, na které https://<hostname>/StaticFiles můžete kliknout:

UseDefaultFiles a provede přesměrování na straně klienta z cílového identifikátoru URI bez koncového identifikátoru URI na cílový identifikátor UseDirectoryBrowser / URI s koncovou příponou / . Například od https://<hostname>/StaticFiles do https://<hostname>/StaticFiles/ . Relativní adresy URL v adresáři StaticFiles jsou neplatné bez koncového lomítka ( / ).

FileExtensionContentTypeProvider

Třída FileExtensionContentTypeProvider obsahuje Mappings vlastnost, která slouží jako mapování přípon souborů na typy obsahu MIME. V následující ukázce je několik přípon souborů mapováno na známé typy MIME. Rozšíření .rtf se nahradí a .mp4 odebere:

// 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"
});

Následující kód ukazuje Startup.Configure s předchozím kódem:

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();
    });
}

Viz typy obsahu MIME.

Nestandardní typy obsahu

Middleware statických souborů rozumí téměř 400 známým typům obsahu souborů. Pokud uživatel požádá o soubor s neznámým typem souboru, middleware statických souborů předá požadavek dalšímu middlewaru v kanálu. Pokud žádost nezpracovává žádné middleware, je vrácena odpověď 404, která nebyla nalezena . Pokud je povoleno procházení adresářů, zobrazí se v seznamu adresářů odkaz na tento soubor.

Následující kód povoluje obsluhu neznámých typů a vykresluje neznámý soubor jako obrázek:

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

Následující kód ukazuje Startup.Configure s předchozím kódem:

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();
    });
}

V předchozím kódu se jako obrázek vrátí požadavek na soubor s neznámým typem obsahu.

Obsluhovat soubory z více míst

UseStaticFiles a UseFileServer jako výchozí pro poskytovatele souborů odkazující na wwwroot . Další instance UseStaticFiles a UseFileServer lze poskytnout jiným poskytovatelům souborů pro obsluhu souborů z jiných umístění. další informace najdete v tomto GitHub problému.

Požadavky na zabezpečení pro statické soubory

• Adresy URL obsahu vystaveného nástroji UseDirectoryBrowser a UseStaticFiles podléhají omezením malých a velkých písmen a znakům základního systému souborů. například Windows rozlišuje malá a velká písmena, ale macOS a Linux ne.

• ASP.NET Core aplikace hostované ve službě IIS používají modul ASP.NET Core k přeposílání všech požadavků do aplikace, včetně požadavků na statické soubory. Obslužná rutina statických souborů služby IIS se nepoužívá a nemá možnost zpracovávat požadavky.

• Provedením následujících kroků ve Správci služby IIS odeberte obslužnou rutinu statického souboru služby IIS na úrovni serveru nebo webu:

  1. Přejděte do funkce moduly .
  2. V seznamu vyberte StaticFileModule .
  3. Na bočním panelu Akce klikněte na Odebrat .

• Umístěte soubory kódu, včetně přípon cs a . cshtml, mimo webový kořenový adresářprojektu aplikace. Vytvoří se logické oddělení mezi obsahem aplikace na straně klienta a kódem serveru. Tím zabráníte úniku kódu na straně serveru.

Další zdroje informací

• Middleware
• Úvod do ASP.NET Core

Od Rick Anderson a Scott Addie

statické soubory, jako jsou HTML, CSS, obrázky a JavaScript, jsou prostředky, které ASP.NET Core aplikace slouží přímo klientům. K povolení obsluhy těchto souborů je potřeba některá konfigurace.

Zobrazit nebo stáhnout ukázkový kód (Jak stáhnout)

Obsluhovat statické soubory

Statické soubory jsou uloženy v kořenovém adresáři webu projektu. Výchozí adresář je {root obsahu}/wwwroot, ale dá se změnit prostřednictvím UseWebRoot metody. Další informace najdete v kořenovém adresáři obsahu a ve webovém kořenovém adresáři .

Webový hostitel aplikace musí být informován o kořenovém adresáři obsahu.

WebHost.CreateDefaultBuilderMetoda nastaví kořen obsahu na aktuální adresář:

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

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

Statické soubory jsou přístupné prostřednictvím cesty relativní k webovému kořenovému adresáři. Například šablona projektu webové aplikace obsahuje několik složek v rámci wwwroot složky:

• wwwroot
  • css
  • images
  • js

Formát identifikátoru URI pro přístup k souboru v podsložce obrázky je http:// <server_address> /images/ <image_file_name>. Příklad: http://localhost:9189/images/banner3.svg.

pokud cílíte .NET Framework, přidejte do projektu balíček Microsoft. AspNetCore. StaticFiles . Pokud cílíte na rozhraní .NET Core, Microsoft.AspNetCore.app Metapackage tento balíček zahrnuje.

Nakonfigurujte middleware, který umožňuje obsluhu statických souborů.

Obsluhovat soubory uvnitř webového kořenového adresáře

Vyvolat UseStaticFiles metodu v rámci Startup.Configure :

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

UseStaticFilesPřetížení metody bez parametrů označí soubory ve webovém kořenovém adresáři jako servé. Následující značky odkazují na wwwroot/images/banner1. SVG:

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

V předchozím kódu znak tildy ~/ ukazuje na kořenový adresář webu.

Obsluhovat soubory mimo web root

Vezměte v úvahu hierarchii adresářů, ve které se statické soubory budou obsluhovat mimo webový kořenový adresář:

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

Požadavek může získat přístup k souboru banner1. SVG nakonfigurováním middleware statického souboru následujícím způsobem:

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"
    });
}

V předchozím kódu se hierarchie adresáře MyStaticFiles zveřejňuje veřejně prostřednictvím segmentu URI StaticFiles . Požadavek na http:// <server_address> /StaticFiles/images/banner1.SVG obsluhuje soubor banner1. SVG .

Následující značky odkazují na MyStaticFiles/images/banner1. SVG:

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

Nastavit hlavičky HTTP odpovědi

StaticFileOptionsObjekt lze použít k nastavení hlaviček odpovědi HTTP. Kromě konfigurace statického souboru obsluha z webového kořenového adresářenastaví následující kód Cache-Control hlavičku:

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}");
        }
    });
}

Pokud chcete zobrazit komentáře ke kódu přeložené do jiných jazyků než angličtiny, dejte nám vědět v tomto problému diskuze na GitHubu.

HeaderDictionaryExtensions.AppendMetoda existuje v balíčku Microsoft. AspNetCore. http .

Soubory byly ve vývojovém prostředí veřejně uložené do mezipaměti po dobu 10 minut (600 sekund):

Autorizace statického souboru

Middleware statických souborů neposkytuje kontroly autorizace. Všechny soubory, které obsluhuje, včetně názvů wwwroot, jsou veřejně přístupné. Pro obsluhu souborů na základě autorizace:

• Uložte je mimo wwwroot a jakýkoliv adresář přístupný pro middleware statických souborů.

• Obsluhuje je pomocí metody akce, na které se autorizace používá. Vrátit FileResult objekt:

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

Povolit procházení adresářů

Procházení adresářů umožňuje uživatelům vaší webové aplikace zobrazit v zadaném adresáři výpis adresářů a soubory. Procházení adresářů je ve výchozím nastavení zakázáno z důvodů zabezpečení (viz téma informace). Povolit procházení adresářů vyvoláním UseDirectoryBrowser metody v 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"
    });
}

Přidejte požadované služby vyvoláním AddDirectoryBrowser metody z Startup.ConfigureServices :

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

Předchozí kód umožňuje procházení adresářů složky wwwroot/imagí pomocí adresy URL http:// <server_address> /MyImages s odkazy na jednotlivé soubory a složky:

Při povolování procházení si přečtěte informace o bezpečnostních rizicích.

Všimněte si dvou UseStaticFiles volání v následujícím příkladu. První volání povoluje obsluhu statických souborů ve složce wwwroot . Druhé volání umožňuje procházení adresářů složky wwwroot/imagí pomocí adresy 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"
    });
}

Slouží jako výchozí dokument.

Nastavení výchozí domovské stránky poskytuje návštěvníkům logický výchozí bod při návštěvě vašeho webu. Chcete-li obsloužit výchozí stránku bez toho, aby uživatel plně kvalifikován identifikátor URI, zavolejte UseDefaultFiles metodu z Startup.Configure :

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

S UseDefaultFiles , požadavky na hledání složky pro:

• default.htm
• default.html
• index.htm
• index.html

První soubor nalezený v seznamu se zobrazí, jako by požadavek byl plně kvalifikovaný identifikátor URI. Adresa URL prohlížeče bude dál odrážet požadovaný identifikátor URI.

Následující kód změní výchozí název souboru na 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();
}

UseFileServer

UseFileServer kombinuje funkce UseStaticFiles UseDefaultFiles , a volitelně UseDirectoryBrowser .

Následující kód povolí obsluhu statických souborů a výchozí soubor. Procházení adresářů není povolené.

app.UseFileServer();

Následující kód staví na přetížení bez parametrů povolením procházení adresářů:

app.UseFileServer(enableDirectoryBrowsing: true);

Zvažte následující hierarchii adresářů:

• wwwroot
  • Css
  • Obrázky
  • Js
• Soubory MyStaticFiles
  • Obrázky
    • banner1.svg
  • default.html

Následující kód povolí statické soubory, výchozí soubory a procházení adresářů 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
    });
}

AddDirectoryBrowser musí být volána, EnableDirectoryBrowsing když je hodnota vlastnosti true :

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

Pomocí hierarchie souborů a předchozího kódu se adresy URL překládaly takto:

Identifikátor URI	Odpověď
http:// <server_address> /StaticFiles/images/banner1.svg	MyStaticFiles/images/banner1.svg
http:// <server_address> /StaticFiles	MyStaticFiles/default.html

Pokud v adresáři MyStaticFiles neexistuje žádný soubor s výchozím názvem, http:// <server_address> /StaticFiles vrátí výpis adresáře s odkazy, na které můžete kliknout:

FileExtensionContentTypeProvider

Třída FileExtensionContentTypeProvider obsahuje vlastnost sloužící jako mapování přípon souborů na typy obsahu Mappings MIME. V následující ukázce je pro známé typy MIME registrováno několik přípon souborů. Rozšíření .rtf se nahradí a .mp4 odebere.

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"
    });
}

Viz Typy obsahu MIME.

Informace o použití vlastního nebo FileExtensionContentTypeProvider ke konfiguraci jiných v StaticFileOptions Blazor serverových aplikacích najdete v tématu BlazorASP.NET Core statické soubory .

Nestandardní typy obsahu

Middleware static file rozumí téměř 400 známým typům obsahu souborů. Pokud uživatel požádá o soubor s neznámým typem souboru, middleware statického souboru předá požadavek dalšímu middlewaru v kanálu. Pokud požadavek nezpracuje žádný middleware, vrátí se odpověď 404 Nenašlo se. Pokud je procházení adresářů povolené, zobrazí se odkaz na soubor ve výpisu adresáře.

Následující kód umožňuje obsluhu neznámých typů a vykreslí neznámý soubor jako obrázek:

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

S předchozím kódem se jako obrázek vrátí požadavek na soubor s neznámým typem obsahu.

Zobrazování souborů z více umístění

UseStaticFiles``UseFileServera výchozí hodnota je poskytovatel souborů odkazující na wwwroot. Můžete poskytnout další instance souborů a s dalšími poskytovateli souborů, kteří budou UseStaticFiles obsluhovat soubory z jiných UseFileServer umístění. Další informace najdete v tomto GitHub.

Požadavky

• Na adresy URL obsahu vystavené pomocí a se vztahují omezení rozlišování velkých a malých písmen a znaků UseDirectoryBrowser UseStaticFiles základního systému souborů. Například v Windows se v systémech macOS a Linux nerozlišovat malá — a velká písmena.

• ASP.NET Core aplikace hostované ve službě IIS používají modul ASP.NET Core k předávání všech požadavků do aplikace, včetně žádostí o statické soubory. Obslužná rutina statického souboru služby IIS se nepouží. Nemá žádnou šanci zpracovávat požadavky, než je modul zřídí.

• Pomocí následujících kroků ve Správci služby IIS odeberte obslužnou rutinu statických souborů služby IIS na úrovni serveru nebo webu:

  1. Přejděte na funkci Moduly.
  2. V seznamu vyberte StaticFileModule.
  3. Na bočním panelu Akce klikněte na Odebrat.

• Umístěte soubory kódu (včetně souborů .cs a .cshtml) mimo webový kořenový adresář projektu aplikace. Proto se vytvoří logické oddělení mezi obsahem aplikace na straně klienta a kódem založeným na serveru. Zabráníte tak úniku kódu na straně serveru.

Další zdroje informací

• Middleware
• Úvod do ASP.NET Core