…………………………………………………………………………………………………………………………………………………………

Fakulteti i Shkencave Kompjuterike dhe Inxhinieri

Programimi i avancuar, 01.07.2019

Emri, Mbiemri: ID:

Detyrat:

1. Cilët janë delegatët e deklaruar në Dot Net Framework, dhe që mund të përdoren menjëherë. (5 pikë)

Delegatët e gatshëm në Dot Net Framework janë Action, Func, Predicate. Gjithashtu edhe EventHandler etj.

delegate void Action();

delegate void Action<T1>(T1 p1);

delegate void Action<T1,T2>(T1 p1, T2 p2);

delegate Tout Action<Tout, T1>(T1 p1);

delegate Tout Action<Tout, T1, T2>(T1 p1, T2 p2); //etj

delegate bool Predicate<T1>(T1 p1);

2. Shpjegoni dallimin mes overriding dhe overloading . (5 pikë)

Overriding është mbishkrimi (ridefinimin) i metodës që është e trashëguar me një metodë të re me emrin e
njëjtë.

Overloading është prezenca e metodave me emër të njëjtë, por me listë të ndryshme të parametrave për nga
tipi dhe numri

3. A janë të lejuara deklarimet, komandat e mëposhtme: (përgjigju me PO ose JO) . (10 pikë)

a. IComparable<int> x = new Icomparable<int>(); Jo

b. Type1 x = new Type1(); // në qoftë se Type1 është një klasë abstrakte Jo
c. Type2 x = new Type3(); // në qoftë se Type3 është një klasë trashëgon nga Type2 Po
d. IType4 x = new Type5(); // në qoftë se Type5 është një klasë që implementon Po
interface-in IType4
e. Type5 x = new IType4(); // në qoftë se Type5 është një klasë që implementon Jo
interface-in IType4
4. Sqaroni tre modelet e programimit asinkron me anë të delegatëve! Qoftë me anë të ndonjë shembulli,
apo skice (10 pikë)
a) Wait-Until-Done: Në këtë model, përdoren vetëm metodat BeginInvoke dhe EndInvoke. EndInvoke
shkakton pritjen (bllokimin) në thread-in kryesor derisa të përfundojë thread-i i iniciuar me
BeginInvoke
b) Polling: Në këtë model, përmes IsCompleted, merret informata se a ka përfunduar thread-i i iniciuar
nga BeginInvoke. Varësisht prej statusit IsCompleted, thread-i kryesor kryen funksione të ndryshme
paralele
c) Callback: Në këtë model, thread-i kryesor e nis thread-in e ri (përmes BeginInvoke), dhe ia dërgon si
parametër metodën Callback (si delegat). Pastaj, thread-i i ri kur mbaron, e bën ekzekutimin e
metodës Callback. Metoda Callback ka për detyrë të bëjë përpunimin e rezultateve që janë
kompletuar nga thread-i i ri, që i merr përmes IndInvoke.

5. Çfarë janë delegatët (delegates)? Shkruani një shembull të përdorimit të tyre! . (10 pikë)
/* * Delegatët janë tip që na mundëson t’i referohemi metodave(funksioneve).
* Definimi i delegatit përcakton signaturën e funksionit.
* Meqë është një tip i ri, ai mund të përdoret për të deklaruar
* variabla si dhe të përdoret si parametër në funksione.
*/

delegate int delFn(int a); //deklaro delegatin

static int Katror(int x) { return x * x; } // kthen x ne katror
static int Dyfish(int x) { return x * 2; } // kthen x*2

static int Ekzekuto(int x, delFn f) // parametri f i tipit delegat

{
return f.Invoke(x); // ekzekuto funksionin prapa f-së
}
static void Main(string[] args)
{
delFn f1 = Katror; //variabla delegat qe referon tek funksioni Katror
delFn f2 = Dyfish; //variabla delegat qe referon tek funksioni Katror
int xHerex = f1.Invoke(4); // ekzekutimi i funksionit permes delegatit
int xHere2 = f2.Invoke(4); // percillen parametrat si dhe lexohet vlera kthyese
//ose
xHerex = Ekzekuto(3, Katror); //ketu percillet emri i funksionit si parameter
xHere2 = Ekzekuto(3, f2); //ketu si parameter eshte variabla f2
}
6. Përshkruani ciklin e përdorimit të Event-it, me një shembull të thjeshtë, duke deklaruar një klasë si
Subscriber, një tjetër si Publisher, bëni shkaktimin e ngjarjes, si dhe konsumimin e saj! . (10 pikë)

