Statische bestanden leveren in ASP.NET Core-apps

Als u statische bestandsafhandeling wilt inschakelen in ASP.NET Core, roept u aan MapStaticAssets.

Sla standaard statische bestanden op in de hoofdmap van het project. De standaardmap is {CONTENT ROOT}/wwwroot, waarbij de tijdelijke aanduiding de {CONTENT ROOT}hoofdmap van de inhoud van de app is. Alleen bestanden in de wwwroot map zijn adresseerbaar, dus u hoeft zich geen zorgen te maken over de rest van uw code.

Alleen bestanden met specifieke bestandsextensies die zijn toegewezen aan ondersteunde mediatypen, worden behandeld als statische webassets.

Statische webassets worden tijdens de build ontdekt en geoptimaliseerd met behulp van inhoud-gebaseerde vingerafdruktechniek om te voorkomen dat oude bestanden opnieuw worden gebruikt. Assets worden ook gecomprimeerd om de leveringstijd van assets te verminderen.

Tijdens runtime worden de gedetecteerde statische webassets weergegeven als eindpunten waarop HTTP-headers zijn toegepast, zoals cachingheaders en headers van inhoudstypen. Een asset wordt eenmalig geleverd totdat het bestand verandert of de browser zijn cache wist. De ETagkopteksten en Last-ModifiedContent-Type kopteksten zijn ingesteld. De browser kan geen verouderde assets gebruiken nadat een app is bijgewerkt.

Levering van statische assets is gebaseerd op eindpuntroutering, zodat het werkt met andere eindpuntbewuste functies, zoals autorisatie. Het is ontworpen om te werken met alle UI-frameworks, waaronder Blazor, Razor Pagina's en MVC.

Statische middelen in kaart brengen biedt de volgende voordelen:

• Bouwtijdcompressie voor alle assets in de app, inclusief JavaScript (JS) en stylesheets, maar exclusief afbeeldings- en lettertypeassets die al zijn gecomprimeerd. Gzip (Content-Encoding: gz) compressie wordt gebruikt tijdens de ontwikkeling. Gzip- en Brotli-compressieContent-Encoding: br () worden beide gebruikt tijdens het publiceren.
• Vingerafdruk voor alle assets tijdens de build met een met Base64 gecodeerde tekenreeks van de SHA-256-hash van de inhoud van elk bestand. Hierdoor wordt voorkomen dat een oude versie van een bestand opnieuw wordt gebruikt, zelfs als het oude bestand in de cache is opgeslagen. Vingerafdrukassets worden opgeslagen in de cache met behulp van de immutable instructie, waardoor de browser de asset nooit meer aanvraagt totdat deze wordt gewijzigd. Voor browsers die de immutable richtlijn niet ondersteunen, wordt er een max-age richtlijn toegevoegd.
  • Zelfs als een asset niet van een vingerafdruk wordt voorzien, wordt inhoud gebaseerd op ETags gegenereerd voor elke statische asset door de vingerafdruk-hash van het bestand te gebruiken als ETag waarde. Dit zorgt ervoor dat de browser alleen een bestand downloadt als de inhoud wordt gewijzigd (of het bestand voor het eerst wordt gedownload).
  • Het framework koppelt intern fysieke activa aan hun vingerafdrukken, zodat de app het volgende kan doen:
    • Automatisch gegenereerde assets zoeken, zoals Razor css met onderdeelbereik voor Blazorde CSS-isolatiefunctie en JS assets die worden beschreven door JS importkaarten.
    • Genereer koppelingstags in de <head> inhoud van de pagina om assets vooraf te laden.

De functie Map Static Assets biedt geen mogelijkheden voor minificatie of andere bestandstransformaties. Minification wordt meestal verwerkt door aangepaste code of hulpprogramma's van derden.

Als u statische bestandsafhandeling wilt inschakelen in ASP.NET Core, roept u aan UseStaticFiles.

