C# 12: De spännande nya funktionerna som kommer att förbättra din utveckling

Detaljer om den efterlängtade C# 12 Preview har läckt ut, vilket ger en tjuvtitt på kommande funktioner som borde revolutionera språket. Dessa funktioner lovar mycket för att förbättra kodläsbarheten, optimera prestanda och låsa upp avancerade funktioner för språket.

Förbättrade switchuttryck

C# 8 introduceras grundläggande switch-uttryck som låter dig uttrycka komplex villkorlig logik kortfattat, i en läsbar form. C# 12 tar detta vidare genom att introducera en ny mönstermatchande syntax för switch-uttryck, vilket gör det ännu lättare att skriva uttrycksfull och koncis kod.

Tänk på följande kodavsnitt.

var resultat = obj växla
{
int i när jag > 0 => "Positiv",
int i när jag < 0 => "Negativ",
 _ => "Noll"
};

Denna kod använder switch-uttryck för att avgöra om ett heltal är positiv, negativ, eller noll. I C# 12 kan du förenkla den här koden ytterligare med den nya mönstermatchningssyntaxen:

var resultat = obj växla
{
 > 0 => "Positiv",
 < 0 => "Negativ",
 _ => "Noll"
};

Denna syntax låter dig utelämna när nyckelord och använd relationsoperatorer direkt i switchuttrycket.

Primära konstruktörer för klasser och konstruktioner

Du kan nu skapa primära konstruktörer i vilken som helst klass eller struct (ett lättviktsklassalternativ). Med hjälp av primära konstruktorer kan du lägga till parametrar till klassdeklarationen och använda dessa värden inuti klasskroppen.

C# 9 introducerade primära konstruktorer som en del av positionssyntaxen för poster. C# 12 utökar dessa till alla strukturer och klasser.

Du kan sätta parametrarna efter typnamnet inom parentes som visas nedan:

offentlig klass Studerande(int id, sträng namn, IEnumerable<decimal> betyg)
{
offentligStuderande(int id, sträng namn): detta(id, namn, Enumerable. Tomt<decimal>()) { }
offentligint Id => id;
offentligsträng Namn { skaffa sig; uppsättning; } = namn. Trim();
offentligdecimal GPA => betyg. Några()? betyg. Genomsnitt(): 4.0m;
}

Parametrarna för en primär konstruktör är i omfattning i hela den deklarerande typens kropp. Du kan ställa in egenskaper eller fält eller kan också använda dem i metoder eller lokala funktioner som variabler. Du kan även tillhandahålla dessa parametrar till en baskonstruktör.

Förbättringar av interpolerade strängar

Interpolerade strängar har funnits sedan C# 6. I C# 12 kan du nu skapa dynamiska värden för strängar med hjälp av komplicerade uttryck.

int jag = 5;
sträng utgång = $"Värdet på i är {i}, och dess kvadrat är {i*i}.";
Trösta. WriteLine (utgång);

Denna kod skriver ut "Värdet på i är 5, och dess kvadrat är 25".

Använda direktiv för ytterligare typer

Med C# 12 kan du använda aliasdirektivet för att aliasa vilken typ som helst, inte bara namngivna typer. Du kan skapa semantiska alias för tupler, arrayer, pekare eller andra osäkra typer.

Här är några exempel:

använder sig av Mått = (sträng Enheter, int Distans);
använder sig av UnitsInt = int?;
Exempel på användning av alias:
offentligtomhetBeräkning(Mätning mätning)
{ 
// Method Body
}

Lambda-uttrycksförbättringar

C# 12 ger lambda-uttryck genom att tillåta dig att definiera standardvärdena för parametrar. Syntaxen är identisk med den för andra standardparametrar:

Till exempel, (int incrementTo = 5) => incrementTo + 1 ställer in ett standardvärde på 5 för parametern incrementTo, som lambda-anropet kommer att använda om du inte skickar ett värde till det.

var incrementWithDefault = (int inkrement till = 5) => öka Till + 1;
incrementWithDefault(); // 6
incrementWithDefault(9); // 10

Förutom det kom många andra förbättringar till lambda-uttryck för att göra dem mer effektiva.

Till exempel:

• Du kan nu skapa mer komplexa uttryck inom lambda-funktioner.
• Du kan nu omvandla lambda-uttryck till uttrycksträd som förenklar komplexa frågor och optimerar prestanda.

Asynkrona strömmar

Du kan iterera genom asynkrona datakällor med den nya asynkrona strömmar funktion i C# 12. Denna nya iterator—invänta foreach—hjälper dig att iterera över en uppsättning asynkrona data:

väntaför varje (var Artikel iGetItemsAsync())
{
 Trösta. WriteLine (objekt.värde);
}

C# 12: Revolutionerande kod med spännande nya funktioner

I väntan på C# 12 kan du förvänta dig en spelförändrande uppdatering med spännande nya funktioner. Dessa framsteg, såsom förbättrade switch-uttryck, primära konstruktorer och förbättringar av lambda-uttryck, indikerar ett starkt fokus på kodens enkelhet, flexibilitet och prestanda.

C# 12 är redo att ge ett betydande steg framåt, vilket gör att du kan skriva mer uttrycksfull, effektiv och kraftfull kod.