Tekenreeksinterpolatie gebruiken om opgemaakte tekenreeksen te maken

In deze zelfstudie leert u hoe u C#- tekenreeksinterpolatie gebruikt om waarden in te voegen in één resultaattekenreeks. U schrijft C#-code en ziet de resultaten van het compileren en uitvoeren ervan. De zelfstudie bevat een reeks lessen die laten zien hoe u waarden kunt invoegen in een tekenreeks en deze waarden op verschillende manieren kunt opmaken.

In deze zelfstudie wordt verwacht dat u een computer hebt die u kunt gebruiken voor ontwikkeling. De .NET-zelfstudie Hallo wereld in 10 minuten bevat instructies voor het instellen van uw lokale ontwikkelomgeving in Windows, Linux of macOS. U kunt ook de interactieve versie van deze zelfstudie in uw browser voltooien.

Een geïnterpoleerde tekenreeks maken

Maak een map met de naam geïnterpoleerd. Maak hiervan de huidige map en voer de volgende opdracht uit vanuit een consolevenster:

dotnet new console

Met deze opdracht maakt u een nieuwe .NET Core-consoletoepassing in de huidige map.

Open Program.cs in uw favoriete editor en vervang de regel Console.WriteLine("Hello World!"); door de volgende code, waarbij u vervangt door <name> uw naam:

var name = "<name>";
Console.WriteLine($"Hello, {name}. It's a pleasure to meet you!");

Probeer deze code door in het consolevenster te typen dotnet run . Wanneer u het programma uitvoert, wordt er een enkele tekenreeks weergegeven waarin uw naam in de begroeting is opgenomen. De tekenreeks die is opgenomen in de WriteLine methodeaanroep is een geïnterpoleerde tekenreeksexpressie. Het betreft een soort sjabloon waarmee u een enkele tekenreeks construeert (die resultaattekenreeks wordt genoemd) uit een tekenreeks waarin ingesloten code is opgenomen. Geïnterpoleerde tekenreeksen zijn met name nuttig voor het invoegen van waarden in een tekenreeks of voor het samenvoegen van tekenreeksen (aan elkaar verbinden).

Dit eenvoudige voorbeeld bevat de twee elementen waarover elke geïnterpoleerde tekenreeks moet beschikken:

• Een letterlijke tekenreeks begint met het $-teken vóór het aanhalingsteken openen. Er mogen zich geen spaties bevinden tussen het $-symbool en het aanhalingsteken. (Als u wilt zien wat er gebeurt als u er een opneemt, voegt u een spatie in na het $ teken, slaat u het bestand op en voert u het programma opnieuw uit door in het consolevenster te typen dotnet run . De C#-compiler geeft een foutbericht weer, 'error CS1056: Unexpected character '$''.)

• Een of meer interpolatie-expressies. Een interpolatie-expressie wordt aangegeven met een accolade openen en sluiten ({ en }). U kunt elke gewenste C#-expressie waarmee een waarde wordt geretourneerd (inclusief null) binnen de accolades plaatsen.

Laten we nog enkele voorbeelden van tekenreeksinterpolatie proberen met enkele andere gegevenstypen.

Verschillende gegevenstypen opnemen

In de vorige sectie hebt u tekenreeksinterpolatie gebruikt om een tekenreeks in te voegen in een andere. Het resultaat van een interpolatie-expressie kan echter van elk gegevenstype zijn. Laten we waarden van verschillende gegevenstypen opnemen in een geïnterpoleerde tekenreeks.

In het volgende voorbeeld definiëren we eerst een klassegegevenstypeVegetable met een Nameeigenschap en een ToStringmethode, waardoor het gedrag van de Object.ToString() methode wordt overschreven. De public wijzigingsfunctie voor toegang maakt die methode beschikbaar voor elke clientcode om de tekenreeksweergave van een Vegetable exemplaar op te halen. In het voorbeeld retourneert de Vegetable.ToString methode de waarde van de Name eigenschap die is geïnitialiseerd op de Vegetableconstructor:

public Vegetable(string name) => Name = name;

Vervolgens maken we een exemplaar van de klasse met de Vegetable naam item met behulp van de new operator en geven we een naam op voor de constructor Vegetable:

var item = new Vegetable("eggplant");

Ten slotte nemen we de item variabele op in een geïnterpoleerde tekenreeks die ook een DateTime waarde, een Decimal waarde en een Unitopsommingswaarde bevat. Vervang alle C#-code in uw editor door de volgende code en gebruik vervolgens de opdracht om deze dotnet run uit te voeren:

using System;

public class Vegetable
{
   public Vegetable(string name) => Name = name;

   public string Name { get; }

   public override string ToString() => Name;
}

public class Program
{
   public enum Unit { item, kilogram, gram, dozen };

   public static void Main()
   {
      var item = new Vegetable("eggplant");
      var date = DateTime.Now;
      var price = 1.99m;
      var unit = Unit.item;
      Console.WriteLine($"On {date}, the price of {item} was {price} per {unit}.");
   }
}

Houd er rekening mee dat de interpolatie-expressie item in de geïnterpoleerde tekenreeks wordt omgezet in de tekst 'aubergine' in de resultaattekenreeks. Wanneer het type van het expressieresultaat geen tekenreeks is, wordt het resultaat op de volgende manier omgezet in een tekenreeks:

• Als de interpolatie-expressie resulteert in null, wordt een lege tekenreeks ("", of String.Empty) gebruikt.

• Als de interpolatie-expressie niet resulteert in null, wordt doorgaans de ToString methode van het resultaattype aangeroepen. U kunt dit testen door de implementatie van de methode bij te Vegetable.ToString werken. Mogelijk hoeft u de ToString methode niet eens te implementeren, omdat elk type een bepaalde implementatie van deze methode heeft. Als u dit wilt testen, markeert u de definitie van de Vegetable.ToString methode in het voorbeeld (plaats hiervoor een opmerkingssymbool, //, ervoor). In de uitvoer wordt de tekenreeks 'aubergine' vervangen door de volledig gekwalificeerde typenaam ('Plantaardig' in dit voorbeeld), wat het standaardgedrag van de Object.ToString() methode is. Het standaardgedrag van de ToString methode voor een opsommingswaarde is om de tekenreeksweergave van de waarde te retourneren.

In de uitvoer van dit voorbeeld is de datum te nauwkeurig (de prijs van aubergine verandert niet elke seconde) en de prijswaarde geeft geen valuta-eenheid aan. In de volgende sectie leert u hoe u deze problemen kunt oplossen door de indeling van tekenreeksweergaven van de expressieresultaten te beheren.

De opmaak van interpolatie-expressies beheren

In de vorige sectie zijn twee slecht opgemaakte tekenreeksen in de resultaattekenreeks ingevoegd. Een betrof een datum- en tijdwaarde waarvoor alleen de datum geschikt was. De tweede was een prijs die niet de valuta-eenheid aangeeft. Beide problemen zijn eenvoudig te verhelpen. Met tekenreeksinterpolatie kunt u opmaaktekenreeksen opgeven die de opmaak van bepaalde typen bepalen. Wijzig de aanroep naar Console.WriteLine uit het vorige voorbeeld om de notatietekenreeksen voor de datum- en prijsexpressies op te nemen, zoals wordt weergegeven op de volgende regel:

Console.WriteLine($"On {date:d}, the price of {item} was {price:C2} per {unit}.");

U geeft een notatietekenreeks op door de interpolatie-expressie te volgen met een dubbele punt (':') en de notatietekenreeks. d is een standaard opmaaktekenreeks voor de datum en de tijd die de korte datumnotatie weergeeft. 'C2' is een standaardtekenreeks voor numerieke notatie die een getal aangeeft als een valutawaarde met twee cijfers na het decimaalteken.

Een aantal typen in de .NET-bibliotheken ondersteunt een vooraf gedefinieerde set opmaaktekenreeksen. Hierbij zijn alle numerieke typen en datum- en tijdtypen inbegrepen. Zie Opmaaktekenreeksen en .NET-klassebibliotheektypen in het artikel Types opmaken in .NET voor een volledige lijst met typen die ondersteuning bieden aan opmaaktekenreeksen.

Wijzig de opmaaktekenreeksen in de teksteditor en voer telkens wanneer u een wijziging aanbrengt het programma opnieuw uit om te zien hoe de wijzigingen van invloed zijn op de opmaak van de datum en tijd en de numerieke waarde. Wijzig de d in {date:d} in t (om de korte tijdnotatie weer te geven), y (om het jaar en de maand weer te geven) en jjjj (om het jaar als een viercijferig getal weer te geven). Wijzig de C2 in {price:C2} in e (voor een exponentiële notatie) en F3 (voor een numerieke waarde met drie decimalen achter de komma).

Naast het beheren van de opmaak kunt u ook de veldbreedte en uitlijning van de opgemaakte tekenreeksen in de resultaattekenreeks bepalen. In de volgende sectie leert u hoe u dit doet.

De veldbreedte en uitlijning van interpolatie-expressies beheren

Wanneer het resultaat van een interpolatie-expressie is opgemaakt als tekenreeks, wordt deze tekenreeks gewoonlijk opgenomen in een resultaattekenreeks zonder voorloop- of volgspaties. Met name wanneer u met een set gegevens werkt, kunt u een veldbreedte en tekstuitlijning beheren om een beter leesbare uitvoer te produceren. Als u dit wilt zien, vervangt u alle code in de teksteditor door de volgende code en typt dotnet run u vervolgens om het programma uit te voeren:

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      var titles = new Dictionary<string, string>()
      {
          ["Doyle, Arthur Conan"] = "Hound of the Baskervilles, The",
          ["London, Jack"] = "Call of the Wild, The",
          ["Shakespeare, William"] = "Tempest, The"
      };

      Console.WriteLine("Author and Title List");
      Console.WriteLine();
      Console.WriteLine($"|{"Author",-25}|{"Title",30}|");
      foreach (var title in titles)
         Console.WriteLine($"|{title.Key,-25}|{title.Value,30}|");
   }
}

