I denne kapittel diskuterer vi hvordan man bygger og sikrer webtjenester ved bruk av .NET 7, med fokus på minimal API-utvikling, som gir et lettvektig og raskt alternativ for å utvikle HTTP-tjenester. Minimal API er et nytt konsept introdusert i .NET 6 og videreutviklet i .NET 7, som forenkler prosessen med å utvikle API-er uten å måtte forholde seg til tungvint infrastruktur som tidligere har vært nødvendig med ASP.NET Core MVC.

Minimal API i .NET 7 er designet for å gjøre utviklingen av små, effektive tjenester så rask og enkel som mulig, samtidig som man beholder den nødvendige fleksibiliteten som kreves for større, mer komplekse applikasjoner. Dette gjør det til et utmerket valg for utviklere som ønsker å lage moderne, skalerbare API-er for både små og store prosjekter.

For å komme i gang med å bygge et minimal API, kreves det kun noen få grunnleggende komponenter. Først og fremst må du definere en HTTP-forespørsel (GET, POST, PUT, DELETE) og en håndterer for forespørselen, som kan behandles av den samme tjenesten. Dette forenkler koden og gjør den lettere å vedlikeholde. Det er ingen behov for tunge controller-klasser eller komplekse rutemønstre, som ofte kan gjøre prosessen unødvendig tung. Minimal API lar deg opprette API-endepunktene rett i programstarten ved å definere dem i Program.cs, uten behov for separate controller-filer.

En annen viktig fordel med minimal API er at det gir høy ytelse ved å redusere overheaden som oppstår i tradisjonelle webapplikasjoner. I .NET 7 er det lagt stor vekt på ytelse, og minimal API er en av de mest optimale måtene å bygge applikasjoner som er både raske og lette på systemressursene.

Sikkerhet er også en kritisk faktor når man bygger webtjenester. I .NET 7 er det forbedringer i hvordan man kan implementere autentisering og autorisasjon. For minimal API kan du enkelt integrere sikkerhet ved hjelp av middleware, som gjør at sensitive operasjoner kan beskyttes gjennom JWT-baserte autentiseringstoken eller andre mekanismer som OAuth 2.0 og OpenID Connect. Dette gir deg muligheten til å bygge API-er som er både raske og sikre, noe som er essensielt for enhver virksomhet i dag.

En viktig del av utviklingen er også logging og overvåkning. Med .NET 7 kan du effektivt logge alle hendelser som skjer i applikasjonen din og spore dem i sanntid. Dette gir verdifulle innsikter som hjelper til med å identifisere problemer tidlig og forbedre applikasjonens pålitelighet og brukeropplevelse. For å gjøre dette, kan du bruke integrerte løsninger som ILogger, som kan kombineres med eksterne tjenester som Azure Application Insights, for å få dypere innsikt i applikasjonens ytelse og feil.

Når det gjelder distribusjon, gir .NET 7 muligheter for fleksible og skalerbare distribusjonsmetoder. Du kan for eksempel bruke Docker-containere for å gjøre tjenestene dine plattformuavhengige og enkle å distribuere til forskjellige miljøer, enten det er på lokale servere eller i skyen. Dette gjør at applikasjonene kan rulles ut raskt og effektivt, og samtidig dra nytte av skybaserte ressurser som Azure.

Det er viktig å forstå at selv om minimal API gir et veldig lettvint og raskt utviklingsmiljø, er det ikke nødvendigvis egnet for alle typer applikasjoner. For mer komplekse, store systemer som krever omfattende forretningslogikk, kan det være mer hensiktsmessig å bruke tradisjonelle API-løsninger med ASP.NET Core MVC, som gir mer struktur og fleksibilitet for å håndtere store kodestrukturer.

Ved å bruke minimal API sammen med andre moderne teknologier som gRPC for mikrotjenester eller GraphQL for fleksibel dataspørring, kan du bygge robuste og skalerbare applikasjoner som leverer høy ytelse og lav latens. Å kombinere disse teknologiene i en helhetlig arkitektur gir et solid grunnlag for å bygge moderne webtjenester.

