szit

Ez az oldal csak olvasható. Megtekintheted a forrását, de nem változtathatod meg. Ha úgy gondolod, hogy ez helytelen, kérdezd az Adminisztrátorokat!
[[:oktatas:programozás:csharp|< CSharp]]

====== CSharp ======

Az alábbi leírás Visual 2010 C# Express szoftveren alapszik.

Az itt található anyag jelenleg 2010 tavaszi tanfolyam első napját fedi le. Az anyag csak a tanfolyam ezen napján elhangzottakat
tükrözi! 

.Net framework kell a programok futtatásához

  * Az XP alapból egyiket sem tartalmazza
  * 3.0-át tartalmazza a Windows Vista
  * 3.5-át tartalmazza a Windows 7

===== Bevezetés =====

A C# kisbetű nagybetű érzékeny

Mentések helye:
  Dokumentumok\Visual Studio\Projects

===== Helló Világ =====

Visual 2010 C# Express alapból:

  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  
  namespace hellovilag
  {
      class Program
      {
          static void Main(string[] args)
          {
              Console.WriteLine("Valaiékezetőő");
              Console.ReadLine();
          }
      }
  }

Futtatás F5 vagy eszköztáron.

===== Változók =====
Unicod rendszerű a nyelv ezért ékezetek is lehetnek a változónevekben. 
  * Egyszerű változók
  * Objektum típusú változók
  * Osztály típusú változó


==== Egyszerű típusú változók ====
Például egész változók
      * int szám = 0; 

==== Osztály típusú változó ====
  * Például: Dátum tárolása
Először létre kell hozni:
  DateTime dátum = new DateTime(2010, 6, 28);
  
  Console.WriteLine(dátum.ToLongDateString());

A metódus minden ország saját formátumához igazodik.



===== Típusok =====

==== Egész ====
  int szám = 0;
  szám = 5 + 6;
  szám = szám + 5;
  

==== Szöveg ====
  string szöveg = "";
  
  szöveg "egy" + "kettő";
  Console.WriteLine(szöveg);
  
==== Bináris típus ====
  bool bináris = true;
  bináris = !bináris; //megfordítottuk
  Console.WriteLine(bináris);


==== Törtszámok ====
  * float
  * double

Példa:
  double lebegő = 1.0;
  lebegő = lebegő / 3;
  Console.WriteLine(lebegő);


===== Konstansok =====
Azt vállaljuk, hogy nem változtatjuk az értékét.
  const double lebegő = 1.0;


===== Enum =====

Felsorolt típusok

  enum Fajta {
    Dobermann = 1,
    Rotweiler = 2
  };

Konkrét példa
  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  
  namespace hellovilag
  {
      class Program
      {
  
          enum Fajta
          {
              Dobermann,
              Rotweiler
          }; 
          static void Main(string[] args)
          {
           
              Fajta kutya = Fajta.Dobermann;
           
              Console.WriteLine("Valami ékezetőő");
  
  
              Console.ReadLine();
          }
      }
  }
Az egyenlőség jel után szóköz, megjelenik a Fajta típus. 

===== Operátrok =====
==== Értékadó operátorok ====

  szám = szám + 5
rövidebben:
  szám += 5;
 
  szám = szám / 5;
helyett:
  szám /= 5; 
 

==== Logikai operátorok ====


^ Operátor ^ Jelntés ^
| == | egyenlőség vizsgálat |
| <nowiki>|</nowiki> | vagy  (mohó)|
| & | és (mohó)|
| <nowiki>||</nowiki> | vagy (lusta)|
| && | és (lusta)|

  // Szorgos (Mohó)
  bináris = true | false ; 
  bináris = ture & false;
  
  // Lusta
  bináris = true || false;
  bináris = true && false;


==== Egy operandusú operátorok ====

^ Operátor ^ Jelntés ^
| ++ | 1-gyel növeli a változó értékét |


==== Három operandusú operátor ====
  Console.WriteLine(bináris ? "igaz" : "hamis");


===== Kommentek =====
  // Megjegyzés


===== Escape karakterek =====
A escape karaktereket visszaperjellel vezetjük be.
  * sortörés \n


===== Hibakövetés =====

  * Piros aláhúzás: szintaktikai hiba
  * Zöld aláhúzás: szemantikai hiba
    * Pl. sosem használunk egy változót
  * Kék aláhúzás: Futtatáskor észlelet hibák