Sla standaard statische bestanden op in de hoofdmap van het project. De standaardmap is {CONTENT ROOT}/wwwroot, waarbij de tijdelijke aanduiding de {CONTENT ROOT}hoofdmap van de inhoud van de app is. Alleen bestanden in de wwwroot map zijn adresseerbaar, dus u hoeft zich geen zorgen te maken over de rest van uw code.

Tijdens de runtime worden statische webassets door de middleware voor statische bestanden geleverd wanneer hierom wordt gevraagd, waarbij headers voor assetwijzigingen en inhoudstypen worden toegepast. De ETagkopteksten en Last-ModifiedContent-Type kopteksten zijn ingesteld.

Statische bestands-middleware maakt het verwerken van statische bestanden mogelijk en wordt gebruikt door een app wanneer UseStaticFiles deze wordt aangeroepen in de aanvraagverwerkingspijplijn van de app. Bestanden worden geserveerd vanaf het pad dat is opgegeven in IWebHostEnvironment.WebRootPath of WebRootFileProvider, waarbij de standaardinstelling de webrootmap is, meestal wwwroot.

Met de methode CreateBuilder wordt de inhoudsroot ingesteld op de huidige map.

var builder = WebApplication.CreateBuilder(args);

Met de methode CreateDefaultBuilder wordt de inhoudsroot ingesteld op de huidige map.

Host.CreateDefaultBuilder(args)

In de verwerkingspijplijn van aanvragen roept u na de aanroep van UseHttpsRedirectionMapStaticAssets aan om statische bestanden vanaf de webroot van de app beschikbaar te maken:

app.MapStaticAssets();

In de verwerkingspijplijn van aanvragen roept u na de aanroep van UseHttpsRedirectionUseStaticFiles aan om statische bestanden vanaf de webroot van de app beschikbaar te maken:

app.UseStaticFiles();

Kortsluiting van de middleware-pijplijn

Om te voorkomen dat de volledige middleware-pijplijn wordt uitgevoerd nadat een statische asset is gekoppeld, wat het gedrag is van UseStaticFiles, roept u ShortCircuit op MapStaticAssets aan. Het aanroepen ShortCircuit voert het eindpunt onmiddellijk uit en retourneert het antwoord, waardoor andere middleware niet kan worden uitgevoerd voor statische assetaanvragen:

app.MapStaticAssets().ShortCircuit();

Statische bestandscache beheren tijdens de ontwikkeling

Bij uitvoering in de Development omgeving, bijvoorbeeld tijdens het testen van de ontwikkeling van Visual Studio Hot Reload , overschrijft het framework cacheheaders om te voorkomen dat browsers statische bestanden in de cache opslaan. Dit gedrag helpt ervoor te zorgen dat de nieuwste versie van bestanden wordt gebruikt wanneer bestanden veranderen, waardoor problemen met verouderde inhoud worden voorkomen. In productie stelt het framework de juiste cacheheaders in, zodat browsers statische assets kunnen opslaan zoals verwacht.

Stel EnableStaticAssetsDevelopmentCaching in op true in het app-instellingenbestand van de Development omgeving (appsettings.Development.json) om dit gedrag uit te schakelen.

Bestanden buiten de hoofdmap van het web bedienen via IWebHostEnvironment.WebRootPath

Wanneer u instelt IWebHostEnvironment.WebRootPath op een andere map dan wwwroot, vertoont de app het volgende standaardgedrag:

• In de Development omgeving worden statische assets geleverd van wwwroot als assets met dezelfde naam zich in beide wwwroot en een andere map bevinden die is toegewezen aan WebRootPath.
• In een andere omgeving dan Development, worden dubbele statische assets geleverd vanuit de WebRootPath map.

Overweeg een web-app die is gemaakt op basis van de lege websjabloon:

• Bevat een Index.html bestand in wwwroot en wwwroot-custom.
• Het Program bestand wordt bijgewerkt om in te stellen WebRootPath = "wwwroot-custom".

