Statiska filer i ASP.NET Core

Av Rick Anderson

Statisk filer, som HTML, CSS, bilder och JavaScript, är resurser som en ASP.NET Core-app tillhandahåller direkt till klienter standardmässigt.

Vägledning för Blazor statiska filer, som kompletterar eller ersätter den här artikeln, finns i ASP.NET Core Blazor statiska filer.

Hantera statiska filer

Statiska filer lagras i projektets webbrotskatalog. Standardkatalogen är {content root}/wwwroot, men den kan ändras med metoden UseWebRoot. Mer information finns i Innehållsrot och webbrot.

Metoden CreateBuilder anger innehållsroten till den aktuella katalogen:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
builder.Services.AddControllersWithViews();

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

app.UseHttpsRedirection();
app.MapStaticAssets();

app.UseAuthorization();

app.MapDefaultControllerRoute().WithStaticAssets();
app.MapRazorPages().WithStaticAssets();

app.Run();

Statiska filer är tillgängliga via en sökväg i förhållande till webrooten. Till exempel innehåller webbapplikationen -projektmallar flera mappar inom mappen wwwroot.

• wwwroot
  • css
  • js
  • lib

Överväg en app med filen wwwroot/images/MyImage.jpg. URI-formatet för att komma åt en fil i mappen images är https://<hostname>/images/<image_file_name>. Till exempel https://localhost:5001/images/MyImage.jpg

MapStaticAssets

Att skapa högpresterande webbappar kräver att leveransen av resurser optimeras till webbläsaren. Möjliga optimeringar är:

• Hantera en viss tillgång en gång tills filen ändras eller webbläsaren rensar cacheminnet. Ställ in ETag-huvudet.
• Förhindra att webbläsaren använder gamla eller inaktuella tillgångar när en app har uppdaterats. Ange senaste ändrade-huvudet.
• Konfigurera rätt cachehuvuden.
• Använd cache-mellanlager.
• Hantera komprimerade versioner av tillgångarna när det är möjligt.
• Använd en CDN för att leverera tillgångarna närmare användaren.
• Minimera storleken på de tillgångar som hanteras i webbläsaren. Den här optimeringen omfattar inte minifiering.

MapStaticAssets:

• Integrerar den information som samlas in om statiska webbtillgångar under bygg- eller publiceringsprocessen med ett körningsbibliotek som bearbetar den här informationen för att optimera filservering till webbläsaren.
• Är routningsslutpunktskonventioner som optimerar leveransen av statiska tillgångar i en app. Den är utformad för att fungera med alla användargränssnittsramverk, inklusive Blazor, Razor Pages och MVC.

UseStaticFiles hanterar även statiska filer, men det ger inte samma optimeringsnivå som MapStaticAssets. En jämförelse av UseStaticFiles och MapStaticAssetsfinns i Optimera leverans av statiska webbtillgånger .

Tillhandahålla filer i rotkatalogen på webben

Standardmallarna för webbappar anropar metoden MapStaticAssets i Program.cs, som gör att statiska filer kan hanteras:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
builder.Services.AddControllersWithViews();

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

app.UseHttpsRedirection();
app.MapStaticAssets();

app.UseAuthorization();

app.MapDefaultControllerRoute().WithStaticAssets();
app.MapRazorPages().WithStaticAssets();

app.Run();

Den parameterlösa UseStaticFiles-metodens överlagring markerar filerna i webbroten som betjänbara. Följande markering refererar till wwwroot/images/MyImage.jpg:

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

I föregående markering pekar tilde-tecknet ~ på webbroten.

Hantera filer utanför webbroten

Överväg en kataloghierarki där de statiska filer som ska hanteras finns utanför webbroten:

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

En begäran kan komma åt red-rose.jpg-filen genom att konfigurera mellanprogrammet för statiska filer på följande sätt:

using Microsoft.Extensions.FileProviders;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
builder.Services.AddControllersWithViews();

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

app.UseHttpsRedirection();

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

app.UseAuthorization();

app.MapDefaultControllerRoute().WithStaticAssets();
app.MapRazorPages().WithStaticAssets();

app.Run();

I föregående kod exponeras MyStaticFiles kataloghierarki offentligt via StaticFiles URI-segment. En begäran om att https://<hostname>/StaticFiles/images/red-rose.jpg hanterar red-rose.jpg-filen.

Följande markering refererar till MyStaticFiles/images/red-rose.jpg:

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

Information om hur du hanterar filer från flera platser finns i Hantera filer från flera platser.

Ange HTTP-svarshuvuden