I tillegg er det viktig å ta hensyn til testing og feilretting i utviklingsprosessen. Minimal API gjør det enklere å skrive enhetstester, ettersom det krever færre konfigurasjoner og mindre kode. Ved å bruke testdrevet utvikling (TDD) kan du kontinuerlig validere at API-endepunktene fungerer som de skal, samtidig som du sikrer høy kodekvalitet gjennom hele utviklingssyklusen.

I sum gir minimal API i .NET 7 en rask, effektiv og sikker løsning for å utvikle webtjenester som kan skaleres etter behov. Med riktige verktøy og praksis på plass, kan utviklere bygge applikasjoner som er både robuste og fleksible, uten å måtte håndtere den unødvendige kompleksiteten som ofte følger med større rammeverk.

Hvordan man opretter et SignalR Hub i en ASP.NET Core MVC-applikation

I udviklingen af realtidskommunikation ved hjælp af SignalR i ASP.NET Core MVC-projekter er der flere essentielle trin, der skal følges for at oprette og konfigurere et SignalR Hub, der muliggør chatfunktioner og beskedudveksling. Dette inkluderer oprettelse af modeller, opsætning af server-side SignalR-hub, samt konfiguration af de nødvendige services i projektet.

En grundlæggende komponent i et SignalR Hub er brugermodel og beskedmodel, som gør det muligt for systemet at håndtere chatbrugere og kommunikere beskeder mellem dem. I den første del af opsætningen defineres en UserModel, der holder oplysninger om brugeren, såsom navn, forbindelse-ID og tilhørende grupper. Denne model gør det muligt at registrere nye brugere og holde styr på deres forbindelser, så beskeder kan sendes til specifikke brugere eller grupper.

csharp
namespace Northwind.Chat.Models; 


public class UserModel 
{ 
    public string Name { get; set; } = null!; 


    public string ConnectionId { get; set; } = null!; 


    public string? Groups { get; set; } // komma-separeret liste 
}

I den næste model, MessageModel, defineres strukturen for en besked, der skal sendes. Denne model indeholder oplysninger om afsenderen, modtageren og beskedens indhold. Modellen gør det muligt at sende beskeder fra én bruger til en anden, eller fra en bruger til en gruppe.

csharp
namespace Northwind.Chat.Models; 
public class MessageModel 
{ 


    public string From { get; set; } = null!; 


    public string To { get; set; } = null!; 
    public string? Body { get; set; } 
}

Når disse modeller er oprettet, kan man begynde at implementere SignalR Hubben, som er kernen i realtidskommunikationen. I hubben defineres de metoder, som klienten kan kalde for at registrere sig selv eller sende beskeder. Et væsentligt aspekt ved SignalR Hubben er, hvordan brugernes forbindelser og grupper håndteres. Hver bruger oprettes eller opdateres i en statisk ordbog, hvor deres navn er den unikke nøgle. Hvis en bruger allerede er registreret, kan systemet opdatere deres forbindelse og gruppeinformationer.

csharp
using Microsoft.AspNetCore.SignalR;


using Northwind.Chat.Models;
namespace Northwind.SignalR.Service.Hubs; 
public class ChatHub : Hub 
{ 
    private static Dictionary<string, UserModel> Users = new(); 


    public async Task Register(UserModel newUser) 