var builder = WebApplication.CreateBuilder(new WebApplicationOptions
{
    Args = args,
    WebRootPath = "wwwroot-custom"
});

Standaard geldt het volgende voor aanvragen voor /:

• In de Development omgeving wordt wwwroot/Index.html geretourneerd.
• In elke andere omgeving dan Development wordt wwwroot-custom/Index.html geretourneerd.

Gebruik wwwroot-custom van de volgende methoden om ervoor te zorgen dat assets altijd worden geretourneerd:

• Dubbel genaamde assets verwijderen in wwwroot.

• Stel ASPNETCORE_ENVIRONMENT in Properties/launchSettings.json in op een andere waarde dan Development.

• Schakel statische webassets uit door <StaticWebAssetsEnabled> in te stellen op false in het projectbestand van de app. WAARSCHUWING: Als u statische webassets Razor uitschakelt, worden klassebibliotheken uitgeschakeld.

• Voeg de volgende XML toe aan het projectbestand:

  <ItemGroup>
    <Content Remove="wwwroot\**" />
  </ItemGroup>
  

De volgende code werkt WebRootPath bij naar een niet-ontwikkelingswaarde (Staging), zodat dubbele inhoud wordt geretourneerd vanuit wwwroot-custom in plaats van wwwroot.

var builder = WebApplication.CreateBuilder(new WebApplicationOptions
{
    Args = args,
    EnvironmentName = Environments.Staging,
    WebRootPath = "wwwroot-custom"
});

Tussenlaag voor statische bestanden

Middleware voor statische bestanden maakt het aanbieden van statische bestanden mogelijk in specifieke scenario’s voor statische bestanden, meestal als aanvulling op routeringsconventies voor Map Static Assets-eindpunten (MapStaticAssets).

Neem middleware voor statische bestanden op in de verwerking van aanvragen wanneer u UseStaticFiles aanroept in de aanvraagverwerkingspijplijn van de app, meestal nadat u de eindpuntconventies voor Map Static Assets (MapStaticAssets) hebt toegevoegd.

Gebruik eindpuntconventies voor het toewijzen van statische assets in apps die gericht zijn op .NET 9 of hoger. Gebruik statische bestands-middleware in apps die gericht zijn op versies van .NET vóór .NET 9.

Middleware voor statische bestanden verzorgt statische bestanden, maar biedt niet dezelfde mate van optimalisatie als de endpointconventies van Map Static Assets. De build-time compressie- en vingerafdrukfuncties van eindpuntconventies van Map Static Assets zijn niet beschikbaar wanneer u alleen afhankelijk bent van statische bestands-middleware.

De eindpuntconventies zijn geoptimaliseerd voor het leveren van assets die de app tijdens runtime kent. Als de app assets van andere locaties, zoals schijf- of ingesloten resources, bedient, gebruikt u statische bestands-middleware.

De volgende functies die in dit artikel worden behandeld, worden ondersteund met statische bestands-middleware, maar niet met de eindpuntconventies van Map Static Assets:

• Bestanden buiten de hoofdmap van het web verwerken
• HTTP-antwoordheaders instellen
• Het bedienen van bestanden vanaf schijf of ingesloten resources, of andere locaties
• Bladeren door mappen
• Standaarddocumenten leveren (met MapStaticAssets, vereist een aanroep naar UseStaticFiles)
• Statische bestanden, standaarddocumenten en bladeren in mappen combineren
• Bestandsextensies toewijzen aan MIME-typen
• Niet-standaardinhoudstypen leveren

De richtlijnen in deze sectie zijn van toepassing op Razor pagina's en MVC-apps. Zie Blazor Web Appvoor richtlijnen die van toepassing zijn op Blazors.

Houd rekening met de volgende markeringen waarmee een bedrijfslogo wordt weergegeven:

<img src="~/logo.png" asp-append-version="true" alt="Company logo">

De ontwikkelaar wil de Image Tag Helper gebruiken om een versie toe te voegen en het bestand vanaf een aangepaste locatie, een map met de naam ExtraStaticFiles, toe te voegen.

