朋友的反义词是什么

A szócikk címe technikai okok miatt pontatlan. A helyes cím: C#.

C#
Paradigma	objektumorientált
Jellemz? kiterjesztés	.cs
Megjelent	2001
Tervez?	Microsoft
Fejleszt?	Microsoft
Utolsó kiadás	14.0 (stabil verzió, 2025. június 9.)
Típusosság	statikus, dinamikus, er?sen típusos, típus biztos, normatív
Dialektusok	Cω, Spec#, Polyphonic C#
Megvalósítások	.NET Framework, Mono, DotGNU
Hatással volt rá	Java, C++, Object Pascal, Eiffel
Befolyásolt nyelvek	Java 5, F#
Weboldal

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.

T?rténete

El?zmények

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? Objektumorientált Nyelv) fed?név alatt. 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.

Verziók

Verziószám	Megjelenés	F?bb újdonságok
2.0	2005. november	Generikus és parciális típusok, anonim metódusok, iterátorok
3.0	2006. november	Implicit módon megadott lokális változók, lambda-, és lekérdezés-kifejezések, kifejezésfák, objektuminicializálók
3.0	2007. november	Language Integrated Query, lambda-kifejezések, kiegészít? metódusok
4.0	2010. április	Dinamikus k?tés, opcionális paraméterek, generikus ko- és kontravariancia, Párhuzamos programozás támogatás, PLINQ
5.0	2012. augusztus	Aszinkron feladatok, párhuzamos programozás továbbfejlesztése
6.0	2015. július	Null kondicionális operátor, statikus importálás, csak olvasható auto tulajdonságok
7.0	2017. március	Out változók, Tuple típus, Pattern matching, helyi metódusok, throw kifejezések
7.1	2017. augusztus	aszinkron Main metódus
7.2	2017. november	private protected hozzáférési szint, számok tagolásához használható a _ karakter
7.3	2018. május	stackalloc t?mb inicializáció
8.0	2019. szeptember	Nullable referencia típusok
9.0	2020. szeptember	Rekordtípusok, init only setterek, mintaillesztés, kódgenerátor

Szabványosítás

A Microsoft benyújtotta a C# nyelvi specifikációját az ECMA-hoz formális szabványosításra. 2001 decemberében az ECMA kiadta az ECMA-334 C# Language Specification szabványt, 2003-ban pedig ISO szabvány lett (ISO/IEC 23270). T?bb független megvalósítás is folyamatban van, t?bbek k?z?tt:

• 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 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.

áttekintés

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.

?sszehasonlítás a Javával

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.

Kódk?nyvtárak

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.

Példaprogramok

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:

public class ExampleClass

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.

System.Console.WriteLine("Helló világ!");

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.

Változók és deklarációk

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.
    }

}

Operátorok

Matematikai

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;...

Relációs: Relációs jelek segítségével két érték k?z?tt végezhetünk viszonyításokat. pl: < (kisebb) > (nagyobb), <= (kisebb vagy egyenl?) >= (nagyobb vagy egyenl?), != (nem egyenl?), == (egyenl?) ...

példa:

...
        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

A logikai m?veletek is elérhet?ek hasonlóan a kiinduló nyelvekhez:

• && : és
• || : vagy
• ! : negáció
• stb.

példa:

...
        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.

Vezérlési szerkezetek

Elágazások (szelekciók)

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.

Példa:

...
        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 egész típusú, akkor is az lesz, mert á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
        }
...

Ciklusok (iterációk)

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. 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++;
        }
...

Felsorolástípus (enum)

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();
    }
}

T?mb?k

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

OOP-programozás (objektumorientált)

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
• public: bárhonnan elérhet?

Struktúra

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.

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.

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.

Nullable referencia típusok

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.

További információk

• Hivatalos oldal (amerikai angol)
• 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. április 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.
• CSharp tutorial (magyarul)