Statikus fájlok a ASP.NET Core-ban

Készítette: Rick Anderson

A statikus fájlok, például a HTML, a CSS, a képek és a JavaScript olyan objektumok, amelyek egy ASP.NET Core-alkalmazás alapértelmezés szerint közvetlenül az ügyfelek számára szolgálnak.

Statikus fájlok kiszolgálása

A statikus fájlok a projekt webes legfelső szintű könyvtárában vannak tárolva. Az alapértelmezett könyvtár {content root}/wwwroot, de a UseWebRoot metódussal módosítható. További információ: Tartalomgyökér és Webgyökér.

A CreateBuilder metódus a tartalomgyökerét az aktuális könyvtárra állítja:

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

app.UseAuthorization();

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

app.Run();

A statikus fájlok egy, a webes gyökérhezviszonyított útvonalon érhetők el. A webalkalmazás projektsablonjai például több mappát tartalmaznak a wwwroot mappában:

• wwwroot
  • css
  • js
  • lib

Fontolja meg a wwwroot/images mappa létrehozását és a wwwroot/images/MyImage.jpg fájl hozzáadását. A images mappában lévő fájlok eléréséhez az URI formátum https://<hostname>/images/<image_file_name>. Például https://localhost:5001/images/MyImage.jpg

Fájlok kiszolgálása a webgyökérben

Az alapértelmezett webalkalmazás-sablonok meghívják a UseStaticFiles metódust Program.cs, amely lehetővé teszi a statikus fájlok kézbesítését:

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

app.UseAuthorization();

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

app.Run();

A paraméter nélküli UseStaticFiles metódustúlterhelése kiszolgálhatóként jelöli meg a webes gyökér fájljait. A következő jelölések wwwroot/images/MyImage.jpg:

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

Az előző jelölésben a tilde karakter ~ a webgyökérmutat.

Fájlok kiszolgálása a webgyökérkönyvtáron kívül

Fontolja meg azt a címtárhierarchiát, amelyben a kiszolgálni kívánt statikus fájlok a webes gyökérkívül találhatók:

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

A kérések az alábbi statikus fájlközvetítő konfigurálásával férhetnek hozzá a red-rose.jpg fájlhoz:

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(new StaticFileOptions
{
    FileProvider = new PhysicalFileProvider(
           Path.Combine(builder.Environment.ContentRootPath, "MyStaticFiles")),
    RequestPath = "/StaticFiles"
});

app.UseAuthorization();

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

app.Run();

Az előző kódban a MyStaticFiles könyvtárhierarchia nyilvánosan elérhető a StaticFiles URI-szegmensen keresztül. A https://<hostname>/StaticFiles/images/red-rose.jpg fájlt egy red-rose.jpg kérés szolgálja ki.

A következő jelölések MyStaticFiles/images/red-rose.jpg:

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

Ha több helyről szeretne fájlokat kiszolgálni, tekintse meg Több helyről származó fájlok kiszolgálásacímű témakört.

HTTP-válaszfejlécek beállítása

A HTTP-válaszfejlécek beállításához StaticFileOptions objektum használható. A statikus fájlok webgyökérből történő kiszolgálásának konfigurálása mellett az alábbi kód beállítja a Cache-Control fejlécet.

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();
app.MapRazorPages();

app.Run();

Az előző kód egy hétig (604800 másodpercig) teszi nyilvánosan elérhetővé a statikus fájlokat a helyi gyorsítótárban.

Statikus fájl engedélyezése

A ASP.NET Core-sablonok meghívják UseStaticFiles, mielőtt meghívják UseAuthorization. A legtöbb alkalmazás ezt a mintát követi. Ha a statikus fájlközvetítési szoftver az engedélyezési köztes szoftver előtt van meghívva:

• A statikus fájlokon nem történik engedélyezési ellenőrzés.
• A Statikus fájl köztes szoftver által kiszolgált statikus fájlok, például a wwwrootalatti fájlok nyilvánosan elérhetők.

Statikus fájlok kiszolgálása engedélyezés alapján:

• Tárolja őket a wwwroot kívül.
• Hívja meg a UseAuthorization-t, majd UseStaticFiles hívásakor adja meg az elérési utat.
• Állítsa be a visszaesési engedélyezési házirendet.

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

