SzoftTechZH20130422 - Laptörténet

User15734: A C# kód bénán volt betördelve, ezt javítottam.

2014-05-09T00:46:25Z

A C# kód bénán volt betördelve, ezt javítottam.

← Régebbi változat		A lap 2014. május 9., 02:46-kori változata
20. sor:		20. sor:

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

31. sor:		31. sor:
	public event KeyEventHandler KeyDown;		public event KeyEventHandler KeyDown;

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

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

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

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

	public void Subscribe()		public void Subscribe()
	{		{
	//feliratkozás		//feliratkozás
	manager.KeyUp += ProcessKeyUp;		manager.KeyUp += ProcessKeyUp;
	}		}

Ruzar, 2014. április 13., 17:54-n

2014-04-13T17:54:04Z

← Régebbi változat		A lap 2014. április 13., 19:54-kori változata
214. sor:		214. sor:

	'''b, Milyen esetben célszerű a dispose minta alkalmazása?'''		'''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 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á.		A dispose tervezési mintának köszönhetően az objektumok által foglalt erőforrások felszabadítása válik determinisztikussá.

Ruzar, 2014. április 13., 17:50-n

2014-04-13T17:50:48Z

← Régebbi változat		A lap 2014. április 13., 19:50-kori változata
214. sor:		214. sor:

	'''b, Milyen esetben célszerű a dispose minta alkalmazása?'''		'''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 drága,és nem felügyelt erőforrások felszabadítására használjuk, pl a File.Close() is dispose-t hív.		A dispose tervezési mintának köszönhetően az objektumok által foglalt erőforrások felszabadítása válik determinisztikussá.
	A ~~nem felügyelt~~ (~~pl. DLL-ek~~) ~~erőforrások felszabadítására a destruktort használjuk, aminek lefutása soha nem determinisztikus.~~

	~~//(destruktor sose az~~ nem, ~~nem valami olyasmi kéne, hogy, ha valami nagy //erőforrásigényű dolgot csináltunk?) <- így van~~.

	~~Mit biztosít számunkra a dispose minta?~~

	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'''		'''c, .Net kóderedet alapú biztonsági mechanizmus lényege'''

Csompi, 2014. április 12., 22:34-n

2014-04-12T22:34:08Z

← Régebbi változat		A lap 2014. április 13., 00:34-kori változata
215. sor:		215. sor:
	'''b, Milyen esetben célszerű a dispose minta alkalmazása?'''		'''b, Milyen esetben célszerű a dispose minta alkalmazása?'''

	A drága,és felügyelt erőforrások felszabadítására használjuk, pl a File.Close() is dispose-t hív.		A drága,és nem felügyelt erőforrások felszabadítására használjuk, pl a File.Close() is dispose-t hív.
	A nem felügyelt (pl. DLL-ek) erőforrások felszabadítására a destruktort használjuk, aminek lefutása soha nem determinisztikus.		A nem felügyelt (pl. DLL-ek) erőforrások felszabadítására a destruktort használjuk, aminek lefutása soha nem determinisztikus.

Szikszayl, 2013. szeptember 14., 21:04-n

2013-09-14T21:04:42Z

← Régebbi változat		A lap 2013. szeptember 14., 23:04-kori változata
318. sor:		318. sor:
	// Az AttributeUsage azt határozza meg, mihez tudjuk az adott attribútumot hozzárendelni		// Az AttributeUsage azt határozza meg, mihez tudjuk az adott attribútumot hozzárendelni
	</pre>		</pre>

			[[Category:Infoalap]]

Regirl, 2013. június 1., 17:45-n

2013-06-01T17:45:31Z

← Régebbi változat		A lap 2013. június 1., 19:45-kori változata
152. sor:		152. sor:
	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.		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,		'''c,'''
	-főszál indít munkaszálat, tegyen be egy számot az item listbe, ezt jelezze a munkaszálnak		* 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		* 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		* 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		* jelzés után vegye ki a listából az elemet
	- írja ki a konzolra		* írja ki a konzolra
	- fejezze be a futást		* fejezze be a futást
	Kölcsönös kizárás biztosítása, ha kell.		Kölcsönös kizárás biztosítása, ha kell.
	~~'''~~
			<pre>
	public class Process		public class Process
	{		{
189. sor:		190. sor:
	}		}
	}		}
			</pre>

	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).		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.		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
			'''5, Generikus típusok'''

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

	<pre>		<pre>
	class Dictionary<K,V>: IDictionary<K,V>		class Dictionary<K,V>: IDictionary<K,V>