In het volgende voorbeeld wordt MapStaticAssets aangeroepen om bestanden van wwwroot en UseStaticFiles om bestanden te serveren vanaf ExtraStaticFiles.

In de aanvraagverwerkingspijplijn, na de bestaande aanroep naar MapStaticAssets (.NET 9 of hoger) of UseStaticFiles (.NET 8 of eerder):

app.UseStaticFiles(new StaticFileOptions
{
    FileProvider = new PhysicalFileProvider(
        Path.Combine(builder.Environment.ContentRootPath, "ExtraStaticFiles"))
});

In het volgende voorbeeld wordt UseStaticFiles twee keer aangeroepen, om bestanden van zowel wwwroot als ExtraStaticFiles te serveren.

In de aanvraagverwerkingspijplijn na de bestaande aanroep naar UseStaticFiles:

app.UseStaticFiles(new StaticFileOptions
{
    FileProvider = new PhysicalFileProvider(
        Path.Combine(builder.Environment.ContentRootPath, "ExtraStaticFiles"))
});

Met behulp van de voorgaande code wordt het ExtraStaticFiles/logo.png bestand weergegeven. De Tag Helper (AppendVersion) voor afbeeldingen wordt echter niet toegepast omdat de Tag Helper afhankelijk is van WebRootFileProvider, die niet is bijgewerkt om de ExtraStaticFiles map op te nemen.

Met de volgende code wordt de WebRootFileProvider bijgewerkt om de map ExtraStaticFiles op te nemen, met behulp van een CompositeFileProvider. Hierdoor kan de Tag Helper voor afbeeldingen een versie toepassen op afbeeldingen in de ExtraStaticFiles map.

Naamruimte voor de volgende API:

using Microsoft.Extensions.FileProviders;

In de aanvraagverwerkingspijplijn vóór de bestaande aanroep naar MapStaticAssets (.NET 9 of hoger) of UseStaticFiles (.NET 8 of eerder):

var webRootProvider = new PhysicalFileProvider(builder.Environment.WebRootPath);
var newPathProvider = new PhysicalFileProvider(
    Path.Combine(builder.Environment.ContentRootPath, "ExtraStaticFiles"));

var compositeProvider = new CompositeFileProvider(webRootProvider, newPathProvider);

app.Environment.WebRootFileProvider = compositeProvider;

Manifest voor statische assets

MapStaticAssets levert assets vanuit een statische-assetsmanifest in plaats van tijdens runtime de webroot te scannen. Het manifest wordt gegenereerd tijdens het bouwen en publiceren en registreert de statische webassets die voor de app zijn gedetecteerd, samen met metagegevens zoals inhoudsafdrukken, headers, Content-Type cachingheaders en de vooraf samengestelde gecomprimeerde weergaven (Gzip en Brotli). Tijdens runtime leest MapStaticAssets het manifest, registreert het een eindpunt voor elke asset en levert het de geoptimaliseerde responses.

Het buildproces genereert het manifest in de build-uitvoermap. De bestandsnaam is gebaseerd op de assemblynaam van het project (bijvoorbeeld, {ASSEMBLY NAME}.staticwebassets.endpoints.jsonwaarbij de tijdelijke aanduiding de {ASSEMBLY NAME} MSBuild-waarde AssemblyName van de app is). Als u een manifest vanaf een andere locatie wilt opgeven, raadpleegt u de sectie Een aangepast statisch bestandsmanifest opgeven .

Omdat MapStaticAssets alleen bestanden aanbiedt die in het manifest worden vermeld, biedt het geen bestanden aan die geen deel uitmaken van het manifest. Bestanden maken geen deel uit van het manifest wanneer dit het volgende is:

• Bevindt zich buiten de webroot tijdens het bouwen, zoals bestanden die vanaf schijf worden aangeboden, ingesloten bronnen of een aangepaste WebRootPath die tijdens runtime is ingesteld.
• Uitgesloten van het manifest met de MSBuild-eigenschap StaticWebAssetEndpointExclusionPattern (zie de sectie Grote verzameling assets).

