C Sharp

A Programozás Wiki wikiből
(C Sharp programozási nyelv szócikkből átirányítva)

C# (Programozási nyelv)[szerkesztés]

A C# (ejtsd: szí sharp) egy általános célú programnyelv, a .NET keretrendszer legfontosabb programnyelve.

A szintaxisa leginkább a Javára és a C++-ra emlékeztet, bár sok olyan eleme van, ami egyikre sem jellemző.

Jellemzői a következőek:

  • Modern objektumorientált nyelv.
  • Professzionális, Neumann elvű.
  • Nagy programok, akár rendszer programok írására alkalmas.
  • A program több fordítási egységből (modulból) áll.
  • Minden egyes modulnak vagy fájlnak azonos a szerkezete.
  • Egy sorba több utasítás is írható.
  • Az utasítások lezáró jele a pontos vessző (;) .
  • Minden változót használat előtt deklarálni kell.
  • A változók, függvények azonosítói ékezetes karaktereket is tartalmazhat.
  • Kis és nagy betűk különbözőek.
  • Minden utasítás helyére összetett utasítás, un. blokk írható. Az összetett utasítást kapcsos zárójelek ({}) közzé írt utasítások definiálják.
  • Nincs mutató használat.
  • Boxing, unboxing. Minden típus őse az object, így például egy egész típust csomagolhatunk objektumba (boxing), illetve vissza (unboxing).
  • Függvények definíciói nem ágyazhatóak egymásba, önmagát meghívhatja (rekurzió). Függvénydefiníció esetén nincs blokkstruktúra. Blokkon belül statikus és dinamikus élettartamú változók deklarálhatók.
  • Függvény polimorfizmus megengedett.
  • Érték, referencia (ref) és output (out) függvényparaméterek.
  • Kezdő [paraméter]]-átadás, változó paraméterszámú függvény deklarálása.
  • Delegáltak, események használata.
  • Hierarchikus névterekben használt osztályok. Mivel minden osztály, ezért a program, a Main függvény public static hozzáférésű. Több osztály is tartalmazhat "Main" függvényt, de ilyen esetben meg kell mondani, hogy melyik osztálybeli "Main" függvény legyen az aktuális induló.
  • Privát konstruktor, statikus konstruktor használata.
  • Nincs destruktor, helyette a keretrendszer szemétgyűjtési algoritmusa van. Szükség esetén az osztály Dispose metódusa újradefiniálható.
  • Egyszeres öröklés, interface-ek használata.
  • Operátorok definiálásának lehetősége, property, indexer definiálás.
  • Kivételkezelés megvalósítása.
  • Párhuzamos végrehajtású szálak definiálhatósága.

Tervezési célok[szerkesztés]

Az ECMA standard-ban leírtak alapján ezek a C# tervezési céljai:

  • Legyen egyszerű, modern, általános célú, objektum-orientált programnyelv
  • A nyelv és az implementációi támogassák az olyan szoftvermérnöki alapelveket mint az erős típusosság, tömb határ ellenőrzés, az értékadás nélkül használt változók használatának detektálását és az automatikus szemétgyűjtést. A legfontosabb cél az elkészült szoftverek robosztussága, megbízhatósága és a programozó produktivitása.
  • A nyelv úgy készült, hogy használható legyen elosztott környezetek szoftver komponenseinek fejlesztésére.
  • A forráskód portabilitása szintén igen fontos, ahogy a programozóé is, különösen azoké akik már ismerik a C/C++ nyelvet.
  • A nemzetköziesítés szintén igen fontos szempont.
  • A C# arra készült hogy használható legyen az összetett, általános célú operációs rendszerektől a kis egyedi, beágyazott célrendszerekig.
  • Habár a C# alkalmazásoknak is gazdaságosan kell bánniuk a memóriával és a számítási teljesítménnyel, a nyelvnek nem célja hogy versenyezzen méretben, és teljesítményben a C vagy assembly alkalmazásokkal.

Történet[szerkesztés]

A C# fejlesztését 1999-ben kezdte meg egy Anders Hejlsberg vezette team, ő egyébként az az ember aki anno a Borlandnál a Turbo Pascal-t tervezte, majd aki a Delphi vezető fejlesztője is volt. A nyelv munkaneve COOL volt (C-like Object Oriented Language), amit aztán később a Microsoft eredetvédelmi okok miatt C#-re változtatott.

Szabványosítás[szerkesztés]

A C# 1.2 2002-ben az ECMA-nál, 2003-ban az ISO/IEC-nél, míg a C# 2.0-t 2006-ban mindkét szervezetnél szabványosították.

Adattípusok[szerkesztés]

A C# a .NET által használt egységes típus rendszert (Common Type System, CTS) használja. A CTS-ben az összes adattípus a System.Object osztály leszármazottja, ennek köszönhetően például minden típus örökli a ToString() függvényt.

