I udviklingen af webapplikationer er håndteringen af data og optimering af ydeevnen essentielle elementer for at sikre en effektiv brugeroplevelse. ASP.NET Core tilbyder en række funktionaliteter, som gør det muligt at forbedre både dataoverførsel og cache-håndtering. Denne sektion dækker hvordan man arbejder med query strings til at sende komplekse objekter, anvender Cache Tag Helpers for at forbedre ydeevnen ved caching, samt hvordan Environment Tag Helpers kan bruges til at vise specifik information i forskellige miljøer.

Når du arbejder med ASP.NET Core, kan du bruge HTTP-forespørgsler til at sende data mellem server og klient. Et af de mest almindelige scenarier er brugen af query strings til at videregive data. For eksempel kan du oprette en handling i din controller, som tager et objekt som parameter, og videresender det til en visning. I eksemplet nedenfor oprettes en handling kaldet Shipper, som modtager en Shipper-enhed fra en query string og videregiver denne enhed til en Razor-vist.

csharp
public IActionResult Shipper(Shipper shipper)


{
    return View(shipper);
}

For at vise dataene i en visning, kan du oprette en Razor-fil kaldet Shipper.cshtml. I denne fil kan du derefter vise oplysninger om den specifikke afsender som f.eks. firmaets navn og telefonnummer.

html
@model Shipper
@{
    ViewData["Title"] = "Shippers";
}
<h2>@ViewData["Title"]</h2>
<table>


    <tr><td>@Model.ShipperId</td><td>@Model.CompanyName</td><td>@Model.Phone</td></tr>


</table>

Hvis du vil vise flere komplekse objekter via query strings, kan du oprette en metode, der henter data fra en database. I eksemplet nedenfor hentes data om en afsender fra en Northwind-database, og disse data gemmes i en ordbog (dictionary), som derefter bruges i Razor-funktionen.

csharp
@inject NorthwindContext db


@functions {
    public async Task<Dictionary<string, string>> GetShipperData()
    {
        Shipper? shipper = await db.Shippers.FindAsync(1);
        Dictionary<string, string> keyValuePairs = new();
        if (shipper != null)
        {
            keyValuePairs = new()
            {
                { "ShipperId", shipper.ShipperId.ToString() },
                { "CompanyName", shipper.CompanyName },
                { "Phone", shipper.Phone ?? string.Empty }
            };
        }
        return keyValuePairs;
    }
}

En udfordring ved at sende komplekse objekter via query strings er den begrænsning, der findes på længden af URL'en, som normalt ikke bør overstige 1000 tegn. For at sende større mængder data anbefales det at bruge POST i stedet for GET-metoden.

Når du har konfigureret disse funktionaliteter, kan du starte dit projekt og teste navigationen på din webside. Dette gør det muligt at observere, hvordan data bliver overført og vist via forskellige handlinger og visninger. En vigtig note er, at ved specifikation af protokollen (HTTP eller HTTPS) sikres det, at den genererede URL inkluderer protokollen, domænet og portnummeret, hvilket gør det til en praktisk metode til at opnå en absolut URL i stedet for den relative URL.

For at optimere ydeevnen på din webapplikation kan du anvende Cache Tag Helpers. Disse hjælper med at cache indholdet på websidens sider og forbedre svartiderne. Du kan vælge at cache indhold i hukommelsen eller anvende en distribueret cache, som er ideel for store webapplikationer, der kører på flere servere. Hvis du kun arbejder med en enkelt server, er en in-memory cache tilstrækkelig.

Cache Tag Helpers tilbyder flere attributter, som kan hjælpe dig med at tilpasse cache-tiden og de betingelser, der bestemmer, hvornår data skal opdateres. For eksempel kan du sætte en expires-after-attribut for at bestemme, hvornår cachen skal udløbe, eller du kan bruge expires-sliding for at sætte en dynamisk udløbstid baseret på aktiviteten i applikationen.

html
<cache expires-after="00:20:00">


    <p>Live UTC: @DateTime.UtcNow.ToLongDateString() at @DateTime.UtcNow.ToLongTimeString()</p>
</cache>
<cache expires-after="00:00:10">


    <p>Cached UTC: @DateTime.UtcNow.ToLongDateString() at @DateTime.UtcNow.ToLongTimeString()</p>


</cache>

Når du implementerer caching, kan du også bruge Environment Tag Helpers, som giver dig mulighed for at vise indhold afhængigt af, hvilket miljø din applikation kører i. For eksempel kan du vise specifik information til udviklere og testere, når applikationen kører i et staging-miljø, men udelade den information, når applikationen er i produktion.

Med Environment Tag Helper kan du nemt styre, hvilket indhold der vises i forskellige miljøer ved at bruge attributter som names, include og exclude.

html
<environment names="Development,Staging">


    <p>This content is visible only in Development or Staging environments.</p>
</environment>

Dette giver dig mulighed for at tilpasse din applikation til forskellige faser af udviklingen og produktionen, og sikrer at kun relevante oplysninger bliver vist til de rigtige brugere.

I alt kan brugen af query strings, caching og miljøspecifik visning hjælpe med at skabe en effektiv, responsiv og optimeret webapplikation. Når du arbejder med disse funktioner, skal du dog være opmærksom på de begrænsninger, der findes med URL-længder, og hvordan du bedst håndterer cachedata for at sikre både performance og korrekt opdatering af indholdet.

Hvordan bygger man en Hello World gRPC-klient i ASP.NET Core?

