Så här fungerar ASP.NET Core

  • 2 minuter

En ASP.NET Core-app är i princip en .NET-app med en Program.cs fil som konfigurerar de webbappskomponentfunktioner som du behöver och får igång den.

Den mest grundläggande ASP.NET Core-appens Program.cs-fil:

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/", () => "Hello World!");

app.Run();

Med föregående kod:

  • En grundläggande ASP.NET Core-webbapp konfigureras som lyssnar efter HTTP GET-begäranden på rot-URL:en ("/") och svarar med "Hello World!".
  • Appen initieras, konfigurerar en enda väg och startar webbservern.

Blazor

Du kan skapa ett interaktivt webbgränssnitt med ASP.NET Core med Blazor. Blazor är ett komponentbaserat webbgränssnittsramverk integrerat med ASP.NET Core, som används för att skapa interaktiva webb-UIs med HTML, CSS och C#.

En återanvändbar Blazor-komponent, till exempel följande Counter komponent, definieras i en Counter.razor-fil :

@page "/counter"
@rendermode InteractiveServer

<PageTitle>Counter</PageTitle>

<h1>Counter</h1>

<p role="status">Current count: @currentCount</p>

<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>

@code {
    private int currentCount = 0;

    private void IncrementCount()
    {
        currentCount++;
    }
}

Med föregående kod:

  • En komponent skapas som visar en räknare.
  • Blocket @code innehåller komponentens logik med hjälp av C#, inklusive en metod för att öka räknaren.
  • Räknarvärdet visas och uppdateras varje gång knappen klickas.
  • En komponentmetod möjliggör återanvändning av kod i olika delar av programmet och har flexibiliteten att köras antingen i webbläsaren eller på servern i en Blazor-app.

Komponenten Counter kan läggas till på valfri webbsida i appen genom att lägga till elementet <Counter /> .

@page "/"

<PageTitle>Home</PageTitle>

<h1>Hello, world!</h1>

<Counter />

API:er

ASP.NET Core tillhandahåller ramverk för att skapa API:er, gRPC-tjänster och realtidsappar med SignalR för att omedelbart skicka datauppdateringar till klienter.

Grundläggande minimalt API:

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/hello", () => "Hello, World!");

app.Run();

Med föregående kod:

  • Ett minimalt API har konfigurerats som lyssnar efter HTTP GET-begäranden på /hello-URL:en och svarar med "Hello, World!".
  • WebApplicationBuilder Används för att konfigurera appen.
  • Metoden MapGet definierar en väg och en hanterare för GET-begäranden.

Mellanprogram

ASP.NET Core använder en pipeline med mellanprogramskomponenter för att hantera HTTP-begäranden och svar. Den här modulära metoden ger flexibilitet så att du kan anpassa och utöka programmets funktioner genom att lägga till eller ta bort mellanprogramskomponenter efter behov.

Pipelinen för mellanprogram bearbetar HTTP-begäranden på ett sekventiellt sätt, vilket säkerställer att varje komponent kan utföra sin avsedda uppgift innan begäran skickas till nästa komponent i pipelinen.

Lägga till inbyggda mellanprogram i filen Program.cs :

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.UseHttpsRedirection();

app.UseRouting();

app.MapStaticAssets();

app.UseAuthentication();

app.UseAuthorization();

app.MapGet("/", () => "Hello World!");

app.Run();

I föregående kod lades flera vanliga mellanprogramskomponenter till:

  • UseHttpsRedirection: Omdirigerar HTTP-begäranden till HTTPS.
  • UseRouting: Aktiverar routning för att mappa begäranden till slutpunkter.
  • MapStaticAssets: Optimerar leveransen av statiska filer som HTML, CSS, JavaScript, bilder och andra tillgångar.
  • UseAuthentication: Lägger till autentiseringsfunktioner.
  • UseAuthorization: Lägger till auktoriseringsfunktioner.
  • app.MapGet: Det här är en enkel slutpunkt som visar att programmet körs.

Beroendeinmatning

ASP.NET Core innehåller inbyggt stöd för beroendeinmatning (DI) för att konfigurera tjänster som används av appen och dess olika ramverkskomponenter.

Du kanske till exempel vill konfigurera en tjänst centralt med hjälp av ett ramverk som EntityFramework Core som andra delar av appen är beroende av för att få åtkomst till en databas. Du kan konfigurera en databaskontext från EntityFramework Core som en tjänst med hjälp av beroendeinmatning så här:

public class MyDbContext : DbContext
{
    public MyDbContext(DbContextOptions<MyDbContext> options) : base(options) { }
    
    public DbSet<Product> Products { get; set; } = default!;
}

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddDbContext<MyDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));

var app = builder.Build();

app.Run();

Med föregående kod:

  • A DbContext konfigureras som en tjänst med hjälp av beroendeinmatning.
  • WebApplicationBuilder Används för att konfigurera appen.
  • Metoden AddDbContext registrerar DbContext med containern för beroendeinmatning.
  • Anslutningssträng hämtas från konfigurationen och används för att konfigurera databaskontexten.

Konfiguration

ASP.NET Core har stöd för åtkomst till konfigurationsdata från en mängd olika källor, till exempel JSON-filer, miljövariabler och kommandoradsargument.

Konfigurera en anslutningssträng i en appsetting.json fil:

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=MyDatabase;Trusted_Connection=True;"
  }
}

I filen Program.cs:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddDbContext<MyDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));

var app = builder.Build();

app.Run();

Med föregående kod:

  • Anslutningssträngen konfigureras i filenappsettings.json .
  • WebApplicationBuilder Används för att konfigurera appen.
  • Metoden AddDbContext registrerar DbContext med containern för beroendeinmatning.
  • Anslutningssträng hämtas från konfigurationen och används för att konfigurera databaskontexten.

Övervakning och diagnostik

ASP.NET Core tillhandahåller en omfattande uppsättning verktyg för övervakning och underhåll av dina programs hälsa och prestanda. Dessa funktioner kan enkelt läggas till i ditt program som mellanprogramkomponenter, vilket integrerar specifika funktioner i projektet:

  • Inbyggda mått: ASP.NET Core innehåller inbyggda mått som spårar olika aspekter av programmets prestanda, till exempel begärandefrekvenser, svarstider och felfrekvenser.
  • Flexibelt loggningsramverk: Ett flexibelt loggningsramverk är inbyggt och stöder olika loggningsproviders, inklusive konsol, felsökning och händelsekälla. Detta hjälper dig att samla in detaljerade loggar för diagnostik och övervakning.
  • Spårning: ASP.NET Core stöder distribuerad spårning, vilket hjälper dig att spåra flödet av begäranden mellan olika tjänster och komponenter. Detta är användbart för att diagnostisera prestandaproblem och förstå interaktionerna mellan olika delar av ditt program.
  • OpenTelemetry: ASP.NET Core integreras med OpenTelemetry, ett ramverk för observerbarhet med öppen källkod för molnbaserad programvara. OpenTelemetry tillhandahåller standardiserade API:er och instrumentation för insamling av mått, loggar och spårningar, så att du kan övervaka och diagnostisera dina program mer effektivt.
  • Hälsokontroller: Med API:et för hälsokontroller kan du övervaka hälsotillståndet för ditt program och dess beroenden. Du kan konfigurera hälsokontroller för att rapportera status för olika komponenter, till exempel databaser, externa tjänster med mera.
  • Diagnostikverktyg: ASP.NET Core innehåller olika diagnostikverktyg, till exempel dotnet-trace, dotnet-dump och dotnet-gcdump, som hjälper dig att samla in och analysera diagnostikdata från ditt program.