class CPublisher
{
public event EventHandler Ngjarja; //deklaro Event-in/Publish
public void Metoda()
{
Console.WriteLine("Filloi Metoda...");
if (DateTime.Now.Minute == 0 && Ngjarja != null)
Ngjarja(this, null); //Shkakto Event-in/Raise
}
}
class CSubscriber
{
CPublisher pub1 = new CPublisher();
public CSubscriber()
{
int curDay = DateTime.Now.Day;
pub1.Ngjarja += Sub1_Ngjarja; //Bashkengjit metoden/Subscribe,Attach
while (DateTime.Now.Day == curDay)
{
pub1.Metoda(); // Ekzekutimi i Metodes
Thread.Sleep(30 * 1000);
}
}
private void Sub1_Ngjarja(object sender, EventArgs e)
{
Console.WriteLine("Ora fiks: " + DateTime.Now.ToString());
Console.WriteLine("Filloi ngjarja");
}
}
class Program
{
static void Main(string[] args)
{
// Krijo nje subscriber qe ekzekutohet paralelisht
new Thread(() => new CSubscriber()).Start();
}
}

7. Është dhënë metoda Metoda1 e tipit void dhe pa parametra. Të tregohet se si mund të startohet 10
herë në mënyrë paralele, duke përdorur klasën Thread dhe metodat e saj. (10 pikë)
Zgjidhja:

static void Metoda1(){/* . . . . */}

static void Main(string[] args)
{
for(int i = 0; i < 10; i++)
{
Thread t = new Thread(Metoda1);
t.Start();
}
}
8. Shikoni programin në vazhdim. Tregoni çfarë shtypet në ekran (10 pikë)! Për sa kohë mbaron
ekzekutimi i plotë i tij (10 pikë)? Tregoni dallimin mes metodave Menyra1() dhe Menyra2() (10 pikë) .
(30 pikë)
class asinkron static void Main(string[] args)
{ {
public async Task<int> Mblidh(int a, int b) asinkron a = new asinkron();
{ Task t1 =
int c = a + b; Task.Run(()=>a.Menyra1());
await Task.Delay(1000 * c); t1.Wait();
Console.WriteLine("a+b=" + c); Task t2 =
return c; Task.Run(()=>a.Menyra2());
} t2.Wait();
public async Task Menyra1() Console.WriteLine("fund" );
{ }
int r1 = await Task.Run(() => Mblidh(1, 2));
Console.WriteLine(r1);
int r2 = await Task.Run(() => Mblidh(2, 3));
Console.WriteLine(r2);
}
public async Task Menyra2()
{
var t1 = Mblidh(4, 5);
var t2 = Mblidh(6, 7);
var tt = new Task<int>[] { t1, t2 };
int[] r1r2 = await Task<int>.WhenAll(t1, t2);
Console.WriteLine(r1r2[0]);
Console.WriteLine(r1r2[1]);
}
}

a+b=3
3
a+b=5
5
a+b=9
a+b=13
9
13
fund
Press any key to continue
Ekzekutimi i plotë zgjat si më poshtë::
Në Main, kemi task-un t1 që zgjat (1+2) + (2+3) sekonda, si dhe task-un t2 që zgjat
(6+7)sekonda. Këta 2 task-a ekzekutohen njëri pas tjetrit, paralel me thread-in kryesor.
Për këtë arsye komplet programi zgjat 21 sekonda.

Menyra1() ekzekuton 2 task, por ato i thirr njërën pas tjetrës, për këtë arsye zgjat
(1+2) + (2+3) sekonda, në total 8 sekonda.
Menyra2() ekzekuton task-et t1 dhe t2 në mënyrë paralele. E para përfundon pas (4+5)
sekondash, e dyta pas (6+7) sekondash. Pra në total 13 sekonda