Historiken för C#

  • Artikel

Den här artikeln innehåller en historik över varje större version av C#-språket. C#-teamet fortsätter att förnya och lägga till nya funktioner. Detaljerad språkfunktionsstatus, inklusive funktioner som beaktas för kommande versioner, finns på dotnet/roslyn-lagringsplatsen på GitHub.

Viktigt!

C#-språket förlitar sig på typer och metoder i vad C#-specifikationen definierar som ett standardbibliotek för vissa av funktionerna. .NET-plattformen levererar dessa typer och metoder i ett antal paket. Ett exempel är undantagsbearbetning. Varje throw instruktion eller uttryck kontrolleras för att säkerställa att objektet som genereras härleds från Exception. På samma sätt kontrolleras varje catch för att säkerställa att den typ som fångas härleds från Exception. Varje version kan lägga till nya krav. Om du vill använda de senaste språkfunktionerna i äldre miljöer kan du behöva installera specifika bibliotek. Dessa beroenden dokumenteras på sidan för varje specifik version. Du kan lära dig mer om relationerna mellan språk och bibliotek för bakgrund av det här beroendet.

C# version 12

Släpptes november 2023

Följande funktioner har lagts till i C# 12:

Och Interceptors - släpptes som en förhandsversionsfunktion.

Totalt sett innehåller C# 12 nya funktioner som gör dig mer produktiv när du skriver C#-kod. Syntax som du redan visste är tillgänglig på fler platser. Annan syntax möjliggör konsekvens för relaterade begrepp.

C# version 11

Publicerad november 2022

Följande funktioner har lagts till i C# 11:

C# 11 introducerar allmän matematik och flera funktioner som stöder det målet. Du kan skriva numeriska algoritmer en gång för alla nummertyper. Det finns fler funktioner som gör det enklare att arbeta med struct typer, till exempel obligatoriska medlemmar och automatiska standardstrukturer. Det blir enklare att arbeta med strängar med råa strängliteraler, ny rad i stränginterpolationer och UTF-8-strängliteraler. Funktioner som lokala filtyper gör att källgeneratorer blir enklare. Slutligen lägger listmönster till mer stöd för mönstermatchning.

C# version 10

Publicerad november 2021

C# 10 lägger till följande funktioner och förbättringar i C#-språket:

Fler funktioner var tillgängliga i förhandsgranskningsläge . För att kunna använda de här funktionerna måste du ange <LangVersion> till Preview i projektet:

C# 10 fortsätter att arbeta med teman för att ta bort ceremonier, separera data från algoritmer och förbättrade prestanda för .NET Runtime.

Många av funktionerna innebär att du skriver mindre kod för att uttrycka samma begrepp. Poststrukturer syntetiserar många av samma metoder som postklasser gör. Structs och anonyma typer stöder uttryck. Globala användningsdirektiv och filomfattande namnområdesdeklarationer innebär att du uttrycker beroenden och namnområdesorganisation tydligare. Lambda-förbättringar gör det lättare att deklarera lambda-uttryck där de används. Nya egenskapsmönster och dekonstruktionsförbättringar skapar mer koncis kod.

De nya interpolerade stränghanterarna och AsyncMethodBuilder beteendet kan förbättra prestandan. Dessa språkfunktioner tillämpades i .NET Runtime för att uppnå prestandaförbättringar i .NET 6.

C# 10 markerar också mer av en övergång till den årliga kadensen för .NET-versioner. Eftersom inte alla funktioner kan slutföras inom en årlig tidsram kan du prova ett par "förhandsversionsfunktioner" i C# 10. Både allmänna attribut och statiska abstrakta medlemmar i gränssnitt kan användas, men dessa förhandsversionsfunktioner kan ändras innan de släpps.

C# version 9

Släpptes november 2020

C# 9 släpptes med .NET 5. Det är standardspråkversionen för alla sammansättningar som är inriktade på .NET 5-versionen. Den innehåller följande nya och förbättrade funktioner:

C# 9 fortsätter tre av temana från tidigare versioner: ta bort ceremonier, separera data från algoritmer och ge fler mönster på fler platser.

Toppnivåinstruktioner innebär att huvudprogrammet är enklare att läsa. Det finns mindre behov av ceremoni: ett namnområde, en Program klass och static void Main() är alla onödiga.

Introduktionen av records ger en koncis syntax för referenstyper som följer värdesemantik för likhet. Du använder dessa typer för att definiera datacontainrar som vanligtvis definierar minimalt beteende. Init-only setters tillhandahåller funktionen för icke-förstörande mutation (with uttryck) i poster. C# 9 lägger också till covarianta returtyper så att härledda poster kan åsidosätta virtuella metoder och returnera en typ som härleds från basmetodens returtyp.

Funktionerna för mönstermatchning expanderade på flera sätt. Numeriska typer stöder nu intervallmönster. Mönster kan kombineras med hjälp av and, oroch not mönster. Parenteser kan läggas till för att förtydliga mer komplexa mönster:

C# 9 innehåller nya förbättringar av mönstermatchning:

  • Typmönster matchar ett objekt som matchar en viss typ
  • Parenteserade mönster framtvingar eller betonar prioriteten för mönsterkombinationer
  • Konjunktiva and mönster kräver att båda mönstren matchar
  • Disjunctive or mönster kräver endera mönster för att matcha
  • Negerade not mönster kräver att ett mönster inte matchar
  • Relationsmönster kräver att indata är mindre än, större än, mindre än eller lika med eller större än eller lika med en viss konstant

Dessa mönster berikar syntaxen för mönster. Tänk på följande exempel:

public static bool IsLetter(this char c) =>
    c is >= 'a' and <= 'z' or >= 'A' and <= 'Z';

Med valfria parenteser för att göra det tydligt att and har högre prioritet än or:

public static bool IsLetterOrSeparator(this char c) =>
    c is (>= 'a' and <= 'z') or (>= 'A' and <= 'Z') or '.' or ',';

En av de vanligaste användningsområdena är en ny syntax för en null-kontroll:

if (e is not null)
{
    // ...
}

Något av dessa mönster kan användas i alla sammanhang där mönster tillåts: is mönsteruttryck, switch uttryck, kapslade mönster och mönstret för en switch instruktions case etikett.

En annan uppsättning funktioner stöder högpresterande databehandling i C#:

  • Typerna nint och nuint modellerar heltalstyperna för den interna storleken på målprocessorn.
  • Funktionspekare ger delegerade funktioner samtidigt som du undviker de allokeringar som krävs för att skapa ett ombudsobjekt.
  • Instruktionen localsinit kan utelämnas för att spara instruktioner.

Prestanda och interop

En annan uppsättning förbättringar stöder scenarier där kodgeneratorer lägger till funktioner:

  • Modulinitierare är metoder som körningen anropar när en sammansättning läses in.
  • Partiella metoder stöder nya åtkomstkänsliga modifierare och icke-void-returtyper. I dessa fall måste ett genomförande tillhandahållas.

Anpassa och avsluta funktioner

C# 9 lägger till många andra små funktioner som förbättrar utvecklarproduktiviteten, både när du skriver och läser kod:

  • Måltyputtryck new
  • static anonyma funktioner
  • Villkorsuttryck av måltyp
  • Tilläggsstöd GetEnumerator() för foreach loopar
  • Lambda-uttryck kan deklarera parametrar för ignorerande
  • Attribut kan tillämpas på lokala funktioner

C# 9-versionen fortsätter arbetet med att hålla C# ett modernt, allmänt programmeringsspråk. Funktioner fortsätter att stödja moderna arbetsbelastningar och programtyper.

C# version 8.0

Publicerad september 2019

C# 8.0 är den första större C#-versionen som specifikt riktar sig till .NET Core. Vissa funktioner förlitar sig på nya CLR-funktioner (Common Language Runtime), andra på bibliotekstyper som endast läggs till i .NET Core. C# 8.0 lägger till följande funktioner och förbättringar i C#-språket:

Standardgränssnittsmedlemmar kräver förbättringar i CLR. Dessa funktioner har lagts till i CLR för .NET Core 3.0. Intervall och index och asynkrona strömmar kräver nya typer i .NET Core 3.0-biblioteken. Nullbara referenstyper, även om de implementeras i kompilatorn, är mycket mer användbara när bibliotek kommenteras för att tillhandahålla semantisk information om null-tillståndet för argument och returvärden. Dessa anteckningar läggs till i .NET Core-biblioteken.

C# version 7.3

Publicerad maj 2018

Det finns två huvudteman i C# 7.3-versionen. Ett tema innehåller funktioner som gör att säker kod kan vara lika högpresterande som osäker kod. Det andra temat ger stegvisa förbättringar av befintliga funktioner. Nya kompilatoralternativ har också lagts till i den här versionen.

Följande nya funktioner stöder temat bättre prestanda för säker kod:

  • Du kan komma åt fasta fält utan att fästa.
  • Du kan omtilldela ref lokala variabler.
  • Du kan använda initialiserare på stackalloc matriser.
  • Du kan använda fixed instruktioner med valfri typ som stöder ett mönster.
  • Du kan använda mer allmänna begränsningar.

Följande förbättringar har gjorts i befintliga funktioner:

  • Du kan testa == och != med tuppelns typer.
  • Du kan använda uttrycksvariabler på fler platser.
  • Du kan koppla attribut till bakgrundsfältet för automatiskt implementerade egenskaper.
  • Metodmatchning när argumenten skiljer sig åt in med förbättrades.
  • Överbelastningsmatchningen har nu färre tvetydiga fall.

De nya kompilatoralternativen är:

  • -publicsign för att aktivera OSS-signering (Open Source Software) för sammansättningar.
  • -pathmap för att tillhandahålla en mappning för källkataloger.

C# version 7.2

Publicerad november 2017

C# 7.2 har lagt till flera små språkfunktioner:

  • Initierare för stackalloc matriser.
  • Använd fixed instruktioner med alla typer som stöder ett mönster.
  • Få åtkomst till fasta fält utan att fästa.
  • Tilldela om ref lokala variabler.
  • Deklarera readonly struct typer för att indikera att en struct är oföränderlig och ska skickas som en in parameter till dess medlemsmetoder.
  • in Lägg till modifieraren för parametrar för att ange att ett argument skickas med referens men inte ändras av den anropade metoden.
  • ref readonly Använd modifieraren på metodreturer för att ange att en metod returnerar dess värde med referens men inte tillåter skrivningar till objektet.
  • Deklarera ref struct typer för att indikera att en struct-typ kommer åt hanterat minne direkt och måste alltid vara stackallokerad.
  • Använd ytterligare allmänna begränsningar.
  • Icke-avslutande namngivna argument:
    • Positionsargument kan följa namngivna argument.
  • Inledande understreck i numeriska literaler:
    • Numeriska literaler kan nu ha inledande understreck före eventuella tryckta siffror.
  • private protected åtkomstmodifierare:
    • Åtkomstmodifieraren private protected ger åtkomst för härledda klasser i samma sammansättning.
  • Villkorsstyrda ref uttryck:
    • Resultatet av ett villkorsuttryck (?:) kan nu vara en referens.

C# version 7.1

Publicerad augusti 2017

C# började släppa punktversioner med C# 7.1. Den här versionen lade till konfigurationselementet för val av språkversion , tre nya språkfunktioner och nytt kompilatorbeteende.

De nya språkfunktionerna i den här versionen är:

  • asyncMain metod
    • Startpunkten för ett program kan ha async modifieraren.
  • default literaluttryck
    • Du kan använda standardliterala uttryck i standardvärdeuttryck när måltypen kan härledas.
  • Anledda tupppelelementnamn
    • Namnen på tuppelns element kan härledas från tuppelns initiering i många fall.
  • Mönstermatchning på generiska typparametrar
    • Du kan använda mönstermatchningsuttryck på variabler vars typ är en allmän typparameter.

