Utiliser des types d’enregistrements

Dans ce tutoriel, vous allez créer une application console qui modélise les températures quotidiennes à l’aide d’enregistrements et de structs.

Dans ce tutoriel, vous allez apprendre à :

• Déclarez les enregistrements positionnels et les structures d'enregistrement.
• Créez une petite hiérarchie d’enregistrements.
• Utilisez l’égalité et la mise en forme générées par le compilateur.
• Utilisez des with expressions pour les mutations non destructeurs.

Prerequisites

• Le plus récent .NET SDK
• éditeur Visual Studio Code
• Le DevKit C#

Instructions d’installation

Sur Windows, ce fichier de configuration WinGet est utilisé pour installer tous les prérequis. Si vous avez déjà installé quelque chose, WinGet ignore cette étape.

1. Téléchargez le fichier et double-cliquez pour l’exécuter.
2. Lisez le contrat de licence, tapez et, puis sélectionnez Entrer lorsque vous êtes invité à accepter.
3. Si vous recevez une invite de contrôle de compte d’utilisateur (UAC) qui clignote dans votre barre des tâches, autorisez la poursuite de l'installation.

Sur d’autres plateformes, vous devez installer chacun de ces composants séparément.

1. Téléchargez le programme d’installation recommandé à partir de la page de téléchargement du Kit de développement logiciel (SDK) .NET et double-cliquez pour l’exécuter. La page de téléchargement détecte votre plateforme et recommande le dernier programme d’installation de votre plateforme.
2. Téléchargez le dernier programme d’installation à partir de la page d’accueil Visual Studio Code et double-cliquez pour l’exécuter. Cette page détecte également votre plateforme et le lien doit être correct pour votre système.
3. Cliquez sur le bouton « Installer » dans la page d’extension devKit C#. Cela ouvre Visual Studio Code et vous demande si vous souhaitez installer ou activer l’extension. Sélectionnez « installer ».

Créer l’application et votre premier enregistrement

Créez un dossier pour votre application, exécutez dotnet new consoleet ouvrez le projet généré.

Ajoutez un fichier nommé DailyTemperature.cset ajoutez une position readonly record struct pour les valeurs de température :

public readonly record struct DailyTemperature(double HighTemp, double LowTemp)
{
    public double Mean => (HighTemp + LowTemp) / 2.0;
}

Ajoutez un fichier nommé Program.cset créez des exemples de données de température :

private static DailyTemperature[] data = [
    new DailyTemperature(HighTemp: 57, LowTemp: 30), 
    new DailyTemperature(60, 35),
    new DailyTemperature(63, 33),
    new DailyTemperature(68, 29),
    new DailyTemperature(72, 47),
    new DailyTemperature(75, 55),
    new DailyTemperature(77, 55),
    new DailyTemperature(72, 58),
    new DailyTemperature(70, 47),
    new DailyTemperature(77, 59),
    new DailyTemperature(85, 65),
    new DailyTemperature(87, 65),
    new DailyTemperature(85, 72),
    new DailyTemperature(83, 68),
    new DailyTemperature(77, 65),
    new DailyTemperature(72, 58),
    new DailyTemperature(77, 55),
    new DailyTemperature(76, 53),
    new DailyTemperature(80, 60),
    new DailyTemperature(85, 66) 
];

Cette syntaxe vous donne une modélisation concise des données avec une sémantique de valeur immuable.

Ajouter un comportement à une structure d'enregistrement

Dans DailyTemperature.cs, le struct d’enregistrement a déjà une propriété calculée Mean :

public double Mean => (HighTemp + LowTemp) / 2.0;

Un struct d’enregistrement fonctionne bien ici, car chaque valeur est petite et autonome.

Créer des types de l’enregistrement pour les calculs de degrés-jours

Créez un fichier nommé DegreeDays.cs avec une hiérarchie pour les calculs des jours degrés pour le chauffage et le refroidissement.

public abstract record DegreeDays(double BaseTemperature, IEnumerable<DailyTemperature> TempRecords);

public sealed record HeatingDegreeDays(double BaseTemperature, IEnumerable<DailyTemperature> TempRecords)
    : DegreeDays(BaseTemperature, TempRecords)
{
    public double DegreeDays => TempRecords.Where(s => s.Mean < BaseTemperature).Sum(s => BaseTemperature - s.Mean);
}

public sealed record CoolingDegreeDays(double BaseTemperature, IEnumerable<DailyTemperature> TempRecords)
    : DegreeDays(BaseTemperature, TempRecords)
{
    public double DegreeDays => TempRecords.Where(s => s.Mean > BaseTemperature).Sum(s => s.Mean - BaseTemperature);
}

Calculez maintenant les totaux à partir de votre Main méthode dans Program.cs:

var heatingDegreeDays = new HeatingDegreeDays(65, data);
Console.WriteLine(heatingDegreeDays);

var coolingDegreeDays = new CoolingDegreeDays(65, data);
Console.WriteLine(coolingDegreeDays);

La sortie générée ToString est utile pour les diagnostics rapides pendant que vous effectuez une itération.

Remplacer PrintMembers pour personnaliser la sortie

Lorsque la sortie par défaut inclut trop de bruit, remplacez-la PrintMembers dans l’enregistrement de base :

protected virtual bool PrintMembers(StringBuilder stringBuilder)
{
    stringBuilder.Append($"BaseTemperature = {BaseTemperature}");
    return true;
}

La substitution conserve la sortie axée sur les informations dont vous avez besoin.

Utiliser avec les expressions pour les mutations non destructrices

Utilisez with pour créer des copies modifiées sans altérer l'enregistrement original :

// Growing degree days measure warming to determine plant growing rates
var growingDegreeDays = coolingDegreeDays with { BaseTemperature = 41 };
Console.WriteLine(growingDegreeDays);

Étendez cette idée pour calculer les totaux cumulatifs à partir de tranches de vos données d’entrée.

// showing moving accumulation of 5 days using range syntax
List<CoolingDegreeDays> movingAccumulation = new();
int rangeSize = (data.Length > 5) ? 5 : data.Length;
for (int start = 0; start < data.Length - rangeSize; start++)
{
    var fiveDayTotal = growingDegreeDays with { TempRecords = data[start..(start + rangeSize)] };
    movingAccumulation.Add(fiveDayTotal);
}
Console.WriteLine();
Console.WriteLine("Total degree days in the last five days");
foreach(var item in movingAccumulation)
{
    Console.WriteLine(item);
}

Cette approche est utile lorsque vous avez besoin de transformations pendant que vous conservez des valeurs d’origine.

Étapes suivantes

• Passez en revue les types d’enregistrements C# pour obtenir des conseils plus approfondis.
• Poursuivez avec le langage C# orienté objet pour des modèles de conception plus larges.
• Explorez les types de conversion pour combiner des enregistrements avec des modèles de conversion sécurisés.