Als u bestanden wilt serveren die zich niet in het manifest bevinden, roept u UseStaticFiles aan, waarmee bestanden tijdens runtime rechtstreeks vanuit de webroot worden aangeboden. Dit is ook de reden waarom het serveren van standaarddocumenten met MapStaticAssets een aanroep van UseStaticFiles vereist.

Build-gegenereerde bestanden integreren in statische webassets

Bouwhulpprogramma's, zoals TypeScript-compilers en JavaScript-bundelaars, produceren vaak bestanden tijdens de build. Als u deze gegenereerde bestanden wilt serveren met de fingerprinting, compressie en caching die MapStaticAssets biedt, moeten de bestanden tijdens de build worden herkend als statische webassets. Gegenereerde bestanden worden meestal buiten de webhoofdmap (wwwroot) bewaard en uitgesloten van broncodebeheer, zodat ze niet standaard worden gedetecteerd als statische webassets. Alleen bestanden die, wanneer statische webassets tijdens de build worden verwerkt, worden vastgesteld als vallend onder wwwroot, worden toegevoegd aan het manifest voor statische assets en aangeboden door MapStaticAssets. Bestanden die zijn gekoppeld aan wwwroot (bijvoorbeeld met een <Content>-item en een Link) worden ook meegenomen, zelfs wanneer het bronbestand buiten wwwroot wordt opgeslagen.

Als u build-gegenereerde bestanden wilt opnemen als statische webassets, gebruikt u een van de volgende benaderingen.

Gegenereerde bestanden koppelen aan de hoofdmap van het web

Voeg een <Content> item toe met een Link bestand dat elk gegenereerd bestand onder wwwrootplaatst. Een bestand dat is gekoppeld aan wwwroot wordt gedetecteerd door de pijplijn voor statische webactiva en door MapStaticAssets aangeboden met fingerprinting, compressie en caching, ook al wordt het bronbestand buiten wwwroot opgeslagen.

In het volgende voorbeeld genereert een buildstap generated in een main.js-map, en het item <Content> koppelt het bestand aan wwwroot:

<ItemGroup>
  <Content Include="generated\main.js" Link="wwwroot\main.js"
    CopyToOutputDirectory="PreserveNewest" />
</ItemGroup>

Het gegenereerde bestand moet bestaan wanneer het buildproces statische webassets oplost.

Een JavaScript-project gebruiken voor complexe build-pijplijnen

Voor een complexe JavaScript- of TypeScript-clientbuild gebruikt u een afzonderlijk JavaScript-project waarmee de clientassets worden gebouwd met het JavaScript-projectsysteem (de Microsoft.VisualStudio.JavaScript.Sdk MSBuild SDK en een .esproj projectbestand). Neem in de ASP.NET Core-app een verwijzing op naar het JavaScript-project, zodat de uitvoer ervan wordt gebruikt als statische webassets. Zie het Microsoft.FluentUI.AspNetCore.Components.Assets.esproj projectbestand (microsoft/fluentui-blazorGitHub opslagplaats) voor een voorbeeld.

Wanneer een app een terugvalautorisatiebeleid gebruikt, is autorisatie vereist voor aanvragen die worden verwerkt door autorisatie-middleware wanneer er geen beleid wordt geproduceerd op basis van autorisatiemetagegevens. Deze vereiste omvat aanvragen voor statische assets die zijn toegewezen als eindpunten. Als u anonieme toegang tot statische bestanden wilt toestaan, past u AllowAnonymousAttribute toe op de eindpuntbouwer:

app.MapStaticAssets().Add(endpointBuilder =>
    endpointBuilder.Metadata.Add(new AllowAnonymousAttribute()));