Ett StaticFileOptions objekt kan användas för att ange HTTP-svarshuvuden. Förutom att konfigurera statisk fil som betjänar från webbrotenanger följande kod Cache-Control--huvudet:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
builder.Services.AddControllersWithViews();

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

app.UseHttpsRedirection();

 var cacheMaxAgeOneWeek = (60 * 60 * 24 * 7).ToString();
 app.UseStaticFiles(new StaticFileOptions
 {
     OnPrepareResponse = ctx =>
     {
         ctx.Context.Response.Headers.Append(
              "Cache-Control", $"public, max-age={cacheMaxAgeOneWeek}");
     }
 });

app.UseAuthorization();

app.MapDefaultControllerRoute().WithStaticAssets();
app.MapRazorPages().WithStaticAssets();

app.Run();

Föregående kod gör statiska filer offentligt tillgängliga i den lokala cachen i en vecka.

Auktorisering av statisk fil

ASP.NET Core-mallarna anropar MapStaticAssets innan de anropar UseAuthorization. De flesta appar följer det här mönstret. När mellanprogrammet för statisk fil anropas före mellanprogrammet för auktorisering:

• Inga auktoriseringskontroller utförs på de statiska filerna.
• Statiska filer som hanteras av Static File Middleware, till exempel de under wwwroot, är offentligt tillgängliga.

Så här hanterar du statiska filer baserat på auktorisering:

• Lagra dem utanför wwwroot.
• Anropa UseStaticFilesoch ange en sökväg när du har anropat UseAuthorization.
• Ange princip för återställningsauktorisering.

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.FileProviders;
using StaticFileAuth.Data;

var builder = WebApplication.CreateBuilder(args);

var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");
builder.Services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlServer(connectionString));
builder.Services.AddDatabaseDeveloperPageExceptionFilter();

builder.Services.AddDefaultIdentity<IdentityUser>(options => options.SignIn.RequireConfirmedAccount = true)
    .AddEntityFrameworkStores<ApplicationDbContext>();
builder.Services.AddRazorPages();

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

var app = builder.Build();

if (app.Environment.IsDevelopment())
{
    app.UseMigrationsEndPoint();
}
else
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseRouting();

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

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

app.MapRazorPages();

app.Run();

I föregående kod kräver reservauktoriseringsprincipen alla användare ska autentiseras. Slutpunkter såsom kontroller, Razor Pages, etc. som anger sina egna auktoriseringskrav använder inte standardauktoriseringsprincipen. Till exempel använder Razor sidor, kontrollanter eller åtgärdsmetoder med [AllowAnonymous] eller [Authorize(PolicyName="MyPolicy")] det använda auktoriseringsattributet i stället för reservauktoriseringspolicyn.

RequireAuthenticatedUser lägger till DenyAnonymousAuthorizationRequirement till den aktuella instansen, vilket framtvingar att den aktuella användaren autentiseras.

Statiska tillgångar under wwwroot är offentligt tillgängliga eftersom standardprogrammet för statisk fil (app.UseStaticFiles();) anropas före UseAuthentication. Statiska tillgångar i mappen MyStaticFiles kräver autentisering. Den exempelkoden visar detta.

En alternativ metod för att hantera filer baserat på auktorisering är att:

• Lagra dem utanför wwwroot och alla kataloger som är tillgängliga för den statiska fil-mellanprogramvaran.

• Hantera dem via en åtgärdsmetod som auktorisering tillämpas på och returnera ett FileResult objekt:

  [Authorize]
  public class BannerImageModel : PageModel
  {
      private readonly IWebHostEnvironment _env;
  
      public BannerImageModel(IWebHostEnvironment env) =>
          _env = env;
  
      public PhysicalFileResult OnGet()
      {
          var filePath = Path.Combine(
                  _env.ContentRootPath, "MyStaticFiles", "images", "red-rose.jpg");
  
          return PhysicalFile(filePath, "image/jpeg");
      }
  }
  

Föregående metod kräver en sida eller slutpunkt per fil. Följande kod returnerar filer eller laddar upp filer för autentiserade användare:

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

        if (File.Exists(filePath))
        {
           return TypedResults.PhysicalFile(filePath, fileDownloadName: $"{fileName}");
        }

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

