Delen via

Statische bestanden in ASP.NET Core

Note

Dit is niet de nieuwste versie van dit artikel. Zie de .NET 9-versie van dit artikelvoor de huidige release.

Warning

Deze versie van ASP.NET Core wordt niet meer ondersteund. Zie de .NET- en .NET Core-ondersteuningsbeleidvoor meer informatie. Zie de .NET 9-versie van dit artikelvoor de huidige release.

Important

Deze informatie heeft betrekking op een pre-releaseproduct dat aanzienlijk kan worden gewijzigd voordat het commercieel wordt uitgebracht. Microsoft geeft geen garanties, uitdrukkelijk of impliciet, met betrekking tot de informatie die hier wordt verstrekt.

Zie de .NET 9-versie van dit artikelvoor de huidige release.

Statische bestanden, ook wel statische assets genoemd, zijn bestanden die een ASP.NET Core-app zijn die niet dynamisch worden gegenereerd. In plaats daarvan worden ze rechtstreeks aan clients aangeboden op aanvraag, zoals HTML-, CSS-, afbeeldings- en JavaScript-bestanden.

Zie voor Blazor richtlijnen voor statische bestanden, die de richtlijnen in dit artikel aanvullen of vervangen, ASP.NET Core Blazor statische bestanden.

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

Statische bestanden worden standaard opgeslagen 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.

Statische bestanden worden standaard opgeslagen 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 uitvoeringstijd worden statische webassets geretourneerd door Static File Middleware wanneer deze worden opgevraagd met toegepaste headers voor assetwijziging en inhoudstype. De ETagkopteksten en Last-ModifiedContent-Type kopteksten zijn ingesteld.

Statische bestandmiddleware maakt het mogelijk om statische bestanden te leveren en wordt door een app gebruikt wanneer deze UseStaticFiles wordt aangeroepen in de verwerkingspijplijn voor aanvragen 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.

U kunt ook statische webassets leveren vanuit projecten en pakketten waarnaar wordt verwezen.

De hoofdmap van het web wijzigen

Gebruik de UseWebRoot methode als u de webroot wilt wijzigen. Zie ASP.NET Overzicht van basisbeginselen van Core voor meer informatie.

Voorkom dat bestanden in wwwroot worden gepubliceerd met het <Content> projectitem in het projectbestand. In het volgende voorbeeld wordt voorkomen dat inhoud wordt gepubliceerd in wwwroot/local en de bijbehorende submappen:

<ItemGroup>
  <Content Update="wwwroot\local\**\*.*" CopyToPublishDirectory="Never" />
</ItemGroup>

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)

Roep in de aanvraagverwerkingspijplijn van de app na de aanroep UseHttpsRedirection naar MapStaticAssets om het verwerken van statische bestanden vanuit de webhoofdmap van de app mogelijk te maken.

app.MapStaticAssets();

Roep in de aanvraagverwerkingspijplijn van de app na de aanroep UseHttpsRedirection naar UseStaticFiles om het verwerken van statische bestanden vanuit de webhoofdmap van de app mogelijk te maken.

app.UseStaticFiles();

Statische bestanden zijn toegankelijk via een pad relatief aan de webhoofdmap.

Toegang krijgen tot een afbeelding op wwwroot/images/favicon.png:

  • URL-indeling: https://{HOST}/images/{FILE NAME}
    • De {HOST} plaatsaanduiding is de host.
    • De {FILE NAME} tijdelijke aanduiding is de bestandsnaam.
  • Voorbeelden
    • Absolute URL: https://localhost:5001/images/favicon.png
    • Relatieve hoofd-URL: images/favicon.png

In een Blazor-app laadt images/favicon.png de pictogramafbeelding (favicon.png) uit de wwwroot/images-map van de app.

<link rel="icon" type="image/png" href="images/favicon.png" />

In Razor pagina's en MVC-apps verwijst het tilde-teken ~ naar de webroot. In het volgende voorbeeld wordt de pictogramafbeelding (~/images/favicon.png) uit de favicon.png map van de app geladen:

<link rel="icon" type="image/png" href="~/images/favicon.png" />

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 ontwikkelomgeving, 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 helpt ervoor te zorgen dat de nieuwste versie van bestanden wordt gebruikt wanneer bestanden veranderen, waardoor problemen met verouderde inhoud worden voorkomen. In productie worden de juiste cacheheaders ingesteld, zodat browsers statische assets kunnen opslaan zoals verwacht.

Als u dit gedrag wilt uitschakelen, stelt u EnableStaticAssetsDevelopmentCaching in op true in het instellingenbestand van de ontwikkelomgeving (appsettings.Development.json).

Statische bestanden in niet-Development omgevingen

Wanneer u een app lokaal uitvoert, worden statische webassets alleen ingeschakeld in de ontwikkelomgeving. Als u statische bestanden wilt inschakelen voor andere omgevingen dan Ontwikkeling tijdens lokale ontwikkeling en testen (bijvoorbeeld in de Staging-omgeving), roept u UseStaticWebAssets aan op WebApplicationBuilder.

Warning

Roep UseStaticWebAssets de exacte omgeving aan om te voorkomen dat de functie in productie wordt geactiveerd, omdat deze bestanden vanaf afzonderlijke locaties op een andere schijf dan het project dient. In het voorbeeld in deze sectie wordt gecontroleerd op de faseringsomgeving met IsStaging.

if (builder.Environment.IsStaging())
{
    builder.WebHost.UseStaticWebAssets();
}

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

Wanneer IWebHostEnvironment.WebRootPath is ingesteld naar een andere map dan wwwroot, worden de volgende standaard gedragingen getoond.

  • In de ontwikkelomgeving 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 ontwikkeling 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 ontwikkelomgeving wordt wwwroot/Index.html geretourneerd.
  • In een andere omgeving dan de ontwikkelomgeving 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"
});

Statische bestands-middleware

Statische bestands-middleware maakt het mogelijk om statische bestanden te verwerken in specifieke scenario's voor statische bestanden, meestal naast routeringsconventies voor statische assets-eindpunten (MapStaticAssets).

Static File Middleware wordt opgenomen in de verwerking van verzoeken wanneer UseStaticFiles wordt aangeroepen in de pijplijn voor het verwerken van verzoeken van de app, meestal nadat eindpuntconventies voor Map Static Assets (MapStaticAssets) zijn toegevoegd.

Eindpuntconventies voor statische assets worden gebruikt in apps die zijn gericht op .NET 9 of hoger. Statische bestands-middleware moet worden gebruikt in apps die gericht zijn op versies van .NET vóór .NET 9.

Static File Middleware dient statische bestanden, maar biedt niet hetzelfde optimalisatieniveau als de conventies van de Map Static Assets-eindpunten. De functies voor build-tijdcompressie en vingerafdruk van eindpuntconventies van Map Static Assets zijn niet beschikbaar wanneer ze alleen afhankelijk zijn van Static File Middleware.

De eindpuntconventies zijn geoptimaliseerd voor het leveren van assets waarvan de app kennis heeft tijdens runtime. Als de app assets van andere locaties bedient, zoals schijf- of ingesloten resources, moet Static File Middleware worden gebruikt.

De volgende functies die in dit artikel worden behandeld, worden ondersteund met Static File Middleware, maar niet met de eindpuntconventies van Map Static Assets.

Bestanden buiten de hoofdmap van het web bedienen via UseStaticFiles

Overweeg de volgende maphiërarchie met statische bestanden die zich buiten de webhoofdmap van de app bevinden in een map met de naam ExtraStaticFiles:

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

Een verzoek kan red-rose.jpg toegang krijgen door een nieuw exemplaar van Static File Middleware te configureren.

Naamruimten voor de volgende API:

using Microsoft.Extensions.FileProviders;

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")),
    RequestPath = "/static-files"
});

In de voorgaande code wordt de ExtraStaticFiles adreslijsthiërarchie openbaar weergegeven via het static-files URL-segment. Een verzoek aan https://{HOST}/StaticFiles/images/red-rose.jpg, waarbij de tijdelijke aanduiding {HOST} de host is, levert het red-rose.jpg bestand op.