===== Tömbök =====


  int[] tömb = new int[100];
  tömb[3] = 15;

A tömbök indexelése 0-val kezdődik.
Egy int[100] esetén a legnagyobb index 99

===== Listák =====
Egy láncolt lista létrehozása
  List<int> lista = new List<int>();

Hozzáfűzés a listához:
  lista.Add(15);
Törlés a listából:
  lista.Remove(15);
Ha többször is szerepel benne, csak az elsőt törli.

Címzés mint a tömböknél:
  szám = lista[0];

Törlés index szerint:
  lista.RemoveAt(1);

===== Szelekció =====

==== if ====
 
  if (feltétel)
    tevékenység;
  
  if (feltétel)
    tevékenység;
  else
    tevékenység2;
    
Ha feltétel igaz, akkor teszünk valamit. Ha hamis akkor mást.

  if (bináris == true)
  {
    Console.WriteLine("igaz");
  }

Két elágazásra példa
  if (bináris == true)
  {
    Console.WriteLine("igaz");
  }
  else if (szám > 10)
  {
    Console.WriteLine("nagy");
  }


Három elágazásra példa:
  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

==== switch ====


Csak egyszerű változókat fogad el.

  int szám = 3;
  
  switch(szám)
  {
    case 1:
      Console.WriteLine("Egy");
      break;
    case 2: 
      Console.WriteLine("Kettő");
      break;
    case 3:
      goto case 2;
    default:
      Console.WriteLine("Egyik sem");
      break;
  }


===== Iteráció =====

==== for ====

A for ciklussal növekményes ciklust tudunk létrehozni. 

  for (kezdő_érték; feltétel; növekmény)
  
  

  for ( int i = 0; i < 10; i++)
  {
      //utasítások
  }
  




==== while ====

Amíg a kifejezés igaz addig fut
  while(kifejezés)
  {
  
  }
  
Egy végtelen ciklus:
  while(true)
  {
  
  }

==== do while ====

  int i = 1;
  do
  {
     Console.WriteLine("Egyik sem");
     i++;
  }while (i < 10);
  
  

==== foreach ====
Egy lista vagy tömb elemeit vesszük  

Lista létrehozása és végigjárása

  List<int> lista = new List<int>();
  
  lista.Add(15);
  lista.Add(10);
  lista.Add(20);
  lista.Add(42);
  lista.Add(30);
  
  foreach(int i in lista)
  {
    Console.WriteLine(i);
  }
  

Szöveges tömb létrehozása és bejárása
  string[] tömb = new string[3];
  tömb[0] = "Máté";
  tömb[1] = "Márk";
  tömb[2] = "Lukács";
  
  foreach(string str in tömb)
  {
    Console.WriteLine(str);
  }
  

===== Build =====


Csak fordítás


===== Függvények =====


Eddig csak Main nevű függvényt használtunk.

Módosító_szavak Visszatérési_érték Név Paraméterek

==== Operátor túlterhelés ====

  Ugyanazon a néven több függvény is lehet, ha különbözik a paraméterük.

^ Típus ^ Jelentés ^
| void | Nincs vissaztérési érték |



==== Paraméter típusok ====
  * érték szerinti
  * Referencia
  * Out paraméter

==== Módosítók típusai ====


  * public 
    * külsőleg hívható
  * protected 
    * védett csak a saját osztályok és azok leszármozattai hívhatják
  * private
    * leszármazottak sem hívhatják

==== Static módosító ====

=== Statikus ===

Nem kell létrehozni példányt 

=== Nem statikus ===

Létre kell hozni egy példányt a használatához

==== Összeadó függvény példa ====

  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  
  namespace hellovilag
  {
      class Program
      {
          static void Main(string[] args)
          {
              Console.WriteLine(Összead(3,2));
              Console.ReadLine();
          }
          static public int Összead(int a, int b)
          {
              int érték = a + b;
              return érték;
          }
      }
  }

==== Több értéket szeretnénk visszakapni ====

  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  
  namespace hellovilag
  {
      class Program
      {
          static void Main(string[] args)
          {
              Console.WriteLine(Összead(3,2));
              
              int eredmény;
              Szoroz(1, 2, out eredmény);
              Console.WriteLine(eredmény);
              Console.ReadLine();
          }
          static public int Összead(int a, int b)
          {
              int érték = a + b;
              return érték;
          }
          public static void Szoroz(int a, int b, out int c)
          {
              c = a * b;
          }
      }
  }



