„Záróvizsga kvíz - Sznikák” változatai közötti eltérés

← Régebbi szerkesztés Újabb szerkesztés →

VizuálisWikiszöveges

@@ 70. sor: / 70. sor: @@
 class DataProcessor
 {
-	static object syncRoot = new object(); // *1
+    static object syncRoot = new object(); // *1
-	bool exit = false; // *2
+    bool exit = false; // *2
-	List<int> data = new List<int>(); // *3
+    List<int> data = new List<int>(); // *3
-	public void AddData(int n)
+    public void AddData(int n)
-	{
+    {
-		data.Add(n); // *4
+        data.Add(n); // *4
-	}
+    }
-	public void SignalExit()
+    public void SignalExit()
-	{
+    {
-		lock (syncRoot)
+        lock (syncRoot)
-		{
+        {
-			exit = true; // *5
+            exit = true; // *5
-		}
+        }
-	}
+    }
-	public void ProcessData()
+    public void ProcessData()
-	{
+    {
-		while (!exit)
+        while (!exit)
-		{
+        {
-			lock (syncRoot) // *6
+            lock (syncRoot) // *6
-			{
+            {
-				if (data.Count > 0) // *7
+                if (data.Count > 0) // *7
-				{
+                {
-					int n = data[0];
+                    int n = data[0];
-					data.RemoveAt(0);
+                    data.RemoveAt(0);
-					Console.WriteLine(n);
+                    Console.WriteLine(n);
-				}
+                }
-			}
+            }
-			Thread.Sleep(10);
+            Thread.Sleep(10);
-		}
+        }
-	}
+    }
 }
 </pre>
@@ 130. sor: / 130. sor: @@
 {{Kvízkérdés|típus=több|válasz=2,3}}
 # Egy C# attribútum alkalmazásakor az attribútum neve elé a @ karaktert kell tenni.
 # Egy C# delegate objektumot át lehet adni függvényparaméterként is.
 # A C# attribútumok segítségével deklaratív módon tudunk információt csatolni többek között tagváltozókhoz, metódusokhoz és osztályokhoz.
 # Feltéve, hogy adott egy Rectangle osztály és annak egy Width tulajdonsága (property), valamint a Rectangle osztály egy rect nevű példánya/objektuma, akkor a tulajdonság beállítása a rect.SetWidth(10) formában lehetséges.
@@ 180. sor: / 180. sor: @@
 # A .NET Framework List osztálya szálbiztos (thread safe).
 # Szálak kiléptetésére a Thread osztály Abort művelete javasolt.
 # A Thread osztály Join műveletével lehet egy szál futásának a végét bevárni.
 == A feladat egy Collection (gyűjtemény) osztály elkészítése C# nyelven, mely egy eseménnyel jelzi, ha az elemszáma megváltozott, és az esemény paramétereiben megadja a régi és az új elemszámot! Adja meg, mely sorok alkalmazásával oldható meg az esemény megvalósítása és biztonságos elsütése! (2022 jan) ==
@@ 208. sor: / 208. sor: @@
 # Snapshot
 # UndoStore