Når du arbejder med gRPC i ASP.NET Core, er der flere vigtige trin, der sikrer, at både serveren og klienten fungerer korrekt. For at forstå, hvordan man bygger en gRPC-klient, skal vi gennemgå nogle specifikke konfigurationer og metoder, som gør integrationen mulig.

Først skal vi oprette og konfigurere gRPC-serveren. Dette gøres ved at tilføje de nødvendige services i programmet. For at sikre, at serveren er korrekt konfigureret til at håndtere gRPC-anmodninger, tilføjes builder.Services.AddGrpc(); i Program.cs, hvor gRPC-tjenesten bliver tilføjet til den HTTP-pipeline. Dernæst skal du konfigurere porten for serveren i filen launchSettings.json i Properties-mappen, så den benytter port 5121:

json
{


  "profiles": {
    "Northwind.Grpc.Service": {
      "commandName": "Project",
      "dotnetRunMessages": true,


      "launchBrowser": false,


      "applicationUrl": "https://localhost:5121",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    }
  }
}

Når serveren er klar, kan vi begynde at oprette klienten, der skal kommunikere med gRPC-tjenesten. Først tilføjer vi et ASP.NET Core MVC-webprojekt, der skal fungere som klienten. I dette projekt tilføjer vi nødvendige pakker, som gør det muligt at kalde gRPC-tjenesten. De vigtigste pakker inkluderer Grpc.Net.ClientFactory og Google.Protobuf, som begge kræves for at kunne kommunikere korrekt med en gRPC-server. Husk at Grpc.Tools-pakken kun er nødvendig under udvikling og bør ikke inkluderes i produktionsmiljøet.

Når pakken er tilføjet, skal du åbne launchSettings.json og konfigurere porten til at bruge 5122 i klientens indstillinger:

json
{
  "profiles": {
    "Northwind.Grpc.Client.Mvc": {
      "commandName": "Project",


      "dotnetRunMessages": true,


      "launchBrowser": false,
      "applicationUrl": "https://localhost:5122",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    }
  }
}

Efter at have konfigureret klienten, skal du kopiere Protos-mappen fra serverprojektet til klientprojektet. Denne mappe indeholder de .proto-filer, som definerer de gRPC-tjenester, der skal bruges. Du skal derefter justere namespace i greet.proto, så det passer til klientens namespace:

proto
option csharp_namespace = "Northwind.Grpc.Client.Mvc";

Dernæst skal du sikre dig, at den registrerede .proto-fil i projektfilen angiver, at den bruges på klientsiden. Dette gøres ved at ændre konfigurationen til at angive GrpcServices som Client, som vist her:

xml
<GrpcServices Include="Protos\greet.proto" GrpcServices="Client" />

Når projektet er bygget, vil de nødvendige klasser blive genereret automatisk, og du vil kunne bruge disse klasser til at kommunikere med gRPC-serveren. En af de vigtige klasser er Greeter.GreeterClient, som kan bruges til at sende og modtage gRPC-anmodninger. I klientens Program.cs skal du importere de nødvendige namespaces for gRPC-klienten og derefter tilføje klienten til servicecontaineren:

csharp
builder.Services.AddGrpcClient("Greeter", options =>


{
    options.Address = new Uri("https://localhost:5121");
});

I controlleren, f.eks. HomeController.cs, kan du bruge gRPC-klienten til at sende en anmodning til serveren. Du kan indlæse gRPC-klienten i controllerens konstruktør via en klientfabrik, som følger:

csharp
public class HomeController : Controller
{
    private readonly ILogger _logger;
    protected readonly Greeter.GreeterClient greeterClient;
    public HomeController(ILogger logger, GrpcClientFactory factory)
    {
        _logger = logger;
        greeterClient = factory.CreateClient("Greeter");
    }
}

I controllerens Index-metode kan du bruge gRPC-klienten til at sende en HelloRequest og modtage et svar, som derefter kan vises på brugergrænsefladen:

csharp
public async Task Index(string name = "Henrietta")


{
    try
    {
        HelloReply reply = await greeterClient.SayHelloAsync(new HelloRequest { Name = name });
        ViewData["greeting"] = "Greeting from gRPC service: " + reply.Message;
    }
    catch (Exception ex)
    {
        _logger.LogWarning($"Northwind.Grpc.Service is not responding.");
        ViewData["exception"] = ex.Message;
    }
    return View();
}

På klientens webside kan du vise svaret fra gRPC-serveren i Index.cshtml ved at renderer beskeden, som kommer fra serveren, hvis den eksisterer:

html
@if (ViewData["greeting"] is not null) {
    @ViewData["greeting"]
}
@if (ViewData["exception"] is not null) {
    @ViewData["exception"]
}

For at sikre, at din gRPC-klient fungerer korrekt, kan du starte både gRPC-serveren og klienten. Når du navigerer til klientens webside på https://localhost:5122/, bør du se en velkomstbesked, der er returneret fra serveren, som bekræfter, at kommunikationen mellem server og klient fungerer som forventet.

Når du arbejder med gRPC i .NET, er det vigtigt at forstå de underliggende teknologier, som f.eks. HTTP/2, der bruges til at opnå høj ydeevne og effektiv kommunikation. GRPC er ikke kun hurtigere end traditionelle REST API'er, men det tilbyder også mere struktureret og stærkt typet kommunikation gennem ProtoBuf. Denne teknologi er især nyttig i mikrotjenestearkitekturer, hvor små tjenester skal kommunikere effektivt og pålideligt.

Hvordan er håndens og hofteleddets knogler opbygget og forbundet?
Hvordan fund kan justere deres faktoreksponeringer for at matche Buffett's afkast
Hvordan man afslutter en akademisk tekst: Konklusioner, ikke forvirring