Werken met gegevens

Tip

Deze inhoud is een fragment uit het eBook, Blazor voor ASP NET-webformulierontwikkelaars voor Azure, beschikbaar op .NET Docs of als een gratis downloadbare PDF die offline kan worden gelezen.

PDF downloaden

Gegevenstoegang is de backbone van een ASP.NET Web Forms-app. Wat gebeurt er met die gegevens als u formulieren voor het web bouwt? Met Web Forms zijn er meerdere technieken voor gegevenstoegang die u kunt gebruiken om te communiceren met een database:

• Gegevensbronnen
• ADO.NET
• Entity Framework

Gegevensbronnen waren besturingselementen die u op een webpagina met webformulieren kunt plaatsen en net als andere besturingselementen kunt configureren. Visual Studio biedt een beschrijvende set dialoogvensters om de besturingselementen te configureren en te binden aan uw webpagina's. Ontwikkelaars die genieten van een 'lage code' of 'geen code' hebben de voorkeur gegeven aan deze techniek toen Web Forms voor het eerst werd uitgebracht.

ADO.NET is de benadering op laag niveau voor interactie met een database. Uw apps kunnen een verbinding met de database maken met opdrachten, gegevenstabellen en gegevenssets voor interactie. De resultaten kunnen vervolgens worden gebonden aan velden op het scherm zonder veel code. Het nadeel van deze benadering was dat elke set ADO.NET objecten (ConnectionCommanden DataTable) gebonden was aan bibliotheken die door een databaseleverancier zijn geleverd. Door gebruik van deze onderdelen is de code stijf en moeilijk te migreren naar een andere database.

Entity Framework

Entity Framework (EF) is het open source object-relationele toewijzingsframework dat wordt onderhouden door de .NET Foundation. In eerste instantie uitgebracht met .NET Framework kan EF code genereren voor de databaseverbindingen, opslagschema's en interacties. Met deze abstractie kunt u zich richten op de bedrijfsregels van uw app en de database laten beheren door een vertrouwde databasebeheerder. In .NET kunt u een bijgewerkte versie van EF met de naam EF Core gebruiken. EF Core helpt bij het genereren en onderhouden van de interacties tussen uw code en de database met een reeks opdrachten die beschikbaar zijn voor u met behulp van het dotnet ef opdrachtregelprogramma. Laten we eens kijken naar enkele voorbeelden om u met een database te laten werken.

EF Code First

U kunt snel aan de slag met het bouwen van uw database-interacties door te beginnen met de klasseobjecten waarmee u wilt werken. EF biedt een hulpprogramma waarmee u de juiste databasecode voor uw klassen kunt genereren. Deze benadering wordt 'Code First'-ontwikkeling genoemd. Bekijk de volgende Product klasse voor een voorbeeld-storefront-app die we willen opslaan in een relationele database, zoals Microsoft SQL Server.

public class Product
{
    public int Id { get; set; }

    [Required]
    public string Name { get; set; }

    [MaxLength(4000)]
    public string Description { get; set; }

    [Range(0, 99999,99)]
    [DataType(DataType.Currency)]
    public decimal Price { get; set; }
}

Product heeft een primaire sleutel en drie extra velden die in onze database worden gemaakt:

• Ef identificeert de Id eigenschap als een primaire sleutel op basis van conventie.
• Name wordt opgeslagen in een kolom die is geconfigureerd voor tekstopslag. Het [Required] kenmerk dat deze eigenschap decoreert, voegt een not null beperking toe om dit gedeclareerde gedrag van de eigenschap af te dwingen.
• Description wordt opgeslagen in een kolom die is geconfigureerd voor tekstopslag en heeft een maximale lengte van 4000 tekens, zoals bepaald door het [MaxLength] kenmerk. Het databaseschema wordt geconfigureerd met een kolom met de naam MaxLength gegevenstype varchar(4000).
• De Price eigenschap wordt opgeslagen als valuta. Het [Range] kenmerk genereert de juiste beperkingen om gegevensopslag buiten de gedeclareerde minimum- en maximumwaarden te voorkomen.

We moeten deze Product klasse toevoegen aan een databasecontextklasse die de verbindings- en vertaalbewerkingen definieert met onze database.

public class MyDbContext : DbContext
{
    public DbSet<Product> Products { get; set; }
}

De MyDbContext klasse biedt de ene eigenschap die de toegang en vertaling voor de Product klasse definieert. Uw toepassing configureert deze klasse voor interactie met de database met behulp van de volgende vermeldingen in de methode van de Startup klasse (of de juiste locatie in Program.cs met behulp van de builder.Services eigenschap in plaats vanservices):ConfigureServices

services.AddDbContext<MyDbContext>(options =>
    options.UseSqlServer("MY DATABASE CONNECTION STRING"));