    { 
        UserModel user; 
        string action = "registreret som en ny bruger"; 
        if (Users.ContainsKey(newUser.Name)) 
        { 
            user = Users[newUser.Name]; 
            if (user.Groups != null) 
            { 
                foreach (string group in user.Groups.Split(',')) 
                { 
                    await Groups.RemoveFromGroupAsync(user.ConnectionId, group); 
                } 
            } 
            user.Groups = newUser.Groups; 
            user.ConnectionId = Context.ConnectionId; 
            action = "opdateret din registrering"; 
        } 
        else 
        { 
            if (string.IsNullOrEmpty(newUser.Name)) 
            { 
                newUser.Name = Guid.NewGuid().ToString(); 
            } 
            newUser.ConnectionId = Context.ConnectionId; 
            Users.Add(newUser.Name, newUser); 
            user = newUser; 
        } 
        if (user.Groups != null) 
        { 


            foreach (string group in user.Groups.Split(',')) 


            { 
                await Groups.AddToGroupAsync(user.ConnectionId, group); 
            } 
        } 
        MessageModel message = new() 
        { 
            From = "SignalR Hub", 
            To = user.Name, 
            Body = string.Format("Du har succesfuldt {0} med forbindelses-ID {1}.", action, user.ConnectionId) 
        }; 
        IClientProxy proxy = Clients.Client(user.ConnectionId); 
        await proxy.SendAsync("ReceiveMessage", message); 
    }
    public async Task SendMessage(MessageModel message) 
    { 
        IClientProxy proxy; 
        if (string.IsNullOrEmpty(message.To)) 
        { 
            message.To = "Alle"; 
            proxy = Clients.All; 
            await proxy.SendAsync("ReceiveMessage", message); 
            return; 
        } 
        string[] userAndGroupList = message.To.Split(','); 
        foreach (string userOrGroup in userAndGroupList) 
        { 
            if (Users.ContainsKey(userOrGroup)) 
            { 
                message.To = $"Bruger: {Users[userOrGroup].Name}"; 
                proxy = Clients.Client(Users[userOrGroup].ConnectionId); 
            } 
            else 
            { 
                message.To = $"Gruppe: {userOrGroup}"; 
                proxy = Clients.Group(userOrGroup); 
            } 
            await proxy.SendAsync("ReceiveMessage", message); 
        } 
    }
}

For at sikre, at SignalR Hubben fungerer korrekt i en ASP.NET Core MVC-applikation, skal du konfigurere SignalR i Program.cs-filen. Dette inkluderer at tilføje SignalR-tjenesten og oprette en rute, der forbinder klienterne til den relevante hub.

csharp
builder.Services.AddSignalR();

Dette trin sikrer, at SignalR er korrekt integreret i applikationen og er klar til at modtage og sende beskeder i realtid.

En vigtig overvejelse, som udviklere bør have i tankerne, er, hvordan man håndterer forskellige scenarier for beskedkommunikation. For eksempel, når en bruger ikke har specificeret en modtager (feltet "To" er tomt), sendes beskeden til alle tilsluttede klienter. Hvis der er en angivet modtager, bliver beskeden sendt direkte til den pågældende bruger eller gruppe. Denne fleksibilitet gør det muligt at sende både individuelle og gruppebaserede beskeder effektivt.

Det er også væsentligt at forstå, hvordan forbindelse og grupperegistrering fungerer i et SignalR-miljø. For eksempel kan brugere tilknyttes flere grupper, og beskeder kan sendes til specifikke grupper baseret på brugerens medlemskab af disse grupper. Hvis en bruger ændrer deres tilknytning til grupper, bliver disse ændringer straks reflekteret i systemet, og de relevante opdateringer bliver sendt til de tilknyttede grupper.

For udviklere, der ønsker at implementere SignalR effektivt, er det vigtigt at tage højde for ydeevne, skalerbarhed og sikkerhed. Når man arbejder med realtidskommunikation, skal systemet kunne håndtere et stort antal samtidige forbindelser og beskedudvekslinger uden at forårsage betydelige forsinkelser. Desuden bør adgangen til SignalR-hubben beskyttes for at sikre, at kun autoriserede brugere kan sende og modtage beskeder.

Hvordan man opretter og arbejder med kategorier i en .NET MAUI-applikation

Når vi udvikler moderne applikationer ved hjælp af .NET MAUI, er det ofte nødvendigt at strukturere data og opretholde en ren arkitektur, der gør det lettere at vedligeholde og udvide applikationen. En af de mest anvendte designmønstre i denne sammenhæng er MVVM (Model-View-ViewModel). Dette mønster adskiller applikationens logik fra præsentationen, hvilket giver os mulighed for at holde koden organiseret og let at teste. I denne sammenhæng skal vi dykke ned i, hvordan vi kan arbejde med kategorier ved hjælp af .NET MAUI og MVVM Community Toolkit.