Slutligen har kompilatorn två alternativ -refout och -refonly den styr referenssammansättningens generering.

C# version 7.0

Publicerad mars 2017

C# version 7.0 släpptes med Visual Studio 2017. Den här versionen har några evolutionära och coola saker i samma anda som C# 6.0. Här är några av de nya funktionerna:

Andra funktioner ingår:

Alla dessa funktioner erbjuder nya funktioner för utvecklare och möjlighet att skriva renare kod än någonsin. En markering komprimerar deklarationen av variabler som ska användas med nyckelordet out och genom att tillåta flera returvärden via tuppeln. .NET Core riktar sig nu mot alla operativsystem och har ögonen på molnet och portabiliteten. Dessa nya funktioner upptar verkligen språkdesignerns tankar och tid, förutom att komma med nya funktioner.

C# version 6.0

Släpptes juli 2015

Version 6.0, som släpptes med Visual Studio 2015, släppte många mindre funktioner som gjorde C#-programmering mer produktiv. Här är några av dem:

Andra nya funktioner är:

  • Indexinitierare
  • Vänta i catch/finally-block
  • Standardvärden för egenskaper endast för getter

Om du tittar på de här funktionerna tillsammans ser du ett intressant mönster. I den här versionen började C# eliminera språk pannplate för att göra koden mer terse och läsbar. Så för fans av ren, enkel kod var den här språkversionen en enorm vinst.

De gjorde en annan sak tillsammans med den här versionen, även om det inte är en traditionell språkfunktion i sig. De släppte Kompilatorn Roslyn som en tjänst. C#-kompilatorn är nu skriven i C#, och du kan använda kompilatorn som en del av dina programmeringsinsatser.

C# version 5.0

Utgiven augusti 2012

C# version 5.0, som släpptes med Visual Studio 2012, var en fokuserad version av språket. Nästan all ansträngning för den versionen gick in i ett annat banbrytande språkkoncept: async och await modellen för asynkron programmering. Här är den viktigaste funktionslistan:

Med attributet caller info kan du enkelt hämta information om kontexten där du kör utan att använda massor av reflektionskod för pannplåt. Den har många användningsområden i diagnostik- och loggningsuppgifter.

Men async och await är de verkliga stjärnorna i denna version. När dessa funktioner kom ut 2012 ändrade C# spelet igen genom att baka asynkront till språket som en förstklassig deltagare.

C# version 4.0

Släpptes april 2010

C# version 4.0, som släpptes med Visual Studio 2010, introducerade några intressanta nya funktioner:

Inbäddade interoptyper underlättade distributionen av COM-interop-sammansättningar för ditt program. Allmän kovarians och kontravarians ger dig mer makt att använda generiska läkemedel, men de är lite akademiska och förmodligen mest uppskattade av ramverks- och biblioteksförfattare. Med namngivna och valfria parametrar kan du eliminera många metodöverlagringar och underlätta. Men ingen av dessa funktioner är exakt paradigmskifte.

Huvudfunktionen var introduktionen av nyckelordet dynamic . Nyckelordet dynamic introducerades i C# version 4.0 möjligheten att åsidosätta kompilatorn vid kompileringstidsskrivning. Genom att använda det dynamiska nyckelordet kan du skapa konstruktioner som liknar dynamiskt skrivna språk som JavaScript. Du kan skapa en dynamic x = "a string" och sedan lägga till sex till den och lämna den till körningen för att reda ut vad som ska hända härnäst.

Dynamisk bindning ger dig potential för fel men också stor kraft inom språket.

C# version 3.0

Utgiven november 2007

