SzoftTechZH20130422

1. feladat:

a) osztály diagramból : c# vagy c++ vagy java kód írás

b) Szöveges feladatból UML diagram

2, Event

C# alkalmazás -> KeyboardManager osztály eventet publikál, billentyű lenyomásra és felengedésre.

A KeyboardSubscriber iratkozzon fel a KeyboardManager billentyű-felengedés eseményére -> konzolra írja ki, hogy melyik billentyű lett felengedve.

// ez az osztály tárolja az eseménnyel kapcsolatos változókat pl. az 
// eseményt kiváltó karaktert

 public class KeyArgs {
	private char _character;
	public char Character { get { return _character; } }

	public KeyArgs(char character) {
           _character = character;	
        }
}

public delegate void KeyEventHandler(KeyArgs args);
public class KeyboardManager
{
	//eventek a feladat kiírás szerint
	public event KeyEventHandler KeyUp;
	public event KeyEventHandler KeyDown;

        // ennek a metódusnak a meghívásával tudjuk a keyup eventet 
        // elsütni

        public void FireKeyUp(char c)
        {
	    if(KeyUp != null)
               KeyUp(new KeyArgs(c));
        }

        // ennek a metódusnak a meghívásával tudjuk a keydown eventet 
        // elsütni
        public void FireKeyDown(char c)
        {
            if(KeyDown != null)
            KeyDown(new KeyArgs(c));
        }
}

public class KeyBoardSubscriber
{
        // egy referenciát tárolunk egy KeyboardManager példányra, hogy
        // fel tudjunk iratkozni az eseményeire
	private KeyboardManager manager = new KeyBoardManager();

	public void Subscribe()
        {
	    //feliratkozás
    	    manager.KeyUp += ProcessKeyUp;
	}
	
	// ez a metódus hívódik meg az event elsütésekor
	public void ProcessKeyUp(KeyArgs args)
	{
		Console.WriteLine(“Billentyű: {0}”, args.Character);
	}
}	

3, Eseményvezérelt programozás, grafikus megjelenítés

a, UserControl fogalma, két legfontosabb szerepe a tervezés/fejlesztés során (ez jó?)

A vezérlőelem maga is egy űrlap, tartalmazhat vezérlőelemeket

_ Tervezési időben vizuálisan elkészíthetjük összetett vezérlőelemeinket, pont úgy, ahogy egy formot is elkészítenénk.

_ Miben más? űrlapokra, illetve más UserControlokra lehet elhelyezni.

_ Példa FilePicker vezérlő: tipikusan együtt előforduló vezérlőelemek összekötése (?)

Gyakvezér mondta sok szar megfejtést olvasott :UserControl=saját vezérlő.....

b, Jár-e kellemetlen következménnyel, ha eseménykezelőben a kód hosszantartó műveletet végez? Ha igen, miért?

Igen, mert a hosszantartó művelet ideje alatt az ablak nem tudja a hozzá beérkező üzeneteket feldolgozni, és az alkalmazás “befagy”.

c, C# alkalmazás részlet: (20,20) px koordináta, zöld, 5px oldalhosszúságú négyzet -> másodpercenként 5px-el növekszik, míg le nem nyomjuk az y billentyűt.

public partial class Form1 : Form
    {
        bool stopped = false;
        int cntr = 1;

        public Form1()
        {
            Timer timer = new Timer();
            timer.Interval = 1000;
            timer.Tick += new EventHandler(timer_Tick);
            timer.Start();

            this.KeyDown += new KeyEventHandler(Form1_KeyDown);
            InitializeComponent();
        }

        void Form1_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Y && !stopped)
            {
                stopped = true;
            } 
        }

        void timer_Tick(object sender, EventArgs e)
        {
            Invalidate();
        }

        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);
            Pen greenpen = new Pen(Color.Green, 3);
            e.Graphics.DrawRectangle(greenpen, 20, 20, cntr * 5, cntr * 5);
            if (!stopped) cntr++;

        }
    }

4, Szálkezelés

a, Többszálú alkalmazások 3 előnye.

1. jobb processzor kihasználtság

2. nem növekvő átlagos válaszidő (interaktivitás – pl. nem akad le a GUI, szerveralkalmazások)

3. időzítés érzékeny feladatok magasabb prioritású szálon futtathatóak

b, ReaderWriterLock, Mutex.

Mutex:

Cél: Mint a lock, de folyamatok között is. Pl. annak megoldására, hogy egy alkalmazásból csak egy példány indulhasson. Folyamatok között is. Sebesség: közepes.

ReaderWriterLock:

Sok olvasóra optimalizált megoldás. Egyszerre több olvasó is hozzáférhet az erőforráshoz, de íróból csak egy (illetve az író kizárja az olvasókat is). Pl. ritkán módosított cache megvalósítása. Folyamatok között: nem. Sebesség: közepes.

c,

• főszál indít munkaszálat, tegyen be egy számot az item listbe, ezt jelezze a munkaszálnak
• várja meg, míg befejezi a futását a munkaszál
• munkaszál indulás után hatékonyan várakozzon a főszál jelzésére
• jelzés után vegye ki a listából az elemet
• írja ki a konzolra
• fejezze be a futást

Kölcsönös kizárás biztosítása, ha kell.