===== Osztályok =====

Az osztály egy egész, az objektum egy konkrét példány

==== Öröklés, származtatás ====


labda osztály 

Két leszármazott
  * amerikai_labda 
  * szimpla_labda


Minden objektumnak egyetlen közös őse van: Object


==== Osztályok tartalma ====

  * Metódusok
  * Osztály szintű változók
 


==== Objektum példa ====

  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  
  namespace hellovilag
  {
      class Program
      {
          static void Main(string[] args)
          {            
              Console.ReadLine();
          }
          class Labda
          {
              public void Rúg();
              private void Felfúj();
          }
  
      }
  }

==== Öröklésre, származtatásra példa ====



  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  
  namespace hellovilag
  {
      class Program
      {
          static void Main(string[] args)
          {
            
              Labda labda;
              labda = new AmerikaiLabda();
              labda.Rúg();
            
              Console.ReadLine();
          }
          abstract class Labda
          {
              abstract public void Rúg();
              //abstarct public void Felfúj();
          }
          class AmerikaiLabda : Labda
          {
              public override void Rúg()
              {
                  Console.WriteLine("Rúg");
              }
          }
          class EurópaiLabda : Labda
          {
              public override void Rúg()
              {
                  Console.WriteLine("Csapva");
              }
          }
      }
  }


==== Tulajdonságok ====
Lehetővé teszik érték lekérdezést kontrollált módon. 

Példa kedvéért a labdának adjuk egy szín tulajdonságot.

prop begépelve kódkiegészítő ablak ugrik elénk.

Két tab-ra tulajdonságot beírja.

  class AmerikaiLabda : Labda
  {
      public int Méret { get; set; }
      public override void Rúg()
      {
          Console.WriteLine("Rúg");
       }
  }
Létrejön egy int típusú változó az objektumban. 


==== Objektumok típusai ====

==== Objektumok konvertálása ====
  * Meghívok egy metódust, ami átkonvertálja
  * Automatikus konvertálás -> Kasztolás

=== Konvertálás metódussal ===

Például szöveg konvertálása egésszé:
  int a = int.Parse("5");

=== Kasztolás ===
  int a = 5;
  double b = (double)a;
A kasztolás osztályokon is működik



===== Hibakezelés =====
  * kivételkezelés
  * debugolás

===== Kivételkezelés =====
Speciális kivételosztályokat használunk

Van egy kivétel alaposztály, ebből több fajta kivétel van származtatva.
Szabványosan tudjuk kezelni a programban fellépő hibákat. 
A cél az összeomlás nélküli működés.

Kivételt úgy kezeljük, hogy "elkapjuk"


==== Kivétel dobása ====

  throw

  throw  new Exception
Eddig csak annyit ír ki, hogy hiba.

Ezért üzenet írunk:
  throw  new Exception("Nem működik a képernyő");
  


Felveszünk egy újabb metódust, amiben elhelyezzük az eldobást:

  static void HibásUtasítás()
  {
      // valami kód
      throw  new Exception("Nem működik a képernyő");
  }


==== Kivétel elkapása ====

Meg kell saccolnunk hol lehet majd hiba.
Ott try utasítással elkapjuk a kivételt:

Kapd el:
  try

Ha elkaptál egy kivételt tedd az e változóba:
  catch(Exception e)


  try 
  {
      HibásUtasítás();
  }
  catch(Exception e)
  {
     Console.WriteLine("Hiba! " + e.Message);
     Console.ReadLine();   
  }
  


==== Final ====

Érzékeny erőforrások esetén le kell zárni azt, fel kell oldani a foglalását. 
Memóriaszivárgás léphet fel az el nem engedett erőforrások kapcsán. 


  try 
  {
      HibásUtasítás();
  }
  catch(Exception e)
  {
     Console.WriteLine("Hiba! " + e.Message);
     Console.ReadLine();   
  }
  finally
  {
     //Erőforrások lezárása
  }
Ha nem volt hiba a catch részt átugorjuk és a finallay rész mindenképpen végrehajtásra kerül.



A kivételek típusa alapján szétválaszthatók:
  try 
  {
      HibásUtasítás();
  }
  catch(FormatException e)
  {
     Console.WriteLine("Hiba! " + e.Message);
     Console.ReadLine();   
  }
  finally
  {
     //Erőforrások lezárása
  }
A példában formátum kivétel esetén írjuk ki az adott hibaüzenetet.


