Hello World!

Mindenki, még a legnagyobb programozók is a Helló World programmal kezdik programozási tanulmányait.

Tehát most a Hello World! forráskódja, és egy rövid magyarázat:

using System; // használjuk a System névteret

namespace Hello_world // ha nem is hozunk létre névteret akkor is                                                     //autómatikusan létrejön egy globális névtér

{

       class HelloWorld  //létrehozunk egy HelloWorld osztályt

       {

               public staic void Main() //a Main() függvény futtatja le a                                                                   //programunkat

                {

                         Console.WriteLine("Hello World!"); // kiírjuk a konzolra                                                                                         //hogy Hello World

                }

         }

}

A // jelek közé sornyi jegyzetet teszünk a /* és a */ közé korlátlanul például: /* ez egy

                            jelek közötti

                                                megjegyzés*/

/// után XML dokumentációt végzünk, melyet, ha lefordítottuk programunkat megtaláljuk.

VÁLTOZÓK, ÉS DEKRALÁCIÓ

Ahhoz, hogy értékeket tudjunk megadni először változót kell dekralálni és utána inicializálni.

deklaráció: int x;

inicializálás: x = 10;

Ezt lehet egyszerre is: int x = 10;

Egy példa a változókra:

using System;

class valtozok
{
    public static void Main()
    {
        int i = 10;                       // egész típusú i változó értéke 10
        Console.WriteLine(i);     // kiírjuk a képernyőre
       
        int i2 , i3;                       // többszörös dekralálás
        i2 = 12;                         //inicializáció
        i3 = 13;
        Console.WriteLine(i2);
        Console.WriteLine(i3);
       
        const double Allando = 3.1415;   //egy állandó deklarációja
                                                            //és inicializálása
        double d = 12.3;                         //tizedestört
        float f = 0.65F;        //AZ F betű azért kell, mert az a szám igazából
                                      // double értékű ezért kell az a jelzés, hogy float

        char c = 'c';   // a char 1 karaktert tud tárolni(és azt ''jelek között //kell megtenni
        string s = "Hello World!"; // a string karaktersorozatot tud tárolni "" //jelek között
        Console.WriteLine("double: {0}, float: {1}, char: {2}, string: {3},  allando: {4}",d,f,c,s,Allando); //kiírjuk a képernyőre az eredményeket. A //{0}helyére a d a {1}helyére az f... fog kerülni.
        Console.ReadKey(); // a program egy billentyű lenyomására vár, //tehát nem fog lefutni a programunk míg meg nem nyomunk egy //gombot.
    }
}

eredmény:

Még van valami. Az adattípusokról egy táblázat, hogy melyik mennyi helyet foglal...

                                               OPERÁTOROK

Matematikai:

Az operátorok műveletek: +, -, *, /, %(maradékképzés)... A nyelvben viszont vannak rövidítések. Ezt mutatom meg:

i = i+1; ez ugyan az mint ez: i++;

i = i+d; ez ugyan az mint ez: i =+ d;

i = i*d;          ->          i =* d;... 

Relációs:

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

példa:

using System;

public class RelaciosJelek
{
    public static void Main()
    {
        int x = 10;
        int y = 23;
        Console.WriteLine(y < x); // kiírja az eredmény false (hamis)
        Console.WriteLine(y == x); // false
        Console.WriteLine(y != x); //true (igaz)
        Console.WriteLine(x <= y); // x kisebb (és egyenlő) mint x true...
        Console.ReadKey();
    }
}                                                           

A relációs jelek:

Logikai / feltételes operátorok:

Logikai típus csak kettő létezik, ez a true és a false (0,1). Amikor logikai értéket dekralálunk akkor jelezni kell, hogy ez egy logikai típus lesz:

bool valami = false;

péda:

using System;

class Logikai
{
    public static void Main()
    {
        bool egyik; // bool típusú egyik
        bool masik = true; // bool típusú masik mely igaz értékű
        egyik = false;
        if(egyik == false && masik == true) //logikai és operátor, ha az //egyik = hamis és masik = igaz akkor kiírja, hogy igaz.
        {
            Console.WriteLine("igaz");
        }
        Console.ReadKey();
    }
}