Først og fremmest skal vi sikre, at vores applikation har de nødvendige afhængigheder. Det betyder, at vi skal tilføje relevante pakker til projektet, såsom .NET MAUI Community Toolkit og MVVM Community Toolkit. Dette gøres let ved at tilføje pakke-referencer i projektfilen for Northwind.Maui.Blazor.Client:

xml
<PackageReference Include="CommunityToolkit.Mvvm" Version="8.0.0" />


<PackageReference Include="Microsoft.Maui.CommunityToolkit" Version="1.0.0" />

Efter at have tilføjet disse pakker skal du bygge projektet for at hente de nødvendige afhængigheder. Du vil sandsynligvis modtage en advarsel, da .NET MAUI Community Toolkit kører en kodeanalysator for at kontrollere, om du har kaldt udvidelsesmetoden for at aktivere værktøjet. Denne metode skal aktiveres i MauiProgram.cs ved at tilføje følgende kode:

csharp
var builder = MauiApp.CreateBuilder();
builder
   .UseMauiApp<App>()
   .UseMauiCommunityToolkit()
   .ConfigureFonts(fonts =>
   {
       fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
   });

Oprettelse af en Observable Model for Kategorier

For at arbejde med kategorier i applikationen skal vi oprette en model, der er kompatibel med MVVM-mønsteret. I Views/Categories-mappen kan vi oprette en ny klasse Category.cs, som implementerer et observerbart objekt ved hjælp af ObservableObject fra Community Toolkit. Dette giver os mulighed for at binde dataene til UI-elementer, således at UI automatisk opdateres, når dataene ændrer sig.

csharp
using CommunityToolkit.Mvvm.ComponentModel;


namespace Northwind.Maui.Blazor.Client.Views.Categories;
internal partial class Category : ObservableObject
{
    [ObservableProperty]
    [NotifyPropertyChangedFor(nameof(PicturePath))]
    private int categoryId;
    [ObservableProperty]
    private string categoryName;
    [ObservableProperty]
    private string description;
    [ObservableProperty]
    private byte[] picture;
    [ObservableProperty]
    private string picturePath;
}

I denne model har vi defineret de nødvendige egenskaber, såsom CategoryId, CategoryName, Description, og Picture. Værdien af PicturePath beregnes dynamisk og formateres til at inkludere kategori-ID’et, så vi kan vise et billede, der er knyttet til hver kategori.

Oprettelse af en ViewModel til Kategorier

Nu skal vi oprette en ViewModel, der styrer logikken for at hente og vise kategorier. Dette gøres i CategoriesViewModel.cs, hvor vi arver fra ObservableCollection<Category>, hvilket giver os mulighed for at oprette en samling af kategorier, som automatisk opdateres, når dataene ændres.

csharp
using CommunityToolkit.Mvvm.Input;


using System.Collections.ObjectModel;
using System.Net.Http.Headers;
using System.Net.Http.Json;
namespace Northwind.Maui.Blazor.Client.Views.Categories;
internal partial class CategoriesViewModel : ObservableCollection<Category>
{
    public string InfoMessage { get; set; } = string.Empty;


    public string ErrorMessage { get; set; } = string.Empty;


    public bool ErrorMessageVisible { get; set; }
    public CategoriesViewModel()
    {
        try
        {
            HttpClient client = new()
            {
                BaseAddress = new Uri("http://localhost:5192")
            };
            InfoMessage = $"BaseAddress: {client.BaseAddress}. ";
            client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
            HttpResponseMessage response = client.GetAsync("api/categories").Result;
            response.EnsureSuccessStatusCode();
            IEnumerable<Category> categories = response.Content.ReadFromJsonAsync<IEnumerable<Category>>().Result;
            foreach (Category category in categories)
            {
                int offset = 78; // remove OLE header
                category.Picture = category.Picture.AsSpan(offset, category.Picture.Length - offset).ToArray();
                category.PicturePath = $"category{category.CategoryId}_small.jpeg";
                Add(category);
            }
            InfoMessage += $"{Count} categories loaded.";
        }
        catch (Exception ex)
        {
            ErrorMessage = ex.Message;
            ErrorMessageVisible = true;
        }
    }
    [RelayCommand]
    private void AddCategoryToFavorites()
    {
        Console.WriteLine("Add category to favorites");
    }
    [RelayCommand]
    private void DeleteCategory()
    {
        Console.WriteLine("Delete category");
    }
}