public class Process
{
List<int> items = new List<int>();
AutoResetEvent addedEvent = new AutoResetEvent(false);
AutoResetEvent removedEvent = new AutoResetEvent(false);
public static void Main(String[] args)
{
	new Process().Start();
}
 
public void Start()
{
	Thread workerThread = new Thread(new ThreadStart(Work));
	workerThread.Start();
	items.Add(5);
	addedEvent.Set(); // jelzünk, hogy kész van a hozzáadás
	removedEvent.WaitOne(); // várunk, amíg a workerthread jelez
}

public void Work()
{
	addedEvent.WaitOne(); // várakozunk, amíg a főszál hozzáad
	int lastElem = items.Last();
	items.Remove(items.Count - 1);
	Console.WriteLine(lastElem);
	removedEvent.Set(); // jelzünk, hogy kész van a worker
}
}

Kölcsönös kizárás megvalósítására nincs szükség, mivel a listához időben szeparáltan férünk hozzá a két szálról(először az elsőről, aztán a másodikról).

Alternatív megoldás, hogy a removedEvent-et kitöröljük a kódból, és a removedEvent.WaitOne() sor helyett workerThread.Join() -t használunk.

5, Generikus típusok

a, Példa generikus kényszer alkalmazására

class Dictionary<K,V>: IDictionary<K,V>
where K: IComparable<K>
where V: IKeyProvider<K>, IPersistable, new()
{ 
public void Add(K key, V value) { ... }
public V Find(K key) {
if ( c.CompareTo( key ) ) { … }
}
}

b, Milyen esetben célszerű a dispose minta alkalmazása?

A drága, és nem felügyelt erőforrások felszabadítására használjuk, pl a File.Close() dispose-t hív.

A Dispose() meghívása nem történik automatikusan, ezt nekünk kell megtenni.

A dispose tervezési mintának köszönhetően az objektumok által foglalt erőforrások felszabadítása válik determinisztikussá.

c, .Net kóderedet alapú biztonsági mechanizmus lényege

Adott helyről letöltött programnak milyen jogai vannak (rosszindulatú kódtól nem véd!)

(CAS) code acces security

Nincsenek felkészítve a mobil kódokra. (levélhez csatolva, netről, dokumentumban tárolva érkezhetnek a gépre) Kód eredetét is kell ellenőrizni

Kódhoz kötött jogosultságok: nem csak a felhasználót azonosítja, hanem a végrehajtott kódot is.

A Szerelvényekhez kell meghatározni, hogy milyen jogaik vannak. (pl: netről töltött kód nem kap írási, és olvasási jogot, csak egy bizonyos mappára-> nem árthat nekünk)

Nem egyesével adnak ki jogokat, hanem biztonsági házirendet alakíthat ki a rendszergazda.

6, Robusztus ADO.NET kapcsolat alapú modell

Írjon példakódot: beszúr rekordot egy táblába: Student(StudentID, Name, YearofBirth)

(Nem szükséges sql paraméter használata.)

				
try {
SqlConnection conn = new SqlConnection( str_data );
conn.Open();						

SqlCommand command = new SqlCommand("INSERT INTO Student(StudentID, Name, YearofBirth) VALUES (1,’Proba Peti’, 1990)");	

command.Connection = conn;
command.ExecuteNonQuery();
}

//ha van kivétel kezeljük	
catch (Exception ex) { Console.WriteLine(ex.Message); }

//ha van kapcsolat lezárjuk
finally {
if((conn!=null) && (conn.State==System.Data.ConnectionState.Open)) 
conn.Close();
}

7, Bináris komponensek

a, Mit értünk dinamiks linkelés alatt? 3 előnye és 1 hátránya a statikus linkeléssel szemben.

Definíció: a futó program csak futásidőben tölti be a számára szükséges könyvtárakat.

Előnyök:

• Ha több process használja a könyvtárat, akkor a memóriába csak egy példányban töltődik be (a kódrész, az adat marad külön!)
• A háttértáron is csak egyszer foglal helyet (ha az alkalmazások megosztottan használják pl. a windows\system könyvtárból)
• Kis alkalmazás (.exe) fájlméret
• Ha a .dll-ben szerepel egy hibás függvény, akkor a programot egyszerűen a .dll cseréjével is javíthatjuk, nem kell újrafordítani.

Hátrányok:

• A program futásakor jelen kell legyenek az általa használt DLL-ek, ezek nélkül az alkalmazás futásképtelen.
• Ha az alkalmazások megosztottan használják (pl. a windows\system könyvtárból): verzió kavarodás, DLL hell.

(DLL hell példa volt a .NET szerelvényeknél)

b, C# kód -> változó típusának kiírása konzolra.

	int asd;
	Type mit = asd.GetType();
	Console.Writeline(mit.FullName);

c, Reflexió milyen szolgáltatásokat nyújt? Soroljon fel 3 konkrét szolgáltatást.

• Lekérdezhetjük, hogy egy szerelvényben milyen típusok vannak
• Lekérdezhetjük: az egyes típusok (osztályok, interfészek, stb). felépítését: pl. tagváltozók, tagfüggvények, event-ek, stb. listája. Be is állíthatjuk a tagváltozók értékét. Meg is hívhatjuk az egyes metódusokat
• Lekérdezhetjük az egyes nyelvi elemekhez (osztályok, tagjaik, stb.) tartozó attribútumokat

d, Attribútum definiálása és használata példakód.

[AttributeUsage(AttributeTargets.Class)]
class StorableClassAttribute: System.Attribute {
public StorableClassAttribute() { }
}

[AttributeUsage(AttributeTargets.Field)]
public class StorableAttribute: System.Attribute
{
string name;
public StorableAttribute(string name)
{
this.name = name;
}
public string Name { get { return name; } }
}

// A System.Attribute osztályból kell egy saját osztályt leszármaztatni
// Az AttributeUsage azt határozza meg, mihez tudjuk az adott attribútumot hozzárendelni