A logikai és operátor elve: Ha mindeggyik jó tovább enged, ha bármennyiből egyetlen rossz akkormár nem enged át ha mind rossz, akkor sem enged át. jele: &&

A logikai vagy operátor(jele: ||) elve: Ha mindeggyik jó tovább enged, habármennyiből egy jó akkor is tovább enged, csak akkor nem enged át, ha mindeggyik rossz.

példa:

using System;

class LogikaiVagy
{
    public static void Main()
    {
        bool igaz = true; // igaz igaz
        bool hamis = false; // hamis hamis
        if( igaz == false || hamis == false ) // ha igaz hamis vagy hamis //hamis akkor kiírja a szöveget.
                                              //mivel az egyik igaz ezért ki is lesz írva!
        {
            Console.WriteLine("Az egyik jo volt");
        }
        Console.ReadKey();
    }
}

Az if használata:

Az előbbiekben kiderölt, hogy hogy kell használni az if-et, de van egy if else kombináció amelynek lényege az, hogyha az ifben elakad (vagyis hamis a kiértékelés) akkor átadja a vezérlést az if-nek.

példa:

using System;

class IfElse
{
    public static void Main()
    {
        int ot = 5;
       
        if( ot == 4 ) // ha ot az egyenlő 4-gyel (de mivek nem nem) akkor //kiírja...
        {
            Console.WriteLine("Ez bizony 5");
        }
        else // ha ot nem egyenlő néggyel akkor viszont ezt írja ki (ha nem //akkor)
        {
            Console.WriteLine("Ez bizony nem 5"); // ezt fogja kiírni
        }
       
        Console.ReadKey();
    }
}

Vezérlési szervezetek

Ide tartoznak az elágazások(switch) ciklusok... Elágazás például az if és az else mivel vagy az vegy ez fut le. De van ennél sokkal kifinomultabb elágazás. Ez a switch, ezt akkor használjuk, ha egy változó több lehetséges állapotát akarjuk vizsgálni.

példa:

using System;

class Switch
{
    public static void Main()
    {
        Console.WriteLine("Adjonmeg egy szamot:");
        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) // vizygáljuk az x-et
        {
            case 17: // ha 17
                Console.WriteLine("x == 17");
                break; // leállítjuk
            case 10: //ha 10
                Console.WriteLine("x == 10");
                break; //leállítjuk
            default: // ha eggyiksem
                Console.WriteLine("Defaualt");
                break; //leálítjuk
        }
        Console.ReadKey();
    }
}

Ciklusok:

Amikor egy adott utasítás többször kell elvégeznünk akkor ciklust használunk. Pl ki kell írni a konzolra 0-100-ig a azámokat.

KÓD:

using System;

class Ciklus
{
    public static void Main()
    {
        for(int i = 0; i <= 100; i++) //addig fog ismétlődni a ciklus mí az í el //nem éri a 100-at
        {
            Console.WriteLine(i);
        }
        Console.ReadKey();
    }
}

Ez a for ciklus volt. Most nézzük a while ciklust.

KÓD:

using System;

class Ciklus
{
    public static void Main()
    {
        int i = 0;//kezdőérték beállítása
       
        while( i <= 100 )// ciklusfeltétel megadása
        {
            Console.WriteLine(i);
            i++; //ciklusváltozó növelése
        }
        Console.ReadKey();
    }
}
     

=====================================================

Mostantól csak forrásfájlok és rövid magyarázás lesz hozzá.

OBJEKTUM ORIENTÁLT PROGRAMOZÁS(OOP)

using System;

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;  // visszaadja az értéket az y-nak
        }
        set
        {
            y = value;  // y = értéke (az érték az amit mi fogunk példányosításnál megadni)
        }
    }
}

 class NewClass // egy másik osztály
{
    public static void Main()
    {
        OOP szarmaztat = new OOP(); // származtatunk az OOP osztályból, //hogy elérhessük annak az osztálynak a tartalmát
       
        szarmaztat.x = 17;  // az OOP osztály x változója = 17
        szarmaztat.Y = 18;  // a set blokkon keresztül értéket adunk az //Y-nak és aztán azt az értéket vissza adjuk az get blokk segítségével //az y-nak
       
        Console.WriteLine("x = {0}, y = {1}", szarmaztat.x, szarmaztat.Y); // x = 17, y = 18
   
        Console.ReadKey();
    }
   
}

