Upgrade naar C# 14: kansen én risico's voor jouw project

1. Het nieuwe field keyword

C# 14 introduceert het contextuele keyword field om boilerplate-code te verminderen bij het aanmaken van properties.

class Lego
{
    private uint _leeftijd;
    public uint leeftijd {
        get;
        set => _leeftijd = (value >= 4 && value <= 99)
            ? value
            : throw new ArgumentOutOfRangeException(nameof(value), "De leeftijd moet tussen de 4 en 99 jaar liggen");
        }
}

In het voorbeeld hierboven is te zien dat er specifiek een backing field aangemaakt moet worden om de leeftijd in op te slaan. De editor geeft ook al een “warning” aan dat dit met C#14 beter kan.

class Lego
{
    public uint leeftijd {
        get;
        set => field = (value >= 4 && value <= 99)
            ? value
            : throw new ArgumentOutOfRangeException(nameof(value), "De leeftijd moet tussen de 4 en 99 jaar liggen");
        }
}

Met het nieuwe field keyword is het niet langer nodig om zelf een backing field te definiëren. De compiler genereert automatisch het backing field, waardoor je direct binnen de setter of getter de waarde kunt toewijzen of ophalen.

Let op: door de introductie van het field keyword is ‘field’ geen geldige identifier meer. Bestaande code waarin field als variabelenaam wordt gebruikt, zal hierdoor niet meer worden gecompileerd. Om dit op te lossen kun je de naam prefixen met een @ (bijvoorbeeld @field) of gebruikmaken van "this.field".

2. Extension blocks: overzicht en risico

Extension Blocks zijn een nieuwe manier in C# 14 om extensie methoden te groeperen in een speciaal blok. Het onderliggende idee is dat extensie methoden vaak verspreid raken over meerdere statische klassen, waardoor het overzicht van deze extensies met iedere toevoeging steeds lastiger wordt, vooral bij het bepalen voor welke type ze bedoeld zijn. Met Extension Blocks kunnen extensie methoden ondergebracht worden in een speciaal codeblok dat direct aangeeft voor welk type ze bedoeld zijn. Dat maakt de structuur overzichtelijker en helpt bij het reduceren van ruis, omdat extensies alleen zichtbaar worden wanneer de scope van het blok in beeld is.

public state class PersonExtensions
{
    extension(Person person)
    {
        public bool IsAdult => person.Age >= 18;
        
        public string Fullname() => $"{person.FirstName} {person.LastName}";
    }

Aangezien het in eerdere versies van C# al mogelijk was om met statische extensie methoden aan te maken, kunnen er problemen ontstaan als de oude en nieuwe methode door elkaar heen worden gebruikt. De oorzaak hiervan is dat Extension Blocks een hogere prioriteit krijgen dan de traditionele methode. Dit betekent dat als een project al extensiemethoden bevat met dezelfde naam en signature, een nieuwe extensiemethode in een Extension Block de oude versie kan overschrijven zonder waarschuwing van de compiler. Ook bij generieke extensies zou dit voor problemen kunnen zorgen.

public state class PersonExtensionsOld
{
    public static bool IsAdult(this Person person)  =>
        person.Age >= 18;
 }
 
 public static class PersonExtensionsNew
 {
     extension(Person person)
     {
         public bool IsAdult => person.Age >= 18;
     }
 }

3. Gebruik ref, in en out in lambdas zonder type-aanduiding

Eén van de nieuwe quality-of-life features die C# 14 introduceert, is het kunnen gebruiken van modifiers binnen lambda-expressies zonder het expliciet definiëren van het type.

// Oud
TryParse<int> parse2 = (string text, out int result) => Int32.TryParse(text, out result);

// Nieuw
TryParse<int> parse1 = (text, out result) => Int32.TryParse(text, out result);

Je kunt dus modifiers zoals ref, in, out, scoped en ref readonly direct op een lambda parameter toepassen, zonder dat je het type hoeft te vermelden. Let op: het params keyword vereist nog wel een expliciet type. Deze verbetering maakt lambdas flexibeler, vooral bij patterns zoals TryParse-delegates en API's die ref/out-parameters gebruiken.

4. Impliciete conversies voor Span

C# 14 introduceert impliciete conversies tussen Span en ReadOnlySpan, die het werken met buffer-achtige structuren eenvoudiger moeten gaan maken. Voor C# 14 moest deze conversie altijd via een actie zoals de ToString-methode of met een expliciete cast. Met de nieuwe versie kan de compiler automatisch meerdere span-varianten aan elkaar koppelen. Dit vermindert uiteindelijk het aantal boilerplatecode, maar het kan ook impact hebben op bestaande codebases die gebruikmaken van de oude scheiding tussen deze types.

Die impact wordt vooral zichtbaar bij API’s die overloads aanbieden voor zowel string als ReadOnlySpan—of voor zowel Span als ReadOnlySpan. Waar de compiler vroeger één specifieke overload moest kiezen en soms compiler errors gaf, kan dezelfde code vanaf C# 14 opeens een andere overload selecteren.

int[] numbers = { 1, 2, 3, 4 };

// int[] -> Span<int> (implicit)
int total = numbers.Sum(); // extension on Span<int>

Console.WriteLine(total); // 10

public static class SpanExtension
{
    public static int Sum(this Span<int> span)
    {
        var total = 0;
        foreach (var value in span)
        {
            total += value;
        }
        return total;
    }
}

Alhoewel de nieuwe functionaliteit veel opties biedt en automatisch werkt, moeten ontwikkelaars vóór de upgrade naar C# controleren of bestaande systemen en interfaceontwerpen geen onverwachte wijzigingen in overloads.bevatten.

Samengevat, let bij het upgraden vooral op deze punten:

• Field keyword: het woord field is nu een contextueel keyword. Als je dit eerder gebruikte als variabelenaam, kan dat compileerfouten geven.
• Extension blocks: extensiemethoden in extension blocks krijgen voorrang boven bestaande extensies. Dat kan leiden tot onverwacht gedrag als er methoden met dezelfde naam en signature zijn.
• Impliciete conversies van Span: de compiler kan nu andere overloads kiezen dan voorheen, wat subtiele wijzigingen in runtime-gedrag kan veroorzaken.

Tip: controleer je codebase zorgvuldig op deze punten voordat je overstapt. Zo voorkom je verrassingen en profiteer je maximaal van de nieuwe mogelijkheden die C# 14 biedt.

Hulp nodig bij de overstap naar C14?

Bij ShareValue werken ervaren .NET-developers die continu bijblijven met de nieuwste ontwikkelingen zoals C# 14. We denken graag mee over architectuur, voeren upgrades zorgvuldig uit en helpen teams slimmer en stabieler te ontwikkelen. Dus zoek je versterking of advies voor je .NET-project? Neem gerust contact met ons op, we helpen je graag verder.