Wanneer een app een terugvalautorisatiebeleid gebruikt, is autorisatie vereist voor aanvragen die worden verwerkt door autorisatie-middleware wanneer er geen beleid wordt geproduceerd op basis van autorisatiemetagegevens. De ASP.NET Core-sjablonen bieden anonieme toegang tot statische bestanden door UseStaticFiles aan te roepen voordat UseAuthorization wordt aangeroepen. De meeste apps volgen dit patroon. Wanneer de statische bestands-middleware wordt aangeroepen vóór de autorisatie-middleware:

• Er worden geen autorisatiecontroles uitgevoerd op de statische bestanden.
• Statische bestanden die worden aangeboden door de middleware voor statische bestanden, zoals bestanden in de webroot (meestal wwwroot), zijn openbaar toegankelijk.

Naamruimten voor de volgende API:

using Microsoft.AspNetCore.Authorization;
using Microsoft.Extensions.FileProviders;

Serviceregistratie:

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

In de aanvraagverwerkingspijplijn na de aanroep naar UseAuthorization:

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

Naamruimten voor de volgende API:

using Microsoft.AspNetCore.Authorization;
using Microsoft.Extensions.FileProviders;

In Startup.ConfigureServices:

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

In Startup.Configure na de oproep naar UseAuthorization:

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

Naamruimten voor de volgende API:

using Microsoft.AspNetCore.StaticFiles;
using Microsoft.Extensions.FileProviders;

Serviceregistratie:

builder.Services.AddDirectoryBrowser();

In de aanvraagverwerkingspijplijn, na de bestaande aanroep naar MapStaticAssets (.NET 9 of hoger) of UseStaticFiles (.NET 8 of eerder):

var fileProvider = new PhysicalFileProvider(
    Path.Combine(builder.Environment.WebRootPath, "images"));
var requestPath = "/DirectoryImages";

app.UseStaticFiles(new StaticFileOptions
{
    FileProvider = fileProvider,
    RequestPath = requestPath
});

app.UseDirectoryBrowser(new DirectoryBrowserOptions
{
    FileProvider = fileProvider,
    RequestPath = requestPath
});

Naamruimten voor de volgende API:

using Microsoft.Extensions.FileProviders;
using System.IO;

In Startup.ConfigureServices:

services.AddDirectoryBrowser();

Na de bestaande aanroep naar Startup.Configure, plaats UseStaticFiles:

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

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

AddDirectoryBrowser voegt services toe die vereist zijn voor de middleware voor het bladeren door mappen, waaronder HtmlEncoder. Deze services kunnen via andere aanroepen worden toegevoegd, zoals AddRazorPages, maar roep AddDirectoryBrowser aan om er zeker van te zijn dat de services worden toegevoegd.

Omdat MapStaticAssets assets die tijdens het buildproces worden ontdekt via eindpuntroutering aanbiedt, biedt het op zichzelf geen standaarddocumenten aan. Aanroep UseDefaultFiles om de aanvraag opnieuw te schrijven, gevolgd door UseStaticFiles de herschreven aanvraag voor het standaarddocument te verwerken:

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

In de aanvraagverwerkingspijplijn vóór de bestaande aanroep naar UseStaticFiles:

app.UseDefaultFiles();

Serviceregistratie:

builder.Services.AddDirectoryBrowser();

In de aanvraagverwerkingspijplijn na de bestaande aanroep naar UseStaticFiles:

app.UseFileServer(enableDirectoryBrowsing: true);

In Startup.ConfigureServices:

services.AddDirectoryBrowser();

Na de bestaande aanroep naar Startup.Configure, plaats UseStaticFiles:

app.UseFileServer(enableDirectoryBrowsing: true);

Naamruimten voor de volgende API:

using Microsoft.Extensions.FileProviders;

Serviceregistratie:

builder.Services.AddDirectoryBrowser();

In de aanvraagverwerkingspijplijn na de bestaande aanroep naar UseStaticFiles:

app.UseFileServer(new FileServerOptions
{
    FileProvider = new PhysicalFileProvider(
        Path.Combine(builder.Environment.ContentRootPath, "ExtraStaticFiles")),
    RequestPath = "/static-files",
    EnableDirectoryBrowsing = true
});