Elérési típusok:

public( bublikus bárhonnan el lehet érni )

static(statikus élettertamú)

public static(bárhonnan el lehet érni és nem lehet pédányosítani hanem: osztálynév.függvény(változó)név))

private(nem lehet elérni másik osztályból, ha mégis értéket akarunk adni neki, akkor szoktuk használni az érték adó tagfüggvényeket. Ha nem adunk meg elérési típust akkor az autómatikusan private)

protected(nem lehet elérni másik osztályból, kivéve azármaztatott osztályból)

FELSOROLÁSTÍPUS(ENUM)

A felsorolás típust akkor szoktuk használni, ha sok elemet akarunk megadni. Ez az enumeration összegyüjtés és magától megszámozza 0 -...-ig, de ha saját számozást akarunk akkor magunk is megszámozhatjuk.

1st péda:

using System;

class EnumClass
{
    enum szinek{piros, kek, zold, sarga};
    
    public static void Main()
    {
        Console.WriteLine(szinek.zold); // kiírja a színt
       
        //ciklus a szineken történő végighaladásra
        for( szinek i = szinek.piros; i <= szinek.sarga; i++)
        { // i = piros, piros kisebb és egyenlő sarga ( piros<kek<zold<sarga )
            Console.WriteLine(i);
        }
        Console.ReadKey();
    }
}

2st péda:

using System;

class Enum2
{
    enum csapatok
    {
        McLaren,
        Ferrari,
        TorroRosso,
        RedbulReanaualt,
        Toyota,
        WilliemsToyota,
        BrawnGP,
        ForceIndia,
        SauberBMW,
        Renaualt
    };
    
    public static void Main()
    {
        for(csapatok i = csapatok.McLaren; i <= csapatok.Renaualt; i++)
        {
            Console.WriteLine(i);
        }
        Console.ReadKey();
    }
}

3st példa:

using System;

class Enum3
{
    enum szinek
    {
        piros = 5, // meghatározzuk a sorszámokat!
        zold = 3,
        sarga = 7,
        lila = 1,
        neonZold = 2
    };    // ha kimarad egy sorszám akkor kiírásnáln ki lessz egészítve azzal a sorszámmal...
    
    public static void Main()
    {
        for(szinek i = szinek.lila; i <= szinek.sarga; i++)
        {
            Console.WriteLine(i);
        }
        Console.ReadKey();
    }
}

TÖMBÖK   

A míg csak egy két változót kell nincs is baj, de mi van, ha több százat? Akkor szoktuk használni a tömböket: int[] valami = new int[20];...

1st példa:

using System;

class Tombok1
{
    public static void Main()
    {
        int[] szamok = new int[5] {1,3,6,3,2}; // létrehozunk egy //tömböt és utána megadjuk az elemeit
        
        int[] szamok2;
        szamok2 = new int[] {3,6,1,6,8,3}; // az elemek számából //magátólkiszámolja, hogy hány elemű...
       
        string[] karakterLanc = new string[3] {"egy","ketto","harom"};
       
        Console.WriteLine("A szamok tomb 4 elemenek erteke: {0}", szamok[4]);
        Console.WriteLine("A szamok2 tomb 3 elemenek erteke: {0}", szamok2[3]);
       
        // ciklus,mely végig halad a tömb elemein
        for( int i = 0; i < karakterLanc.Length; i++ )
        {
            Console.WriteLine(karakterLanc[i]);
        }
        Console.ReadKey();
    }
}

2st példa:

// a karakter lánc is "tömbnek " mondható lehet hivatkozni a betűore
using System;