I denne ViewModel henter vi kategorierne fra en webtjeneste og opdaterer vores ObservableCollection<Category>, som automatisk binder sig til UI’et og viser de nye data. Vi definerer også nogle kommandoer, såsom at tilføje en kategori til favoritter eller slette en kategori.

Integration med UI

Når vi har oprettet vores ViewModel og Model, kan vi binde dem til UI’et i CategoriesPage.xaml. I denne fil definerer vi brugerfladen og binder den til vores ViewModel. Vi viser kategorierne i et carousel og tilføjer funktionalitet til at vise beskeder og fejl, afhængigt af om webtjenesten har hentet data korrekt.

xaml
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"


             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:categories="clr-namespace:Northwind.Maui.Blazor.Client.Views.Categories"
             x:Class="Northwind.Maui.Blazor.Client.Views.CategoriesPage"
             BackgroundColor="{DynamicResource PageBackgroundColor}">
    <VerticalStackLayout Spacing="25" Padding="30">
        <Label Text="{Binding InfoMessage}" />
        <Label Text="{Binding ErrorMessage}" IsVisible="{Binding ErrorMessageVisible}" TextColor="Red" />
        <CarouselView ItemsSource="{Binding}">
            <CarouselView.ItemTemplate>
                <DataTemplate>
                    <Image Source="{Binding PicturePath}" />
                </DataTemplate>
            </CarouselView.ItemTemplate>
        </CarouselView>
    </VerticalStackLayout>
</ContentPage>

Vigtige overvejelser

Når du arbejder med .NET MAUI og MVVM, er det vigtigt at sikre, at dine data bindings er korrekt opsat, og at du tager højde for eventuelle opdateringer af UI’et, når dataene ændres. Vær opmærksom på, at MVVM kræver, at du holder logik og præsentation adskilt, hvilket giver en renere og mere vedligeholdelsesvenlig kode.

Desuden er det vigtigt at forstå, at selvom vi benytter et serverbaseret API til at hente data, kan der opstå problemer med netværksforbindelser eller serverfejl, som skal håndteres korrekt i applikationen. Fejlmeddelelser bør være klare og brugervenlige for at sikre en god brugeroplevelse.

Hvordan opretter man enhedstest for Entity Models i EF Core?

Når vi arbejder med Entity Framework (EF) Core og SQL Server, er en vigtig del af udviklingsprocessen at sikre, at databasen og entitetsmodellerne fungerer korrekt. En effektiv metode til at validere, at vores applikation fungerer som forventet, er at bruge enhedstest. Enhedstest giver os mulighed for at isolere og validere dele af vores kode, hvilket gør det muligt at sikre korrekt integration og stabilitet.

I denne sammenhæng vil vi fokusere på, hvordan man skriver enhedstest for at sikre, at vores databasekontekst og entitetsmodeller fungerer som ønsket i en EF Core-applikation. For at illustrere dette, lad os bruge et eksempel fra Northwind-databasen.

Når man opretter en enhedstest for EF Core, er det nødvendigt at følge tre grundlæggende trin: Arrange (Forberedelse), Act (Handling), og Assert (Bekræftelse).

Arrange: Forberedelse af data og kontekst

Først definerer vi de nødvendige variabler og forbereder vores testmiljø. Dette indebærer at oprette en instans af databasekonteksten. For eksempel, hvis vi arbejder med en NorthwindContext, skal vi sikre, at en forbindelse til databasen er oprettet. Her opretter vi en instans af NorthwindContext og sørger for, at vi har adgang til dataene i den korrekte form.

Act: Handling af testet

Når miljøet er forberedt, udfører vi handlingen, som vi ønsker at teste. I dette tilfælde kan det være at kontrollere, om vi kan oprette forbindelse til databasen. Vi bruger EF Core’s CanConnect() metode til at teste, om en forbindelse kan etableres til databasen. Et andet eksempel kan være at hente en bestemt post fra databasen og kontrollere, om den opfylder de forventede betingelser.

Assert: Bekræftelse af resultater