211. sor:		217. sor:
	A drága,és felügyelt erőforrások felszabadítására használjuk, pl a File.Close() is dispose-t hív.		A drága,és felügyelt erőforrások felszabadítására használjuk, pl a File.Close() is dispose-t hív.
	A nem felügyelt (pl. DLL-ek) erőforrások felszabadítására a destruktort használjuk, aminek lefutása soha nem determinisztikus.		A nem felügyelt (pl. DLL-ek) erőforrások felszabadítására a destruktort használjuk, aminek lefutása soha nem determinisztikus.


	//(destruktor sose az nem, nem valami olyasmi kéne, hogy, ha valami nagy //erőforrásigényű dolgot csináltunk?) <- így van.		//(destruktor sose az nem, nem valami olyasmi kéne, hogy, ha valami nagy //erőforrásigényű dolgot csináltunk?) <- így van.
219. sor:		224. sor:
	A dispose tervezési mintának köszönhetően az objektumok által foglalt erőforrások felszabadítása válik determinisztikussá.		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		'''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!)		Adott helyről letöltött programnak milyen jogai vannak (rosszindulatú kódtól nem véd!)

	(CAS) code acces security		(CAS) code acces security

	Nincsenek felkészítve a mobil kódokra. (levélhez csatolva, netről, dokumentumban tárolva érkezhetnek a gépre)		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ó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.		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)		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.		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)		'''6, Robusztus ADO.NET kapcsolat alapú modell'''
	(Nem szükséges sql paraméter használata.)'''
			'''Írjon példakódot: beszúr rekordot egy táblába: Student(StudentID, Name, YearofBirth)'''

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

	<pre>		<pre>
254. sor:		267. sor:
	</pre>		</pre>

	'''7, Bináris komponensek		'''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.'''
			'''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.		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:		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!)		* 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)		* 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		* 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.		* 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:		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.		* 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.		* 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)		(DLL hell példa volt a .NET szerelvényeknél)

			'''b, C# kód -> változó típusának kiírása konzolra.'''
	b, C# kód -> változó típusának kiírása konzolra.
	<pre>		<pre>
	int asd;		int asd;

Regirl, 2013. június 1., 17:40-n

2013-06-01T17:40:33Z

← Régebbi változat		A lap 2013. június 1., 19:40-kori változata
1. sor:		1. sor:
	'''1. feladat:		'''1. feladat:

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

	b) Szöveges feladatból UML diagram'''		b) Szöveges feladatból UML diagram'''

	'''2, Event'''		'''2, Event'''

	'''C# alkalmazás -> KeyboardManager osztály eventet publikál, billentyű lenyomásra és felengedésre.		'''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.'''		A KeyboardSubscriber iratkozzon fel a KeyboardManager billentyű-felengedés eseményére -> konzolra írja ki, hogy melyik billentyű lett felengedve.'''

19. sor:		23. sor:
	}		}
	}		}

	public delegate void KeyEventHandler(KeyArgs args);		public delegate void KeyEventHandler(KeyArgs args);
	public class KeyboardManager		public class KeyboardManager
63. sor:		68. sor:
	}		}
	</pre>		</pre>

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

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

	A vezérlőelem maga is egy űrlap, tartalmazhat vezérlőelemeket		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.		_ 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.		_ 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		_ Példa FilePicker vezérlő: tipikusan együtt előforduló vezérlőelemek összekötése
	(?)		(?)
75. sor:		86. sor:

	'''b, Jár-e kellemetlen következménnyel, ha eseménykezelőben a kód hosszantartó műveletet végez? Ha igen, miért?'''		'''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”.		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.'''		'''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.'''

			<pre>
	public partial class Form1 : Form		public partial class Form1 : Form
	{		{
116. sor:		130. sor:
	}		}
	}		}
			</pre>

			'''4, Szálkezelés'''

	'''~~4, Szálkezelés~~		'''a, Többszálú alkalmazások 3 előnye.'''
	a, Többszálú alkalmazások 3 előnye.'''

	1. jobb processzor kihasználtság		1. jobb processzor kihasználtság

	2. nem növekvő átlagos válaszidő (interaktivitás – pl. nem akad le a GUI, szerveralkalmazások)		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		3. időzítés érzékeny feladatok magasabb prioritású szálon futtathatóak

	'''b, ReaderWriterLock, Mutex.'''		'''b, ReaderWriterLock, Mutex.'''

	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.		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:		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.		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.

Regirl, 2013. június 1., 17:37-n

2013-06-01T17:37:29Z

Változtatások megtekintése

Regirl: Új oldal, tartalma: „'''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 even…”

2013-06-01T17:29:32Z

Új oldal, tartalma: „'''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 even…”

Új lap

'''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 felügyelt erőforrások felszabadítására használjuk, pl a File.Close() is dispose-t hív.
A nem felügyelt (pl. DLL-ek) erőforrások felszabadítására a destruktort használjuk, aminek lefutása soha nem determinisztikus.

//(destruktor sose az nem, nem valami olyasmi kéne, hogy, ha valami nagy //erőforrásigényű dolgot csináltunk?) <- így van.

Mit biztosít számunkra a dispose minta?

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