hu en hu hu hu hu hu hu en en hu hu en hu fr hu ru hu ru hu hu hu hu hu en hu de hu en hu ja hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu sk hu hu hu hu hu hu hu hu hu hu hu en en hu en en hu en en hu en hu hu en hu hu zh hu hu en hu hu nb hu hu tr en hu hbs_lat hu hu be hu hu sv hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu en hu en hu hu hu hu hu hu hu hu lt hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu en hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu en cs de hu en id es ar en en ml en pt en en en en nl ja en de en en en zh en de en en en it en de de pl pl en lt en en ja ceb en bg en hu hu hu fr en en en en hu hu sk hu hu ru hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu de hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu en ar arz az ru sv bg bn hbs_lat ca en mzn hbs_lat da de el eo es et eu fa fi fr lt gu ku he hi hbs_lat hy id is it ja ka uz kk km ko cs lt lv en ml ms my nds ne nl nb nb pl pnb pt ro ru bxr hbs_lat en sk sl sq hbs_lat sv hu ta en th tr fy ur uz vi pl zh da zh fr zh hu hu hu hu hu hu hu hu hu hu
A Wikipédiából, a szabad enciklopédiából
Ez a közzétett változat, ellenőrizve: 2021. december 30.
Ugrás a navigációhoz Ugrás a kereséshez
A szócikk címe technikai okok miatt pontatlan. A helyes cím: C#.
10.0 (stabil verzió, 2021. november 8.)[1]
statikus, dinamikus, erősen típusos, típus biztos, normatív
Java, C++, Object Pascal, Eiffel
A C# (kiejtése: szí-sárp, de ismert a cisz elnevezés is) a Microsoft által a .NET keretrendszer részeként kifejlesztett objektumorientált programozási nyelv. A nyelv alapjául a C++ és a Java szolgált.
A 90-es években a Microsoft a saját Java keretkörnyezetét a saját operációsrendszer-specifikus függvényeivel és szolgáltatásaival bővítette ki, amire viszont nem volt engedélye (a Java licencét birtokló) Sun Microsystemstől. A Microsoft-féle Javára fejlesztett alkalmazások nem lettek volna futtathatók más rendszereken, ami ellenkezik a Java platform-függetlenségre vonatkozó alapelvével. A Sun végül beperelte a Microsoftot, és ezt követően a Microsoft a Java eltávolítására kényszerült a Windows rendszerekből (természetesen a Java-t a továbbiakban is lehet külön rendszerként telepíteni). A Microsoft egy saját keretrendszer fejlesztésébe kezdett. Ez lett a .NET (kiejtése: dotnet), és ehhez a keretrendszerhez adták ki programnyelvként a C# első verzióját. A későbbiekben ezt a nyelvet úgy fejlesztették tovább, hogy meglegyen az egyensúly a programozó nyelvi szabadsága és a gyors alkalmazásfejlesztés lehetősége között. Rengeteg hivatalosan kiadott bővítmény létezik hozzá, amelyek a kódolást könnyebbé teszik.
A C# fejlesztését Anders Hejlsberg vezette, aki a Turbo Pascal tervezője is volt. A .NET osztálykönyvtárait a programozók eredetileg egy sajátos, ún. SMC (Simple Managed C) nyelven írták. 1999-ben azonban Hejlsberg (aki addig a J++ nyelven dolgozott) vezetésével egy csapat alakult egy új programozási nyelv létrehozására, akkoriban COOL (C-like Object Oriented Language, magyarul: C-szerű Objektum Orientált Nyelv) fedőnév alatt.[2] A cél egy olyan nyelv megalkotása volt, mellyel teljesen objektumorientált módon lehet a keretrendszer komponenseit fejleszteni. Egy évvel később, 2000 júliusában a PDC konferencián a .NET-tel, és az ASP.NET-tel együtt a C#-ot is bemutatták, immár ezen névvel, hogy az esetleges szerzői jogi problémákat megelőzzék. Bár sok bírálat érte megjelenésekor, főleg a Java-s táborból, miszerint a Microsoft pusztán legyártotta a saját Java verzióját, Anders azt nyilatkozta, hogy a nyelvet sokkal inkább a C++-hoz szerették volna közelíteni.[3]
Generikus és parciális típusok, anonim metódusok, iterátorok
Implicit módon megadott lokális változók, lambda-, és lekérdezés-kifejezések, kifejezésfák, objektuminicializálók
Language Integrated Query, lambda-kifejezések, kiegészítő metódusok
Dinamikus kötés, opcionális paraméterek, generikus ko- és kontravariancia, Párhuzamos programozás támogatás, PLINQ
Aszinkron feladatok, párhuzamos programozás továbbfejlesztése
Null kondicionális operátor, statikus importálás, csak olvasható auto tulajdonságok
Out változók, Tuple típus, Pattern matching, helyi metódusok, throw kifejezések
private protected hozzáférési szint, számok tagolásához használható a _ karakter
Rekordtípusok, init only setterek, mintaillesztés, kódgenerátor[4]
Mono, a Ximian nyílt forráskódú .NET implementációja
dotGNU és a Portable.NET a Free Software Foundationtól
Bár a Mono Project egy nagyrészt kompatibilis[5] nyílt forráskódú C# fordítót állított elő (lehetővé téve az ilyen kódok futtatását Linux és Macintosh rendszereken), a nyelv Windows operációs rendszereken kívüli használata nem terjedt el, mivel az osztálykönyvtárakat szolgáltató .NET Framework portolása más rendszerek alá még kezdetleges stádiumban van.[forrás?] Ugyanakkor a Mono az utóbbi években rohamos fejlődésnek indult, amit elősegített a Microsoft és a Novell (a Mono „anyacége”) együttműködése a Microsoft Silverlight technológiájának Linux illetve Macintosh rendszerekkel kompatibilis változatának – a Moonlightnak – a készítésekor.
A C# az a programozási nyelv, ami a legközvetlenebb módon tükrözi az alatta működő, minden .NET programot futtató .NET keretrendszert, valamint erősen függ is attól: nincsen nem menedzselt, natív módban futó C# program. A primitív adattípusai objektumok, a .NET típusok megfelelői. Szemétgyűjtést használ, valamint az absztrakcióinak többsége (osztályok, interfészek, delegáltak, kivételek…) a .NET futtatórendszert használja közvetlen módon.
A C vagy C++ nyelvhez hasonlítva a C# több korlátozást és továbbfejlesztést is tartalmaz. A lehetőségei közül néhány:
A mutatók és a nem ellenőrzött aritmetika csak egy speciális, nem biztonságos módban (unsafe mode) használható. A legtöbb objektum-hozzáférés csak biztonságos hivatkozásokon keresztül tehető meg, és az aritmetikai műveletek debug módban túlcsordulás szempontjából ellenőrzöttek.
Az objektumok nem szabadíthatók fel közvetlen módon, ehelyett a szemétgyűjtő szabadítja fel őket, mikor már nincs rájuk hivatkozás. Ez a módszer kizárja a nem létező objektumokra való hivatkozás lehetőségét.
A destruktorok (~) elérhetőek. A megfelelően megírt IDisposable interfész (Disposable programozási minta), aminek a lefutását garantálja using blokk, együtt kikényszerítheti az azonnali felszabadítást az osztályon belüli natív erőforrások esetében. A nem natív erőforrások felszabadítását ebben az esetben is a szemétgyűjtő (Garbage Collector) végzi. A finalizerek szintén rendelkezésre állnak, de nem váltanak ki azonnali felszabadítást. Finalizer a Dispose eljárás javasolt implementációs módozatában nem fut le, mivel az ajánlás szerint a szemétgyűjtőt utasítani kell a finalizer hívás kihagyására.
A nyelv csak egyszeres öröklődést támogat, de egy osztály több interfészt is megvalósíthat.
A C# sokkal típusbiztosabb, mint a C++. Az egyetlen implicit konverzió a biztonságos konverzió, úgy mint az egészek tágabb intervallumba konvertálása vagy a leszármazott osztályok alaposztályba konvertálása. Nincs implicit konverzió az egészek és a logikai típus (boolean) között, a felsorolás tagok és az egészek között. Nincsenek void mutatók (bár az Object osztályra mutató mutatók hasonlóak), valamint bármely, a felhasználó által definiált implicit konverziót explicit módon meg kell jelölni.
A felsorolás adattagjai a saját névterükben helyezkednek el.
A 2.0-s verziótól felfelé már rendelkezik a generikus programozás néhány eszközével.
Tulajdonságok (Properties) használhatók, amelyek úgy tesznek lehetővé kódfuttatást mezők beállításakor és olvasásakor, hogy közben az adattagok szintaxisát használja.
A Microsoft bár úgy fejlesztette ezt a nyelvet, mint a saját Java implementációját, bizonyos tulajdonságokban azonban eltérő szemléletmódot követ a két rendszer. Ilyen különbségek például:
A Java alapértelmezett láthatósága mindig csomagon (package) belül publikus, a C#-nál mindig privát, a protected jelentése eltér, illetve támogatja az internal és a protected internal láthatóságot
A C# támogatja a parciális osztályokat (2.0-s verziótól felfelé), és az operátor-felüldefiniálást (en:Operator Overloading)
A metódusok a Javában alapból virtuálisak, ellentétben a C#-pal
A Java ellenben például lehetővé teszi a fordításidejű kivételkezelést
A Java támogatja az egzisztenciális generikusokat, míg a C# a ko- és kontravarianciát (4.0-s verziótól) a generikusoknál
A C# támogatja az azonos nevű, de eltérő verziójú szerelvények betöltését, ezzel szemben a Java-ban nincs ilyen támogatás
Java esetén nincsenek tulajdonságok, amelyek megkönnyítenék az objektumok belső változóinak az ellenőrzött lekérését és módosítását. Helyette ez a funkció Getter és Setter metódusokkal van megvalósítva.
A C# támogatja a delegált metódusokat, amely hasonló funkciót valósít meg, mint C++ esetén a függvény mutatók.
A C# a delegált metódusoknak köszönhetően támogatja az eseménykezelést
A C# esetén van unsafe (nem biztonságos) kontextus, amelyben létezik mutató típus. (optimalizációt segíti)
A C# esetén van unchecked (nem ellenőrzött) kontextus, amiben a változók túlcsordulása és helyes típus konvertálása felülbírálható (optimalizációt segíti)
Szintaxisban a két nyelv ugyanabba a nyelvcsaládba (C/C++ alapú nyelvek) tartozik, tehát mindkettőre a kapcsos zárójeles tagolás, sor végi pontosvessző a jellemző, ezért a kód nagyban hasonlít.
A legtöbb programozási nyelvtől eltérően a C# megvalósítások nem rendelkeznek önálló, eltérő osztály- vagy függvénykönyvtárakkal. Ehelyett a C# szorosan kötődik a .NET keretrendszerhez, amitől a C# kapja a futtató osztályait és függvényeit. A .NET keretrendszer osztálykönyvtárat tartalmaz, ami a .NET nyelvekből felhasználható egyszerű feladatok (adatreprezentáció és szövegmanipuláció) végrehajtásától kezdve a bonyolult (dinamikus ASP.NET weblapok generálása, XML feldolgozás és reflexió) feladatokig. A kód névterekbe van rendezve, mely a hasonló funkciót ellátó osztályokat fogja össze. Például System.Drawing a grafikai, System.Collections az adatstruktúra és System.Windows.Forms a Windows ablakos megjelenítéséért felelős funkciókat fogja össze.
További rendezési szint az assembly (szerelvény). Egy assembly állhat egy fájlból, vagy több összelinkelt fájlból (az al.exe segítségével), ami több névteret és objektumot tartalmazhat. A különböző feladatokhoz szükséges osztályokat assemblyk (például System.Drawing.dll, System.Windows.Forms.dll) hivatkozásával vagy a központi könyvtár (mscorlib.dll a Microsoft megvalósításában) használatával érhetik el a programok.
A .NET keretrendszer támogatja azonos nevű, de eltérő verziójú assemblyk betöltését, amelyek verziózott implementációkat tartalmazhatnak, így könnyedén lehetővé válik egy alkalmazáson belül a visszafelé kompatibilitás eltérő implementációk betöltésével és példányosításával.
Egy egyszerű C# program:
public class ExampleClass { public static void Main() { System.Console.WriteLine("Helló világ!"); } }
A program megjeleníti a Helló világ! szöveget a konzolon. A program részletei a következők:
Ez az osztálydeklaráció. Publikus, azaz bármely más projekt szabadon használhatja az osztályt. Az összes információ a kapcsos zárójelek között az osztály leírását szolgálja. Minden programban kötelező legalább egy osztályt implementálni, itt ennek neve ExampleClass lett.
public static void Main()
Ez a függvény a program belépési pontja, ahol a program végrehajtása megkezdődik, mindig a Main() nevet viseli.
Ez a rész felel meg a feladat végrehajtásának. A Console egy rendszerobjektum, ami egy parancssort jelképez. A Console objektum WriteLine metódusának meghívása a paraméterként átadott szöveget kiírja a parancssorba.
Ahhoz, hogy értékeket tudjunk megadni, először változót kell deklarálni, és utána inicializálni azt. deklaráció: int x; inicializálás: x = 10; Ezt lehet egyszerre is: int x = 10;
Egy példa a változókra:
class Változók // A nyelv támogatja az Unicode-karakterek használatát, így pl. ékezetek is tehetők a nevekbe. { public static void Main() { int i = 10; // Az egész típusú i változó értéke 10. System.Console.WriteLine(i); // Kírjuk a képernyőre. int i2 , i3; // Többszörös deklarálás i2 = 12; // Inicializáció i3 = 13; Console.WriteLine(i2); Console.WriteLine(i3); const double állandó = 3.1415; //Egy állandó deklarációja és inicializálása double d = 12.3; //Tizedestört float f = 0.65F; //Az F betűvel jelezzük, hogy lebegőpontosan ábrázolandó. char c = 'c'; // A char 1 karaktert tud tárolni (és azt ' ' jelek között kell megtenni). string s = "Helló világ!"; // A string karaktersorozatot tud tárolni "" jelek között. Console.WriteLine("double: {0}, float: {1}, char: {2}, string: {3}, állandó: {4}",d,f,c,s,állandó); //kiírjuk a képernyőre az eredményeket. A {0} helyére a d, az {1} helyére az f... fog kerülni. Console.ReadKey(); // A program egy billentyű lenyomására vár, //tehát nem fog véget érni a programunk, míg meg nem nyomunk egy gombot. } }
Az operátorok műveletek: +, -, *, /, %(maradékképzés). A C++-ban bevezetett jelölések itt is léteznek, tehát például:
i = i+1; ez ugyanaz, mint ez: i++;
i = i+d; ez ugyanaz, mint ez: i += d;
i = i*d; ez ugyanaz, mint ez: i *= d;...
Egy relációs jel segítségével két érték között végezhetünk viszonyításokat. pl:  ,  =, !=(nem egyenlő), ==(egyenlő)...
... int x = 10; int y = 23; Console.WriteLine(y < x); // kiírja, hogy false (hamis) Console.WriteLine(y == x); // hamis Console.WriteLine(y != x); //true (igaz) Console.WriteLine(x <= y); // x kisebb (vagy egyenlő) mint y: igaz Console.ReadKey(); ...
Logikai / feltételes operátorok:
A logikai műveletek is elérhetőek hasonlóan a kiinduló nyelvekhez:
... bool igaz = true; // Az igaz nevű változó értéke igaz. bool hamis = false; // A hamis nevűé hamis. if( igaz == false || hamis == false ) // Ha az igaz hamis vagy a hamis hamis, akkor kiírja a szöveget. { System.Console.WriteLine("Az egyik jó volt."); } ...
A && balról jobbra haladva kezdi kiértékelni a vele összekapcsolt kifejezéseket, és ha olyat talál, ami hamis, akkor a többit már ki sem értékeli, hiszen a teljes kifejezés értéke most már biztosan hamis lesz. Ugyanígy ha a || elér egy igaz kifejezéshez, tovább már nem értékel, mert itt már biztos, hogy a teljes kifejezés igaz lesz.
Az elágazás valamilyen feltételtől függő tevékenység végrehajtását jelenti. Két alapvető fajtája van: a kétágú és a többágú szelekció. Kétágú szelekció esetén (if, else) a program futása vagy az igaz vagy a hamis ágon folytatódik. Többágú szelekciónál lehetőség van egy kifejezés eredményének több lehetséges állapotától függő tevékenység elvégzésére.
... Console.WriteLine("Adjon meg egy számot:"); int x = Convert.ToInt32(Console.ReadLine()); // bekérünk egy egész típusú számot, ha nem is egész típusú akkor is az lesz mivel átkonvertáljuk. switch(x) // vizsgáljuk az x-et { case 17: // ha 17 Console.WriteLine("x == 17"); break; // kilépünk a switchből case 10: //ha 10 Console.WriteLine("x == 10"); break; // kilépünk default: // ha egyik sem Console.WriteLine("Default"); break; // kilépünk } ...
Amikor egy adott utasítás vagy utasítássorozatot többször kell elvégeznünk akkor ciklust használunk, például: ki kell írni a konzolra 0-100-ig a számokat. A ciklusoknak alapvetően három típusa létezik: a számlálásos, az elöltesztelős és a hátultesztelős. A számlálásos ciklus egyik megvalósítási formája a for ciklus:
for(int i = 0; i <= 100; i++) //addig fog ismétlődni a ciklus, amíg az i el nem éri a 100-at { System.Console.WriteLine(i); }
Elöltesztelős ciklus a while kulcsszóval érhető el:
int i = 0; //kezdőérték beállítása while( i <= 100 ) // ciklusfeltétel megadása { System.Console.WriteLine(i); i++; //ciklusváltozó növelése }
Hátultesztelős a do-while párossal:
do { Console.WriteLine("Adjon meg két számot:"); int egyik = Convert.ToInt32(Console.ReadLine()); int másik = Convert.ToInt32(Console.ReadLine()); int eredmény = egyik + másik; Console.WriteLine("Az összeguk: {0}", eredmény); Console.WriteLine("Ha ki akar lépni, üsse be, hogy kilépés, ha nem, akkor azt, hogy vissza!"); választás = Convert.ToString(Console.ReadLine()); } while (választás != "kilépés"); // Ha nem a kilépés szót írjuk be, újrakezdődik a ciklus.
Létezik a C#-ban még egy különlegesebb ciklusvezérlő, ez a foreach. Egy adott tömb, vagy lista elemein megy végig, a különlegessége, hogy nem kell megadni kilépési pontot, sem feltételt, egyszerűen akkor marad abba, ha a végére ér az adott adatstruktúrának. Használata javasolt, mivel írásmódja szebb, mint a hagyományos for ciklusé, és a belőle forduló kód a legtöbb esetben optimálisabb CIL kódot eredményez a többi módszerhez képest.[6] Példa:
... int[] számok = new int[7]{1,3,2,5,7,4,9}; int páros = 0; int páratlan = 0; foreach( int i in számok ) { if (i % 2 == 0) páros++; else páratlan++; } ...
A felsorolás típust akkor szoktuk használni, ha sok elemet akarunk megadni. Ez az összegyűjtés (enumeration) magától megszámozza az elemeket 0 -...-ig, de ha saját számozást akarunk, akkor magunk is megszámozhatjuk. Például:
class EnumClass { enum színek{piros, kék, zöld, sárga}; public static void Main() { System.Console.WriteLine(színek.zöld); // kiírja a színt //ciklus a színeken történő végighaladásra for( színek i = színek.piros; i <= színek.sárga; i++) { // i = piros, piros kisebb és egyenlő sárga ( piros<kék<zöld<sárga ) System.Console.WriteLine(i); } System.Console.ReadKey(); } }
A tömb az az adattípus, amikor egy adott típusú változóból egy sorozatot, vektort vagy mátrixot készítünk. Általános szintaxis: Típus[] változónév = new Típus[hossz];. Például:
class Tömbök1 { public static void Main() { int[] számok = new int[5] {1, 3, 6, 3, 2}; // létrehozunk egy tömböt és utána megadjuk az elemeit int[] számok2; számok2 = new int[] {3, 6, 1, 6, 8, 3}; // az elemek számából magától kiszámolja, hogy hány elemű... string[] karakterlánc = new string[3] {"egy", "kettő", "harom"}; Console.WriteLine("A számok tömb 5. elemének értéke: {0}", számok[4]); Console.WriteLine("A számok2 tömb 3. elemének értéke: {0}", számok2[2]); // a tömbök indexelése 0-tól kezdődik, így a 4. indexű elem a tömb 5. eleme // ciklus, mely végighalad a tömb elemein: for( int i = 0; i < karakterlánc.Length; i++ ) Console.WriteLine(karakterlánc[i]); Console.ReadKey(); } }
A System.Collections.Generic névtér további adatszerkezeteket tartalmaz, amelyek bizonyos célokra hasznosabbak, mint a tömbök:
Sorozat (Queue): egyszerű FIFO-adatszerkezet
Verem (Stack): egyszerű LIFO-adatszerkezet
Lista (List): hasonlít a tömbhöz, de nincs előre definiált mérete
Halmaz (HashSet): hasonlít a listához, de az elemeknek nincs sorrendje, és egy elem legfeljebb egyszer szerepelhet benne
Szótár (Dictionary): kulcs-érték párok halmaza
class OOP { public int x; //publikus elérésű egész x private int y; //private, tehát nem lehet elérni másik osztályból public int Y //itt egy tulajdonság, mely tulajdonságot ad az y private változónak, hogy el lehessen érni { get { return y; } set { y = value; } } } class ÚjOsztály // egy másik osztály { public static void Main() { OOP származtat = new OOP(); // származtatunk az OOP osztályból, hogy elérhessük annak az osztálynak a tartalmát származtat.x = 17; // az OOP osztály x változója = 17 származtat.Y = 18; // a set blokkon keresztül értéket adunk az Y-nak és aztán azt az értéket visszaadjuk a get blokk segítségével az y-nak Console.WriteLine("x = {0}, y = {1}", származtat.x, származtat.Y); // x = 17, y = 18 Console.ReadKey(); } }
Osztályok láthatósága a C#-ban (zárttól a nyitott felé):
private: nem lehet elérni másik osztályból. Alapesetben minden osztály, metódus, stb. ilyen.
protected: származtatott osztályból érhető el.
internal: azonos assembly-ből elérhető
protected internal: fenti két csoport uniója
A struktúra egy másik adatszerkezet a nyelven belül, mely nagyban hasonlít az osztályra. A fő különbség az, hogy míg az osztályok példányait referenciaként kezeli a nyelv, a struktúrapéldányokat érték szerint. Ez akkor válik nyilvánvalóvá, amikor pl. egyedet másolunk. Ha objektumról (osztályról) van szó, és a másolatban megváltoztatunk egy adott adattagot (módosítunk/felülírunk egy struktúrapéldányt vagy felülírunk egy osztálypéldányt), akkor az a tulajdonság az eredeti egyedben is megváltozik. Ellenben, ha struktúráról beszélünk, akkor másolatnál egy teljesen új memóriaterületre íródik le az új adattag, ezért ha azt meg is változtatjuk, az az eredetit nem befolyásolja.[7]
struct struktúra_1 { public int kor; private string név; // mivel private, létre kell hoznunk egy értékadó tagfüggvényt. public string Név { get return név; set név = value; } } public class struktúra_használ { public static void Main() { struktúra_1 adatok = new struktúra_1(); // példányosítunk adatok.kor = 14; adatok.Név = "Kovács István"; Console.WriteLine("Az életkorom: {0}, a nevem: {1}", adatok.kor, adatok.Név); Console.ReadKey(); } }
Egy másik különbség, hogy struktúráknak nem adhatunk meg paraméter nélküli konstruktort, automatikusan generálódik hozzá egy. Amennyiben fontos számunkra a struktúra érvényessége, készíthetünk hozzá ellenőrző metódust.[8]
Egy különleges alkalmazási formája a csak olvasható struktúra, amelyek használata javasolt elemi, adattároló struktúrák esetén.[9]
A C# 8.0 legnagyobb újdonsága a Nullable referencia típusok, ami kicsit félrevezető név. A referencia típusok eddig is felvehettek null értéket. Ha azt nem kezeltük le, hogy egy referencia null értéket is felvehet és úgy próbáltunk rajta metódust hívni, vagy tulajdonságot lekérdezni/írni, akkor NullReferenceException típusú kivételt kaptunk.
Ez pedig sajnos a "legnépszerűbb" futásidejű hiba típussá nőtte ki magát az elmúlt jó pár évben. Ez alatt az értendő, hogy a fejlesztők leginkább ilyen kivételekkel találkoznak fejlesztés közben, ha nem jól írják meg a kódjukat.
Ebben hivatott segíteni a Nullable reference types bevezetése. Ez a gyakorlatban azt jelenti, hogy a ? operátort ki kell tennünk referencia típusok esetén, ha azt szeretnénk jelezni, hogy az a változó megengedett, hogy null értéket vegyen fel.
Ebben az esetben, ha elmulasztjuk a null ellenőrzést, akkor már fordítási idejű figyelmeztetést kapunk.
Ha pedig nem jeleztük, hogy a változó null értéket is felvehet, akkor a fordító a változót úgy fogja kezelni, mint ami referencia, de normál körülmények között nem lenne szabad neki null értéket felvennie. Ebben az esetben a null check elmulasztása szintén fordítási idejű figyelmeztetést fog generálni.[10]
↑ How ASP.NET began in Java (angol nyelven). The Register, 2007. október 30. (Hozzáférés: 2012. július 5.)
↑ John Osborn: Deep Inside C#: An Interview with Microsoft Chief Architect Anders Hejlsberg (angol nyelven) (html). windowsdevcenter.com, 2010. január 8. (Hozzáférés: 2012. július 5.)
↑ What's new in C# 9.0 - C# Guide. docs.microsoft.com, 2020. szeptember 4. (Hozzáférés: 2021. március 11.)
↑ Compatibility (angol nyelven). mono-project.com, 2011. december 19. (Hozzáférés: 2012. július 5.)
↑ Brian Pautsch: Item 11: Prefer foreach Loops (angol nyelven). Keylimetie, 2005. július 18. [2012. május 20-i dátummal az eredetiből archiválva]. (Hozzáférés: 2012. július 5.)
↑ Classes and Structs (C# Programming Guide) (angol nyelven) (aspx). MSDN. (Hozzáférés: 2012. július 5.)
↑ Hide parameterless constructor on struct (angol nyelven). stackoverflow.com, 2009. február 11. (Hozzáférés: 2012. július 5.)
↑ Immutabale Atomic Value Type (angol nyelven) (pdf). Effective C#. (Hozzáférés: 2012. július 5.)
↑ Nullable reference types. (Hozzáférés: Hiba: Érvénytelen idő.)
Java és C# különbségek
Dr. Sipos Marianna: Programozás élesben - C#, INFOKIT kiadó, 2004, ISBN 978-963-216-652-0
Illés Zoltán: Programozás C# nyelven. Budapest: Jedlik Oktatási Stúdió. 2005. ISBN 963 86514 1 5 Hozzáférés: 2020. ápr. 17.
Programozni egyszerű! Programozás alapjai kezdőknek C# nyelven Archiválva 2011. szeptember 24-i dátummal a Wayback Machine-ben (magyarul)
C# programozási nyelv - parancsok-operátorok listája, egyszerű összehasonlítás további nyelvekkel.
Informatikai portál • összefoglaló, színes tartalomajánló lap
A lap eredeti címe: „https://hu.wikipedia.org/w/index.php?title=C_Sharp&oldid=24519995”
Kevés forrással rendelkező lapok
Hivatkozás erre a változatra
Hogyan hivatkozz erre a lapra?
A lap utolsó módosítása: 2021. december 30., 00:00
A lap szövege Creative Commons Nevezd meg! – Így add tovább! 3.0 licenc alatt van; egyes esetekben más módon is felhasználható. Részletekért lásd a felhasználási feltételeket.