Professional Documents
Culture Documents
Sallai András - A C# Nyelv
Sallai András - A C# Nyelv
< CSharp
A C# nyelv
Szerző: Sallai András
Copyright © Sallai András, 2011, 2013, 2014, 2015
Licenc: GNU Free Documentation License 1.3
Web: http://szit.hu
A C# nyelvről
Bevezetés
A C# nyelv egy objektumorientált programozási nyelv. Angolos kiejtése szí-sárp. A nyelvet először MS
valósította meg a .Net keretrendszeren belül.
A .Net keretrendszer teljes értékű szabad szoftveres alternatívája a Mono. A Monot eredetileg a
Ximian nevű cég hozta létre, amelyet felvásárolt a Novell. A Mono tehát most a Novell kezelésében
áll. A Mono rendszer telepíthető a Linux, Mac OS X és Windows operációs rendszerekre.
A C# nyelv szigorúan osztályok halmaza, kis és nagybetű érzékeny, minden utasítást pontosvesszővel
zárunk.
Fogalmak
Kezelt kód
Managed code
A C# forráskód lefordítása után kapjuk. Ez egy közbenső nyelv, amely az alacsony szintű gépikód és a
magas szintű C# kód között van. A közbenső nyelvet hívjuk angolosan: intermediate language (IL,
CIL, MSIL). A Java bájtkódjának feleltethető meg.
CLR
Ebben a környezetben értelmezi a kezelt kódot futási időben a JIT (Just-in-time) fordító, alacsony
szintű gépikódként.
SzitWiki - http://szit.hu/
Last update:
oktatas:programozás:csharp:csharp_nyelv http://szit.hu/doku.php?id=oktatas:programoz%C3%A1s:csharp:csharp_nyelv
2015/10/22 08:26
Garbage collector GC
Gyakorlat
1. Mi az a kezelt kód?
2. Telepíthető-e a Mono rendszer Solaris operációs rendszerre?
3. Ki fejlesztette ki a .Net keretrendszert?
4. Hogyan nevezik angolul a Közös nyelvű futási idejű környezetet?
5. Nyílt forrású-e a Mono rendszer?
6. Mire jó a Garbage collector?
Első program
Program01.cs
using System;
class Program01
{
static void Main()
{
Console.WriteLine("Helló Világ!");
}
}
csc Program01.cs
gmcs Program01.cs
dmcs Program01.cs
A program megírható, fordítható például Visual 2010 C# Express fejlesztői környezetben is. Ha
parancssorból fordítunk, akkor ügyeljünk arra, hogy a csc fordítónak útvonalban kell lenni, vagy
fordításkor meg kell adnunk az egész elérési útvonalát, ami nem kényelmes.
Linux operációs rendszer alatt a gmcs vagy a dmcs fordítót kell használnunk, amely a Mono
keretrendszer része. 2013-ban a LinuxMint rendszereken már telepíthető a mono-dmcs csomag,
amely Mono 4.x verzióját tartalmazza. Minimum ennek a csomagnak a használata ajánlott.
Elemzés
Létrehoztunk egy Program01 nevű osztályt és abban egy Main metódust. A nyelvben az osztály
használata kötelező. A kiinduló osztályunk neve tetszőleges. Egy egyszerű konzolos program esetén a
kiinduló osztályunknak van egy kötelező metódusa ez a „Main”. A program végrehajtása ezzel
kezdődik.
Ha „using System;” sort ha nem használjuk, akkor az utasítást a névtér megadásával kell kezdenünk:
Program01.cs
class Program01
{
static void Main()
{
System.Console.WriteLine("Helló Világ!");
}
}
A példában az utasítást a „System” kulcsszóval kezdjük, amellyel jelezzük, hogy a Console osztály
ebben a névtérben van.
Gyakorlat
SzitWiki - http://szit.hu/
Last update:
oktatas:programozás:csharp:csharp_nyelv http://szit.hu/doku.php?id=oktatas:programoz%C3%A1s:csharp:csharp_nyelv
2015/10/22 08:26
Kivitel
A System névtéren belül, a Console osztály WriteLine() metódusa a paraméterként megadott kifejezés
értékét írja a képernyőre, majd egy sortörést:
Program01.cs
class Program01
{
static void Main()
{
System.Console.WriteLine("abc");
}
}
Program01.cs
class Program01
{
static void Main()
{
System.Console.Write("abc");
}
}
Escape szekvenciák
Literálok
Ha több karaktert akarunk a képernyőre íratni, fentebb láttuk, hogy a karaktereket egyszerűen
idézőjelek között felsorolom, mint azt az alábbi program is szemlélteti.
Program01.cs
class Program01
{
static void Main()
{
System.Console.WriteLine("abc");
}
Az idézőjelek helyett tehetünk egyszerű aposztrófokat, így azonban csak egy darab karaktert írhatunk
közéjük.
Program01.cs
class prog
{
static void Main()
{
System.Console.WriteLine('a');
}
}
kiszam.cs
class Program
{
static void Main()
{
System.Console.WriteLine(3);
}
}
Amikor megadok egy számot, karaktert vagy egy karaktersorozatot ezeket állandóknak hívom. Azért
állandó, mert ilyen formában a forráskódba írva, a program további részében az nem változtatható
meg. Nem is akármilyen állandóknak, „literális” állandóknak hívjuk őket. Hogy egy állandó literális,
annyit jelent, hogy nincs neve, „az ami”.
35
'a'
"abc"
Helyettesítő karakter
Helyettesítő karakterek vagy Escape sorozatok. Néhány karakternek speciális jelentése is lehet az
eredeti szerepe helyett. Ilyen például az „a” karakter. Karaktersorozatban, vagy egy önálló
karakterként kiíratva, szimplán megjelenik a képernyőn. Néha lehet azonban más jelentése is. Ha más
jelentéssel kívánjuk használni azt valamilyen módon jelezni kell. Erre szolgál a visszaperjel. Ha egy
karakterállandóban visszaperjel következik, ezzel jelezzük hogy a következő karakter speciális
értelmezésű. A „\a” például megszólaltatja a beépített hangszórót.
SzitWiki - http://szit.hu/
Last update:
oktatas:programozás:csharp:csharp_nyelv http://szit.hu/doku.php?id=oktatas:programoz%C3%A1s:csharp:csharp_nyelv
2015/10/22 08:26
Program01.cs
using System;
class Program01
{
static void Main()
{
Console.WriteLine("\a");
}
}
Program01.cs
using System;
class prog
{
static void Main()
{
Console.WriteLine("Első sor\nMásodik sor");
}
}
Vegyük észre hogy az idézőjel a karakter sorozatok kezdését és befejezését jelzi. Így annak kiíratása
is problémás lenne escape szekvenciák nélkül:
idezojel.cs
using System;
class prog
{
static void Main()
{
Console.WriteLine("\"idézet\"");
}
}
Gyakorlat
1. Mi a literális állandó.
2. Mondjon példát két escape szekvenciára.
3. Hogyan íratunk escape szekvenciával sortörést?
4. Hogyan mondjuk meg C# nyelven, hogy a következő karakter escape szekvenciaként lesz
értelmezve?
5. Írjon programot, amely a következőt írja a képernyőre, egyetlen utasítással:
Változó
Általában szeretnénk adatokat eltárolni a programírás során. Ezt a memóriában tehetjük meg. A
memória egy helyét elnevezem, majd elhelyezek egy értéket az adott helyen. Egy programban mi
ennek a memóriahelynek csak a nevével találkozunk és változónak hívjuk. Változónak, mert az adott
memóriahely tartalmát lecserélhetem.
A változókban többféle típusú értéket tárolhatunk. Lehetnek egész vagy valós számok, karakterek,
karaktersorozatok.
A C# nyelv típusos nyelv, a változókat használatuk előtt deklarálni kell, ahol megadjuk milyen típusú
értéket kívánunk tárolni az adott változóban.
valtozok.cs
using System;
class Prog
{
static void Main()
{
int a = 3;
int b = 4;
SzitWiki - http://szit.hu/
Last update:
oktatas:programozás:csharp:csharp_nyelv http://szit.hu/doku.php?id=oktatas:programoz%C3%A1s:csharp:csharp_nyelv
2015/10/22 08:26
int c;
c = a + b;
}
}
A C# nyelvben a változók deklarációja a típus megadásával kezdődik. Ezt követi a változó neve.
Típus változónév;
A változó első karaktere csak betű vagy alulvonás jel (_) lehet. A név többi részében szám is
szerepelhet. A C# megengedi az ékezetek használatát is, ezt azonban kerüljük.
A változónak rögtön kezdőértéket is adhatunk. Az érték adás egy darab egyenlőség jellel történik.
A C# típusai
értéktípusok
referencia típusok
mutatók
Egyszerű értéktípusok
bool, char
sbyte, short, int, long
byte, ushort, uint, ulong
float, double, decimal
Típusok
C# kulcsszó .Net típus Tartomány Mérete (byte)
sbyte SByte -128 .. 127 1
byte Byte 0 .. 255 1
short Int16 -32768 .. 32767 2
ushort UInt16 0 .. 65535 2
int Int32 -2147483648 .. 2147483647 4
uint UInt32 0 .. 4294967295 4
long Int64 -263 .. 263-1 8
64
ulong UInt64 0 .. 2 -1 8
float Single ±1.5E-45 .. ±3.4E38 4
Típusok
C# kulcsszó .Net típus Tartomány Mérete (byte)
double Double ±5E-324 .. ±1.7E308 8
decimal Decimal ±1E-28 .. ±7.9E28 (128 Bit) 16
bool Boolean true, false 1
char Char Unicode karakter 2
string String Unicode karaktersorozat
int a = 3;
bool b = a > 5;
Az „a > 5” kifejezése értéke hamis, így a b változóban a „false” érték lesz eltárolva. A bool típusú
változóknak ennél több haszna van. Egy if()-ben megvizsgálhatjuk az értékét:
int a = 3;
bool b = a > 5;
if(b)
Console.WriteLine("Nagyobb 5-nél");
else
Console.WriteLine("Kisebb vagy egyenlő 5-el");
A vizsgálat működött volna a „b == true” formában is, de felesleges kiírni a teljes kifejezést.
Ha állandóként szeretnénk decimálist típussal dolgozni, akkor egy „m” karaktert kell a szám végére
tenni:
Az egész állandók automatikusan decimalként vannak értelmezve, tört számok esetén használhatjuk
az „m” vagy „M” utótagot.
Összetett típusok
enum
struct
Természetesen használhatunk sztringeket és tömböket is, de azok nem típusként vannak deklarálva,
hanem osztályként.
SzitWiki - http://szit.hu/
Last update:
oktatas:programozás:csharp:csharp_nyelv http://szit.hu/doku.php?id=oktatas:programoz%C3%A1s:csharp:csharp_nyelv
2015/10/22 08:26
enum
enum.cs
using System;
class Program
{
enum MunkaNapok {Hetfő, Kedd, Szerda, Csütörtök, Péntek};
static void Main()
{
Console.WriteLine(MunkaNapok.Hetfő);
}
}
struct
A struct szerkezetet különböző típusú értékek tárolására találták ki. A létrehozása metóduson kívül
engedélyezett. A metódusban mint egy típust használhatjuk fel.
struct.cs
using System;
class Program
{
struct Pelda
{
public string Nev;
public int Kor;
}
static void Main()
{
Pelda Joska;
Joska.Nev = "Nagy József";
Joska.Kor = 35;
Console.WriteLine(Joska.Nev);
Console.WriteLine(Joska.Kor);
}
}
struct2.cs
using System;
class Program
{
struct Pelda
{
string Nev;
public int Kor;
public string lekerNev()
{
return Nev;
}
public void beallitNev(string atvettNev)
{
Nev = atvettNev;
}
}
static void Main()
{
Pelda Joska = new Pelda();
Joska.beallitNev("Nagy József");
Joska.Kor = 35;
Console.WriteLine(Joska.lekerNev());
Console.WriteLine(Joska.Kor);
}
}
Állandók
literális
nevesített
A literális állandókról tehát már volt szó, de mi a nevesített állandó? Természetesen az amikor egy
állandónak nevet adunk. Egy állandó nevének meghatározása hasonló, mint a változóé. Az állandó
neve előtt megadjuk annak típusát és a típus előtt egy „const” módosítót írok:
A példában az „a” állandót deklaráljuk. Amikor használom a const módosítót, akkor tulajdonképpen
azt vállalom (mint programozó), hogy az „a” értékét a program további részében sosem változtatom
meg. Erre persze a fordító sem ad lehetőséget.
SzitWiki - http://szit.hu/
Last update:
oktatas:programozás:csharp:csharp_nyelv http://szit.hu/doku.php?id=oktatas:programoz%C3%A1s:csharp:csharp_nyelv
2015/10/22 08:26
const int a;
Azonosítók
Mint láttuk az általunk létrehozott változók és állandók számára valamilyen nevet, azaz azonosítót kell
megadnunk. Van a C# nyelven 77 kulcsszó, amelyet nem használhatunk azonosító létrehozására,
mert azt maga a nyelv használja. Szokás ezeket foglalt szavak néven is emlegetni.
Foglalt szavak
abstract
as
base
bool
break
byte
case
catch
char
checked
class
const
continue
decimal
default
delegate
do
double
else
enum
event
explicit
extern
false
finally
fixed
float
for
foreach
goto
if
implicit
in
int
http://szit.hu/ Printed on 2016/12/22 14:46
2016/12/22 14:46 13/63 A C# nyelv
interface
internal
is
lock
long
namespace
new
null
object
operator
out
override
params
private
protected
public
readonly
ref
return
sbyte
sealed
short
sizeof
stackalloc
static
string
struct
switch
this
throw
true
try
typeof
uint
ulong
unchecked
unsafe
ushort
using
virtual
void
volatile
while
Gyakorlat
1. Írja le, hogyan deklarál egy valós típusú változót, amelynek neve: „homerseklet”.
2. Írja le, hogyan deklarál egy dupla-pontosságú változót, amelynek neve „oszto”.
3. Milyen állandók vannak?
4. A változó deklarálásánál hova tesszük a típust, a változó neve után vagy elé?
SzitWiki - http://szit.hu/
Last update:
oktatas:programozás:csharp:csharp_nyelv http://szit.hu/doku.php?id=oktatas:programoz%C3%A1s:csharp:csharp_nyelv
2015/10/22 08:26
Operátorok
Aritmetikai operátorok
* szorzás
/ osztás
% maradkék képzés
+ összeadás
- kivonás
Általános
Például:
Console.WriteLine(checked(50000 * 50000));
Console.WriteLine(unchecked(50000 * 50000));
Egyoperandusú operátorok
+ pozitív szám
- negatív szám
! negálás, ellentétbe fordítás
~ egyes komplemens képzés
(típus)x kasztolás
true igaz
false hamis
& egy objektum címét adja vissza
sizeof() típus mérete
Írjunk programot például, amely egy „a” nevű logikai változót deklarál, adjuk kezdőértéknek „true”-t,
majd kiíratásnál fordítsuk meg az értékét:
bool a = true;
Console.WriteLine(!a);
A fenti operátorok közül talán a kasztolás a legérdekesebb. Tulajdonképpen típuskonverzióról van szó.
Adott például egy egész szám, amit valóssá szeretnénk alakítani, ez problémamentesen megtehető
így:
int a = 3;
double b = a;
Ha azonban fordítva szeretnénk, a valós számot akarjuk egésszé alakítani hibaüzenetet kapunk. Ezért
kasztolnunk kell:
double a = 3.5;
int b = (int) a;
Az „a” változó tartalmát „b” változóba szeretnénk konvertálni, ezért az „a” változó elé zárójelbe
megjegyzem, milyen típusúvá szeretnénk átkonvertálni. Ezt nevezzük kasztolásnak.
A táblázatból lássuk a sizeof() operátort. Egy típus méretét tudjuk megnézni vele. Eredményül
megkapjuk hány bájton tárolódik az adott típus. Lássuk hány byton tárolja értékeit például az int:
Console.WriteLine(sizeof(int));
Logikai operátorok
^ Logikai XOR
& Logikai AND
| Logikai OR
int a = 3;
int b = 5;
int c = a ^ b;
Console.WriteLine(c); //6
Feltételes operátorok
int a = 3;
SzitWiki - http://szit.hu/
Last update:
oktatas:programozás:csharp:csharp_nyelv http://szit.hu/doku.php?id=oktatas:programoz%C3%A1s:csharp:csharp_nyelv
2015/10/22 08:26
Összerendelő operátorok
= legyen egyenlő
+= a = a + b
-= a = a - b
*= a = a * b
/= a = a / b
%= a = a % b
&= a = a & b
|= a = a | b
^= a = a ^ b
«= a = a « b
»= a = a » b
?? Ha b null, akkor -1 lesz a (a = b ?? -1)
Gyakorlat
Formátumozott kivitel
Egy vagy akár több változónak megadható a kiírás formátuma. A formátum egy karaktersorozat, ami
mindig az első paraméter. Az első paraméterben egy változóra vonatkozó formátum karaktersorozat
mindig ”{„ nyitó kapcsos zárójellel kezdődik és egy ”}„ záró kapcsos zárójellel záródik. Minimálisan
megadandó karakter egy index. Annak a változónak az indexe, amelyet az adott helyen meg akarunk
jeleníteni.
Változók indexe
Az alábbi kiíró utasításban az „a” változó indexe 0, a „b” változó indexe 1, mivel az „a” változó
előrébb van mint a „b”, az indexelés pedig 0-ától kezdődik.
int a = 3, b = 4;
Console.WriteLine("{0} {1}", a, b);
3 4
Megtehetem fordítva is. Az első formátum karakter-sorozatban hivatkozom az 1-s indexű változóra,
majd a másikban a 0-ás indexű változóra:
int a = 3, b = 4;
Console.WriteLine("{1} {0}", a, b);
4 3
Formátumkarakterek
Kiíratás pénznemben
A Ft persze csak magyar környezetben lesz kiírva. Más nyelvi környezet más pénznemet eredményez.
SzitWiki - http://szit.hu/
Last update:
oktatas:programozás:csharp:csharp_nyelv http://szit.hu/doku.php?id=oktatas:programoz%C3%A1s:csharp:csharp_nyelv
2015/10/22 08:26
Lebegőpontos alak:
Vezető nullák
Ha a szám kétjegyű mint a példában, akkor a nem létező számjegyek helyén 0-ás karakter fog
szerepelni:
00085
Hány helyen ábrázoljunk egy számjegyet, az eddigiektől eltérően kettőspont helyett vesszővel tagolva
adjuk meg:
Ha szeretnénk a már ismertetett például vezető nullákat is, akkor azt következő formában tehetjük
meg:
A megjegyzésben a kiíratás formátumát látjuk. Vegyük észre, hogy a -10 alakban a ”-„ azt jelenti a
számot balra igazítjuk.
Alternatív ábrázolás
Szokásos formátumok
Ezredesenkénti csoportosítás:
Console.WriteLine("{0:##-####-#####}", 1234567891); //
"12-3456-7891"
Globalizálás
globalizal.cs
using System;
using System.Globalization;
class Program
{
static void Main()
{
CultureInfo nezet = CultureInfo.GetCultureInfo("eu-ES");
Console.WriteLine(string.Format(nemzet, "{0:c}", 85));
Console.ReadKey();
}
SzitWiki - http://szit.hu/
Last update:
oktatas:programozás:csharp:csharp_nyelv http://szit.hu/doku.php?id=oktatas:programoz%C3%A1s:csharp:csharp_nyelv
2015/10/22 08:26
Használható nemzetnevek:
eu-ES
en-US
en-GB
fr-FR
hu-HU
stb.
Nyelv és nyelvterület
Gyakorlat
Math osztály
Abs()
Math.Abs(x);
PI
A PI nem metódus, helyette egy mező. Mező, mert nem csinál semmit csak egy értéket szolgáltat.
Math.PI
Sin()
eredmeny = Math.Sin(x);
Az x érték szinuszát adja vissza. Az x radiánban értendő. Ha szöget kell szinuszra váltanunk, akkor át
kell azt számoljuk radiánba. Például:
Cos()
eredmeny = Math.Cos(x);
Tan()
eredmeny = Math.Tan(x);
Sqrt()
Gyökvonás:
eredmeny = Math.Sqrt(9);
Pow()
Hatványozás:
eredmeny = Math.Pow(3,2);
Round()
SzitWiki - http://szit.hu/
Last update:
oktatas:programozás:csharp:csharp_nyelv http://szit.hu/doku.php?id=oktatas:programoz%C3%A1s:csharp:csharp_nyelv
2015/10/22 08:26
Console.WriteLine(Math.Round(3.4)); // "3"
Console.WriteLine(Math.Round(3.5)); // "4"
Console.WriteLine(Math.Round(3.6)); // "4"
Console.WriteLine(Math.Round(3.1237)); // "3,124"
Min()
Console.WriteLine(Math.Min(3,8)); // "3"
Max()
Console.WriteLine(Math.Max(3,8)); // "8"
Truncate()
Console.WriteLine(Math.Truncate(3.12345)); //"3"
Ceiling()
Kerekítés felfelé
Console.WriteLine(Math.Ceiling(3.1)); //"4"
Floor()
Lefele kerekít.
Console.WriteLine(Math.Floor(3.9)); //"3"
BigMul()
Kimenet:
Log()
Általánosan:
Log(Double)
Console.WriteLine(Math.Log(3.5)); // "1,25276296849537"
Általánosan:
Log(Double,Double)
A bemenő paraméter két valós szám. Az első számnak a második számon alapuló logaritmusa.
Console.WriteLine(Math.Log(3.5,1.2)); // "1,25276296849537"
Sign()
Console.WriteLine(Math.Sign()); // "0"
Console.WriteLine(Math.Sign(3)); // "1"
Console.WriteLine(Math.Sign(-3)); // "-1"
Gyakorlat
Idő lekérdezése
Idő egyszerűen
using System;
class Program
{
static void Main()
{
Console.WriteLine(DateTime.Now);
}
}
using System;
class Program
{
static void Main()
{
string datum = DateTime.Now.ToString();
Console.WriteLine(datum);
}
}
Idő formázva
Program.cs
using System;
class Program
{
static void Main()
{
Formázás karaktersorozattal
Program.cs
using System;
class Program
{
static void Main()
{
DateTime AktIdo = DateTime.Now;
Console.WriteLine(AktIdo.ToString(format));
}
}
Program.cs
using System;
class Program
{
public static void Main()
{
SzitWiki - http://szit.hu/
Last update:
oktatas:programozás:csharp:csharp_nyelv http://szit.hu/doku.php?id=oktatas:programoz%C3%A1s:csharp:csharp_nyelv
2015/10/22 08:26
Console.WriteLine(DateTime.Now.ToLongTimeString() + "," +
DateTime.Now.ToLongDateString());
}
}
Egész számok
Véletlen szám generálására System névtérben lévő Random osztályt használhatjuk. Példányosítása
kötelező, azaz ebben a formában kell objektumot generálni:
A fenti példában a random nevű objektumot generáltuk, amelynek metódusai képesek egész és valós
véletlen számok előállítására.
Next()
Next(Int32)
Next(Int32, Int32)
Valós szám
Program.cs
using System;
class Program
{
public static void Main()
{
Console.WriteLine(a);
}
}
Byte-ok
A NextBytes() metódus segítségével egy byte tömböt képesek vagyunk egyetlen mozdulattal
feltölteni véletlen számokkal.
Program.cs
using System;
class Program
{
public static void Main()
{
Gyakorlat
Konverzió
Kasztolás
int a = 12345678;
long b = a;
int c = (int) b; //explicit konverzió
Az utolsó esetben szükség van a (int) explicit konverzióra, mert c változó kisebb mint a b. Így ha
túlcsordulás történik a fordító dob egy kivételt.
Convert osztály
A System névtérben találunk egy Convert nevű osztályt, amelynek metódusai a különböző típusokba
való konvertálást megoldják.
SzitWiki - http://szit.hu/
Last update:
oktatas:programozás:csharp:csharp_nyelv http://szit.hu/doku.php?id=oktatas:programoz%C3%A1s:csharp:csharp_nyelv
2015/10/22 08:26
using System;
class Program
{
static void Main()
{
String s = 4;
int a = Convert.ToInt32(s);
}
}
További lehetőségek
Adatbekérés
Stringek beolvasása
Adatbekérés a konzolról:
prog.cs
using System;
class Prog
{
static void Main()
{
string s;
Console.Write("Neved: ");
s = Console.ReadLine();
Console.WriteLine("Ezt írtad: " + s);
}
}
A programban deklaráltunk egy s változót. Viszont fentebb már említettük, hogy a „string” valójában
nem típus, hanem osztály. Az „s” egy olyan objektum, amit nem kell példányosítani a new
kulcsszóval. Később látni fogjuk, hogy az „s” objektumnak vannak metódusai, amiket használhatunk.
Az alábbi utasítás:
s = Console.ReadLine();
egy tehát a beolvasott karaktersorozatot az s változóban fogja eltárolni. Az s változó pedig string
típussal deklaráltuk.
Számértékek beolvasása
Egész számok
using System;
class Program
{
static void Main()
{
int a;
a = Convert.ToInt32(Console.ReadLine());
}
}
using System;
class Program
{
static void Main()
{
int a;
a = int.Parse(Console.ReadLine());
}
}
using System;
class Program
SzitWiki - http://szit.hu/
Last update:
oktatas:programozás:csharp:csharp_nyelv http://szit.hu/doku.php?id=oktatas:programoz%C3%A1s:csharp:csharp_nyelv
2015/10/22 08:26
{
static void Main()
{
int a;
a = Int32.Parse(Console.ReadLine());
}
}
Valós számok
using System;
class Program
{
static void Main()
{
double a, b;
a = Double.Parse(Console.ReadLine());
b = Convert.ToDouble(Console.ReadLine());
}
}
Gyakorlat
Szekvenciális tevékenység
Változók hatásköre
Az eddigi példákban az egyes változókat is a metódusokban hoztuk létre. Néha azonban előfordul,
hogy olyan változókat szeretnénk használni amelyhez több metódus is hozzáfér. A változót ilyenkor a
metóduson kívül, de az osztályon belül hozzuk létre. Az ilyen változókat mindig a metódusok előtt
szoktuk létrehozni az osztály mezőinek nevezzük.
prog.cs
using System;
class Prog
{
static string s;
}
}
Szelekciós tevékenység
a > 3
Vagy:
a > b
if
SzitWiki - http://szit.hu/
Last update:
oktatas:programozás:csharp:csharp_nyelv http://szit.hu/doku.php?id=oktatas:programoz%C3%A1s:csharp:csharp_nyelv
2015/10/22 08:26
if (feltétel)
tevékenység;
Láthatjuk, hogy az if után zárójelben adjuk meg a feltételt. Fontos, hogy a feltétel után ne zárjuk le a
pontosvesszővel az if utasítást. A feltételt követi az utasítás, amelyet végre kell hajtani. Vegyük észre,
hogy a példában csak egyetlen utasítás szerepel. Ha a feltétel teljesül az utasítás végrehajtódik.
A következőkben általános formában azt látjuk, hogyan lehet megadni, ha a feltétel nem teljesül,
akkor mi is történjen.
if {feltétel)
tevékenység;
else
tevékenység2;
Az else után írt utasítás akkor kerül végrehajtásra, ha a feltétel nem igaz.
A következő példák az általános forma helyett már egy konkrét C# megvalósítást mutatnak be.
if (bináris == true)
{
Console.WriteLine("igaz");
}
else if (szám > 10)
{
Console.WriteLine("nagy");
}
Többágú elágazást hozhatunk létre, ha az else után ismét egy if utasítást írunk egy újabb feltétellel.
Szokás „else if” utasításnak is hívni.
if (bináris == true)
{
Console.WriteLine("igaz");
}
else if (szám > 10)
{
Console.WriteLine("nagy");
}
else
{
Console.WriteLine("egyébként");
}
Az else if esetén kiveszem az else részt akkor az if-től egy önálló if blokk következik. A ”{„ blokk nyitó
karakter és ”}„ blokk záró karakterek nem kötelezőek, ha csak egyetlen utasítás szerepel a blokkban.
switch
A switchet többágú szelekcióra találták ki, de ssak egyszerű változókat fogad el a vizsgálathoz.
Legyen például egy „szam” nevű változó, amelynek tartalma alapján különböző szövegeket
szeretnénk a képernyőre íratni:
int szam = 3;
switch(szam)
{
case 1:
Console.WriteLine("Egy");
break;
case 2:
Console.WriteLine("Kettő");
break;
case 3:
goto case 2;
default:
Console.WriteLine("Egyik sem");
break;
}
Ha a „szam” tartalma 1, akkor az „Egy” szöveget írjuk ki, ha 2, akkor „Kettő”, stb. Ha egyik érték sem
volt, akkor az „Egyik sem” szavakat írjuk ki.
Iteráció
Az iteráció más néven ciklus vagy ismétlés. Valamilyen tevékenység ismételt végrehajtása. A
ciklusoknak két fajtájáról szoktunk beszélni. Ezek:
növekményes
amíg ciklus
A növekményes ciklus esetén mindig tudjuk hányszor kell ismételnünk, de legalábbis valamiből ez
előre kiderül. Az „amíg” típusú ciklusok esetén nem tudjuk meddig kell mennünk, mert az vagy a
SzitWiki - http://szit.hu/
Last update:
oktatas:programozás:csharp:csharp_nyelv http://szit.hu/doku.php?id=oktatas:programoz%C3%A1s:csharp:csharp_nyelv
2015/10/22 08:26
felhasználótól, vagy egy adatsorozat hosszától, vagy más külső tényezőtől függ, amit előre nem
ismerünk.
for
A legáltalánosabb ciklus utasítás a for. Alapvetően növekményes ciklusok létrehozására találták ki, de
a C# nyelvben és minden C alapú nyelvben használhatjuk „amíg” típusú ciklus megvalósítására is.
A ciklus fejrésze három részre osztható. A három részt egymástól pontosvesszővel választjuk el.
Növekményes ciklusoknál mindig használunk egy ciklusváltozót, amelyben számoljuk, hogy éppen hol
járunk a ciklusban. Az fejrész első paramétere ennek a ciklusváltozónak a kezdőértéke. A második a
feltétel, azaz meddig menjen a ciklus. A harmadik pedig megmondja számunkra, hogyan növeljük a
ciklusváltozót. Egyesével, kettesével vagy más növekményben. A ciklus során végrehajtandó
utasításokat nevezzük a ciklus törzsének.
Ha egyetlen utasításunk van a ciklus törzsben akkor nem kötelező blokk nyitó és blokk záró kapcsos-
zárójeleket elhelyeznünk. Több utasítás esetén azonban ez kötelező. Ezzel jelezzük, hogy mely
utasítások tartoznak a ciklus törzséhez.
Egy konkrét példa, amelyben a ciklus változó tartalmát kiíratjuk. A ciklus 0-tól – 9-ig írja a számokat a
képernyőre.
while
A while ciklust alapvetően „amíg” típusú ciklusok létrehozására találták ki, de létrehozható vele
növekményes ciklus is.
while(kifejezés)
{
utasítás;
while(true)
{
do while
A do while ciklus megegyezik a while ciklussal azzal a különbséggel, hogy hátultesztelő. Ez azt jelenti,
hogy a ciklus törzse egyszer mindenképpen végrehajtódik, és csak az után vizsgáljuk meg, hogy a
következő ciklus is végrehajtható-e.
int i = 1;
do
{
Console.WriteLine("Egyik sem");
i++;
}while (i < 10);
foreach
A foreach utasítással olyan ciklusokat tudunk létrehozni, amelyek egy lista vagy tömb elemeit
bejárják, azaz végig veszik.
lista.Add(15);
lista.Add(10);
lista.Add(20);
lista.Add(42);
lista.Add(30);
foreach(int i in lista)
{
Console.WriteLine(i);
}
A példában a lista elemei egész számok. Az int változót a foreach fejrészében deklaráljuk „int i”,
ebben kapjuk vissza az aktuális számot. Az i változót kötelező a foreach fejrészében deklarálnunk! A
következő forma helytelen:
SzitWiki - http://szit.hu/
Last update:
oktatas:programozás:csharp:csharp_nyelv http://szit.hu/doku.php?id=oktatas:programoz%C3%A1s:csharp:csharp_nyelv
2015/10/22 08:26
foreach(i in lista)
...
Sztringek
A Sztringekről
A sztring adattípus az egyik nagyon fontos adattípus. Elméletileg több milliárd hosszú lehet a mérete,
de az operációs rendszer is határt szab számára. A „string” vagy „String” típusként deklaráljuk, az
UTF-16 kódolással tárolt karaktereket.
A string egyik tulajdonsága a Length, amely a szöveg hosszát tartalmazza. Készítsünk egy programot,
amelyben a egy s nevű változót deklarálunk, majd kiíratjuk annak hosszát:
string s = "Alma";
Console.WriteLine(s.Length);
String s = "Alma";
Console.WriteLine(s.Length);
Metódusok
Concat
Az első dolog, amit általában szeretnénk egy sztringgel, összefűzni másik sztringgel. Sztringek
összefűzésének művelete a konkatenálás.
Tulajdonképpen ezt csináljuk akkor is, amikor egy sztring változóhoz sztring literális konstanst fűzök:
string s1 = "egyik";
string s2 = "másik";
Console.WriteLine(s1 + s2);
Az összefűzésre a ”+„ operátort használjuk. Az összefűzésre persze van külön metódus is, amelynek a
neve Concat().
string s = "alma";
string s2 = "valami";
Console.WriteLine(String.Concat(s, s2));
Összefűzés
Compare
A Compare() metódus, egy 0-át ad vissza, ha egyezik a két összehasonlított sztring, -1-et ha nem
egyezik.
string s1 = "Alma";
string s2 = "Alba";
Console.WriteLine(String.Compare(s1, s2));
Console.WriteLine(String.Compare(s, "Abba"));
Console.WriteLine(String.Compare(s, null));
CompareTo
string s1 = "Alma";
string s2 = "Alba";
Console.WriteLine(s1.CompareTo(s2));
SzitWiki - http://szit.hu/
Last update:
oktatas:programozás:csharp:csharp_nyelv http://szit.hu/doku.php?id=oktatas:programoz%C3%A1s:csharp:csharp_nyelv
2015/10/22 08:26
CompareOrdinal
string s1 = "alma";
string s2 = "Alma";
Console.WriteLine(String.CompareOrdinal(s, s2));
Equal
s = "alma";
s2 = "valami";
Console.WriteLine(s.Equals("alma"));
Console.WriteLine(String.Equals(s, s2));
Egyenlőség vizsgálata
Join
System.String.Format(”{0} szorzat {1} = {2}„, a, b, (a * b));
+
=
!=
==
Contains
string s = "megbízható";
bool tartalmaz = s.Contains("bíza");
IndexOf
string s = "megbízmhatóm";
int hol = s.IndexOf('m');
Remove
string s = "megbízható";
string s2 = s.Remove(4);
string s = "megbízható";
string s2 = s.Remove(4, 2);
Insert
A példában a mondat nevű változóhoz fűzzük a „Kossuth” szót, majd eltároljuk a mondat2-ben.
ToLower és ToUpper
string s = "MEGbízható";
string s2 = s.ToLower();
string s3 = s.ToUpper();
Program1.cs
using System;
using System.Text;
class Program
{
static void Main()
SzitWiki - http://szit.hu/
Last update:
oktatas:programozás:csharp:csharp_nyelv http://szit.hu/doku.php?id=oktatas:programoz%C3%A1s:csharp:csharp_nyelv
2015/10/22 08:26
{
string s;
s = "Valami";
Console.WriteLine(s);
Console.WriteLine(s.Substring(2,2));
Console.WriteLine(s.Replace("al","ág"));
}
}
Program2.cs
using System;
class str
{
public static void Main()
{
Console.WriteLine("Szövegkezelés Java nyelven");
//Szöveg darabolása
string sor ="alma:körte:barack:szilva";
string[] tomb = sor.Split(':');
Console.WriteLine(tomb[1]);
}
}
if(mondat.ToLower().IndexOf("alma")>= )
Console.WriteLine("Tartalmazza az alma szót");
Kisbetűssé alakítás:
Módosítható szöveg
A szimpla String típusként létrehozott karaktersorozatok valójában nem módosíthatók, mint azt
fentebb már tárgyaltuk. A StringBuilder osztállyal módosítható szöveget hozhatunk létre.
using System.Text;
A példában láttuk, hogy az „s” StringBuilder változóhoz egy Append() metódussal tudunk egy szimpla
karaktersorozat literált, de akár egy változót is hozzáfűzni. Vegyük észre, hogy megoldottuk a String
típus StringBuilder típussá konvertálását. Visszafele a ToString() metódussal történik a konverzió:
Beszúrás
s.Append("Szilvi");
s.Insert(4,"a");
Rendezés
Program01.cs
using System;
class Program
{
static void Main()
{
String[] t = {"Szilva", "Körte", "Barack", "Alma"};
Array.Sort(t);
foreach(String s in t)
Console.WriteLine(s);
}
}
Példa
Program.cs
using System;
class tomb
{
public static void Main()
{
Console.WriteLine("Szó");
string szo = Convert.ToString(Console.ReadLine());
Tömbök
Vektor:
375286
Számokat tárolunk.
int[]
double[]
float[]
string[]
char[]
short[]
long[]
ulong[]
sbyte[]
byte[]
uint[]
bool[]
meret = tomb.Length;
Alternatív megadás
Tömb kezdőértéke
vagy
vagy
Tömb átméretezése
Program.cs
using System;
class Program
{
static void Main()
{
char[] tomb = new char[4];
tomb[] = 'P';
tomb[1] = 'e';
tomb[2] = 'r';
tomb[3] = 'l';
Console.WriteLine(tomb[2]);
Array.Resize(ref tomb, 2);
}
}
Mátrix
Egy értékadás:
tomb[2,2] = 3;
Program.cs
class Program
{
static void Main()
{
int[,] tomb = new int[,]{
{3,4,5},
{6,3,2},
{8,2,7}
};
}
}
Mátrix átméretezése
Program.cs
using System;
class Program
{
static private void ResizeIntArray(ref int[,] original, int cols,
int rows)
{
int[,] newArray = new int[rows, cols];
Array.Copy(original, newArray, original.Length);
original = newArray;
}
ResizeIntArray(ref szamok,5,10);
}
SzitWiki - http://szit.hu/
Last update:
oktatas:programozás:csharp:csharp_nyelv http://szit.hu/doku.php?id=oktatas:programoz%C3%A1s:csharp:csharp_nyelv
2015/10/22 08:26
original = newArray;
Program.cs
using System;
class Program
{
public static void Main()
{
//~ tomb[0, 0, 0] = 3;
Console.WriteLine(tomb[1,,]);
Console.WriteLine(tomb4[1,,,]);
}
}
Tömb paraméterként
Program.cs
using System;
class Program
{
public static void Main()
{
int[] tomb = {35, 45, 63, 77};
kiir(tomb);
}
static void kiir(int[] t)
{
for(int i=; i<t.Length; i++)
Console.WriteLine(t[i]);
}
}
Tömben tömb
Program.cs
using System;
class Program
{
public static void Main()
{
//Tömben tömb vagy egyenletlen tömb (minden sor más elemszámot
tartalmazhat
SzitWiki - http://szit.hu/
Last update:
oktatas:programozás:csharp:csharp_nyelv http://szit.hu/doku.php?id=oktatas:programoz%C3%A1s:csharp:csharp_nyelv
2015/10/22 08:26
tomb[][] = 3;
tomb[][1] = 5;
tomb[][2] = 8;
tomb[1][] = 15;
tomb[1][1] = 123;
tomb[1][2] = 2;
Console.WriteLine(tomb[][1]);
}
}
Program.cs
using System;
class Program
{
public static void Main()
{
//Tömben tömb vagy egyenletlen tömb (minden sor más elemszámot
tartalmazhat
Console.WriteLine(tomb[][1]);
}
}
Lista
Program01.cs
using System;
using System.Collections.Generic;
class Program01
{
static void Main()
{
lista.Add(35);
lista.Add(45);
lista.Add(29);
Console.WriteLine(lista[]);
Console.WriteLine(lista.Count);
lista.Clear();
Console.WriteLine(lista.Count);
}
}
Struktúrák
A struktúrák a C nyelvből származnak, de ilyen szerkezet található a Pascal nyelvben, csak ott
rekordnak hívják. A struktúrák használatának célja, hogy különböző típusú adatokat tudjunk tárolni.
Csak gondoljunk bele, mit tárolhatunk egy tömbbe?! Több azonos típusú adatot. A struktúrában
ugyanígy több adat tárolható, de ezek típusa eltérhet egymástól.
A C# struktúrái egy kicsit többek a C nyelvben kitalált eredeti verziótól. A struktúrák ugyanis
hasonlóan működnek az osztályokhoz. Vagyis nem csak változókat deklarálhatunk bennünk, hanem
metódusokat is, amelyek valamilyen műveletet végeznek a változókon.
A C# struktúra típusként viselkedik, vagyis egy változót kell vele deklarálnunk a használatához. Az
egyes tagokat úgy érjük el, hogy ponttal tagolva leírom a változónév után a struktúrában található
változó nevét.
Az alábbiakban egy egyszerű példát látunk a használatukra. A struktúrában követelmény, hogy nem
hozható létre metóduson belül.
Első példa
Program.cs
class Program
{
struct Egyszeru
{
public int Pozicio;
public bool Kesz;
public double UtolsoErtek;
};
SzitWiki - http://szit.hu/
Last update:
oktatas:programozás:csharp:csharp_nyelv http://szit.hu/doku.php?id=oktatas:programoz%C3%A1s:csharp:csharp_nyelv
2015/10/22 08:26
A példában egy „Egyszeru” nevű struktúrát hozunk létre, amelynek változóit a Main() metódusban
értékekkel töltjük fel. Vegyük észre, hogy a struktúrát a az osztályon belül hoztuk létre.
A következőkben egy olyan példát látunk, ahol a struktúrát az osztályon kívül hozzuk létre.
Második példa
Program.cs
using System;
struct TEgyszeru
{
public String nev;
public int kor;
public long fizetes;
}
class Program
{
static void Main()
{
Console.WriteLine("Hi");
TEgyszeru dolgozo;
Console.ReadKey();
}
}
Metódusok
Több metódus
Eddig egyetlen metódust használtunk, melynek neve a „Main”. Ebbe írtuk utasításainkat. Ha sok
egymással összefüggő utasításunk van, akkor azokat metódusokba rendezzük, adunk neki egy nevet.
Az utasítást csoportot ezek után a metódus nevének plusz zárójeles rész leírásával hívjuk.
Program.cs
using System;
class Program
{
static void Main()
{
Console.WriteLine("Nagy József");
Console.WriteLine("1142 Budapest");
Console.WriteLine("Nyár u. 3.");
Console.WriteLine("Tel.: +36(1)2345-123");
Console.WriteLine("Fax.: +36(1)2345-124");
}
}
Nevjegy();
Program.cs
using System;
class Program
{
static void Nevjegy()
SzitWiki - http://szit.hu/
Last update:
oktatas:programozás:csharp:csharp_nyelv http://szit.hu/doku.php?id=oktatas:programoz%C3%A1s:csharp:csharp_nyelv
2015/10/22 08:26
{
Console.WriteLine("Nagy József");
Console.WriteLine("1142 Budapest");
Console.WriteLine("Nyár u. 3.");
Console.WriteLine("Tel.: +36(1)2345-123");
Console.WriteLine("Fax.: +36(1)2345-124");
}
A következőkben egy olyan metódust alkotunk amely összead két számot, majd kiírja a képernyőre:
Program.cs
using System;
class Program
{
static void Osszead()
{
int eredmeny = 3 + 5;
Console.WriteLine(eredmeny);
}
Tegyük fel, hogy én most nem 5-öt, hanem valamilyen más számot szeretnék hozzáadni. Egy
objektumon vagy osztályon végrehajtható eljárás. Két fajta metódus van, a statikus és a példány.
Statikus metódus
Program.cs
class Program
{
static void Kiir()
{
System.Console.WriteLine("A metódus meghívása");
}
Program.Kiir();
A példában viszont azt látjuk, hogy meghívható az osztály neve nélkül is, mivel osztályon belül
vagyunk.
Kiir();
Példánymetódus
Program.cs
class Program
{
void Kiir()
{
System.Console.WriteLine("A metódus meghívása");
}
Az Program osztálynak létrehozzuk egy külön példányát. A példában ez a „p”. A p egy olyan
objektum, amely a Program osztályból lett származtatva.
SzitWiki - http://szit.hu/
Last update:
oktatas:programozás:csharp:csharp_nyelv http://szit.hu/doku.php?id=oktatas:programoz%C3%A1s:csharp:csharp_nyelv
2015/10/22 08:26
Fájlkezelés
1. Folyam megnyitása
2. Kapcsolódás a folyamhoz
3. Olvasás/Írás a folyamba
Olvasás a fájlból
A fájlkezelő osztályok a System.IO névtérben vannak, ezért szükségünk van egy új „using” kezdetű
sorra:
using System;
using System.IO;
...
Írás a fájlba
Program.cs
using System;
using System.IO;
class Program
{
public static void Main()
{
Console.WriteLine("Hi");
iro.WriteLine("Alma");
iro.WriteLine("Körte");
iro.Close();
}
}
Egyéb módok
CreateNew
Új fájl létrehozása. A fájlrendszerben írásjog szükséges. Ha fájl léterzik IOExcepton kivétel
keletkezik
Create
Új fájl keletkezik, ha létezik felülíródik. Írási jog szükséges a fájlrendszeren
FileIOPermissionAccess.Write.
Open
Létező fájl megnyitása. System.IO.FileNotFoundException kivétel keletkezik, ha nem
létezik a fájl.
OpenOrCreate
Ha létezik megnyitja, egyébként létrehozza.
Truncate
Létező fájl megnyitása. Megnyitás után 0 byte nagyságú lesz.
Append
Megnyit egy fájlt, ha létezik a fájl végéhez fűz, ha nem létrehozza a fájlt.
Hozzáfűzés a fájlhoz
Program.cs
using System;
using System.IO;
class Program
{
static void Main()
{
Console.WriteLine("Írás");
SzitWiki - http://szit.hu/
Last update:
oktatas:programozás:csharp:csharp_nyelv http://szit.hu/doku.php?id=oktatas:programoz%C3%A1s:csharp:csharp_nyelv
2015/10/22 08:26
iro.Write("valami");
iro.Write(45);
iro.Flush();
iro.Write(60);
iro.WriteLine();
iro.Close();
}
}
Fájlkezelés egyszerűbben
Ha nem szeretnénk fájlmódot megadni, akkor használhatjuk csak a StreamReader osztályt egy
állomány olvasásához.
Program.cs
using System;
using System.IO;
class Program
{
static void Main()
{
Console.WriteLine("Olvasás fájlból");
StreamReader olvaso = File.OpenText("adat.txt");
string sor = null;
while ((sor = olvaso.ReadLine()) != null)
Console.WriteLine(sor);
olvaso.Close();
}
}
Program.cs
using System;
using System.IO;
http://szit.hu/ Printed on 2016/12/22 14:46
2016/12/22 14:46 57/63 A C# nyelv
class Program
{
static void Main()
{
Console.WriteLine("Olvasás fájlból");
StreamReader olvaso = File.OpenText("adat.txt");
olvaso.Close();
}
}
Program.cs
using System;
using System.IO;
class Program
{
static void Main()
{
Console.WriteLine("Írás fájlba");
}
}
Program.cs
using System;
using System.IO;
class Program
{
static void Main()
{
Console.WriteLine("Írás fájlba");
SzitWiki - http://szit.hu/
Last update:
oktatas:programozás:csharp:csharp_nyelv http://szit.hu/doku.php?id=oktatas:programoz%C3%A1s:csharp:csharp_nyelv
2015/10/22 08:26
iro.WriteLine("körte");
iro.WriteLine("szilva");
iro.Close();
}
}
Hibakezelés
try
{
using(StreamReader olvaso = new StreamReader("adat.txt");)
{
while((sor = olvaso.ReadLine()) != null)
Console.WriteLine(sor);
olvaso.Close();
}
} catch (Exception e)
{
Console.WriteLine("A fájl nem létezik: ");
Console.WriteLine(e.Message);
}
using System;
using System.IO;
using System.Text;
class Program
{
static void Main()
{
Console.WriteLine("Olvasás fájlból");
StreamReader olvaso = new StreamReader("adat.txt", Encoding.UTF8);
string sor = null;
while ((sor = olvaso.ReadLine()) != null)
Console.WriteLine(sor);
olvaso.Close();
}
}
Megadható kódolások:
Encoding.UTF8
Encoding.ASCII
Encoding.Unicode
Encoding.Default
Szerkezet
A C# programban metódusokat írunk. Kezdőként természetesen csak egy metódusunk van, ahogy
fentebb láttuk ez a Main() metódus. Később azonban, ha már nagyon sok utasításunk lesz, vagy csak
mert logikailag ésszerű külön tenni bizonyos utasításokat, újabb metódusokat hozunk létre, ezeket is
a főosztályon belül.
Ha már nagyon sok metódusunk van, akkor a logikailag összetartozó metódusokat tehetjük külön
osztályba is. A forráskódunk, amely tulajdonképpen egy állomány ekkor különálló több osztályból fog
állni.
Ha már nagyon sok osztályunk egy állományban, azokat névterekbe rendezhetjük. Ha már nagyon
sok névterünk azokat pedig újabb állományokba írhatjuk.
A C# program tehát egy vagy több állományból áll. Minden állományban lehet egy vagy több névtér.
A névtereken belül egy vagy több osztályt hozhatunk létre.
SzitWiki - http://szit.hu/
Last update:
oktatas:programozás:csharp:csharp_nyelv http://szit.hu/doku.php?id=oktatas:programoz%C3%A1s:csharp:csharp_nyelv
2015/10/22 08:26
Az eddigi példákban nem használtunk névtereket. Ebből is következik, hogy az nem kötelező. A
névtér használata azért lehet, hasznos mert így egy osztálynevét többször is használhatunk, a sok-
sok osztály pedig csoportosíthatjuk.
A „Helló Világ” nevű program saját névtérbe helyezve így nézhetne ki:
hello3.cs
using System;
namespace Elso
{
class Program
{
static void Main()
{
Console.WriteLine("Helló Világ!");
}
}
}
A példában a saját Main() metódusunkat egy „Elso” nevű névtérbe helyeztük. A névterek
használatával, tulajdonképpen összefoghatjuk, illetve csoportosíthatjuk az osztályokat.
Ha már nagyon sok osztályunk van, szeretnénk egy részét külön állományokban tartani. Az
alábbiakban készítek egy állományt amelynek sajat.cs lesz a neve. Elhelyezek benne egy Elelem nevű
névteret, a névtérben lesz egy Gyumolcs nevű osztályunk, az pedig tartalmaz egy kiir() metódust,
amely gyümölcsök neveit írja a képernyőre:
sajat.cs
using System;
namespace Elelem
{
class Gyumolcs
{
public static void kiir()
{
Console.WriteLine("alma\nkörte\nbarack");
}
}
}
Ezek után létrehozunk egy állományt, amely használni fogja az Elelem névteret, benne a Gyumolcs
osztály kiir() metódusát:
main.cs
using Elelem;
class Belepesipont
{
static void Main()
{
Gyumolcs.kiir();
}
}
DLL-ek használata
Az alábbiakban egy DLL-t készítünk amely tartalmaz egy számláló és egy érték visszaadó metódust.
Forrás
Szamlalo.cs
SzitWiki - http://szit.hu/
Last update:
oktatas:programozás:csharp:csharp_nyelv http://szit.hu/doku.php?id=oktatas:programoz%C3%A1s:csharp:csharp_nyelv
2015/10/22 08:26
{
val = val + x;
}
Prog.cs
using System;
class Prog {
Fordítás
MS keretrendszerrel
Mono rendszerrel
From:
http://szit.hu/ - SzitWiki
Permanent link:
http://szit.hu/doku.php?id=oktatas:programoz%C3%A1s:csharp:csharp_nyelv
SzitWiki - http://szit.hu/