A nyelvben leggyakrabban használt típusok:

  • bool - egyszerű true (igaz) vagy false (hamis) értéket tartalmazhat. A true és a false konstansok az igaz és hamis értékek megadására, például: bool alma=true; Fontos megjegyezni, hogy a C# a C++ programozási nyelvvel ellentétben szigorúan csak bool típusú kifejezéseket enged megadni a feltételekben, illetve a ciklusok feltétel részében.
  • int - 32 bites előjeles egész
  • short - 16 bites előjeles egész
  • long - 64 bites előjeles egész
  • byte - 8 bites előjel nélküli egész szám
  • UInt16 - 16 bites előjel nélküli egész szám
  • UInt32 - 32 bites előjel nélküli egész szám
  • UInt64 - 64 bites előjel nélküli egész szám
  • enum - felsorolás típust megvalósító osztály
  • float - 32 bites lebegőpontos szám
  • double - 64 bites lebegőpontos szám
  • decimal - 128 bites lebegőpontos szám
  • char - 2 byte-n tárolt Unicode karakter
  • string - szöveg; char típusok szekvenciája
  • DateTime - Dátum / idő
  • object - az objektumok alap osztálya

Ezen kívül még sok-sok osztály van a rendszerben, de ezek azok, amikkel legnagyobb eséllyel találkozik azonnal az ember.

Alapvető nyelvi elemek[szerkesztés]

Az alapvető nyelvi elemek (vezérlésátadás, deklaráció, stb) a C nyelvből öröklődtek. A nyelv alapjában véve függvény alapú, az egyes függvényeket pontosvessző választja el. Az egyes vezérlésátadó utasítások (if, else, stb) illetve ciklusok mindig az utánuk következő egy függvényre vonatkoznak, kivéve ha kapcsos zárójellel egy blokkba szervezzük őket.

Például:

  if (feltetel()) 
     fuggveny1(); 
  fuggveny2();

esetén fuggveny1 csak akkor hajtódik végre, ha a feltetel() függvény igazat ad vissza, míg fuggveny2 mindig.

Ebben az esetben viszont mindkét függvény csak akkor hajtódik végre,ha a feltétel igaz:

 if (feltetel()) 
 { 
    fuggveny1(); 
    fuggveny2(); 
 }

Az operátorok is hasonlóan működnek mint a C++-ban, azaz például léteznek a jól megszokott prefix és postfix operátorok (a++ és ++a), a logikai &, |, ^ operátorok, az x+=12; és társaik.

Helló világ[szerkesztés]

A legjobb példa a nyelv bemutatására egy egyszerű Helló világ. Ez itt 100x egymás után írja ki.

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApplication1
  {
  class Program //Alap Program osztály
    {
    static void Main(string[] args) // Maga a Program itt kezdődik!
      {
      for (int i = 0; i < 100; i++)   // A szöveg 100X kerül kiiratásra
      Console.WriteLine("Helló világ");
      }
      Console.Read(); // Megvárjuk míg a felhasználó Entert nyom!
    }
  }

Generikusok (generics)[szerkesztés]

Ez a lehetőség a nyelvben (és a CLR-ben) a C# 2.0 változatával jelent meg. A generikusok lehetővé teszik a .NET keretrendszerben a típus paramétereket, amivel lehetővé válik az olyan osztályok tervezése amikben egy vagy több típus specifikációja csak a kliens kódban deklarálódik és példányosul meg.

Vegyünk például egy objektumok tárolására szolgáló konténert, mondjuk egy listát. Ebbe bele lehet pakolni elemeket, majd az adott elemet mint a konténer [n]. elemét el lehet érni. Generikusok nélkül ezt általánosra csak úgy lehet megcsinálni hogy object típusú elemeket tároltunk, és felhasználáskor castoltuk a kívánt típusra.

Pl:

ArrayList lst = new ArrayList();

lst.Add(10);

lst.Add(20);

lst.Add(30);

Console.WriteLine((int)lst[1]);

Ennek a dolognak azonban van legalább két hátulütője:

1. Így a konténerünkben bármi lehet, nem feltétlenül az adott elem. Ami rosszabb, ha teszem azt a második sorban mondjuk dátumot teszünk bele, a program vígan lefordul, és csak futáskor jön szembe a hiba.

2. Az ide-oda castolás nincs ingyen, futásidővel fizetünk érte.

A megoldás a generikus konténer használata:

List<int> lst = new List<int>();

lst.Add(10);

lst.Add(20);

lst.Add(30);

Console.WriteLine(lst[1]);

Itt egyrészt már az Add is int paramétert vár, azaz nem tehetünk bele teszem azt stringet véletlenül, másrészt a benne lévő elemek a megadott típusúak, nem kell őket castolni amikor el akarjuk érni őket, azaz a dolog nem csak elegánsabb és biztonságosabb, de jóval gyorsabb is.