Tenta 2023 Flashcards
- Vad är kärnidén bakom beroendeinjektion?
Välj ett alternativ:
- Att fokusera på skapandet av objekt istället för dess användande.
- Att kombinera ett objekts skapande med dess användning.
- Att separera ett objekts skapande från dess användning
- Att separera ett objekts skapande från dess användning.
Motivering:
- Kärnidén bakom beroendeinjektion är att separera ett objekts skapande från dess användning. Genom att använda beroendeinjektion kan vi skapa objekt oberoende av de specifika detaljerna för hur de används, vilket gör vår kod mer flexibel och underlättar testning och underhåll.
Vilken typ av beroendeinjektion används i koden?
1. interface IJumpBehavior
2. {
3. void Execute();
4. }
5.
6. class Player
7. {
8. IJumpBehavior jumpBehavior;
9.
10. public Player(IJumpBehavior jumpBehavior)
11. => this.jumpBehavior = jumpBehavior;
12.
13. public void SetJumpBehavior(IJumpBehavior jumpBehavior)
14. => this.jumpBehavior = jumpBehavior;
15.
16. public void Jump()
17. => jumpBehavior.Execute();
18. }
- Välj ett alternativ:
- Konstruktor-injektion och Egenskaps-injektion.
- Konstruktor-injektion och Metod-injektion.
- Metod-injektion och Egenskaps-injektion.
- Konstruktor-injektion och Metod-injektion.
Motivering:
- I koden används konstruktor-injektion för att tillhandahålla IJumpBehavior-beroendet vid skapandet av en instans av Player. Konstruktorn tar jumpBehavior som en parameter och sätter det när en ny Player skapas.
- Metoden Jump() i koden använder en form av metod-injektion. Beroendet jumpBehavior injiceras i Jump()-metoden och används där direkt för att utföra Execute()
I termer av Strategy Pattern, vilken roll spelar typen IWeaponBehavior?
1. interface IWeaponBehavior
2. {
3. void Attack();
4. }
5.
6. class Player
7. {
8. IWeaponBehavior behavior;
9.
10. public Player(IWeaponBehavior behavior)
11. => this.behavior = behavior;
12.
13. public void Attack()
14. => behavior.Attack();
15. }
- Välj ett alternativ:
- Konkret strategi
- Kontext
- Abstrakt strategi
- Abstrakt strategi
Motivering: Typen IWeaponBehavior representerar den abstrakta strategin i Strategy Pattern. Den definierar det gemensamma gränssnittet för alla konkreta strategier som implementerar olika vapenbeteenden (Attack). Genom att använda en abstrakt strategi tillåter mönstret att dynamiskt byta ut och bygga olika beteenden vid körning, vilket ökar flexibiliteten och möjliggör en enkel utökning av systemet genom att lägga till nya vapenbeteenden.
Vad blir resultatet av att köra följande program?
1. List<IA> list = new List<IA>() { new A(), new A(), new B() };
2.
3. foreach (IA a in list)
4. {
5. C c = new C(a);
6. c.Execute();
7. }
8.
9.
10. interface IA
11. {
12. void Run();
13. }
14.
15. class A : IA
16. {
17. public void Run() => Console.Write("x");
18. }
19.
20. class B : IA
21. {
22. public void Run() => Console.Write("y");
23. }
24.
25. class C
26. {
27. private IA a;
28.
29. public C(IA a)
30. => this.a = a;
31.
32. public void Execute()
33. => a.Run();
34. }
- Välj ett alternativ:
- Koden kompilerar inte.
- yxx
- xxy
- xxy
Motivering: När listan List< IA> skapas, fylls den med två instanser av A och en instans av B. Sedan genomgår en foreach-loop varje element i listan och skapar en ny instans av C med varje IA-objekt från listan och anropar sedan Execute-metoden. Eftersom C-konstruktorn tar en IA-parameter, kan den ta både A och B.
Så, när Execute-metoden anropas, utförs Run-metoden för varje IA-objekt. Eftersom Run-metoden för A skriver ut “x” och för B skriver ut “y”, blir resultatet “xxy”.
Vad ska ____ ersättas med för att programmet ska generera det angivna resultatet?
1. A a = new A(new B());
2. a.Execute();
3.
4. interface IStrategy
5. {
6. void Execute();
7. }
8.
9. class B : IStrategy
10. {
11. public void Execute()
12. => Console.WriteLine("B");
13. }
14.
15. class A
16. {
17. private IStrategy s;
18.
19. public A(IStrategy s)
20. => this.s = s;
21.
22. public void Execute()
23. => _ _ _ _
24. }
- Välj ett alternativ:
- this.Execute();
- s.Execute();
- a.Execute();
- s.Execute();
Motivering: För att korrekt anropa Execute-metoden från den instans som är lagrad i IStrategy-fältet s i klassen A, bör alternativ 2. s.Execute(); användas. Eftersom A har en komposition med IStrategy (tillhandahållen vid instansiering) kan Execute-metoden för den specifika strategin, som i detta fall är en instans av B, kallas korrekt genom att använda s.Execute();
Vilket påstående beskriver bäst varför komposition föredras över arv?
- Välj ett alternativ:
- Arv ger oss endast möjligheten att återanvända kod ifrån en superklass i dess subklasser.
- Komposition möjliggör återanvändning av kod ifrån en superklass i dess subklasser.
- Komposition ger oss möjligheten att återanvända kod ifrån en superklass i dess subklasser.
- Arv ger oss endast möjligheten att återanvända kod ifrån en superklass i dess subklasser.
Vilket påstående stämmer?
1. class A
2. {
3. B b;
4. public A(B b) => this.b = b;
5. }
6.
7. class B : A
8. {
9. public B() : base(null) { }
10. }
- Välj ett alternativ:
- A is-a B.
- A has-a B.
- B has-a A.
- A has-a B.
Motivering: I detta fall har klassen A en medlem av typen B med namnet b
Vad blir resultatet av att köra följande program?
1. Y y = new Y2(new X1());
2. Console.WriteLine(y.GetY());
3.
4. interface IX
5. {
6. string GetX();
7. }
8.
9. class X1 : IX
10. {
11. public string GetX() => "Green";
12. }
13.
14. class X2 : IX
15. {
16. public string GetX() => "Blue";
17. }
18.
19. abstract class Y
20. {
21. protected IX x;
22. public Y(IX x) => this.x = x;
23. public abstract string GetY();
24. }
25.
26. class Y1 : Y
27. {
28. public Y1(IX x) : base(x) { }
29. public override string GetY()
30. => x.GetX() + " Rectangle";
31. }
32.
33. class Y2 : Y
34. {
35. public Y2(IX x) : base(x) { }
36. public override string GetY()
37. => x.GetX() + " Circle";
38. }
- Välj ett alternativ:
- Green Rectangle
- Green Circle
- Blue Circle
- Green Circle
Motivering:
- Y y = new Y2(new X1()); skapar en instans av Y2 och skickar en instans av X1 som parameter.
- Inom Y2-klassen anropas x.GetX() där x är en instans av X1. Detta returnerar “Green”.
- Sedan läggs “ Circle” till och resultatet som skrivs ut är “Green Circle”.
Vad ska ____ ersättas med för att programmet ska generera det angivna resultatet?
1. AL x = new CL(new R());
2. Console.WriteLine(x.Exec());
3.
4. interface IR
5. {
6. string Exec();
7. }
8.
9. class R : IR
10. {
11. public string Exec() => "Concrete Right";
12. }
13.
14. abstract class AL
15. {
16. protected IR r;
17. public AL(IR r) => this.r = r;
18. public virtual string Exec()
19. => _ _ _ _
20. }
21.
22. class CL : AL
23. {
24. public CL(IR r) : base(r) { }
25. }
- Välj ett alternativ:
r.Exec();
this.r;
this.Exec();
r.Exec();
Motivering:
För att anropa Exec()-metoden från den instans av IR som är lagrad i r-fältet i klassen AL, bör r.Exec(); användas i rad 19. Detta möjliggör korrekt körning av Exec() för den specifika implementeringen av IR, som i detta fall är en instans av R.
Vad representerar T1 och T2 i Pair< T1,T2> i koden nedan?
1. class Pair<T1, T2>
2. {
3. public T1 Item1 { get; private set; }
4. public T2 Item2 { get; private set; }
5.
6. public Pair(T1 item1, T2 item2)
7. {
8. Item1 = item1;
9. Item2 = item2;
10. }
11. }
- Välj ett alternativ:
- Specifika datatyper som int eller string.
- Typ-parametrar som kan ersättas av valfri datatyp när den generiska typen konstrueras.
- Typ-argument som används istället för T1 och T2.
- Typ-parametrar som kan ersättas av valfri datatyp när den generiska typen konstrueras.
Motivering:
I koden representerar T1 och T2 generiska typ-parametrar, vilket innebär att de kan ersättas av valfria datatyper när en instans av den generiska klassen skapas. Det möjliggör skapandet av en flexibel och återanvändbar klass som kan hantera olika datatyper.
Kompilerar följande program?
1. Pair<int, string> pair = new Pair<int, string>("hello", 5);
2.
3. class Pair<T1, T2>
4. {
5. public T1 Item1 { get; set; }
6. public T2 Item2 { get; set; }
7.
8. public Pair(T1 item1, T2 item2)
9. {
10. Item1 = item1;
11. Item2 = item2;
12. }
13. }
- Välj ett alternativ:
- Nej, p.g.a. syntax-fel.
- Nej, p.g.a. typ-fel.
- Ja.
- Nej, p.g.a. typ-fel.
Motivering:
Ordningen för Pair är < int, string>.
Vi skickar dock in (“hello”, 5) vilket kommer orsaka typ-fel då string:en och int:en ligger i omvänd ordning.
Kompilerar följande program?
1. Apple apple = new Apple();
2. Box<Fruit> box = new Box<Fruit>(apple);
3. string variety = box.Item.Variety;
4.
5. class Fruit
6. {
7. public bool IsRipe { get; set; }
8. }
9.
10. class Apple : Fruit
11. {
12. public string Variety { get; set; }
13. }
14.
15. class Box<T>
16. {
17. public T Item { get; private set; }
18. public Box(T item) => Item = item;
19. }
- Välj ett alternativ:
- Nej, eftersom Box inte stödjer objekt av typ Apple.
- Nej, eftersom variabeln box och det objekt den pekar på är av typen Box< Fruit> och inte Box< Apple>.
- Ja.
- Nej, eftersom variabeln box och det objekt den pekar på är av typen Box< Fruit> och inte Box< Apple>.
Motivering:
Box< Fruit> och Box< Apple> är olika typer, även om Apple ärver från Fruit. I C# är generiska typer inte covarianta, vilket betyder att du inte kan använda en Box< Apple> där en Box< Fruit> förväntas.
- Så, felet ligger i att box är av typen Box< Fruit>, och den försöker referera till en instans av Box< Apple>
denna var fel
denna var fel
Vad ska ____ ersättas med för att programmet ska generera det angivna resultatet?
1. Calculator calc = new Calculator();
2. Console.WriteLine(calc.Add(10, 20));
3.
4. interface ICalculator<T>
5. {
6. T Add(T a, T b);
7. }
8.
9. class Calculator : ICalculator<int>
10. {
11. _ _ _ _
12. }
30.
- Välj ett alternativ:
- public int Add(T a, T b) => a + b;
- public int Add(int a, int b) => a + b;
- public T Add(T a, T b) => a + b;
- public int Add(int a, int b) => a + b;
Motivering: Eftersom Calculator implementerar ICalculator< int>, behöver metoden Add ha samma signatur som definierats i gränssnittet ICalculator< T>. I detta fall är T ersatt med int, så metoden måste acceptera två int-parametrar och returnera en int.
Kompilerar följande program?
1. class Factory<T> where T : class
2. {
3. public T CreateItem() => new T();
4. }
Välj ett alternativ:
- Ja, eftersom alla typer har en parameterlös konstruktor.
- Ja, eftersom alla klasser har en parameterlös konstruktor.
- Nej, eftersom T inte nödvändigtvis har en parameterlös konstruktor.
- Nej, eftersom T inte nödvändigtvis har en parameterlös konstruktor.
Motivering: När du försöker skapa en instans av T med new T() antar detta att T har en parameterlös konstruktor, vilket inte är garanterat när du använder en generisk typparameter. Det är därför kompilatorn inte kommer att tillåta detta om inte T är begränsat med new()-begränsningen för att indikera att T måste ha en parameterlös konstruktor.
