C#12 bezit allerlei nieuwe, simpele features. Maar waar vind je die informatie eigenlijk? .NET is tegenwoordig open-source. Dus: gewoon op hun Git-pagina. Op GitHub kan je de hele repository achter C#, maar ook .Net, inzien en doornemen om erachter te komen welke features de nieuwe previews bezitten. Say no more, dacht Ewout. Dus hij zocht er een aantal grondig uit:

Door Ewout de Gast

Effe terug: C#12, hoe zit dat nu?

We herhalen: C# is de programmeertaal en .NET een framework ontwikkeld door Microsoft. Met de komst van .NET Core en de overstap naar multi-platform is zowel C# als .NET sinds 2014 open-source. Het resultaat: je kan als Developer de hele repository bekijken. En niet alleen bekijken, maar er ook wat van vinden. In het laatste geval ben je zelfs in staat om jouw feedback te delen via issues op de GitHub repository, waar je je kan mengen in discussies. Er zijn dus ontwikkelaars van over de hele wereld die nieuwe features aanmaken via een Pull Request. Microsoft kan dit vervolgens oppakken.

Some upcoming features in C#12

Maar dat is nog lang niet alles. Ewout verdiepte zich namelijk in een selectie van nieuwe features waarvan hij overtuigd is dat ze het werk als Developer een stukje makkelijker gaan maken. Ondanks dat de features simpel zijn in toepassing. En here they are:

1. Primary Constructors
2. Using Aliases for any type
3. Default parameters for Lambda’s
4. Semi-autoproperties

1. Primary Constructors

Primacy Constructor is een bekend concept voor Developers die regelmatig recordtypes gebruiken. De mogelijkheid om direct properties te declareren en te initialiseren in de Constructor Parameter. Voorheen een feature die alleen beschikbaar was voor records, maar binnenkort ook mogelijk op Class- en Structtypes. Dit betekent dat de Record Primary Constructor public read-only properties genereert. De Class- en Structtypes genereren juist private field properties. Een belangrijk verschil.

Over naar het praktische werk: neem de onderstaande code voor een Persoon Class. Aan de hand van Primary Constructor kan er met al een paar regels een klasse worden gemaakt. Hoe? Met een aantal private fields:

public class Persoon(string naam, string achternaam)
{
        public override string ToString()
    {
            return $"{naam} {achternaam}";
    }
}

Bovenstaande code zal gecompileerd worden tot de onderstaande C# code. De gecompileerde code is bijna volledig in lijn met wat we momenteel moeten schrijven om tot hetzelfde resultaat te komen.

public class Persoon
{
        private string _naam;
        private string _achternaam;
        public Persoon(string naam, string achternaam)
    {
            _naam = naam;
            _ achternaam = achternaam;
    }
        public override string ToString()
    {
            return string.Concat(_naam, " ", _achternaam);
    }
}

2. Using Aliases for any type

Een Type Alias geeft je de mogelijkheid om een naam te geven aan een bestaand type. Dit is handig als je types gebruikt die dezelfde naam hebben of om de leesbaarheid van de code te verbeteren. Met de onderstaande Alias kan de aangegeven Dictionary aangemaakt worden. Hiervoor wordt gebruikgemaakt van de MyDictionary type.

using MyDictionary = System.Collections.Generic.Dictionary<string, System.Collections.Generic.List>;

Het gebruik van aliassen was beperkt tot classes en namespaces. Met de komst van C#12 is de ondersteuning van type aliassen uitgebreid naar Tuple, Array en Unsafe types, zoals pointers. Met als resultaat dat Developers dezelfde verbeteringen door kunnen voeren.

using MyPoint = (int xPosition, int yPosition);

using Coordinates = int[];

3. Default parameters voor Lambda’s

Lambda’s zijn een eenvoudige manier om anonieme functies te definiëren en stellen je in staat om compacte code te schrijven voor simpele functies. Ze zijn ook zeer nuttig wanneer je deze functie wil meegeven als parameter aan een andere methode. Met C#12 is het mogelijk om een default-waarde toe te wijzen aan een parameter van de Lambda. Het toewijzen gebeurt eenvoudig met het gelijkteken (“=”). Dit houdt de functie in de Lambda compact, aangezien er geen extra controles nodig zijn op de waarde.

4. Semi-autoproperties

Een welbekende irritatie onder ons Developers – correct me if I’m wrong – als je aan het werk bent, is de situatie waarin je de achterliggen velden van jouw Autoproperties niet kan benaderen.

public string X { get; set; }

Mocht je hier omheen willen werken, wordt een private field geïntroduceerd:

private string _x;
public string X
{
    set
    {
        _x = value;
    }
    get
    {
        return _x;
    }
}

Vanaf C#12 is het field keyword geïntroduceerd. Dit geeft toegang tot het achterliggende veld, wat automatisch gegenereerd wordt. Hiermee vervalt de noodzaak van het private field:

public string X
{
    set
    {
        field = value;
    }
    get
    {
        return field;
    }
}

Bovenstaande voorbeelden zijn allemaal gelijk aan elkaar. Bij de laatste twee voorbeelden is het echter mogelijk om de waarde te beïnvloeden aan de hand van het private field _x of het field keyword.

Conclusie

C#12 wordt steeds meer een functionele en zelfs hybride taal. Waar het vroeger heel project-georiënteerd was, is het de laatste tijd meer functioneel ingericht. Uiteindelijk komt het allemaal neer op één ding: met simpele, nieuwe features hoeft steeds minder code geschreven te worden om hetzelfde te bereiken. Wat wil een Developer nog meer?

Nou, dan weten we nog wel iets. De laatste ontwikkelingen bijhouden van .NET, bijvoorbeeld. Dit kan via het Microsoft blog. Of meteen aan de slag met de laatste preview features? Download de preview en zet de language versie op preview met: preview .

Via een stageplek bij Innvolve de IT ingedoken en ondertussen ongekend professioneel in wat hij doet. Gebruikt zijn kennis niet alleen in zijn werk maar deelt dit ook graag met anderen. Zo schrijft hij blogs en spreekt hij regelmatig op onze Community Talks. Meer weten over C#12, gewoon even sparren of graag een keer een Community Talk bijwonen? Let us know!