De volgende markeringen verwijzen ExtraStaticFiles/images/red-rose.jpg:

<img src="static-files/images/red-rose.jpg" alt="A red rose" />

In het voorgaande voorbeeld wordt tilde-slash-notatie ondersteund in Razor pagina's en MVC-weergaven (src="~/StaticFiles/images/red-rose.jpg"), niet voor Razor onderdelen in Blazor apps.

Bestanden vanaf meerdere locaties 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;

UseStaticFiles en UseFileServer verwijzen standaard naar de bestandsprovider die naar wwwrootwijst. Extra exemplaren van UseStaticFiles en UseFileServer kunnen worden geleverd met andere bestandsproviders om bestanden van andere locaties te verwerken. Zie UseStaticFiles nog steeds nodig met UseFileServer voor wwwroot (dotnet/AspNetCore.Docs #15578) voor meer informatie.

HTTP-antwoordheaders instellen

Gebruik StaticFileOptions om HTTP-antwoordheaders in te stellen. Naast het configureren van Static File Middleware voor statische bestanden, stelt de volgende code de Cache-Control header in op 604.800 seconden (één week).

Naamruimten voor de volgende API:

using Microsoft.AspNetCore.Http;

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

app.UseStaticFiles(new StaticFileOptions
{
    OnPrepareResponse = ctx =>
    {
        ctx.Context.Response.Headers.Append(
            "Cache-Control", "public, max-age=604800");
    }
});

Grote verzameling middelen

Wanneer u te maken hebt met grote verzamelingen activa, die als ongeveer 1000 of meer activa worden beschouwd, raden we u aan een bundelaar te gebruiken om het uiteindelijke aantal activa te verminderen dat door de app wordt geleverd of om te combineren MapStaticAssets met UseStaticFiles.

MapStaticAssets laadt gretig de vooraf berekende metagegevens die tijdens het buildproces voor de resources zijn vastgelegd om compressie, caching en vingerafdruk te ondersteunen. Deze functies zijn de kosten van meer geheugengebruik door de app. Voor assets die vaak worden gebruikt, zijn de kosten meestal de moeite waard. Voor assets die niet vaak worden gebruikt, zijn de kosten mogelijk niet de moeite waard.

Als u geen bundeling gebruikt, raden we u aan om te combineren MapStaticAssets met UseStaticFiles. In het volgende voorbeeld ziet u de benadering.

In het projectbestand (.csproj) wordt de StaticWebAssetEndpointExclusionPattern eigenschap MSBuild gebruikt om eindpunten uit het uiteindelijke manifest voor MapStaticAssetste filteren. Uitgesloten bestanden worden geleverd door UseStaticFiles en profiteren niet van compressie, caching en vingerafdruk.

Wanneer u de waarde instelt StaticWebAssetEndpointExclusionPattern, moet u het $(StaticWebAssetEndpointExclusionPattern) standaarduitsluitingspatroon van het framework behouden. Voeg extra patronen toe in een door puntkomma's gescheiden lijst.

In het volgende voorbeeld voegt het uitsluitingspatroon de statische bestanden in de lib/icons map toe, die een hypothetische batch pictogrammen vertegenwoordigt.

<StaticWebAssetEndpointExclusionPattern>
  $(StaticWebAssetEndpointExclusionPattern);lib/icons/**
</StaticWebAssetEndpointExclusionPattern>

Na verwerking van HTTPS Redirection Middleware (app.UseHttpsRedirection();) in het Program bestand:

app.UseStaticFiles();

app.UseAuthorization();

app.MapStaticAssets();

Autorisatie van statische bestanden

Wanneer een app een terugvalautorisatiebeleid accepteert, is autorisatie vereist voor alle aanvragen die niet expliciet een autorisatiebeleid opgeven, inclusief aanvragen voor statische bestanden nadat Autorisatie Middleware aanvragen verwerkt. Anonieme toegang tot statische bestanden toestaan door AllowAnonymousAttribute toe te passen op de builder voor eindpunten voor statische bestanden.

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

Wanneer een app een terugvalautorisatiebeleid accepteert, is autorisatie vereist voor alle aanvragen die niet expliciet een autorisatiebeleid opgeven, inclusief aanvragen voor statische bestanden nadat Autorisatie Middleware aanvragen verwerkt. 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 Static File Middleware wordt aangeroepen vóór de autorisatie-middleware:

  • Er worden geen autorisatiecontroles uitgevoerd op de statische bestanden.
  • Statische bestanden die worden geserveerd door de Static File Middleware, zoals de webroot (meestal wwwroot), zijn openbaar toegankelijk.

Statische bestanden verwerken op basis van autorisatie:

  • Controleer of in de app het autorisatiebeleid voor terugval is ingesteld om geverifieerde gebruikers te vereisen.
  • Sla het statische bestand buiten de webhoofdmap van de app op.
  • Na het aanroepen van UseAuthorization, voert u UseStaticFiles uit, waarbij u het pad naar de map met statische bestanden buiten de webroot specificeert.

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, "SecureStaticFiles")),
    RequestPath = "/static-files"
});

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, "SecureStaticFiles")),
    RequestPath = "/static-files"
});

In de voorgaande code vereist het autorisatiebeleid voor terugval geverifieerde gebruikers. Eindpunten, zoals controllers en Razor Pagina's, die hun eigen autorisatievereisten opgeven, maken geen gebruik van het terugvalautorisatiebeleid. Zo gebruiken Razor pagina's, controllers of actiemethoden met [AllowAnonymous] of [Authorize(PolicyName="MyPolicy")] het toegepaste autorisatiekenmerk in plaats van het autorisatiebeleid voor terugval.

RequireAuthenticatedUser voegt DenyAnonymousAuthorizationRequirement toe aan het huidige exemplaar, waardoor de huidige gebruiker wordt geverifieerd.

Statische assets die zijn opgeslagen in de webhoofdmap van de app, zijn openbaar toegankelijk omdat de standaard Static File Middleware (UseStaticFiles) eerder UseAuthorizationwordt aangeroepen. Voor statische assets in de SecureStaticFiles map is verificatie vereist.

Een alternatieve benadering voor het verwerken van bestanden op basis van autorisatie is het volgende:

  • Sla de bestanden op buiten de hoofdmap van het web en elke map die toegankelijk is voor Static File Middleware.
  • Serveer de bestanden via een actiemethode waarop autorisatie wordt toegepast en retourneer een FileResult object.

Vanaf een Razor pagina (Pages/BannerImage.cshtml.cs):

public class BannerImageModel : PageModel
{
    private readonly IWebHostEnvironment _env;

    public BannerImageModel(IWebHostEnvironment env) => _env = env;

    public PhysicalFileResult OnGet()
    {
        var filePath = Path.Combine(
            _env.ContentRootPath, "SecureStaticFiles", "images", "red-rose.jpg");

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

Vanaf een controller (Controllers/HomeController.cs):

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

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

Voor de voorgaande benadering is een pagina of eindpunt per bestand vereist.

Het volgende voorbeeld van een route-eindpunt retourneert bestanden voor geverifieerde gebruikers.

In het bestand Program:

builder.Services.AddAuthorization(options =>
{
    options.AddPolicy("AuthenticatedUsers", b => b.RequireAuthenticatedUser());
});

...

app.MapGet("/files/{fileName}", IResult (string fileName) => 
{
    var filePath = GetOrCreateFilePath(fileName);

    if (File.Exists(filePath))
    {
        return TypedResults.PhysicalFile(filePath, fileName);
    }

    return TypedResults.NotFound("No file found with the supplied file name");
})
.WithName("GetFileByName")
.RequireAuthorization("AuthenticatedUsers");

In het volgende route-eindpunt worden bestanden geüpload voor geverifieerde gebruikers in de beheerdersrol ("admin").

In het bestand Program:

builder.Services.AddAuthorization(options =>
{
    options.AddPolicy("AdminsOnly", b => b.RequireRole("admin"));
});

...

// IFormFile uses memory buffer for uploading. For handling large 
// files, use streaming instead. See the *File uploads* article
// in the ASP.NET Core documentation:
// https://free.blessedness.top/aspnet/core/mvc/models/file-uploads
app.MapPost("/files", async (IFormFile file, LinkGenerator linker, 
    HttpContext context) =>
{
    // Don't rely on the value in 'file.FileName', as it's only metadata that can 
    // be manipulated by the end-user. Consider the 'Utilities.IsFileValid' method 
    // that takes an 'IFormFile' and validates its signature within the 
    // 'AllowedFileSignatures'.

    var fileSaveName = Guid.NewGuid().ToString("N") + 
        Path.GetExtension(file.FileName);
    await SaveFileWithCustomFileName(file, fileSaveName);

    context.Response.Headers.Append("Location", linker.GetPathByName(context, 
        "GetFileByName", new { fileName = fileSaveName}));

    return TypedResults.Ok("File Uploaded Successfully!");
})
.RequireAuthorization("AdminsOnly");

In Startup.ConfigureServices:

services.AddAuthorization(options =>
{
    options.AddPolicy("AuthenticatedUsers", b => b.RequireAuthenticatedUser());
});

In Startup.Configure:

app.MapGet("/files/{fileName}", IResult (string fileName) => 
{
    var filePath = GetOrCreateFilePath(fileName);

    if (File.Exists(filePath))
    {
        return TypedResults.PhysicalFile(filePath, fileName);
    }

    return TypedResults.NotFound("No file found with the supplied file name");
})
.WithName("GetFileByName")
.RequireAuthorization("AuthenticatedUsers");

Met de volgende code worden bestanden geüpload voor geverifieerde gebruikers in de beheerdersrol ("admin").

In Startup.ConfigureServices:

services.AddAuthorization(options =>
{
    options.AddPolicy("AdminsOnly", b => b.RequireRole("admin"));
});

In Startup.Configure:

// IFormFile uses memory buffer for uploading. For handling large 
// files, use streaming instead. See the *File uploads* article
// in the ASP.NET Core documentation:
// https://free.blessedness.top/aspnet/core/mvc/models/file-uploads
app.MapPost("/files", async (IFormFile file, LinkGenerator linker, 
    HttpContext context) =>
{
    // Don't rely on the value in 'file.FileName', as it's only metadata that can 
    // be manipulated by the end-user. Consider the 'Utilities.IsFileValid' method 
    // that takes an 'IFormFile' and validates its signature within the 
    // 'AllowedFileSignatures'.

    var fileSaveName = Guid.NewGuid().ToString("N") + 
        Path.GetExtension(file.FileName);
    await SaveFileWithCustomFileName(file, fileSaveName);

    context.Response.Headers.Append("Location", linker.GetPathByName(context, 
        "GetFileByName", new { fileName = fileSaveName}));

    return TypedResults.Ok("File Uploaded Successfully!");
})
.RequireAuthorization("AdminsOnly");

Bladeren door mappen

Het bladeren door directories staat de weergave van directory-inhoud binnen opgegeven directories toe.

Bladeren door mappen is standaard uitgeschakeld om veiligheidsredenen. Zie Beveiligingsoverwegingen voor statische bestandenvoor meer informatie.

Schakel directory-bladeren in met de volgende API:

In het volgende voorbeeld:

  • Een images map in de rootmap van de app bevat afbeeldingen voor mappenoverzicht.
  • Het aanvraagpad om door de afbeeldingen te bladeren is /DirectoryImages.
  • Door UseStaticFiles aan te roepen en FileProvider in te stellen, wordt StaticFileOptions ingeschakeld om browserlinks naar de afzonderlijke bestanden weer te geven.

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

Met de voorgaande code kunt u door mappen bladeren in de wwwroot/images map met behulp van de URL https://{HOST}/DirectoryImages met koppelingen naar elk bestand en elke map, waarbij de tijdelijke aanduiding de {HOST} host is.

AddDirectoryBrowser voegt services toe die zijn vereist voor de Directory Browsing Middleware, waaronder HtmlEncoder. Deze services kunnen worden toegevoegd door andere aanroepen, zoals AddRazorPages, maar we raden u aan aan te roepen AddDirectoryBrowser om ervoor te zorgen dat de services worden toegevoegd.

Standaarddocumenten serveren

Het instellen van een standaardpagina biedt bezoekers een startpunt op een site. Als u een standaardbestand wilt gebruiken van wwwroot zonder dat de aanvraag-URL de naam van het bestand moet opnemen, roept u de UseDefaultFiles methode aan.

UseDefaultFiles is een URL-rewriter die het bestand niet dient. In de aanvraagverwerkingspijplijn vóór de bestaande aanroep naar MapStaticAssets (.NET 9 of hoger) of UseStaticFiles (.NET 8 of eerder):

app.UseDefaultFiles();

Met UseDefaultFilesworden verzoeken naar een map in wwwroot uitgevoerd voor het zoeken naar:

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

Het eerste bestand uit de lijst wordt geleverd alsof de aanvraag de naam van het bestand bevat. De browser-URL blijft de aangevraagde URI weerspiegelen.

Met de volgende code wordt de standaardbestandsnaam gewijzigd in default-document.html:

var options = new DefaultFilesOptions();
options.DefaultFileNames.Clear();
options.DefaultFileNames.Add("default-document.html");
app.UseDefaultFiles(options);

Statische bestanden, standaarddocumenten en bladeren in mappen combineren

UseFileServer combineert de functionaliteit van UseStaticFiles, UseDefaultFilesen eventueel UseDirectoryBrowser.

In de aanvraagverwerkingspijplijn na de bestaande aanroep naar MapStaticAssets (.NET 9 of hoger) of UseStaticFiles (.NET 8 of eerder), roept UseFileServer u aan om het leveren van statische bestanden en het standaardbestand in te schakelen:

app.UseFileServer();

Bladeren in mappen is niet ingeschakeld voor het voorgaande voorbeeld.

De volgende code maakt het leveren van statische bestanden, het standaardbestand en het bladeren door mappen mogelijk.

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

Retourneert voor het hostadres (/) UseFileServer het standaard HTML-document vóór de standaardpagina Razor (Pages/Index.cshtml) of standaard MVC-weergave (Home/Index.cshtml).

Houd rekening met de volgende mappenstructuur:

  • wwwroot
    • css
    • images
    • js
  • ExtraStaticFiles
    • images
      • logo.png
    • default.html

De volgende code maakt het leveren van statische bestanden, het standaardbestand en het bladeren door ExtraStaticFilesmappen mogelijk.

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

AddDirectoryBrowser moet worden aangeroepen wanneer de eigenschapswaarde van de EnableDirectoryBrowsing is true.

Met behulp van de voorgaande bestandshiërarchie en code worden URL's opgelost zoals weergegeven in de volgende tabel (de {HOST} tijdelijke aanduiding is de host).

URI Antwoordbestand
https://{HOST}/static-files/images/logo.png ExtraStaticFiles/images/logo.png
https://{HOST}/static-files ExtraStaticFiles/default.html

Als er geen standaardbestand in de ExtraStaticFiles directory bestaat, geeft https://{HOST}/static-files de inhoud van de directory weer met klikbare koppelingen, waarbij de tijdelijke aanduiding {HOST} de host is.

UseDefaultFiles en UseDirectoryBrowser voeren aan de clientzijde een omleiding uit van de doel-URI zonder / naar de doel-URI met een afsluitende /. Bijvoorbeeld van https://{HOST}/static-files (geen volg /) naar https://{HOST}/static-files/ (inclusief een volging /). Relatieve URL's in de ExtraStaticFiles map zijn ongeldig zonder een afsluitende slash (/), tenzij de RedirectToAppendTrailingSlash optie van DefaultFilesOptions wordt gebruikt.

Bestandsextensies toewijzen aan MIME-typen

Note

Zie Blazorvoor hulp die van toepassing is op Blazor apps.

Gebruik FileExtensionContentTypeProvider.Mappings dit om bestandsextensies toe te voegen of te wijzigen in MIME-inhoudstypetoewijzingen. In het volgende voorbeeld worden verschillende bestandsextensies toegewezen aan bekende MIME-typen. De .rtf extensie wordt vervangen en .mp4 wordt verwijderd:

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

Zie MIME-inhoudstypen voor meer informatie.

Niet-standaardinhoudstypen

De Static File Middleware begrijpt bijna 400 bekende bestandsinhoudstypen. Als de gebruiker een bestand met een onbekend bestandstype aanvraagt, geeft de Static File Middleware de aanvraag door aan de volgende middleware in de pijplijn. Als er geen middleware de aanvraag verwerkt, wordt een 404 Niet gevonden antwoord geretourneerd. Als bladeren in mappen is ingeschakeld, wordt een koppeling naar het bestand weergegeven in een lijst met mappen.

Met de volgende code kunt u onbekende inhoudstypen leveren en het onbekende bestand weergeven als een afbeelding:

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

Met de voorgaande code wordt een aanvraag voor een bestand met een onbekend inhoudstype geretourneerd als een afbeelding.

Warning

Het inschakelen van ServeUnknownFileTypes is een beveiligingsrisico. Het is standaard uitgeschakeld en het gebruik ervan wordt afgeraden. Bestandsextensies toewijzen aan MIME-typen biedt een veiliger alternatief voor het leveren van bestanden met niet-standaardextensies.

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 er een relatief pad wordt gebruikt, zoekt het framework naar het bestand in de AppContext.BaseDirectory.

Beveiligingsoverwegingen voor statische bestanden

Warning

UseDirectoryBrowser en UseStaticFiles kunnen geheimen lekken. Het uitschakelen van mappenlijstweergave in productieomgevingen wordt ten zeerste aanbevolen. Controleer zorgvuldig welke mappen zijn ingeschakeld via UseStaticFiles of UseDirectoryBrowser. De volledige map en de bijbehorende submappen worden openbaar toegankelijk. Sla bestanden op die geschikt zijn voor het publiek in een toegewezen map, zoals <content_root>/wwwroot. Scheid deze bestanden van MVC-weergaven, Razor Pagina's, configuratiebestanden, enzovoort.

  • De URL's voor inhoud die worden weergegeven met UseDirectoryBrowser en UseStaticFiles zijn onderhevig aan de gevoeligheid van hoofdletters en tekens van het onderliggende bestandssysteem. Windows is bijvoorbeeld niet hoofdlettergevoelig, maar macOS en Linux zijn dat niet.

  • ASP.NET Core-apps die worden gehost in IIS, gebruiken de ASP.NET Core Module- om alle aanvragen door te sturen naar de app, inclusief statische bestandsaanvragen. De statische IIS-bestandshandler wordt niet gebruikt en heeft geen kans om aanvragen te verwerken.

  • Voer de volgende stappen uit in IIS-beheer om de statische IIS-bestandshandler op server- of websiteniveau te verwijderen:

    1. Navigeer naar de functie Modules.
    2. Selecteer StaticFileModule in de lijst.
    3. Klik op verwijderen in de zijbalk Acties.

Warning

Als de statische IIS-bestandshandler is ingeschakeld en de ASP.NET Core-module onjuist is geconfigureerd, worden statische bestanden geleverd. Dit gebeurt bijvoorbeeld als het web.config bestand niet is geïmplementeerd.

  • Plaats codebestanden, inclusief .cs en .cshtml, buiten de webhoofdmap van het app-project. Daarom wordt er een logische scheiding gemaakt tussen de inhoud aan de clientzijde van de app en servercode. Dit voorkomt dat code aan de serverzijde wordt gelekt.

MSBuild-eigenschappen

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

Vastgoed Description
EnableDefaultCompressedItems Hiermee schakelt u standaardcompressiepatronen voor opnemen/uitsluiten in.
CompressionIncludePatterns Door puntkomma's gescheiden lijst met bestandspatronen die moeten worden opgenomen voor compressie.
CompressionExcludePatterns Door puntkomma's gescheiden lijst met bestandspatronen die moeten worden uitgesloten van compressie.
EnableDefaultCompressionFormats Hiermee worden standaardcompressieformaten ingeschakeld (Gzip en Brotli).
BuildCompressionFormats Compressieformaten die tijdens de build moeten worden gebruikt.
PublishCompressionFormats Compressie-indelingen die tijdens het publiceren moeten worden gebruikt.
DisableBuildCompression Schakelt compressie uit tijdens de build.
CompressDiscoveredAssetsDuringBuild Comprimeert gedetecteerde assets tijdens de build.
BrotliCompressionLevel Compressieniveau voor het Brotli-algoritme.
StaticWebAssetBuildCompressAllAssets Comprimeert alle assets tijdens de build, niet alleen assets die tijdens een build zijn gedetecteerd of berekend.
StaticWebAssetPublishCompressAllAssets Comprimeert alle assets tijdens het publiceren, niet alleen assets die tijdens een build zijn gedetecteerd of berekend.
Vastgoed Description
StaticWebAssetBasePath Basis-URL-pad voor alle assets in een bibliotheek.
StaticWebAssetsFingerprintContent Hiermee schakelt u inhoudsvingerafdrukken in voor cachebusting.
StaticWebAssetFingerprintingEnabled Hiermee schakelt u de functie voor vingerafdruk voor statische webassets in.
StaticWebAssetsCacheDefineStaticWebAssetsEnabled Hiermee schakelt u caching in voor statische webassetdefinities.
StaticWebAssetEndpointExclusionPattern Patroon voor het uitsluiten van eindpunten.
Artikelengroep Description Metagegevens
StaticWebAssetContentTypeMapping Hiermee worden bestandspatronen toegewezen aan inhoudstypen en cacheheaders voor eindpunten. Pattern, Cache
StaticWebAssetFingerprintPattern Definieert patronen voor het toepassen van vingerafdrukken op statische webassets voor cachebusting. Pattern, Expression

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. Hiermee bepaalt u het cachegedrag van de browser (bijvoorbeeld max-age=3600, must-revalidate voor mediabestanden).

  • 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" />
</ItemGroup>

Runtime-configuratieopties

In de volgende tabel worden de runtimeconfiguratieopties beschreven.

Configuratiesleutel Description
ReloadStaticAssetsAtRuntime Maakt het dynamisch herladen van statische resources tijdens ontwikkeling mogelijk: gebruikt gewijzigde bestanden in de webhoofdmap (wwwroot), herberekent ETag en hercomprimeert indien nodig in plaats van de manifestversies die tijdens de bouw zijn gemaakt. Staat standaard ingeschakeld alleen wanneer een buildmanifest wordt geleverd, tenzij anders expliciet is ingesteld.
DisableStaticAssetNotFoundRuntimeFallback Wanneer true wordt ingeschakeld, wordt het terugval-eindpunt uitgeschakeld dat nieuw toegevoegde bestanden bedient die niet in het buildmanifest aanwezig zijn. Wanneer false afwezig is, geeft een bestand-controle {**path} terugvaloptie (GET/HEAD) een waarschuwing en serveert het bestand met een berekende ETag.
EnableStaticAssetsDevelopmentCaching Wanneer true, behoud de oorspronkelijke Cache-Control headers op asset-descriptors. Wanneer false afwezig is, herschrijft het Cache-Control headers naar no-cache om agressieve caching door clients tijdens de ontwikkeling te voorkomen.
EnableStaticAssetsDevelopmentIntegrity Wanneer true, behoudt het integriteitseigenschappen van asset descriptors. Wanneer false of afwezig is, verwijdert het een integriteitseigenschap om mismatches te voorkomen wanneer bestanden tijdens de ontwikkeling veranderen.

Aanvullende bronnen