Naamruimten voor de volgende API:

using Microsoft.Extensions.FileProviders;
using System.IO;

In Startup.ConfigureServices:

services.AddDirectoryBrowser();

Na de bestaande aanroep naar Startup.Configure, plaats UseStaticFiles:

app.UseFileServer(new FileServerOptions
{
    FileProvider = new PhysicalFileProvider(
        Path.Combine(env.ContentRootPath, "ExtraStaticFiles")),
    RequestPath = "/static-files",
    EnableDirectoryBrowsing = true
});

using Microsoft.AspNetCore.StaticFiles;
using Microsoft.Extensions.FileProviders;

...

// 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
{
    ContentTypeProvider = provider
});

Wanneer u verschillende opties voor statische bestanden hebt om te configureren, kunt u de provider ook instellen met behulp van StaticFileOptions:

var provider = new FileExtensionContentTypeProvider();

...

builder.Services.Configure<StaticFileOptions>(options =>
{
    options.ContentTypeProvider = provider;
});

app.UseStaticFiles();

In Startup.Configure:

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 = "/images",
    ContentTypeProvider = provider
});

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

Een aangepast manifest voor statische bestanden opgeven

Als staticAssetsManifestPathnull is, wordt IHostEnvironment.ApplicationName gebruikt om het manifest te vinden. U kunt ook een volledig pad naar het manifestbestand opgeven. Als u een relatief pad gebruikt, zoekt het framework naar het bestand in de AppContext.BaseDirectory.

MSBuild-eigenschappen

In de volgende tabellen worden de eigenschappen en metagegevens van MSBuild voor statische bestanden weergegeven.

In het volgende voorbeeld worden JavaScript-bestanden uitgesloten van compressie:

<PropertyGroup>
  <CompressionExcludePatterns>$(CompressionExcludePatterns);**\*.js</CompressionExcludePatterns>
</PropertyGroup>

Compressie van statische assets volledig uitschakelen:

<PropertyGroup>
  <CompressionEnabled>false</CompressionEnabled>
</PropertyGroup>

Beschrijvingen van metagegevens:

• Pattern: Een globpatroon dat wordt gebruikt om bestanden te vinden. Voor StaticWebAssetContentTypeMapping, komt het overeen met bestanden om hun inhoudstype te bepalen (bijvoorbeeld *.js voor JavaScript-bestanden). Voor StaticWebAssetFingerprintPattern, identificeert het bestanden met meerdere extensies die speciale vingerafdrukbehandeling vereisen (bijvoorbeeld *.lib.module.js).

• Cache: Hiermee geeft u de Cache-Control headerwaarde voor het overeenkomende inhoudstype op. Deze waarde bepaalt het cachegedrag van de browser (bijvoorbeeld max-age=3600, must-revalidate voor mediabestanden).

• Priority: Bepaalt de prioriteit wanneer meerdere StaticWebAssetContentTypeMapping items overeenkomen met hetzelfde bestand. Hogere numerieke waarden hebben voorrang op lagere waarden. Priority is vereist.

• Expression: Hiermee definieert u hoe de vingerafdruk in de bestandsnaam wordt ingevoegd. De standaardwaarde is #[.{FINGERPRINT}], waarmee de vingerafdruk ({FINGERPRINT} tijdelijke aanduiding) vóór de extensie wordt ingevoegd.

In het volgende voorbeeld wordt het bitmap-patroon (.bmp) toegewezen aan het image/bmp inhoudstype met de {CACHE HEADER} placeholder voor de Cache-Control header die moet worden gebruikt voor eindpunten zonder vingerafdruk.

<ItemGroup>
  <StaticWebAssetContentTypeMapping Include="image/bmp" Cache="{CACHE HEADER}"
    Pattern="*.bmp" Priority="1" />
</ItemGroup>

Runtime-configuratieopties

In de volgende tabel worden de runtimeconfiguratieopties beschreven.