C ascuțit

Titlu corect: „ C # ”.

Din cauza limitărilor tehnice, tipografia dorită a titlului nu a putut fi redată corect.

VS #



Data primei versiuni	2001
Paradigmă	Structurat , imperativ , orientat spre obiect
Autor	Microsoft
Ultima versiune	9,0 (4 septembrie 2020)
Versiune de dezvoltare	8.0
Tastare	Static , puternic , nominativ
Dialecte	1.0, 1.1, 1.2, 2.0 (ECMA), 3.0, 3.5, 4.0, 5.0, 6.0, 7.0, 7.1, 7.2, 7.3, 8.0, 9.0
Influențată de	C ++ , Java
Influențat	Swift , Vala , F # , Kotlin , TypeScript
Implementări	Microsoft .NET , Mono , DotGNU
Sistem de operare	Cross-platform
Site-ul web	docs.microsoft.com/en-us/dotnet/csharp și docs.microsoft.com/de-de/dotnet/csharp
Extensie de fișier	.cs

C # ( C sharp [ s i ː . Ʃ ɑ ː p ] în engleza britanică ) este un limbaj de programare orientată pe obiecte , comercializat de Microsoft din 2002 și conceput să se extindă pe platforma Microsoft .NET .

Este derivat din C ++ și foarte aproape de Java, din care preia sintaxa generală, precum și conceptele, adăugând noțiuni precum supraîncărcarea operatorului , indexatori și delegați . Este utilizat în special pentru a dezvolta aplicații web pe platforma ASP.NET .

Prezentare

C # este un limbaj de programare orientat obiect , puternic tastat , derivat din C și C ++ , limbajul ca Java . Este folosit pentru a dezvolta aplicații web , precum și aplicații desktop, servicii web , comenzi, widget-uri sau biblioteci de clase. În C #, o aplicație este un pachet de clase în care una dintre clase are o metodă principală , așa cum se face în Java.

C # este destinat dezvoltării pe platforma .NET , un stack tehnologic creat de Microsoft pentru a reuși COM .

Executabile în C # sunt împărțite în ansambluri, spații de nume, clase și membri ai clasei. Un ansamblu este forma compilată, care poate fi un program (un executabil) sau o bibliotecă de clase (un dll). Un ansamblu conține codul executabil în MSIL, precum și simbolurile. Codul MSIL este tradus în limbajul mașinii în timpul rulării prin funcția just-in-time a platformei .NET.

Platforma .NET

C # este destinat dezvoltării pe platforma .NET. Inima acestei stive tehnologice este cadrul .NET , compus din:

Mediile ASP.NET și Winforms care sunt utilizate pentru a rula aplicații web, resp. desktopuri concepute pentru platforma .NET.
O bibliotecă de clase care vă permite să manipulați fișiere, să manipulați tabele sau structuri de copac, să accesați Internetul, să creați interfețe grafice, să accesați baze de date, să accesați registrul Windows și multe alte lucruri. Cea mai mare parte a funcționalității este asigurată de clase din spațiul de nume Sistem .

