C sharp: differenze tra le versioni
Contenuto cancellato Contenuto aggiunto
m Annullata la modifica di ~2025-28382-52 (discussione), riportata alla versione precedente di Emayeah Etichetta: Rollback |
|||
| (270 versioni intermedie di oltre 100 utenti non mostrate) | |||
Riga 1:
{{titolo errato|C#}}
{{Linguaggio di programmazione
|nome = C#
|didascalia =
|autore = [[Anders Hejlsberg]]
|data = [[2000]]
|utilizzo = Generico
|paradigmi = Multi-paradigma: [[Programmazione strutturata|Strutturata]], [[Programmazione imperativa|Imperativa]], [[Programmazione orientata agli oggetti|Object-Oriented]], [[Programmazione funzionale|Funzionale]], [[Programmazione a eventi|a eventi]]
|tipizzazione = [[Tipizzazione statica|Statica]], [[Tipizzazione dinamica|Dinamica]], [[Tipizzazione forte|Forte]], [[Sicurezza rispetto ai tipi|Sicura]]
|specifiche =
|estensione = .cs, .csx
|influenzato_da = [[Delphi]], [[C++]], [[Java (linguaggio di programmazione)|Java]], [[Eiffel (linguaggio)|Eiffel]], [[Haskell (linguaggio)|Haskell]], [[ML (linguaggio di programmazione)|ML]]
|ha_influenzato = [[D (linguaggio)|D]], [[F Sharp|F#]], [[Java (linguaggio di programmazione)|Java]], [[TypeScript]]
|implementazione_riferimento =
|sistema_operativo =
|lingua =
|licenza =
|sito_web =
}}
Il '''C#''' (pronuncia inglese: {{IPA|[ˈsiː ˈʃɑːp]|en}}, come l'espressione ''see sharp'', "vedere nitidamente"<!--la fonte è sempre MSDN, vedi nota che segue-->)<ref>Il nome gioca sul fatto che C♯, in inglese e altre lingue, indica la nota musicale Do diesis, un semitono sopra il "C", ovvero il Do (fonte: {{Cita web
|url= http://www.jameskovacs.com/blog/CNETHistoryLesson.aspx
|titolo= C#/.NET History Lesson
|nome= James
|cognome= Kovacs
|data= 7 settembre 2007
|accesso= 7 giugno 2012
|dataarchivio= 21 agosto 2011
|urlarchivio= https://www.webcitation.org/616vU96EP?url=http://jameskovacs.com/2007/09/07/cnet-history-lesson/
|urlmorto= sì
}}). In effetti, il nome del linguaggio andrebbe scritto con il simbolo del [[diesis]], ma in sostituzione si usa il [[cancelletto]] per praticità di scrittura (fonte: [[Microsoft Developer Network|MSDN]], [https://msdn.microsoft.com/it-it/vcsharp/aa336822.aspx Domande frequenti su Visual C#]). In italiano, il gioco di parole viene perso.</ref> è un [[linguaggio di programmazione]] multi-paradigma che supporta tutti i concetti della programmazione orientata agli oggetti. Esso è stato sviluppato da [[Microsoft]] all'interno dell'iniziativa [[Microsoft .NET|.NET]], e successivamente approvato come standard dalla [[ECMA International|ECMA]] (ECMA-334) e [[Organizzazione internazionale per la normazione|ISO]] (norma [[ISO 23270|ISO/IEC 23270]]).
La [[sintassi]] e struttura del C# prendono spunto da vari linguaggi nati precedentemente, in particolare [[Delphi]], [[C++]], [[Java (linguaggio di programmazione)|Java]] e [[Visual Basic]].
== Storia del linguaggio ==
Il progettista principale di C# è [[Anders Hejlsberg]], un informatico danese precedentemente coinvolto nello sviluppo dei linguaggi [[Turbo Pascal]] e Borland [[Embarcadero Delphi|Delphi]] (attualmente di proprietà di Embarcadero).
È opinione comune che l'ispirazione venne dal linguaggio [[Java (linguaggio di programmazione)|Java]], dato che perfino il suo ideatore [[James Gosling]], nonché [[Bill Joy]] di Sun Microsystem, lo definirono una sua imitazione, ma più limitata dal punto di vista dell'affidabilità, della sicurezza e della produttività<ref>{{Cita web|url=https://www.cnet.com/news/why-microsofts-c-isnt/|titolo=Why Microsoft C# isn't|lingua=EN}}</ref>. Invece, secondo Anders Hejlsberg e Microsoft stessa, la struttura di C# è più vicina a quella del [[C++|linguaggio C++]] di quella di [[Java (linguaggio di programmazione)|Java]]<ref>{{Cita web|url=https://msdn.microsoft.com/en-us/library/ms836794.aspx|titolo=C# and Java: Comparing Programming Languages|lingua=EN}}</ref>.
C# è strettamente legato allo sviluppo di [[.NET Framework]]. Infatti gli ingegneri di Microsoft utilizzarono nelle prime fasi della sua stesura un framework chiamato SMC, ovvero Simple Managed C, un sistema utilizzante il [[C (linguaggio)|linguaggio C]] in modo gestito o "managed". Nel gennaio 1999, [[Microsoft]] mise Anders Hejlsberg a capo di un gruppo di lavoro con il compito di produrre un nuovo linguaggio, chiamato provvisoriamente "Cool", acronimo di "C-like Object Oriented Language" (linguaggio orientato agli oggetti simile a C)<ref>{{Cita news |lingua=en |autore=Naomi Hamilton |url=http://www.computerworld.com.au/article/261958/-z_programming_languages_c |titolo=The A-Z of Programming Languages: C# |pubblicazione=[[Computerworld (blog)|Computerworld]] |data=1º ottobre 2008 |accesso=4 febbraio 2017}}</ref>. Il nome commerciale definitivo divenne C# alla presentazione ufficiale del progetto .NET da parte di Microsoft alla Professional Developers Conference tenutasi nel [[luglio]] [[2000]] a [[Orlando (Florida)|Orlando]], quando anche le [[Libreria (software)|librerie]] di classi e il runtime di [[ASP.NET]] vennero convertite in linguaggio C#.
Nel tempo C# e [[Java (linguaggio di programmazione)|Java]] hanno percorso strade differenti, aumentando complessivamente le differenze reciproche, sebbene ci siano stati anche evidenti casi di reciproco scambio di caratteristiche. Per esempio C#, a differenza di Java, utilizza sin dalla versione 2 la [[Reificazione (informatica)|reificazione]] per generare oggetti generici che possono essere usati come classi, riservando al momento del caricamento della classe in fase di esecuzione la compilazione effettiva del codice. Anche l'implementazione in ambedue i linguaggi dei [[tipi generici]], sebbene concettualmente identica, è stata implementata in maniera piuttosto differente. Invece, il concetto di boxing e unboxing propri di C# sono stati implementati successivamente anche in linguaggio Java<ref>{{Cita web|url=http://www.artima.com/weblogs/viewpost.jsp?thread=6543|titolo=After Java and C# - what is next?|autore=Klaus Kreft and Angelika Langer|lingua=EN|accesso=4 febbraio 2017}}</ref>.
La versione C# 1.0, basata su .NET Framework 1.0, fu pubblicata commercialmente da Microsoft nel gennaio 2002 con il pacchetto di sviluppo Visual Studio .NET 2002. In seguito sono state pubblicate sino ad oggi nuove versioni del linguaggio e del framework .NET con i pacchetti [[Microsoft Visual Studio]].
<ref>{{Cita web|url=https://docs.microsoft.com/it-it/dotnet/csharp/whats-new/csharp-version-history|titolo=Cronologia di C#|lingua=it}}</ref>
{| class="wikitable"
!Versione C#
!Data di presentazione
!Versione .NET
!Visual Studio
|-
|1.0
|gennaio 2002
|1.0
|Visual Studio .NET 2002
|-
|2.0
|novembre 2005
|2.0
|Visual Studio .NET 2003
|-
|3.0
|novembre 2007
|2.0/3.5
|Visual Studio 2008-2010
|-
|4.0
|aprile 2010
|4.0
|Visual Studio 2010
|-
|5.0
|agosto 2012
|4.5
|Visual Studio 2012-2013
|-
|6.0
|luglio 2015
|4.6
|Visual Studio 2015
|-
|7.0
|marzo 2017
|4.6.2
|Visual Studio 2017
|-
|7.1
|agosto 2017
|4.7
|Visual Studio 2017 Ver. 15.3
|-
|7.2
|novembre 2017
|4.7.1
|Visual Studio 2017 Ver. 15.5
|-
|7.3
|maggio 2018
|4.7.2
|Visual Studio 2017 Ver. 15.7
|-
|8.0
|settembre 2019
|4.8
|Visual Studio 2019
|-
|9.0
|settembre 2020
|5
|Visual Studio 2019
|-
|10.0
|novembre 2021
|6
|Visual Studio 2022
|-
|11.0
|novembre 2022
|7
|Visual Studio 2022
|-
|12.0
|novembre 2023
|8
|Visual Studio 2022
|}
== Caratteristiche del linguaggio ==
C# è, in un certo senso, il linguaggio che meglio degli altri descrive le linee guida sulle quali ogni programma [[Microsoft .NET|.NET]] gira
Definire in forma classica C# come linguaggio interpretato o compilato nel senso classico dei termini è piuttosto complicato. In effetti è ambedue le cose allo stesso tempo. Data la sua stretta integrazione con il framework .NET, i codici sorgente scritti in C# sono normalmente compilati secondo i criteri [[Compilatore just-in-time|JIT]]. In pratica, la trasformazione in codice macchina (ovvero eseguito direttamente dalla [[CPU]]) viene compiuta solo all'atto di caricamento ed esecuzione del programma. In prima istanza il [[codice sorgente]] viene convertito dal framework in un codice intermedio detto [[Common Intermediate Language|CIL]] e solo all'esecuzione del programma il [[Common Language Runtime|CLR]] specifico per il [[sistema operativo]] utilizzato converte il CIL in [[linguaggio macchina]] specifico per l'[[hardware]] ospite, man mano che viene eseguito. Ciò comporta che l'esecuzione del codice può risultare più lenta alla prima esecuzione diventando poi più veloce. Inoltre, vengono tipicamente svolte durante la compilazione stessa delle ottimizzazioni progressive del codice macchina, producendo così un codice eseguito più velocemente e teoricamente "ottimale" solo dopo alcune esecuzioni complete dello stesso.
Una seconda possibilità è la cosiddetta ''compilazione Ngen'', che permette di convertire tutto il codice CIL in codice macchina in una volta sola. Ciò ha il vantaggio di consentire l'implementazione di ambienti di sviluppo che utilizzino C# in qualunque sistema operativo, una volta implementato il [[Common Language Runtime|CLR]] specifico.
La sintassi di base del C# è spesso molto simile o identica a quella dei linguaggi C, C++ e Java. Alcune delle caratteristiche di base sono:
* I nomi di variabili, funzioni, classi e altri elementi sono sempre sensibili alle minuscole, ovvero "case-sensitive".
* Ogni specifica dev'essere chiusa dal carattere [[punto e virgola]] (;).
* Gli indici degli elementi di [[array]] e [[Matrice|matrici]] sono numerati a partire da 0.
* Le parentesi graffe ({}) sono usate per raggruppare specifiche.
* Secondo le consuetudini dei linguaggi orientati agli oggetti, le specifiche sono di regola raggruppate in ''metodi'' (ovvero funzioni), i ''metodi'' sono raggruppati in ''classi'', e le ''classi'' sono raggruppate nei [[namespace]].
=== Differenze da C e C++ ===
Rispetto a [[C (linguaggio)|C]] o a [[C++]] il linguaggio C# presenta varie modifiche, volte principalmente ad evitare errori tipici e ambiguità della programmazione in [[C (linguaggio)|linguaggio C]]:
* I puntatori possono essere utilizzati solo in particolari blocchi di codice marcati come ''unsafe''.
* In molte operazioni aritmetiche vengono controllati eventuali [[Arithmetic overflow|overflow]].
* Gli oggetti dinamici non vengono deallocati esplicitamente, ma viene gestita automaticamente e implicitamente dal [[garbage collection|garbage-collector]] quando non esistono più riferimenti a tali oggetti. Questo sistema evita i due problemi dei ''[[dangling pointer]]'' e del ''[[memory leak]]'', anche se con una riduzione delle prestazioni.
* Come in [[Java (linguaggio di programmazione)|Java]] è possibile ereditare da una sola classe, diversamente da quanto avviene in [[C++]], ma è possibile implementare un numero indefinito di ''interfacce''. A differenza del [[C++]], non è consentita l'ereditarietà di tipo ''private''.
* Le sole conversioni implicite consentite sono quelle ''safe'', ovvero che non espongono al rischio di perdita di dati causata dal diverso tipo di dato. Per esempio non sono consentite conversioni implicite fra ''integer'' e ''boolean'' oppure tra enumeratori ed ''integer''.
* C# non dispone dei ''template'' tipici del [[C++]], ma nella versione 2.0 sono stati introdotti i ''generic''.
=== Differenze da Java ===
Sebbene C# sia ritenuto simile a [[Java (linguaggio di programmazione)|Java]], esistono alcune importanti differenze fra i due linguaggi. Quella maggiormente visibile è certamente la presenza in C# di molti costrutti, alcuni dei quali chiaramente derivati dal [[C++]], che in [[Java (linguaggio di programmazione)|Java]] sono stati deliberatamente vietati. I sostenitori del C# affermano che tutto ciò rende il codice più chiaro, mentre i sostenitori di [[Java (linguaggio di programmazione)|Java]] affermano che proprio la presenza di un gran numero di parole-chiave e di regole da ricordare rende il linguaggio più difficile da imparare e utilizzare.
Altre differenze evidenti sono le seguenti:
* [[Java (linguaggio di programmazione)|Java]] utilizza i commenti Javadoc-sintax per generare la documentazione dal codice sorgente, mentre C# utilizza la sintassi [[XML]] nei commenti per lo stesso scopo.
* Quello che in [[Java (linguaggio di programmazione)|Java]] è chiamato ''[[package (Java)|package]]'', in C# viene chiamato ''[[namespace]]'' o "spazio di nomi". Un ulteriore livello di organizzazione in C# è costituito dagli ''assembly'', che possono contenere al proprio interno diversi spazi di nomi.
* Java utilizza un diverso modo per richiamare i metodi costruttori di una classe, ovvero dalla prima riga di un costruttore ne richiama un altro.
=== Funzionalità introdotte con gli aggiornamenti ===
==== Versione 3 ====
* [[Lambda calcolo|Lambda expressions]]
* Tipi anonimi
* [[LINQ]]
* Extension methods
==== Versione 4 ====
* Pseudo tipo ''dynamic''
* [[Covarianza e controvarianza|Covarianza e Controvarianza]] nei tipi di parametri per interfacce generiche e delegati<ref>{{Cita web|url=https://msdn.microsoft.com/it-it/library/mt654055.aspx|titolo=Covariance and Contravariance (C#)|sito=MSDN|lingua=EN}}</ref>
* Specifica ''ref'' opzionale per l'uso di [[Component Object Model|COM]]
* Parametri opzionali e nomi di argomenti
* Indicizzatori di Proprietà (riconosciuti, ma non utilizzati dagli oggetti in C#)
==== Versione 5 ====
<ref>{{Cita news|lingua=en|url=https://blogs.msdn.microsoft.com/mvpawardprogram/2012/03/26/an-introduction-to-new-features-in-c-5-0/|titolo=An Introduction to New Features in C# 5.0|pubblicazione=The Microsoft MVP Award Program Blog|accesso=4 febbraio 2017}}</ref>
* Metodi asincroni
* Attributi ''Caller Info''
==== Versione 6 ====
<ref>{{Cita web|url=https://msdn.microsoft.com/it-it/magazine/dn802602.aspx|titolo=C# 6.0 nuovo e migliorato|cognome=Michaelis|nome=Mark|sito=msdn.microsoft.com|lingua=it|accesso=ottobre 2014}}</ref>
* Servizio compilatore
* Importazione di membri di tipo statico nel namespace
* Filtri di eccezione
* ''Await'' nei blocchi ''catch''/''finally''
* Inizializzatori di proprietà automatici
* Valori di default per proprietà di tipo ''getter'' esclusivo
* Membri expression-bodied
* Propagatore di ''null''
* Interpolazione stringhe
* Operatore ''nameof''
* Inizializzatore di dizionario
==== Versione 7 ====
<ref>{{Cita web|url=https://github.com/dotnet/roslyn/blob/c830f88e093d8753e92e7f1054393e456e6fac20/docs/Language%20Feature%20Status.md|titolo=Language Features Status|lingua=EN}}</ref>
* ''Binary literals''
* Decostruttori
* Separatori di cifra
* Funzioni locali
* Tipo ''switch''
* ''Ref'' ''return''
* ''Tuple'' con nome
* ''Out va''r
* Pattern Matching
* Ritorni asincroni arbitrari
* ''Records''
* Get e Set nelle definizioni di espressioni
* Costruttori e finalizzatori nelle definizioni di espressioni
==== Versione 8 ====
<ref>{{Cita web|url=https://docs.microsoft.com/it-it/dotnet/csharp/whats-new/csharp-8|titolo=Novità C# 8|lingua=IT}}</ref>
* Nullable reference types
* Membri di interfaccia di default
* Flussi asincroni
* Switch expressions
* Funzioni statiche locali
* Membri struct di sola lettura
* Miglioramento delle stringhe verbatim interpolate
* Records migliorati
* Indici ed intervalli
* Assegnamento con null-coalescing
==== Versione 9 ====
<ref>{{Cita web|url=https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-9|titolo=Novità C# 9|lingua=IT}}</ref>
* Dichiarazioni di primo livello
* Miglioramenti della corrispondenza dei modelli
* I setter solo Init
* Numeri interi di dimensioni native
* Puntatori a funzione
* Funzioni static anonime
* Parametri di scarto di Lambda
* Records migliorati
* Attributi su funzioni locali
* Nuove funzionalità per metodi parziali
== Esempi ==
=== Hello world! ===
Il seguente esempio visualizza il testo "[[Hello world]]" su console.
<
using System;
class HelloWorldApp
{
public static void Main(string[] args) // punto d'ingresso del programma
{
}
}
</syntaxhighlight>
Invece il seguente esempio stampa il testo "[[Hello
<syntaxhighlight lang="csharp">
using System.Windows.Forms;
class HelloWorldApp
{
Riga 66 ⟶ 267:
}
}
</syntaxhighlight>
=== Definizione di classe ===
Il seguente esempio definisce una classe di nome Persona che espone una proprietà ''Nome'' il cui valore viene memorizzato nella variabile ''mNome'':
<syntaxhighlight lang="csharp">
using System;
namespace Program
{
class Persona
{
private string mNome;//se non specifico "private" non ci sono differenze, perché è sottinteso.
public string Nome
{
Riga 83 ⟶ 285:
set { mNome = value; }
}
}
}
</syntaxhighlight>
Lo stesso esempio si può scrivere in una forma equivalente, utilizzando la sintassi delle
<syntaxhighlight
class Persona
{
public string Nome { get; set; }
}</syntaxhighlight>
Da notare che il linguaggio C# risulta
=== Deserializzazione di un file JSON ===
In questo esempio si utilizza il namespace nativo <code>System.Text.Json</code> per deserializzare un semplice file JSON, il cui contenuto viene in seguito formattato e stampato su <code>System.Console</code>.
Prendiamo in considerazione il seguente JSON.<syntaxhighlight lang="json">
{
"0": "Carthago delenda est.",
"1": "Alea iacta est.",
"2": "Cogito ergo sum."
}
</syntaxhighlight>Questo il codice in C#.<syntaxhighlight lang="csharp">using System.Text.Json;
namespace JSONDeserialization;
class Program
{
// Creiamo un'istanza di "JsonSerializerOptions.Default".
// È sempre consigliato inizializzarne solo una per programma.
// La parola chiave "readonly" significa che la variabile non verrà modificata dopo l'inizializzazione.
private readonly static JsonSerializerOptions JsonOptions = JsonSerializerOptions.Default;
// La funzione riceve come parametro la directory del file JSON che vogliamo deserializzare.
// Ci ritorna un dizionario contenente chiavi, identificatori unici di tipo "Int32", e un valore di tipo "String" per ogni chiave.
private static Dictionary<int, string> GetJsonAsDictionary(string directory)
{
// Dichiariamo un dizionario vuoto e nullable.
Dictionary<int, string>? data = [];
// Deserializziamo il file usando questa funzione statica e specificando il tipo di ritorno.
// Alcune funzioni richiedono che venga specificato il tipo di ritorno tra due parentesi angolari.
data = JsonSerializer.Deserialize<Dictionary<int, string>>(File.ReadAllText(directory), JsonOptions);
// File è una classe statica fornita da System per semplici manipolazioni di file.
// Se il dizionario è nullo o vuoto, facciamo scattare una "Exception".
// Le "Exception" spezzano immediatamente il runtime flow di un programma.
if (data is null || data.Keys.Count == 0)
throw new Exception("Il file è vuoto o non è stato deserializzato correttamente.");
return data;
}
private static void Main()
{
// Infine usiamo "string.Join" per scrivere l'output della funzione sulla Console.
Console.WriteLine(string.Join(", ", GetJsonAsDictionary("test.json")));
}
}</syntaxhighlight>L'output sarà quindi: <code>[0, Carthago delenda est.], [1, Alea iacta est.], [2, Cogito ergo sum.]</code>
=== Calcolatrice ===
Questo esempio mostra una semplice calcolatrice.<syntaxhighlight lang="c#">
using System;
namespace Calcolatrice
{
class Program
{
static void Main(string[] args)
{
int Numero1 = 0, Numero2 = 0; // Dichiara due numeri e li inizializza a 0.
int Risultato; // Variabile che serve per il risultato dei due numeri.
char Scelta; // Scelta dell'utente riferito alle opzioni nel menù.
do
{
Console.Clear(); // Cancella tutte le scritte presenti nella console.
/* Menù */
Console.WriteLine("Benvenuto nella calcolatrice."); // Scrive nella console "Benvenuto nella calcolatrice.".
Console.WriteLine("1. Addizione"); // Scrive nella console "1. Addizione".
Console.WriteLine("2. Sottrazione"); // Scrive nella console "2. Sottrazione".
Console.WriteLine("3. Moltiplicazione"); // Scrive nella console "3. Moltiplicazione".
Console.WriteLine("4. Divisione"); // Scrive nella console "4. Divisione".
Console.WriteLine("5. Esci"); // Scrive nella console "5. Esci".
Scelta = Console.ReadKey().KeyChar; // L'opzione dell'utente viene memorizzata nella variabile "Scelta"
Console.Clear(); // Cancella tutte le scritte presenti nella console.
if(Scelta != '5')
{
Console.Write("Inserisci il Primo numero: "); // Chiede all'utente di inserire il primo numero.
Numero1 = Convert.ToInt32(Console.ReadLine()); // Assegna il primo numero inserito dall'utente alla variabile "Numero1".
Console.Write("Inserisci il secondo numero: "); // Chiede all'utente di inserire il secondo numero.
Numero2 = Convert.ToInt32(Console.ReadLine()); // Assegna il secondo numero inserito dall'utente alla variabile "Numero2".
}
switch(Scelta) // Con lo switch si analizzano i vari casi del valore della variabile.
{
case '1':
{
Risultato = Numero1 + Numero2; // Il risultato dell'addizione va a finire dentro alla variabile "Risultato".
Console.WriteLine(Numero1 + " + " + Numero2 + " = " + Risultato); // Dice all'utente il risultato.
break; // Termina subito lo switch per non fare anche gli altri casi
}
case '2':
{
Risultato = Numero1 - Numero2; // Il risultato della sottrazione va a finire dentro alla variabile "Risultato".
Console.WriteLine(Numero1 + " - " + Numero2 + " = " + Risultato); // Dice all'utente il risultato.
break; // Termina subito lo switch per non fare anche gli altri casi
}
case '3':
{
Risultato = Numero1 * Numero2; // Il risultato della moltiplicazione va a finire dentro alla variabile "Risultato".
Console.WriteLine(Numero1 + " * " + Numero2 + " = " + Risultato); // Dice all'utente il risultato.
break; // Termina subito lo switch per non fare anche gli altri casi
}
case '4':
{
if (Numero2 != 0) // La divisione per zero è impossibile quindi si aggiunge un if
{
Risultato = Numero1 / Numero2; // Il risultato della divisione va a finire dentro alla variabile "Risultato".
Console.WriteLine(Numero1 + " / " + Numero2 + " = " + Risultato); // Dice all'utente il risultato.
}
else
{
Console.WriteLine(Numero1 + " / " + Numero2 + " = Impossibile!"); // Risultato impossibile
}
break; // Termina subito lo switch per non fare anche gli altri casi
}
case '5':
{
break; // Termina subito lo switch per non fare anche gli altri casi
}
default:
{
Console.WriteLine("Opzione Errata");
break;
}
}
Console.WriteLine("Premere invio per andare avanti");
Console.ReadKey();
}
while (Scelta != '5'); // Se la condizione è vera il codice al suo interno viene rieseguito!
}
}
}
</syntaxhighlight>
== Implementazioni ==
Il [[compilatore]] di riferimento è [[Microsoft]] [[Visual C#]], parte del pacchetto [[Microsoft]] [[Visual Studio]] e attualmente [[open source]]<ref>{{Cita web|url=https://github.com/dotnet/roslyn|titolo=DonTen Roslyn project on GutHub|lingua=EN}}</ref>.
Esistono sul mercato e nei circuiti dell'[[open source]] altre implementazioni.
=== Mono ===
Il progetto [[Mono (progetto)|Mono]] implementa un compilatore C# con licenza [[open source]], un'implementazione completa [[open source]] del [[Common Language Infrastructure|CLI]], o ''[[Common Language Infrastructure]]'', comprendente le librerie di framework richieste da specifiche [[ECMA]], oltre a una quasi completa implementazione delle librerie di classi proprietarie di [[Microsoft .NET|.NET]] attualmente aggiornate alla versione 3.5. Fino alla versione 2.6 di Mono non è prevista l'implementazione di ''Windows Presentation Foundation'' ([[Windows Presentation Foundation|WPF]]), sebbene sia invece prevista per successive evoluzioni della piattaforma Mono. Inoltre attualmente sono previste implementazioni solo parziali di [[LINQ to SQL]] e [[WCF]].
=== DotGNU ===
Il progetto [[DotGNU]], attualmente non più supportato<ref>{{Cita web|url=https://www.gnu.org/software/dotgnu/|titolo=DotGNU Project|lingua=EN}}</ref>, include un compilatore C#, una implementazione parziale della [[Common Language Infrastructure|CLI]], comprese le librerie richieste secondo le specifiche [[ECMA]], oltre a un sottoinsieme di alcune librerie di classi [[Microsoft .NET|.NET]] proprietarie di Microsoft, aggiornate alla versione .NET 2.0.
=== Rotor ===
Il progetto Rotor di Microsoft, distribuito con licenza gratuita solo per scopi didattici e di ricerca, fornisce una implementazione del runtime CLR e un compilatore C#, con un sottoinsieme dell'infrastruttura CLI conforme alle specifiche ECMA<ref>{{Cita web|url=https://msdn.microsoft.com/en-us/library/cc749640.aspx|titolo=Progetto Rotor in MSDN|lingua=EN}}</ref>.
== Standardizzazione ==
Nel dicembre del [[2001]] ECMA ha pubblicato "ECMA-334 C# Language Specification"<ref>{{Cita web |url=https://www.ecma-international.org/publications/standards/Ecma-334.htm|titolo=Standard ECMA-334<!-- Titolo generato automaticamente -->}}</ref>.
C# è diventato uno standard ISO nel [[2003]] ([[ISO 23270|ISO/IEC 23270]])<ref>{{Cita web |url=http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=36768 |urlarchivio=https://web.archive.org/web/20120508100146/http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=36768 |titolo=Standardizzazione ISO}}</ref>.
== Note ==
<references />
== Bibliografia ==
* {{cita libro|nome=John|cognome=Sharp|titolo=Microsoft Visual C# 2012|anno=2014|editore=Mondadori Informatica|p=251|isbn=978-88-6114-404-0}}
* {{cita libro|autore=A. Boehm, J. Murach|nome=|cognome=|titolo=Murach's C# 2015|url=https://archive.org/details/murachsc20150000boeh|anno=2016|editore = Mike Murach & Associates|lingua=EN|p=908|isbn=978-1-890774-94-3}}
* {{cita libro|autore=D. Bochicchio, C. Civera, M. De Sanctis, A. Leoncini, M. Leoncini, S. Mostarda|nome=|cognome=|titolo=C#6 e Visual studio 2015. Guida completa per lo sviluppatore|anno=2016|editore=Hoepli Informatica|p=456|isbn=978-88-203-7099-2}}
* {{cita libro|titolo=Programmare con C# 8. Guida completa|nome=Antonio|cognome=Pelleriti|anno=2019|editore=Edizioni LSWR|isbn=978-88-68957698|p=928}}
* {{cita libro|autore=A. Troelsen, P. Japikse|nome=|cognome=|titolo=C# 6.0 and the .NET 4.6 Framework|anno=2016|editore=Apress|lingua=EN|p=1625|isbn=978-1-4842-1333-9}}
* {{cita libro|autore=J. Albahari, B. Albahari|nome=|cognome=|titolo=C# 6.0 in a Nutshell: The Definitive Reference|anno=2016|editore=O'Reilly Media|lingua=EN|p=1136|isbn=978-1-4919-2706-9}}
*(IT) A. Pelleriti Programmare con C# 8, Digital Life Style, p. 243, ISBN 978-88-6895-769-8
== Altri progetti ==
{{interprogetto|b}}
== Collegamenti esterni ==
* {{Collegamenti esterni}}
* {{FOLDOC||C#}}
* {{cita web|https://msdn.microsoft.com/it-it/library/a72418yk.aspx|Getting started with C#}}
* {{cita web|https://msdn.microsoft.com/en-us/library/ms228593.aspx|C# Language Specification (MSDN)}}
* {{cita web|https://www.mono-project.com/Main_Page|Mono: Piattaforma di sviluppo Opensource}}
* {{cita web|http://www.ugidotnet.org|User Group Italiano dot NET}}
* {{cita web|http://www.dotgnu.org/|DotGNU Project - a Free Software .NET compatible platform}}
{{Linguaggio C}}
{{Principali linguaggi di programmazione}}
{{Controllo di autorità}}
{{portale|informatica|Microsoft}}
[[Categoria:.NET]]
[[Categoria:Linguaggi di programmazione multi-paradigma]]
[[Categoria:Linguaggi di programmazione funzionali]]
[[Categoria:Linguaggi di programmazione orientati agli oggetti]]
[[Categoria:Linguaggi di programmazione strutturati]]
[[Categoria:Linguaggi di programmazione imperativi]]
| |||