Az előző kódban a tartalék jogosultsági szabályzat megköveteli, hogy minden felhasználót hitelesíteni kell. Az olyan végpontok, mint a vezérlők, Razor oldalak stb., amelyek saját engedélyezési követelményeket határoznak meg, nem használják a tartalék engedélyezési szabályzatot. Például az Razor lapok, a [AllowAnonymous] vagy [Authorize(PolicyName="MyPolicy")] vezérlők, illetve műveleti módszerek az alkalmazott engedélyezési attribútumot használják a tartalék engedélyezési szabályzat helyett.

RequireAuthenticatedUser hozzáadja a DenyAnonymousAuthorizationRequirement-et az aktuális példányhoz, amely biztosítja, hogy az aktuális felhasználó hitelesített legyen.

A wwwroot alatti statikus objektumok nyilvánosan elérhetők, mert az alapértelmezett statikus fájlközvetítõ (app.UseStaticFiles();) meghívása UseAuthenticationelõtt történik. A MyStaticFiles mappában lévő statikus objektumok hitelesítést igényelnek. Ezt a mintakód szemlélteti.

A fájlok hitelesítésen alapuló kiszolgálásának másik módszere a következő:

• Tárolja őket a wwwroot és a Statikus fájl köztes szoftver számára elérhető könyvtáron kívül.

• Egy olyan műveletmetóduson keresztül szolgálja ki őket, amelyre az engedélyezést alkalmazza, és egy FileResult objektumot ad vissza:

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

Az előző megközelítés fájlonként egy lapot vagy végpontot igényel. Az alábbi kód fájlokat ad vissza, vagy fájlokat tölt fel hitelesített felhasználók számára:

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

// IFormFile uses memory buffer for uploading. For handling large file use streaming instead.
// https://learn.microsoft.com/aspnet/core/mvc/models/file-uploads#upload-large-files-with-streaming
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
        // Take a look at 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();

A teljes mintát a StaticFileAuth GitHub-mappában találja.

Címtár-böngészés

A címtárböngészés lehetővé teszi a címtárak adott könyvtárakon belüli felsorolását.

A címtárböngészés alapértelmezés szerint biztonsági okokból le van tiltva. További információ: Statikus fájlok biztonsági szempontjai.

Könyvtárböngészés engedélyezése AddDirectoryBrowser és 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.UseStaticFiles();

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();
app.MapRazorPages();

app.Run();

Az előző kód lehetővé teszi a wwwroot/images mappa könyvtárban való böngészését a https://<hostname>/MyImagesURL-címmel, az egyes fájlokra és mappákra mutató hivatkozásokkal:

AddDirectoryBrowser hozzáadja azokat a szolgáltatásokat, amelyeket a könyvtárböngésző köztes szoftver igényel, beleértve HtmlEncoder. Ezeket a szolgáltatásokat más hívások is hozzáadhatják, például AddRazorPages, de javasoljuk, hogy hívja meg AddDirectoryBrowser, hogy a szolgáltatások minden alkalmazásban fel legyenek véve.

Alapértelmezett dokumentumok kiszolgálása

Az alapértelmezett lap beállításával a látogatók kiindulópontot hozhatnak létre egy webhelyen. Ha egy alapértelmezett fájlt szeretne kiszolgálni wwwroot anélkül, hogy a kérelem URL-címének tartalmaznia kellene a fájl nevét, hívja meg a UseDefaultFiles metódust:

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();
app.MapRazorPages();

app.Run();

UseDefaultFiles az alapértelmezett fájl kiszolgálásához UseStaticFiles előtt kell meghívni. UseDefaultFiles egy URL-író, amely nem szolgálja ki a fájlt.

A UseDefaultFilesesetén a wwwroot mappába irányuló kérések a következőre keresnek:

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

A listából talált első fájl úgy lesz kézbesítve, mintha a kérés tartalmazza a fájl nevét. A böngésző URL-címe továbbra is a kért URI-t tükrözi.

Az alábbi kód az alapértelmezett fájlnevet mydefault.htmlértékre módosítja:

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();
app.MapRazorPages();

app.Run();

UseFileServer alapértelmezett dokumentumokhoz

UseFileServer egyesíti a UseStaticFiles, UseDefaultFilesés opcionálisan UseDirectoryBrowserfunkcióit .

Hívja meg app.UseFileServer a statikus fájlok és az alapértelmezett fájl kiszolgálásának engedélyezéséhez. A címtárböngészés nincs engedélyezve:

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();
app.MapRazorPages();

app.Run();

Az alábbi kód lehetővé teszi a statikus fájlok, az alapértelmezett fájl és a címtárböngészés kiszolgálását:

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();
app.MapRazorPages();

app.Run();

Vegye figyelembe a következő címtárhierarchiát:

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