Common Language Runtime (ABR. CLR) este runtime folosit de limbile platforma .NET (C #, Visual Basic .NET , J # , etc), serviciile oferite de CRJ sunt lansarea și executarea de programe , colectarea gunoiului și gestionarea excepțiilor . Un program pentru platforma .NET este mai întâi compilat într-o formă intermediară, MSIL, apoi acest cod MSIL este transformat în cod mașină care va fi executat de CLR. Acest cod al mașinii se numește cod gestionat, deoarece execuția sa se află sub controlul CLR.

Un alt produs al platformei .NET este mediul de dezvoltare Visual Studio .NET , un instrument utilizat de obicei pentru programarea în C #.

Caracteristici

C # este un limbaj derivat din C ++ , oferă tastare sigură , precum și posibilități de încapsulare , moștenire și polimorfism al limbajelor orientate obiect. În C # toate tipurile sunt obiecte . Limba are un colector de gunoi și un sistem de manipulare a excepțiilor .

Tastarea sigură înseamnă, în special, că următoarele operații sunt refuzate: utilizarea unei variabile neinițializate, încercarea de a accesa dincolo de limitele unui tablou, conversii de tip ale căror rezultate nu sunt previzibile, depășirea limitelor în timpul operațiunilor aritmetice.

Multe dintre posibilitățile Java se găsesc în C # și există o asemănare puternică între codul scris în C # și codul echivalent în Java.

În C #, variabilele pot fi de tip referință sau de tip valoare . Tipurile de valori sunt tipuri primitive, enumerări, struct și tip nul. Tipurile de referință sunt clase, interfețe, tablouri și delegate .

Tipuri primitive

Tipurile primitive sunt sbyte, short, int, long, byte, ushort, uint, ulong, char, float, double, decimal și bool.

clasă

Cele mai fundamentale constructe ale limbajului C # sunt clasele . Acestea pot conține constante, câmpuri, proprietăți, indexatori, metode, evenimente, operatori, constructori, destructori sau subclase. Clasele elementare sunt șir și obiect.

struct

Structurile sunt similare claselor, dar sunt tipuri de valori și nu pot fi moștenite .

delega

Un delegat este o referință la o metodă care are anumiți parametri. Delegații sunt folosiți pentru a atribui metode variabilelor și a le transmite ca parametri.

enum

Un tip enumerat este un tip de valoare care are un set de constante. Fiecare tip enumerat are un tip de bază: un tip primitiv determinat în funcție de valorile constantelor.

tip nul

Nullables sunt tipuri primitive care pot fi în plus nule . Fiecare tip primitiv T are un tip nul nul asociat? De exemplu, o variabilă de tip int? poate conține un int sau nul.

Sintaxă

Exemplu de cod :

using System; public class HelloWorld { public static void Main(string[] args) { Console.WriteLine("Hello world!"); } } Cuvinte cheie

Cuvintele cheie din C # 1.0 sunt:

abstract class event if new readonly as const explicit implicit null ref base continue extern in object return bool decimal false int operator sbyte break default finally interface out sealed byte delegate fixed internal override short case do float is params sizeof catch double for lock private stackalloc char else foreach long protected static checked enum goto namespace public string struct throw typeof unchecked using volatile switch true uint unsafe virtual while this try ulong ushort void

Cuvinte cheie adăugate între C # 2.0 și 6.0:

add dynamic join select alias equals let set ascending from nameof value async get on var await global orderby where by group partial when descending into remove yield

Diferențe față de C ++

Limbajul are o serie de modificări față de C / C ++; trebuie menționate în special următoarele puncte:

Manipularea directă a indicatorilor poate fi făcută numai în codul marcat ca fiind nesigur și numai programele cu permisiunile corespunzătoare pot executa blocuri de cod nesigur . Cea mai mare manipulare a indicatorului se face prin referințe sigure, a căror adresă nu poate fi modificată direct, iar majoritatea operațiilor de indicare și alocare sunt verificate în funcție de depășirile de memorie. Pointerii pot indica numai tipurile de valori , tipurile de obiecte , gestionate de colectorul de gunoi , pot fi referite doar;
obiectele nu pot fi distruse în mod explicit. Gunoier are grijă de memorie eliberator atunci când nu mai există nici o referire la un obiect. Cu toate acestea, pentru obiectele care manipulează tipuri neadministrate, este posibilă implementarea interfeței IDisposablepentru a specifica procesarea care trebuie efectuată atunci când resursa este eliberată;
moștenirea mai multor clase este interzisă, dar o clasă poate implementa un număr nelimitat de interfețe, iar o interfață poate moșteni de la mai multe interfețe;
C # este mult mai tastat decât C ++; singurele conversii implicite sunt cele dintre diferitele game de numere întregi și cele de la un tip derivat la un tip părinte. Nu are loc nicio conversie implicită între booleeni și numere întregi, între membrii de enumerare și numere întregi, sau indicii către un tip de gol (deși pentru acest ultim punct utilizarea referințelor la tipul de obiect permite să obțină același efect). Conversiile definite de utilizator pot fi definite ca implicite sau explicite;
sintaxa pentru declararea matricilor nu este aceeași: int[] a = new int[5]înlocuiți int a[5]. Deoarece este o alocare dinamică, int [] a este declarația unei referințe (nulă dacă nu este inițializată). Cu toate acestea, alocarea manuală a unui tablou pe stivă rămâne posibilă cu cuvântul cheie stackalloc ;
membrii unei enumerări sunt adunați în propriul spațiu de nume ;
C # nu gestionează șabloanele , dar această funcționalitate a fost înlocuită de tipurile generice care au apărut cu C # 2.0;
proprietățile au fost introduse și oferă o sintaxă specifică pentru accesarea datelor membrilor (precum și facilitarea accesului simultan de mai multe fire );
de reflecție tipurile totale disponibile;
delegații, care sunt liste de indicatori către funcții, sunt utilizați în special pentru programarea evenimentelor.

Diferențe față de Java

Deși C # este similar cu Java, există câteva diferențe notabile, de exemplu:

Java nu permite supraîncărcarea operatorului ;
Java are verificate excepțiile, în timp ce excepțiile din C # nu sunt verificate, ca și în C ++;
Java permite generarea automată de documentație HTML din fișiere sursă utilizând descrieri de sintaxă Javadoc, în timp ce C # utilizează descrieri bazate pe XML;
Java nu are un limbaj preprocesator;
C # acceptă indexatori, metode de delegare și evenimente (unde Java este mulțumit de modelul de proiectare Observer );
C # nu acceptă implementări anonime de interfețe și clase abstracte;
C # acceptă doar clase interioare statice;
C # suportă structuri în plus față de clase (structurile sunt tipuri de valori : stocăm conținutul și nu adresa);
C # folosește un limbaj încorporat (DllImport) și o sintaxă portabilă pentru a apela o bibliotecă nativă, în timp ce Java folosește Java Native Interface ;
C # integrează genericitatea , iar mașina .NET a fost modificată pentru a permite acest lucru (Java îl integrează și el, dar implementarea sa a fost făcută în compilatorul javac fără a schimba codul secundar Java). Mai multe detalii despre aspectul teoretic al acestei realizări pot fi găsite în referință, diapozitivele 70-89 .

Istorie

În septembrie 2002, platforma .NET și C # au fost prezentate publicului. C # devine limbajul de facto al acestei platforme, a fost folosit și pentru implementarea unei părți a platformei .NET.

versiuni

An	Versiune	Bibliotecă	Schimbare principală
2002	1.0	.NET framework 1.0 și 1.1
2005	2.0	.NET framework 2.0	genericitate adăugată la C # și cadru
2008	3.0	.NET framework 3.5	LINQ (interogări lingvistice integrate)
2010	4.0	.NET framework 4.0	tipuri dinamice
2012	5.0	.NET framework 4.5	metode asincrone
2015	6.0	.NET framework 4.6	versiune pentru Linux
2016	7.0	.NET framework> = 4.5	Tuples, funcții locale
2019	8.0	.NET standard> = 2.1 și .NET Core> = 3.0	ReadOnly Member, Operator de asociere de îmbinare

C # 2.0

Microsoft a pus la dispoziția publicului înOctombrie 2005, după o lungă perioadă de testare beta, versiunea 2.0 a bibliotecii .NET, însoțită de o nouă versiune a aproape tuturor instrumentelor asociate. C # nu face excepție de la regulă și, prin urmare, este lansat în versiunea 2.0, cu următoarele adăugiri:

Clase parțiale, permițând distribuirea implementării unei clase peste mai multe fișiere.
Cele Tipurile generice , care nu sunt o simplă copie a șablonului C ++. De exemplu, găsim în C # generice restricția de tip (pentru a specifica tipurile care pot fi utilizate într-o generalizare). Pe de altă parte, este imposibil să se utilizeze expresii ca parametri pentru generalizare.
Un nou iterator care permite utilizarea coroutinelor prin intermediul cuvântului cheie yield, echivalent cu yieldcel găsit în Python .
Metode anonime cu reguli de închidere configurabile.
Tipuri „Nullable”, adică capacitatea de a specifica că un tip de valoare poate fi nul. Acestea sunt declarate cu semnul întrebării "? „După numele tipului, ca aceasta: int? i = null;.
Noul operator cu semn de întrebare dublu "?? »Folosește doi operanzi și returnează primul non-zero. A fost introdus pentru a specifica o valoare implicită pentru tipurile „nulabile”.

Pentru referință, specificațiile complete ale noilor caracteristici introduse în versiunea 2.0 sunt disponibile la linkurile externe .

Anders Hejlsberg , tatăl lui Delphi, a vorbit despre implementarea genericelor în C #, Java și C ++ în acest interviu (în) .

Funcționalitatea tipurilor nulabile a fost corectată cu doar câteva săptămâni înainte de lansarea publică a versiunii 2.0, deoarece s-a dezvăluit că, dacă valoarea variabilei era într-adevăr zero, această variabilă nu era nulă în sensul tradițional al termenului, adică nu este o referință goală. Astfel, convertirea unui tip primitiv cu valoare zero la un obiect a dus la o referință diferită de zero la o valoare zero. Pentru a corecta această problemă, a fost, prin urmare, necesar să corectați nucleul CLR și să efectuați numeroase verificări și corecții pe toate produsele din gama .NET 2.0 (Visual Studio 2005, SQL Server 2005, C # și VB.NET).

C # 3.0

C # 3.0 a fost prezentat la PDC 2005. Versiunea finală este disponibilă de atunci 19 noiembrie 2007pentru descărcare de pe site-ul Microsoft (en) . Principalele caracteristici noi sunt următoarele:

Adăugarea de cuvinte cheie select, fromprecum și wherepentru a permite formarea și executarea SQL, interogări XML, sau direct pe colecții. Această funcționalitate face parte din programul Language Integrated Query (LINQ ) .
Nouă posibilitate de inițializare a unui obiect: în loc de Client c = new Client(); c.Nom = "Dupont";, putem folosiClient c = new Client{ Nom = "Dupont" };
Expresii Lambda : ListeTrucs.Where( delegate(Truc x) { return x.Size > 10; } );devineListeTrucs.Where( x => x.Size > 10 );
Inferența tipului de variabile locale: string s = "Dupont"poate fi înlocuită cuvar s = "Dupont"
Introducere de tipuri anonime: var x = new { Nom = "Dupont" }poate fi folosit în loc declass __anonymous { private string _nom; public string Nom { get { return _nom; } set { _nom = value; } } } __anonymous x = new __anonymous(); x.Nom = "Dupont";
Arborii de expresie: permit compilarea codului sub formă de arbori de obiecte ușor analizate și manipulabile.
Metode extinse: vă permite să adăugați metode la o clasă prin adăugarea unui prim parametru this.

O prezentare generală a C # 3.0 și LINQ poate fi găsită pe pagina .NET Framework Development Center .

Codul compilat în C # 3.0 este pe deplin compatibil cu cel din 2.0, deoarece îmbunătățirile aduse sunt pur sintactice sau constau din comenzi rapide compensate în momentul compilării. Cu toate acestea, noile funcții introduse în bibliotecile versiunii 3.5 (LINQ etc.) nu pot fi utilizate cu versiunile anterioare ale C #.

Această versiune necesită Windows XP sau o versiune ulterioară ( Vista sau Windows 7 ). Nu este disponibil pentru Windows 2000 .

C # 4.0

Limba versiunii 4 oferă mai multe funcții noi:

tastarea dinamică a variabilelor folosind cuvântul cheie dynamic ;
argumente numite și opționale;
suport pentru covarianță și contravarianță pentru interfețe și delegați generici.

.NET 4.0 Cadrul a fost lansat pe12 aprilie 2010, însoțit de Visual Studio 2010. Oferă printre altele:

noua bibliotecă paralelă: Task Parallel Library ;
o versiune optimizată a Entity Framework pentru acces la baze de date prin utilizarea LINQ;
versiunea paralelă a LINQ numită PLINQ.

C # 5.0

Versiunea 5 Limbajul utilizat pentru a programa programe asincrone pur și simplu prin adăugarea de cuvinte cheie asyncși await.

Comportamentul închiderilor în buclă foreacha fost modificat. Nu mai este necesar să introduceți o variabilă locală într-o buclă foreachpentru a evita problemele de închidere .

Rețineți, de asemenea, informațiile referitoare la apelant care permit cunoașterea numelui metodei care a apelat o proprietate.

C # 6.0

A șasea versiune a C # face mai multe modificări, inclusiv:

Proprietățile implementate automat (sau proprietățile automate) au apărut pentru prima dată în C # 3, pentru a simplifica declararea proprietăților care încapsulează pur și simplu accesul la câmpuri. Deși fac codul mai concis, au un dezavantaj: nu este posibil să le inițializăm la nivelul declarației, trebuie să se facă neapărat în constructor. În plus, nu este posibil să facem proprietăți automate numai în citire, deoarece acestea nu au mutator (setter) și, prin urmare, nu le-am putea atribui o valoare.

C # 6 abordează această problemă permițând inițializarea proprietăților automate la nivel de declarație.

Standardizare

C # a fost standardizat de ECMA (ECMA-334) îndecembrie 2001și de ISO / IEC ( ISO / IEC 23270 ) în 2003 .

Modificările din versiunea 2.0 au fost standardizate de ECMA (ECMA-334) îniunie 2006și de ISO / IEC ( ISO / IEC 23270: 2006 ) înSeptembrie 2006.

Microsoft a deschis codul sursă pentru unele biblioteci utilizate de C # în octombrie 2007sub licența sursă de referință Microsoft (MS-RSL).

Numele limbii

Standardul ECMA 334 și ISO 23270 definesc numele limbii ca caracterul Unicode 0043 (majuscule C) urmat de caracterul 0023 (#). Se pronunță „C ascuțit” și nu „H hash”, „ascuțit” desemnând într-adevăr simbolul muzical ♯ dar # fiind necesar pentru accesul ușor de pe o tastatură a computerului care oferă în schimb crucea („hash”).
Numele „C #” este inspirat de notația muzicală, unde o claritate indică faptul că nota scrisă ar trebui mărită cu un semiton. Acest lucru este similar cu numele limbajului C ++, unde „++” indică faptul că o variabilă ar trebui să fie incrementată cu 1 după evaluare. Simbolul # arată, de asemenea, ca o ligatură de patru simboluri "+" (într-o grilă două-la-două), ceea ce implică faptul că limbajul este un increment al C ++.

C++ ++

Anexe

linkuri externe

(ro) Pagina standard ISO / IEC 23270: 2006
(ro) pagina standard ECMA 334
(ro) C # Development Center - MSDN Site

Bibliografie

C # și .NET - Gérard Leblanc - 2002 - Éditions Eyrolles - ( ISBN 2-212-11066-9 )
C # și .NET Versiunea 2 - Gérard Leblanc - 2006 - Éditions Eyrolles - ( ISBN 2-212-11778-7 )
C # Head First - Andrew Stellman, Jennifer Greene - 2008 - Éditions Digit Books - ( ISBN 978-2-81500-001-7 )
Introducere în C # - Pierre-Yves Saumont, Antoine Mirecourt - 2001 - Éditions Eyrolles - ( ISBN 2-7464-0301-3 )
The C # Survival Guide - Gilles Tourreau - 2010 - Éditions Pearson Education - ( ISBN 978-2-7440-2432-0 )
Benoît Prieur, programare C #: pregătire pentru certificările MCSA - Examenul 70-483 , edițiile ENI,16 mai 2018, 448 p. ( ISBN 978-2-409-01382-9 , OCLC 1038026533 )
(ro) Referința programatorului C # 2005 - Adrian Kingsley-Hughes, Kathie Kingsley-Hughes - 2006 - Ediția Wrox - ( ISBN 0-470-04641-4 )
(ro) C # Essentials, ediția a doua - Ben Albahari, Peter Drayton, Brad Merrill - 2002 - O'Reilly Media Edition - ( ISBN 0-596-00315-3 )
(ro) Professional C #, Ediția a 3-a - Simon Robinson, Christian Nagel, Karli Watson, Jay Glynn, Morgan Skinner, Bill Evjen - 2004 - Ediția Wrox - ( ISBN 0-7645-5759-9 )

Note și referințe

(fr) [1]
„ https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-8 ” (Accesat la 3 iulie 2019 )
(en) Balagurusamy, Programming In C # , Tata McGraw-Hill Education - 2008, ( ISBN 9780070667570 )
(ro) Anders Hejlsberg - Mads Torgersen - Scott Wiltamuth - Peter Golde, Limbajul de programare C # (Acoperind C # 4.0), Documente portabile , Addison-Wesley Professional - 2010, ( ISBN 9780132481724 )
(ro) Mark Michaelis - Eric Lippert, Essential C # 6.0 , Addison-Wesley Professional - 2015, ( ISBN 9780134176130 )
(en) site MSDN
(in) Suport în timpul subtipării MPRI [PDF] , diapozitive 73-80 .
http://msdn.microsoft.com/fr-fr/library/vstudio/dd264739(v=vs.100).aspx
(în) Site MSDN .
http://blogs.msdn.com/b/ericlippert/archive/2009/11/12/closing-over-the-loop-variable-considered-harmful.aspx
http://msdn.microsoft.com/fr-fr/library/hh534540.aspx
Thomas Levesque , „ Caracteristici noi în C # 6 ” (accesat la 19 septembrie 2015 ) .
Licență sursă de referință Microsoft (MS-RSL)
ECMA 334, p. 11