C# version 3.0 kom i slutet av 2007, tillsammans med Visual Studio 2008, även om den fullständiga båten med språkfunktioner faktiskt skulle komma med .NET Framework version 3.5. Den här versionen markerade en stor förändring i tillväxten av C#. Det etablerade C# som ett verkligt formidabelt programmeringsspråk. Låt oss ta en titt på några viktiga funktioner i den här versionen:

I efterhand verkar många av dessa funktioner både oundvikliga och oskiljaktiga. De passar alla ihop strategiskt. Den här C#-versionens mördarfunktion var frågeuttrycket, även kallat Language-Integrated Query (LINQ).

En mer nyanserad vy undersöker uttrycksträd, lambda-uttryck och anonyma typer som grunden som LINQ bygger på. Men i båda fallen presenterade C# 3.0 ett revolutionerande koncept. C# 3.0 började lägga grunden för att göra C# till ett hybridobjektorienterat/funktionellt språk.

Mer specifikt kan du nu skriva deklarativa frågor i SQL-stil för att bland annat utföra åtgärder på samlingar. I stället för att skriva en for loop för att beräkna medelvärdet av en lista med heltal kan du nu göra det så enkelt som list.Average(). Kombinationen av frågeuttryck och tilläggsmetoder gjorde en lista över heltal mycket smartare.

C# version 2.0

Släpptes november 2005

Låt oss ta en titt på några viktiga funktioner i C# 2.0, som släpptes 2005, tillsammans med Visual Studio 2005:

Andra C# 2.0-funktioner har lagt till funktioner i befintliga funktioner:

  • Separat hjälpmedel för Getter/setter
  • Metodgruppkonverteringar (ombud)
  • Statiska klasser
  • Delegera slutsatsdragning

Medan C# började som ett generiskt objektorienterat språk (OO), ändrade C# version 2.0 det snabbt. Med generiska läkemedel kan typer och metoder fungera på en godtycklig typ samtidigt som typsäkerheten bibehålls. Om du till exempel har en List<T> kan du ha List<string> eller List<int> och utföra typsäkra åtgärder på dessa strängar eller heltal medan du itererar genom dem. Det är bättre att använda generiska objekt än att skapa en ListInt typ som härleds från ArrayList eller från Object för varje åtgärd.

C# version 2.0 förde iteratorer. För att uttrycka det kortfattat låter iteratorer dig undersöka alla objekt i en List (eller andra uppräkningsbara typer) med en foreach loop. Att ha iteratorer som en förstklassig del av språket förbättrade dramatiskt läsbarheten för språket och människors förmåga att resonera om koden.

C# version 1.2

Släpptes april 2003

C# version 1.2 levereras med Visual Studio .NET 2003. Det innehöll några små förbättringar av språket. Det mest anmärkningsvärda är att koden som genereras i en foreach loop som anropas Dispose på en IEnumerator när den IEnumerator implementerade IDisposablebörjar med den här versionen.

C# version 1.0

Utgiven januari 2002

När du går tillbaka och tittar såg C# version 1.0, som släpptes med Visual Studio .NET 2002, ut ungefär som Java. Som en del av sina uttalade designmål för ECMA försökte det vara ett "enkelt, modernt, allmänt objektorienterat språk.". På den tiden innebar det att se ut som Java att det uppnådde dessa tidiga designmål.

Men om du ser tillbaka på C# 1.0 nu, skulle du finna dig själv lite yr. Den saknade de inbyggda asynkrona funktionerna och några av de smarta funktionerna kring generiska läkemedel som du tar för givna. Faktum är att den saknade generiska läkemedel helt och hållet. Och LINQ? Inte tillgängligt än. Dessa tillägg skulle ta några år att komma ut.

C# version 1.0 såg ut att vara fråntagen funktioner, jämfört med idag. Du skulle skriva utförlig kod. Men ändå måste du börja någonstans. C# version 1.0 var ett genomförbart alternativ till Java på Windows-plattformen.

De viktigaste funktionerna i C# 1.0 inkluderade:

Artikel som ursprungligen publicerades på NDepend-bloggen, med tillstånd av Erik Dietrich och Patrick Smacchia.