De voorgaande code maakt verbinding met een SQL Server-database met de opgegeven verbindingsreeks. U kunt de verbindingsreeks in uw appsettings.json-bestand, omgevingsvariabelen of andere configuratieopslaglocaties plaatsen en deze ingesloten tekenreeks op de juiste manier vervangen.

Vervolgens kunt u de databasetabel genereren die geschikt is voor deze klasse met behulp van de volgende opdrachten:

dotnet ef migrations add 'Create Product table'
dotnet ef database update

De eerste opdracht definieert de wijzigingen die u aanbrengt in het databaseschema als een nieuwe EF-migratie met de naam Create Product table. Een migratie definieert hoe u wijzigingen in de nieuwe database toepast en verwijdert.

Nadat u deze hebt toegepast, hebt u een eenvoudige Product tabel in uw database en enkele nieuwe klassen toegevoegd aan het project waarmee u het databaseschema kunt beheren. U vindt deze gegenereerde klassen standaard in een nieuwe map met de naam Migrations. Wanneer u wijzigingen aanbrengt in de Product klasse of meer gerelateerde klassen toevoegt die u wilt gebruiken met uw database, moet u de opdrachtregelopdrachten opnieuw uitvoeren met een nieuwe naam van de migratie. Met deze opdracht wordt een andere set migratieklassen gegenereerd om uw databaseschema bij te werken.

EF Database First

Voor bestaande databases kunt u de klassen voor EF Core genereren met behulp van de .NET-opdrachtregelprogramma's. Gebruik een variatie van de volgende opdracht om de klassen te maken:

dotnet ef dbcontext scaffold "CONNECTION STRING" Microsoft.EntityFrameworkCore.SqlServer -c MyDbContext -t Product -t Customer

De voorgaande opdracht maakt verbinding met de database met behulp van de opgegeven verbindingsreeks en de Microsoft.EntityFrameworkCore.SqlServer provider. Zodra er verbinding is gemaakt, wordt er een databasecontextklasse met de naam MyDbContext gemaakt. Daarnaast worden ondersteunende klassen gemaakt voor de Product en Customer tabellen die zijn opgegeven met de -t opties. Er zijn veel configuratieopties voor deze opdracht om de klassehiërarchie te genereren die geschikt is voor uw database. Raadpleeg de documentatie van de opdracht voor een volledig overzicht.

Meer informatie over EF Core vindt u op de Microsoft Docs-site.

Communiceren met webservices

Toen ASP.NET voor het eerst werd uitgebracht, hadden SOAP-services de voorkeur voor webservers en clients om gegevens uit te wisselen. Sindsdien is er veel veranderd en de voorkeursinteracties met services zijn verschoven naar directe HTTP-clientinteracties. Met ASP.NET Core en Blazorkunt u de configuratie van uw HttpClient in Program.cs of in de Startup klassemethode ConfigureServices registreren. Gebruik deze configuratie wanneer u moet communiceren met het HTTP-eindpunt. Houd rekening met de volgende configuratiecode:

// in Program.cs
builder.Services.AddHttpClient("github", client =>
{
    client.BaseAddress = new Uri("http://api.github.com/");
    // GitHub API versioning
    client.DefaultRequestHeaders.Add("Accept", "application/vnd.github.v3+json");
    // GitHub requires a user-agent
    client.DefaultRequestHeaders.Add("User-Agent", "BlazorWebForms-Sample");
});

Wanneer u toegang nodig hebt tot gegevens vanuit GitHub, maakt u een client met de naam .github De client is geconfigureerd met het basisadres en de aanvraagheaders worden op de juiste wijze ingesteld. Injecteer de IHttpClientFactory onderdelen Blazor met de @inject instructie of een [Inject] kenmerk op een eigenschap. Maak uw benoemde client en communiceer met services met behulp van de volgende syntaxis:

@inject IHttpClientFactory factory

...

@code {
    protected override async Task OnInitializedAsync()
    {
        var client = factory.CreateClient("github");
        var response = await client.GetAsync("repos/dotnet/docs/issues");
        response.EnsureStatusCode();
        var content = await response.Content.ReadAsStringAsync();
    }
}

Deze methode retourneert de tekenreeks die de verzameling problemen beschrijft in de GitHub-opslagplaats dotnet/docs . Het retourneert inhoud in JSON-indeling en wordt gedeserialiseerd in de juiste GitHub-probleemobjecten. Er zijn veel manieren waarop u het HttpClientFactory kunt configureren om vooraf geconfigureerde HttpClient objecten te leveren. Probeer meerdere HttpClient exemplaren met verschillende namen en eindpunten te configureren voor de verschillende webservices waarmee u werkt. Met deze aanpak kunt u gemakkelijker werken met deze services op elke pagina. Zie HTTP-aanvragen maken met IHttpClientFactory voor meer informatie.

VorigeVolgende