app.MapPost("/files", 
       async (IFormFile file, LinkGenerator linker, HttpContext context) =>
    {
        // Don't rely on the file.FileName as it is only metadata that can be
        // manipulated by the end-user. See 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");

app.Run();

IFormFile i föregående exempel använder minnesbuffert för uppladdning. Använd direktuppspelning för hantering av stora filer. Se Ladda upp stora filer med strömmande.

Se mappen StaticFileAuth GitHub för det fullständiga exemplet.

Katalogbläddring

Katalogbläddring tillåter kataloglistning inom angivna kataloger.

Katalogbläddring är inaktiverat som standard av säkerhetsskäl. Mer information finns i Säkerhetsöverväganden för statiska filer.

Aktivera katalogbläddring med AddDirectoryBrowser och UseDirectoryBrowser:

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

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
builder.Services.AddControllersWithViews();

builder.Services.AddDirectoryBrowser();

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

app.UseHttpsRedirection();

app.MapStaticAssets();

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

// Enable displaying browser links.
app.UseStaticFiles(new StaticFileOptions
{
    FileProvider = fileProvider,
    RequestPath = requestPath
});

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

app.UseAuthorization();

app.MapDefaultControllerRoute().WithStaticAssets();
app.MapRazorPages().WithStaticAssets();

app.Run();

Föregående kod tillåter katalogbläddring av mappen wwwroot/images med hjälp av URL:en https://<hostname>/MyImages, med länkar till varje fil och mapp:

AddDirectoryBrowser lägger till tjänster som krävs av katalogbläddringsmellanprogrammet, inklusive HtmlEncoder. Dessa tjänster kan läggas till av andra anrop, till exempel AddRazorPages, men vi rekommenderar att du anropar AddDirectoryBrowser för att säkerställa att tjänsterna läggs till i alla appar.

Hantera standarddokument

Om du anger en standardsida får besökare en startpunkt på en webbplats. Om du vill hantera en standardfil från wwwroot utan att begärande-URL:en måste innehålla filens namn anropar du metoden UseDefaultFiles:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
builder.Services.AddControllersWithViews();

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

app.UseHttpsRedirection();

app.UseDefaultFiles();

app.UseStaticFiles();
app.UseAuthorization();

app.MapDefaultControllerRoute().WithStaticAssets();
app.MapRazorPages().WithStaticAssets();

app.Run();

UseDefaultFiles måste anropas innan UseStaticFiles för att hantera standardfilen. UseDefaultFiles är en URL-omskrivare som inte serverar filen.

Med UseDefaultFilessöker begäranden till en mapp i wwwroot efter:

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

Den första filen som hittades i listan hanteras som om begäran innehöll filens namn. Webbläsarens URL fortsätter att återspegla den begärda URI:n. I exempelappen hanterar till exempel en begäran om att https://localhost:<port>/def/default.html från wwwroot/def.

Följande kod ändrar standardfilnamnet till mydefault.html:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
builder.Services.AddControllersWithViews();

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

app.UseHttpsRedirection();

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

app.UseStaticFiles();

app.UseAuthorization();

app.MapDefaultControllerRoute().WithStaticAssets();
app.MapRazorPages().WithStaticAssets();

app.Run();

UseFileServer för standarddokument

UseFileServer kombinerar funktionerna i UseStaticFiles, UseDefaultFilesoch eventuellt UseDirectoryBrowser.

Anropa app.UseFileServer för att aktivera servering av statiska filer och standardfilen. Katalogbläddring är inte aktiverat:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
builder.Services.AddControllersWithViews();

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

app.UseHttpsRedirection();

app.UseFileServer();

app.UseAuthorization();

app.MapDefaultControllerRoute().WithStaticAssets();
app.MapRazorPages().WithStaticAssets();

app.Run();

Följande kod möjliggör servering av statiska filer, standardfilen och katalogbläddring:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
builder.Services.AddControllersWithViews();

builder.Services.AddDirectoryBrowser();

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

app.UseHttpsRedirection();

app.UseFileServer(enableDirectoryBrowsing: true);

app.UseRouting();

app.UseAuthorization();

app.MapDefaultControllerRoute().WithStaticAssets();
app.MapRazorPages().WithStaticAssets();

app.Run();

Överväg följande kataloghierarki:

• wwwroot
  • css
  • images
  • js
• MyStaticFiles
  • defaultFiles
    • default.html
    • image3.png
  • images
    • MyImage.jpg

Följande kod möjliggör servering av statiska filer, standardfilen och katalogbläddring av MyStaticFiles:

using Microsoft.Extensions.FileProviders;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
builder.Services.AddControllersWithViews();

builder.Services.AddDirectoryBrowser();

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

app.UseHttpsRedirection();

app.UseStaticFiles();

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

app.UseAuthorization();

app.MapDefaultControllerRoute().WithStaticAssets();
app.MapRazorPages().WithStaticAssets();

app.Run();

AddDirectoryBrowser måste anropas när EnableDirectoryBrowsing egenskapsvärdet är true.

Med hjälp av den föregående filhierarkin och koden matchar URL:er på följande sätt:

URI	Svar
https://<hostname>/StaticFiles/images/MyImage.jpg	MyStaticFiles/images/MyImage.jpg
https://<hostname>/StaticFiles	kataloglista
https://<hostname>/StaticFiles/defaultFiles	MyStaticFiles/defaultFiles/default.html
https://<hostname>/StaticFiles/defaultFiles/image3.png	MyStaticFiles/defaultFiles//image3.png

Om det inte finns någon standardnamnfil i katalogen MyStaticFiles returnerar https://<hostname>/StaticFiles kataloglistan med klickbara länkar:

UseDefaultFiles och UseDirectoryBrowser utför en omdirigering på klientsidan från mål-URI:n utan en avslutande / till mål-URI:n med en avslutande /. Till exempel från https://<hostname>/StaticFiles till https://<hostname>/StaticFiles/. Relativa URL:er i katalogen StaticFiles är ogiltiga utan ett avslutande snedstreck (/) såvida inte RedirectToAppendTrailingSlash alternativet DefaultFilesOptions används.

FileExtensionContentTypeProvider

Klassen FileExtensionContentTypeProvider innehåller en egenskap Mappningar som fungerar som en mappning av filnamnstillägg till MIME-innehållstyper. I följande exempel mappas flera filnamnstillägg till kända MIME-typer. Tillägget .rtf ersätts och .mp4 tas bort:

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

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
builder.Services.AddControllersWithViews();

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

app.UseHttpsRedirection();

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

app.UseAuthorization();

app.MapDefaultControllerRoute().WithStaticAssets();
app.MapRazorPages().WithStaticAssets();

app.Run();

Se MIME-innehållstyper.

Innehållstyper som inte är standard

Static File Middleware förstår nästan 400 kända filinnehållstyper. Om användaren begär en fil med en okänd filtyp skickar Static File Middleware begäran till nästa mellanprogram i pipelinen. Om inget mellanprogram hanterar begäran returneras ett 404 Hittades inte svar. Om katalogbläddring är aktiverat visas en länk till filen i en kataloglista.

Följande kod aktiverar servering av okända typer och renderar den okända filen som en bild:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
builder.Services.AddControllersWithViews();

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

app.UseHttpsRedirection();

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

app.UseAuthorization();

app.MapDefaultControllerRoute().WithStaticAssets();
app.MapRazorPages().WithStaticAssets();

app.Run();

Med föregående kod returneras en begäran om en fil med en okänd innehållstyp som en bild.

Varning

Att aktivera ServeUnknownFileTypes är en säkerhetsrisk. Den är inaktiverad som standard och dess användning rekommenderas inte. FileExtensionContentTypeProvider är ett säkrare alternativ till att hantera filer med tillägg som inte är standard.

Hantera filer från flera platser

Överväg följande Razor sida som visar /MyStaticFiles/image3.png-filen:

@page

<p> Test /MyStaticFiles/image3.png</p>

<img src="~/image3.png" class="img" asp-append-version="true" alt="Test">

UseStaticFiles och UseFileServer är som standard inställda på att filprovidern pekar på wwwroot. Ytterligare instanser av UseStaticFiles och UseFileServer kan tillhandahållas med andra filleverantörer för att hantera filer från andra platser. I följande exempel anropas UseStaticFiles två gånger för att hantera filer från både wwwroot och MyStaticFiles:

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

Använd föregående kod:

• Filen /MyStaticFiles/image3.png visas.
• Image Tag HelpersAppendVersion tillämpas inte eftersom Tag Helpers är beroende av WebRootFileProvider. WebRootFileProvider har inte uppdaterats för att inkludera mappen MyStaticFiles.

Följande kod uppdaterar WebRootFileProvider, vilket gör att bildtaggens hjälpfunktion kan ge en version.

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

var compositeProvider = new CompositeFileProvider(webRootProvider,
                                                  newPathProvider);

// Update the default provider.
app.Environment.WebRootFileProvider = compositeProvider;

app.MapStaticAssets();

Anteckning

Föregående metod gäller för Razor Pages- och MVC-appar. Vägledning som gäller för Blazor Web Apps finns i ASP.NET Core Blazor statiska filer.

Säkerhetsöverväganden för statiska filer

Varning

UseDirectoryBrowser och UseStaticFiles kan läcka hemligheter. Vi rekommenderar starkt att du inaktiverar katalogbläddring i produktion. Granska noggrant vilka kataloger som är aktiverade via UseStaticFiles eller UseDirectoryBrowser. Hela katalogen och dess underkataloger blir offentligt tillgängliga. Lagra filer som är lämpliga för att betjäna allmänheten i en dedikerad katalog, till exempel <content_root>/wwwroot. Avgränsa dessa filer från MVC-vyer, Razor sidor, konfigurationsfiler osv.

• URL:erna för innehåll som exponeras med UseDirectoryBrowser, UseStaticFilesoch MapStaticAssets omfattas av skiftlägeskänsligheten och teckenbegränsningarna i det underliggande filsystemet. Windows är till exempel skiftlägesokänsligt, men macOS och Linux är det inte.

• ASP.NET Core-appar som finns i IIS använder ASP.NET Core Module för att vidarebefordra alla begäranden till appen, inklusive statiska filbegäranden. Den statiska IIS-filhanteraren används inte och har ingen chans att hantera begäranden.

• Slutför följande steg i IIS-hanteraren för att ta bort den statiska IIS-filhanteraren på server- eller webbplatsnivå:

  1. Gå till funktionen Moduler.
  2. Välj StaticFileModule i listan.
  3. Klicka på Ta bort i sidofältet Åtgärder.

Varning

Om den statiska IIS-filhanteraren är aktiverad och ASP.NET Core Module har konfigurerats felaktigt, hanteras statiska filer. Detta inträffar till exempel om web.config filen inte har distribuerats.

• Placera kodfiler, inklusive .cs och .cshtml, utanför appprojektets webbrot. Därför skapas en logisk separation mellan appens innehåll på klientsidan och serverbaserad kod. Detta förhindrar att kod på serversidan läcker ut.

Hantera filer utanför wwwroot genom att uppdatera IWebHostEnvironment.WebRootPath

När IWebHostEnvironment.WebRootPath är inställt på en annan mapp än wwwroot:

• I utvecklingsmiljön levereras statiska tillgångar som finns i både wwwroot och i den uppdaterade IWebHostEnvironment.WebRootPath från wwwroot.
• I andra miljöer än utveckling levereras kopior av statiska tillgångar från den uppdaterade mappen IWebHostEnvironment.WebRootPath.

Överväg att skapa en webbapp med den tomma webbmallen:

• Innehåller en fil Index.html i wwwroot och wwwroot-custom.

• Med den följande uppdaterade Program.cs-filen, som anger WebRootPath = "wwwroot-custom":

  var builder = WebApplication.CreateBuilder(new WebApplicationOptions
  {
      Args = args,
      // Look for static files in "wwwroot-custom"
      WebRootPath = "wwwroot-custom"
  });
  
  var app = builder.Build();
  
  app.UseDefaultFiles();
  app.MapStaticAssets();
  
  app.Run();
  

I den föregående koden görs förfrågningar till /:

• I utvecklingsmiljön returnerar wwwroot/Index.html
• I alla miljöer utom utvecklingsmiljö returnera wwwroot-custom/Index.html

Använd någon av följande metoder för att säkerställa att tillgångar från wwwroot-custom returneras:

• Ta bort duplicerade namngivna tillgångar i wwwroot.

• Ange "ASPNETCORE_ENVIRONMENT" i Properties/launchSettings.json till vilket värde som helst utom "Development".

• Inaktivera statiska webbtillgångar helt genom att ange <StaticWebAssetsEnabled>false</StaticWebAssetsEnabled> i projektfilen. VARNING, inaktivering av statiska webbtillgångar inaktiverar Razor klassbibliotek.

• Lägg till följande XML i projektfilen:

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

Följande kod uppdaterar IWebHostEnvironment.WebRootPath till ett värde som inte är för utveckling, vilket garanterar att duplicerat innehåll returneras från wwwroot-custom istället för wwwroot.

var builder = WebApplication.CreateBuilder(new WebApplicationOptions
{
    Args = args,
    // Examine Hosting environment: logging value
    EnvironmentName = Environments.Staging,
    WebRootPath = "wwwroot-custom"
});

var app = builder.Build();

app.Logger.LogInformation("ASPNETCORE_ENVIRONMENT: {env}",
      Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT"));

app.Logger.LogInformation("app.Environment.IsDevelopment(): {env}",
      app.Environment.IsDevelopment().ToString());

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

app.Run();

Ytterligare resurser

• Visa eller ladda ned exempelkod (hur du laddar ned)
• Mellanprogram
• Introduktion till ASP.NET Core
• ASP.NET Core Blazor filuppladdningar
• ASP.NET Core Blazor filnedladdningar