Efter at have udført handlingen, skal vi bekræfte, om resultatet er som forventet. Dette sker ved at bruge assertion-metoder. For eksempel, hvis vi tester, om en produktpost med ID 1 har navnet "Chai", kan vi bruge en assertion til at bekræfte, at resultatet stemmer overens med forventningen.

Et eksempel på enhedstest kunne være som følger:

csharp
[Fact]
public void CanConnectIsTrue()
{
    using (NorthwindContext db = new()) // Arrange
    {
        bool canConnect = db.Database.CanConnect(); // Act
        Assert.True(canConnect); // Assert
    }
}

En anden test kunne være at kontrollere, om en bestemt databaseudbyder bruges, som her:

csharp
[Fact]


public void ProviderIsSqlServer()
{
    using (NorthwindContext db = new())
    {
        string? provider = db.Database.ProviderName;
        Assert.Equal("Microsoft.EntityFrameworkCore.SqlServer", provider);
    }
}

Disse tests sikrer, at de grundlæggende funktionaliteter fungerer korrekt, og de giver os den nødvendige tryghed, når vi arbejder med databasens kontekst.

Udførelse af enhedstest

Når enhedstestene er blevet skrevet, skal de køres for at bekræfte, at de fungerer korrekt. Dette kan gøres i Visual Studio ved at navigere til "Test | Run All Tests" og se resultaterne i "Test Explorer". I Visual Studio Code kan testen køres ved hjælp af dotnet test kommandoen i terminalen. Resultaterne vil vise, om tests er blevet kørt korrekt, og om de har bestået.

Rydning af dataressourcer

Efter at have kørt vores enhedstest og arbejdet med databasen, er det vigtigt at rydde op i de ressourcer, vi har brugt. Dette kan omfatte at stoppe og fjerne Docker-containere, hvis vi har brugt dem til at køre SQL Server, samt at fjerne eventuelle Azure-ressourcer, vi måtte have oprettet under udviklingen. For at undgå ekstra omkostninger, bør man sørge for at fjerne alle ressourcer, der ikke længere er nødvendige.

Når man arbejder med Azure SQL Database, kan ressourcer fjernes ved at finde den relevante ressourcegruppe i Azure-portalen og slette den. Hvis man har brugt Docker, kan man stoppe containeren og fjerne den med følgende kommandoer:

bash
docker stop azuresqledge
docker rm azuresqledge
docker rmi mcr.microsoft.com/azure-sql-edge

Vigtige overvejelser og yderligere tests

Ud over de grundlæggende tests, som vi har gennemgået, kan det være nyttigt at udvide testdækningen for at sikre, at alle aspekter af applikationen fungerer korrekt. Eksempler på yderligere tests inkluderer:

  • Test af relationer mellem entiteter (f.eks. en én-til-mange relation mellem produkter og kategorier).

  • Validering af, at alle obligatoriske felter i entiteterne er korrekt fyldt ud.

  • Test af forretningslogik, der er integreret i entiteterne, som f.eks. beregning af priser eller rabatter.

  • Test af databasens ydeevne under belastning for at sikre, at den kan håndtere store mængder data effektivt.

Det er også vigtigt at forstå, hvordan Entity Framework Core fungerer under hætten. EF Core bruger LINQ til at generere SQL-forespørgsler, som derefter køres på databasen. Derfor kan det være nyttigt at udføre præstationsmålinger og optimere forespørgsler for at undgå ineffektiv databehandling. En nyttig teknik her er at bruge værktøjer som Benchmark.NET til at sammenligne ydeevnen mellem ADO.NET og EF Core.

Testning og optimering af databasetilgange er afgørende for at opbygge en robust og effektiv applikation. Uanset om det er via enhedstest eller performance benchmarking, er det vigtigt at kontinuerligt evaluere og forbedre, hvordan applikationen interagerer med databasen.

Hvordan LDA-modellering og Evaluering Af Emner Kan Berige Tekstanalyse
Hvordan fungerer Deep Learning sammenlignet med Maskinlæring i moderne applikationer?
Hvordan kan madspild omdannes til naturgas gennem hydrotermisk karbonisering?