Az alábbi kód lehetővé teszi a statikus fájlok kiszolgálását, az alapértelmezett fájl megjelenítését és a könyvtár böngészését MyStaticFilesesetében:

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();
app.MapRazorPages();

app.Run();

AddDirectoryBrowser akkor kell meghívni, ha a EnableDirectoryBrowsing tulajdonság értéke true.

Az előző fájlhierarchiát és -kódot használva az URL-címek a következőképpen oldódnak fel:

URI	Válasz
https://<hostname>/StaticFiles/images/MyImage.jpg	MyStaticFiles/images/MyImage.jpg
https://<hostname>/StaticFiles	MyStaticFiles/default.html

Ha a MyStaticFiles könyvtárban nincs alapértelmezett névvel ellátott fájl, https://<hostname>/StaticFiles kattintásra használható hivatkozásokkal adja vissza a címtár listáját:

UseDefaultFiles és UseDirectoryBrowser ügyféloldali átirányítást hajtanak végre a cél URI-ról, amely nem tartalmazza a záró /-t, a cél URI-ra, amely tartalmaz egy záró /-at. Például a https://<hostname>/StaticFiles-tól https://<hostname>/StaticFiles/-ig. A StaticFiles könyvtárban lévő relatív URL-címek perjel (/) nélkül érvénytelenek, kivéve, ha a RedirectToAppendTrailingSlashDefaultFilesOptions beállítását használja.

FájlkiterjesztésTartalomtípusSzolgáltató

A FileExtensionContentTypeProvider osztály egy Mappings tulajdonságot tartalmaz, amely a fájlkiterjesztések MIME-tartalomtípusokhoz való leképezésére szolgál. Az alábbi példában több fájlkiterjesztés is megfeleltethető az ismert MIME-típusoknak. A .rtf bővítmény lecserélődik, és a .mp4 el lesz távolítva:

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();
app.MapRazorPages();

app.Run();

Lásd: MIME-tartalomtípusok.

Nem szabványos tartalomtípusok

A Static File Middleware közel 400 ismert fájltartalomtípust ismer. Ha a felhasználó ismeretlen fájltípusú fájlt kér, a Statikus fájl köztes szoftver átadja a kérést a folyamat következő köztes szoftverének. Ha a köztes szoftver nem kezeli a kérést, a rendszer egy 404 Nem található választ ad vissza. Ha a címtárböngészés engedélyezve van, a fájlra mutató hivatkozás megjelenik egy címtárlistában.

Az alábbi kód lehetővé teszi az ismeretlen típusok kiszolgálását, és képként jeleníti meg az ismeretlen fájlt:

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();
app.MapRazorPages();

app.Run();

Az előző kóddal egy ismeretlen tartalomtípusú fájl kérése lesz képként visszaadva.

Figyelmeztetés

A ServeUnknownFileTypes engedélyezése biztonsági kockázatot jelent. Alapértelmezés szerint le van tiltva, és használata nem ajánlott. FileExtensionContentTypeProvider biztonságosabb alternatívát kínál a nem szabványos kiterjesztésű fájlok kiszolgálására.

Fájlok kiszolgálása több helyről

Fontolja meg az alábbi Razor lapot, amely megjeleníti a /MyStaticFiles/image3.png fájlt:

@page

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

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

UseStaticFiles és UseFileServer alapértelmezés szerint a fájlszolgáltatóra mutatnak, amely a wwwroot-re irányul. A UseStaticFiles és UseFileServer további példányai más fájlszolgáltatókkal is elláthatók más helyekről származó fájlok kiszolgálásához. Az alábbi példa kétszer hívja meg UseStaticFiles, hogy wwwroot és MyStaticFilesfájljait is kiszolgálja:

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

Az előző kód használata:

• Megjelenik a /MyStaticFiles/image3.png fájl.
• A rendszer nem alkalmazza a képcímke-segédeketAppendVersion, mert a címkesegítők WebRootFileProviderfüggnek. WebRootFileProvider nem lett frissítve, hogy tartalmazza a MyStaticFiles mappát.

A következő kód frissíti a WebRootFileProvider-t, ami lehetővé teszi, hogy a képcímke-segéd egy verziót adjon meg.

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.UseStaticFiles();

Jegyzet

Az előző megközelítés Razor Pages- és MVC-alkalmazásokra vonatkozik. Az Blazor Web Apps-ekre vonatkozó útmutatásért tekintse meg ASP.NET Core Blazor statikus fájlokcímű témakört.

A statikus fájlok biztonsági szempontjai

Figyelmeztetés