De namen van auteurs worden links uitgelijnd en de titels die ze hebben geschreven, zijn rechts uitgelijnd. U geeft de uitlijning op door een komma (",") toe te voegen na een interpolatie-expressie en de minimale veldbreedte aan te wijzen. Als de opgegeven waarde een positief getal is, wordt het veld rechts uitgelijnd. Als het een negatief getal is, wordt het veld links uitgelijnd.

Probeer de negatieve tekens uit de {"Author",-25} code en {title.Key,-25} te verwijderen en voer het voorbeeld opnieuw uit, zoals met de volgende code gebeurt:

Console.WriteLine($"|{"Author",25}|{"Title",30}|");
foreach (var title in titles)
   Console.WriteLine($"|{title.Key,25}|{title.Value,30}|");

Deze keer is de informatie van de auteur rechts uitgelijnd.

U kunt een uitlijningsaanduiding en een notatietekenreeks combineren voor één interpolatie-expressie. Geef hiervoor eerst de uitlijning op, gevolgd door een dubbele punt en de notatietekenreeks. Vervang alle code in de Main methode door de volgende code, waarmee drie opgemaakte tekenreeksen met gedefinieerde veldbreedten worden weergegeven. Voer vervolgens het programma uit door de opdracht in te dotnet run voeren.

Console.WriteLine($"[{DateTime.Now,-20:d}] Hour [{DateTime.Now,-10:HH}] [{1063.342,15:N2}] feet");

De uitvoer ziet er ongeveer als volgt uit:

[04/14/2018          ] Hour [16        ] [       1,063.34] feet

U hebt de zelfstudie voor tekenreeksinterpolatie voltooid.

Zie het onderwerp Tekenreeksinterpolatie en de zelfstudie Tekenreeksinterpolatie in C# voor meer informatie.