class tomb2
{
    public static void Main()
    {
        Console.WriteLine("Irjon be egy szot");
        string szo = Convert.ToString(Console.ReadLine());
        
        Console.WriteLine("A beirt szo els betuje: {0}\n\n", szo[0]);
       
        Console.WriteLine("Irja be a nevet.");
        string nev = Convert.ToString(Console.ReadLine());
       
        if( nev == "Attila" || nev[0] == 'A')
        {
            Console.WriteLine("A neved Attila vagy A betuvel kezdodik.");
        }
        else
        {
            Console.WriteLine("A neved nem Attila es nem A betuvel kezdodik hanem : {0}", nev);
        }
        Console.ReadKey();
    }
}

STRUKTÚRA

A struktúra az tulajdonképpen egy ostály, csak inkább adatok megadására szoktuk használni.using System;

1st péda:

struct struktura_1
{
    public int kor;
    private string nev; // mivel private létre kell hoznunk egy értékadó //tagfüggvényt.
    public string Nev
    {
        get
        {
            return nev;
        }
        set
        {
            nev = value;
        }
    }
}

public class struktura_hasznal
{
    public static void Main()
    {
        struktura_1 adatok = new struktura_1(); // példányosítunk
        
        adatok.kor = 14;
        adatok.Nev = "Terbe Daniel";
       
        Console.WriteLine("Az eletkorom: {0}, a nevem: {1}", adatok.kor, adatok.Nev);
        Console.ReadKey();
    }
}

2st példa:

using System;

struct Struktura_pelda2
{
    public int kor;
}

class StrukturaHasznal
{
    public static void Main()
    {
        Struktura_pelda2 sp = new Struktura_pelda2();
        sp.kor = 14;
        Console.WriteLine(sp.kor);
        
        Struktura_pelda2[] spv = new Struktura_pelda2[5];
        for( int i = 0; i < 5; i++)
        {
            int[] tarolo = new int[5];
            tarolo[i] = spv[i].kor + i;
            Console.WriteLine(tarolo[i]); // az eredmeny: 0,1,2,3,4(egymás alatt)
        }
       
        Console.ReadKey();
    }
   
   
}

DO WHILE CIKUS

A do while ciklusnak az a lényege, hogy ha a while igaz akkor vissza adja az irányítást a do-nak, így vissza lehet lépni a kódban.

1st példa:

using System;

class DoWhile

{

      public static void Main()

      {

            string valasztas; // itt dekralálunk, hogy a while ciklus lássa az értéket.

            do

            {

                  Console.WriteLine("adjon meg ketto szamot");

                  int egyik = Convert.ToInt32(Console.ReadLine());

                  int masik = Convert.ToInt32(Console.ReadLine());

                  int eredmeny = egyik + masik;

                  Console.WriteLine("Az osszeguk: {0}", eredmeny);

                  Console.WriteLine("Ha ki akar lepni usse be, hogy kilepes, ha nem akkor azt, hogy vissza");

                  valasztas = Convert.ToString(Console.ReadLine());

            }

            while( valasztas != "kilepes" ); // igaz, akkor is vissza lép, ha nem a //vissza-tütjükbe, a feltétel az, hogy ne kilepes legyen.

      }

}

PÁROS PÁRATLAN

foreach ciklust használunk, mely végigpörgeti a tömbök elemeit, és a feltétel szerint mindet megviszgálja. Ezt használjuk ki mi:

KÓD:

using System;

class Foreach
{
    public static void Main()
    {
        int[] szamok = new int[7]{1,3,2,5,7,4,9};
        int paros = 0;
        int paratlan = 0;
       
        foreach( int i in szamok )
        {
            if(  i % 2 == 0 )
            {
                paros++; // paros = paros+1
            }
            else
            {
                paratlan++;
            }
        }
        Console.WriteLine("Paros: {0}, Paratlan: {1}", paros,paratlan);
        Console.ReadKey();
    }
}

Az eredmény 2 páros és 5 páratlan lesz!

Paraméter átadások  

Ha egy függvénynek paramétert szeretnénk átadni, annak többféle módja is van. -érték szerinti -referencia(hivatkozás) szerinti...

1st példa érték szerinti:

Oldal: Forráskódok
A jövő a C# és az XNA - © 2008 - 2026 - gct.hupont.hu

A Hupont.hu weboldal szerkesztő segítségével készült. Itt Önnek is lehetséges a weboldal készítés.

ÁSZF | Adatvédelmi Nyilatkozat