UseDirectoryBrowser és UseStaticFiles titkokat szivárogtathatnak ki. Nagyon ajánlott letiltani a könyvtárböngészést éles környezetben. Gondosan ellenőrizze, hogy mely könyvtárak vannak engedélyezve UseStaticFiles vagy UseDirectoryBrowseráltal. A teljes könyvtár és annak alkönyvtárai nyilvánosan elérhetők lesznek. A nyilvános használatra alkalmas fájlok tárolása dedikált címtárban, például <content_root>/wwwroot. Különítse el ezeket a fájlokat az MVC-nézetektől, Razor lapoktól, konfigurációs fájloktól stb.

• A UseDirectoryBrowser és UseStaticFiles közzétett tartalmak URL-címére az alapul szolgáló fájlrendszer kis- és nagybetűkre vonatkozó bizalmassági és karakterkorlátozásai vonatkoznak. Például a Windows nem érzékeny a kis- és nagybetűkre, de a macOS és a Linux igen.

• ASP.NET IIS-ben üzemeltetett Core-alkalmazások a ASP.NET Core-modul használatával továbbítják az összes kérést az alkalmazásnak, beleértve a statikus fájlkérelmeket is. Az IIS statikus fájlkezelője nincs használatban, és nincs lehetősége a kérések kezelésére.

• Hajtsa végre a következő lépéseket az IIS-kezelőben az IIS statikus fájlkezelő kiszolgálói vagy webhelyszintű eltávolításához:

  1. Menjen a(z) Modulok funkcióhoz.
  2. Válassza StaticFileModule a listában.
  3. Kattintson az Eltávolítás gombra a Műveletek oldalsávon.

Figyelmeztetés

Ha az IIS statikus fájlkezelője engedélyezve van , és a ASP.NET core modul helytelenül van konfigurálva, a rendszer statikus fájlokat szolgál ki. Ez például akkor fordul elő, ha a web.config fájl nincs üzembe helyezve.

• Helyezze el a kódfájlokat, beleértve a .cs és a .cshtml, az alkalmazásprojekt webes gyökérkívül. Ezért logikai elkülönítés jön létre az alkalmazás ügyféloldali tartalma és a kiszolgálóalapú kód között. Ez megakadályozza a kiszolgálóoldali kód kiszivárgását.

Külső fájlok kiszolgálása az IWebHostEnvironment.WebRootPath frissítésével

Amikor IWebHostEnvironment.WebRootPath más mappának van beállítva, mint wwwroot:

• Fejlesztési környezetben a statikus objektumok, amelyek a wwwroot-ban és a frissített IWebHostEnvironment.WebRootPath-ben találhatók, a wwwroot-ből kerülnek kiszolgálásra.
• A fejlesztési környezettől eltérő minden más környezetben a rendszer a frissített IWebHostEnvironment.WebRootPath mappából szolgálja ki a duplikált statikus elemeket.

Fontolja meg az üres websablonnal létrehozott webalkalmazást:

• Egy Index.html fájlt tartalmaz wwwroot-ben és wwwroot-custom-ben.

• Az alábbi frissített Program.cs fájllal, amely beállítja 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.UseStaticFiles();
  
  app.Run();
  

Az előző kódban a /-hoz érkező kérések:

• A fejlesztési környezetben térjen vissza wwwroot/Index.html
• A fejlesztési megtérülési wwwroot-custom/Index.html kivételével minden környezetben

A wwwroot-custom származó eszközök visszaadásának biztosításához használja az alábbi módszerek egyikét:

• Ismétlődő elnevezett objektumok törlése wwwroot.

• A "ASPNETCORE_ENVIRONMENT"-ban állítsa be a Properties/launchSettings.json-t bármilyen értékre a "Development"kivételével.

• A statikus webes objektumok teljes letiltása a projektfájlban <StaticWebAssetsEnabled>false</StaticWebAssetsEnabled> beállításával. FIGYELMEZTETÉS, a statikus webes objektumok letiltása letiltja az Razor osztálykönyvtárakat.

• Adja hozzá a következő JSON-t a projektfájlhoz:

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

A következő kód IWebHostEnvironment.WebRootPath értékét nem fejlesztési (üzemi) értékre módosítja, ezáltal biztosítva, hogy a duplikált tartalmat wwwroot-custom adja vissza, nem pedig 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.UseStaticFiles();

app.Run();

További erőforrások

• Mintakód megtekintése vagy letöltése (hogyan kell letöltani)
• Köztes szoftver
• Az ASP.NET Core bemutatása