+== Adottak az alábbi állítások a Document-View (Dokumentum-Nézet) architektúra vonatkozásában. Jelölje meg, mely állítások igazak! (2021 jan) ==
+FIGYELEM, akárhány helyes válasz létezhet!
+{{Kvízkérdés|típus=több|válasz=3,4}}
+# A Document-View architektúrában a Controller osztály feladata a felhasználói interakciók kezelése.
+# A Document-View architektúrában a dokumentumban külön tagváltozót vezetünk be minden egyes nézetre.
+# A Document-View architektúrában a dokumentumnak van egy vagy több olyan művelete, mellyel az állapotát a nézetek bármikor le tudják kérdezni.
+# A Document-View architektúrában a nézetnek van egy hivatkozása a dokumentumára.
+== Az alábbi állítások a .NET Framework platformra vonatkoznak! Jelölje meg, mely állítások igazak! FIGYELEM, akárhány helyes válasz létezhet! (2021 jan) ==
+{{Kvízkérdés|típus=több|válasz=1,3}}
+# .NET platformra lehet C++nyelven is fejleszteni
+# .NET környezetben az objektumok azonnal felszabadulnak, amint az utolsó hivatkozás is megszűnik rájuk
+# A .NET futtatókörnyezet rövid neve: CLR
+== Adott az alábbi C# nyelvű .NET alkalmazás kódrészlet. (2021 jan) ==
+<pre>
+class Counter
+{
+    int counter = 0; // *1
+    object syncRoot = new object(); // *2
+    public int GetValue() // *3
+    {
+        lock (syncRoot)
+            { return counter; }
+    }
+    public void IncreaseCounter(int delta) // *4
+    {
+        lock (syncRoot)
+            { counter += delta; }
+    }
+}
+</pre>
+Jelölje meg mely állítások igazak a kódrészlet vonatkozásában többszálú környezetben! FIGYELEM, akárhány helyes válasz létezhet!
+{{Kvízkérdés|típus=több|válasz=1,2,3}}
+# A *2 sor elejére nem kell plusszban beírni a static kulcsszót, anélkül is helyes a működés
+# A kód nem működne megfelelően, ha a *2 sorban a syncRoot típusát int-re cserélnénk
+# A *3 GetValue() függvényben a lock utasítás eltávolítható (ha legalább 32 bites környezetről van szó)
+# A *4 IncreaseCounter() függvényben a lock utasítás eltávolítható
+# A *4 IncreaseCounter() függvényben a lock utasítás eltávolítható, de akkor ki kell írni a függvény elé a synchronized kulcsszót.
+== A feladat egy Car osztály elkészítése C# nyelven, mely egy eseménnyel jelzi, ha az autó sebessége meghalad egy adott sebességkorlátot! (2021 jan) ==
+Adja meg, mely sorok alkalmazására van szükség a megoldásban, ha nem használhatja a ?. operátort!
+{{Kvízkérdés|típus=több|válasz=2,4,9,12}}
+# event void SpeedLimitExceededDelegate(int speed, double percent);
+# delegate void SpeedLimitExceededDelegate(int speed, double percent);
+# public SpeedLimitExceededDelegate SpeedLimitExceeded;
+# public event SpeedLimitExceededDelegate SpeedLimitExceeded;
+# public delegate SpeedLimitExceededDelegate SpeedLimitExceeded;
+# public event SpeedLimitExceededDelegate SpeedLimitExceeded(int speed, double percent);
+# public SpeedLimitExceededDelegate SpeedLimitExceeded(int speed, double percent);
+# public delegate SpeedLimitExceededDelegate SpeedLimitExceeded(int speed, double percent);
+# if (SpeedLimitExceeded != null)
+# if (SpeedLimitExceededDelegate != null)
+# SpeedLimitExceededDelegate(speed, percent);
+# SpeedLimitExceeded(speed, percent);
+== Adott egy Car nevű C# nyelven megírt osztály, mely már rendelkezik egy int típusú speed nevű tagváltozóval. Ezt kell egy olyan tulajdonsággal (property) kiegészíteni, mellyel a jármű sebessége lekérdezhető, beállítható, de a beállításra csak az osztályon belül van lehetőség. Melyik a helyes és legcélravezetőbb megoldás? (2021 jan) ==
+{{Kvízkérdés|típus=egy|válasz=4}}
+# <pre>public int Speed { get { return speed; }; set { speed = value; } }</pre>
+# <pre>public int Speed { get { return length; }; set { } }</pre>
+# <pre>public int Speed { get { return speed; }; }</pre>
+# <pre>public int Speed { get { return speed; }; private set { speed = value; } }</pre>
+# <pre>public int Speed { get { return speed; }; set; }</pre>
+== Adottak az alábbi állítások különböző tervezési mintákkal kapcsolatban! Jelölje meg, mely állítások igazak. FIGYELEM, akárhány helyes válasz létezhet! (2021 jan) ==
+{{Kvízkérdés|típus=több|válasz=1,2,4}}
+# Az Adapter tervezési mintában a Client osztálynak van egy Target típusú mutatója vagy hivatkozása az Adapter osztály egy példányára.
+# Az Adapter tervezési mintában az Adapter osztály a Target osztályból származik (vagy a Target interfészt implementálja).
+# Az Adapter minta Object Adapter változatában a Adaptee implementálja a Target interfészt (vagy a Target osztályból származik).
+# Az Adapter tervezési mintában (legalábbis annak object adapter változatában) az Adapter (adaptáló) osztály - amennyibe lehetősége van rá - továbbítja (delegálja) a kéréseket az Adaptee (adaptálandó) osztálynak.
+== Egy online bolt alkalmazásban a feladata egy a bevásárlókosár lezárását (szállítási cím kezelése, megerősítés, fizetés) kezelő osztály megvalósítása. Az osztálynak több fizetési módot (pl. bankkártya, átutalás) kell támogatnia, és könnyen kiterjeszthetőnek kell lennie újabb fizetési módokkal. Mely tervezési mintát alkalmazná a megvalósítás során? (2021 jan) ==
+{{Kvízkérdés|típus=egy|válasz=4}}
+# Composite
+# Memento
+# Observer
+# Strategy
+# Singleton
+# Proxy
+# Factory method
+# Adapter
+# Abstract factory
+== Az alábbi állítások a .NET Framework platformra vonatkoznak! Jelölje meg, mely állítások igazak! FIGYELEM, akárhány helyes válasz létezhet! (2021 jan) ==
+{{Kvízkérdés|típus=több|válasz=2}}
+# A C# kódot a JIT compiler fordítja gépi (IL) kódra
+# A dinamikusan lefoglalt memória felszabadítása nem a fejlesztő feladata
+# Az elterjedtebb processzorok képesek a köztes (IL) kódot közvetlenül futtatni
+# A C# kódot a JIT compiler fordítja köztes (IL) kódra
+== Ön egy alkalmazást fejleszt .NET platformra. Az alkalmazást a felhasználók a saját gépeiken több példányban is mepróbálhatják elindítani (akár teljesen egyidőben). Az ön feladata annak megoldása, hogy az alkalmazás csak egy példányban fusson: vagyis, ha az alkalmazásból úgy indít új példányt a felhasználó, hogy már fut, akkor az újabb példány ezt detektálja, és azonnal lépjen ki (fejezze be a futását). Mit használna az alábbiak közül ennek megvalósításához? (2021 jan) ==
+{{Kvízkérdés|típus=egy|válasz=5}}
+# lock
+# synchronized
+# StartCoordinator
+# AutoResetEvent
+# Mutex
+# Singleton
+# ThreadPool
+== Adja meg, mely tervezési mintát valósítja meg az alábbi C# nyelvű kódrészlet! (2021 jan) ==
+<pre>interface Item
+{
+    void Method1();
+}
+class SimpleItem: Item
+{
+    public void Method1() { … }
+}
+class SeveralItems: Item
+{
+    Item[] items;
+…
+    public void Method1()
+    {
+        foreach (var item in items)
+        item.Method1();
+    }
+}
+class Client
+{
+    Item[] items;
+    …
+    void PorcessAllItems() // [sic.]
+    {
+        …
+        foreach (var item in items)
+        item.Method1();
+        …
+}
+}</pre>
+{{Kvízkérdés|típus=egy|válasz=1}}
+# Composite
+# Adapter
+# Memento
+# Observer
+# Proxy
+# Abstract factory
+# Singleton
+# Strategy
+# Factory method