===== Debuger =====
A memóriát lépésről lépésre képes vagyok kezelni. 

A programba bele kell fordítani a debugolási információkat. A Visual Studió ezeket automatikusan bele teszi.

Release módban nem kerülnek bele a kódba a debug információk, de gyorsabban fut.

==== BreakPoint ====

A szerkesztő ablak baloldalán kattintok breakpointot szúrok be. 

A program mindig megáll amikor a futtatás az adott kódrészhez ér.

==== Watch ====


  Változó felett: Jobb gomb -> AddWach

==== Stack ====

  A program végrehajtása során hívásokat tároljuk itt

==== Immediate Window ====

  A kód szerkesztése nélkül tudunk kódrészeket beleírni. 
  Például a lista egyik elemét töröljük.

==== Végrehajtás lépésenként ====

Program futásának követése

F10 gombot nyomogatva léptetni tudjuk a programot. 

Nehézség több szálas programok debugolásánál fordul elő.

===== Fájlkezelés =====
Amivel dolgozunk
  * Olvasó objektum
  * Adatforrás objektum

Hasonlóan írunk olvasunk fájlokba, memóriába.


==== Fájl megnyitása olvasásra ====

  using System;
  using System.IO;
  
  namespace hellovilag
  {
      class Program
      {
          static void Main(string[] args)
          {
              StreamReader reader = new StreamReader(new FileStream(@"c:\test.txt", FileMode.Open));
              while (!reader.EndOfStream)
              {
                  Console.WriteLine(reader.ReadLine());
              }
              reader.Close();
              Console.ReadLine();
          }    
      }
  }

Ha egy Sztring elé @ karaktert teszünk az escape szekvenciák nem kerülnek behelyettesítésre.
  @"c:\test.txt"

===== Windows Formok =====

Különbségek az eddigiekhez:
  * Eseményvezérelt módon dolgozunk.
  * Űrlapokkal dolgozunk

Minden amit használunk egy-egy osztály. 

Visual Studoban:
  Új projekt -> WindowsFormsApplication


  View -> Other Windows -> Solutions Exploler

  View -> Other Windows -> ToolBox

  Rajzszögre kattintunk

  View -> Other Windows -> Properties Window

Előkészítés
  Form1 Load esemény


  namespace WindowsFormsApplication1
  {
      public partial class Form1 : Form
      {
          public Form1()
          {
              InitializeComponent();
          }
  
          private void Form1_Load(object sender, EventArgs e)
          {
  
          }
      }
  }

  * sender ki küldte az objektumot
  * e paraméterek


mbox tab tab

  MessageBox.Show("Test");

Egy komplett program:
  using System;
  using System.Collections.Generic;
  using System.ComponentModel;
  using System.Data;
  using System.Drawing;
  using System.Linq;
  using System.Text;
  using System.Windows.Forms;
  
  namespace WindowsFormsApplication1
  {
      public partial class Form1 : Form
      {
          public Form1()
          {
              InitializeComponent();
          }
  
          private void Form1_Load(object sender, EventArgs e)
          {
              VálasztócomboBox.Items.Add("Körte");
              VálasztócomboBox.Items.Add("Alma");
              VálasztócomboBox.Items.Add("Barack");
          }
  
          private void button1_Click(object sender, EventArgs e)
          {
              MessageBox.Show(VálasztócomboBox.Text);
          }
      }
  }



===== Konkrét példa megoldása =====

            StreamReader reader = new StreamReader(new FileStream(@"c:\adat.txt", FileMode.Open));
  
            string str;
            string[] stomb;
            while (!reader.EndOfStream)
            {
                
                str = reader.ReadLine();
                stomb = str.Split(':');
                str = stomb[0] + ", " + stomb[1] + " Ft, " + stomb[2];
                listBox1.Items.Add(str);
            }
            reader.Close();


        private void BetöltésGomb_Click(object sender, EventArgs e)
        {
            StreamReader reader = new StreamReader(new FileStream(@"c:\adat.txt", FileMode.Open));
  
            string str;
            string[] stomb;
            while (!reader.EndOfStream)
            {
                
                str = reader.ReadLine();
                stomb = str.Split(':');
                str = stomb[0] + ", " + stomb[1] + " Ft, " + stomb[2];
                listBox1.Items.Add(str);
            }
            reader.Close();
            HozzáadásGomb.Enabled = true;
            //betöltve = true;
  
        }