Skip to content

Commit 0fcd052

Browse files
buraksenyurtburaksenyurt
committed
Added chatper 04 topics
1 parent 63c1a30 commit 0fcd052

8 files changed

+391
-5
lines changed

‎Chapter03/HttpManager.cs

+1
Original file line numberDiff line numberDiff line change
@@ -38,6 +38,7 @@ Şu anki senaryoda base ile Exception sınıfı ifade edilir.
3838
public InvalidUrlException(string url)
3939
: base($"{url} bilgisi geçersiz.")
4040
{
41+
4142
}
4243
}
4344
}

‎Chapter03/Program.cs

+6-4
Original file line numberDiff line numberDiff line change
@@ -33,17 +33,19 @@ static void Main(string[] args)
3333

3434
// throw new ArgumentException("Argüman hatası");
3535

36-
//var silo = new HttpManager();
37-
//var result = silo.Send("http://movies.api/action/12", "");
38-
//Console.WriteLine(result);
36+
// var silo = new HttpManager();
37+
// var result = silo.Send("http://movies.api/action/12", "");
38+
// Console.WriteLine(result);
3939

4040
/*
4141
Plane is a GameObject.
4242
4343
vecihi değişkeni üzerinden GameObject'teki X,Y özelliklerine erişebilir
4444
Draw metodunu çağırabiliriz ve ayrıca kendi metotlarını da kullanabiliriz.
4545
*/
46-
Plane vecihi = new Plane { X = 10, Y = 20 };
46+
47+
Plane vecihi = new() { X = 10, Y = 20 };
48+
// decimal salary = 1000.50M;
4749
vecihi.Draw(); //base class metodu
4850
vecihi.Fire(); // kendi metodu
4951

‎Chapter04/AbstractSampleApplication.cs

+181
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,181 @@
1+
namespace Chapter04
2+
{
3+
public struct Vector2D
4+
{
5+
public int X { get; set; }
6+
public int Y { get; set; }
7+
}
8+
/*
9+
abstract üyeler(members) diğer üyeler gibi iş yapan kod blokları içermezler
10+
abstract üyeler, abstract sınıf içerisinde olabilirler
11+
abstract sınıflar new operatörü ile örneklenemez (normal bir sınıftan en büyük farkı budur)
12+
*/
13+
public abstract class GameEntity
14+
{
15+
protected Guid Id { get; private set; } // Read-only ve sadece türeyen tipler erişebilir
16+
public Vector2D Position { get; private set; } // Read-only
17+
/*
18+
GameEntity construct metodu protected erişim belirleyicisi ile tanımlanmıştır.
19+
Buna göre sadece türeyen sınıflardan erişilebilir.
20+
*/
21+
protected GameEntity(Vector2D position)
22+
{
23+
Id = Guid.NewGuid();
24+
Position = position;
25+
}
26+
/*
27+
Draw ve Update metotlarının virtual versiyondan önemli bir ayrımları var.
28+
virtual kullanımında türeyen türler isterlerse bu davranışını override edebiliyorlar.
29+
Burada ise türeyen türlerin mutlaka bu davranışı yazması isteniyor
30+
*/
31+
public abstract void Draw(); // Dikkat! Method Body yok
32+
public abstract void Update();
33+
}
34+
35+
public class Vehicle
36+
: GameEntity
37+
{
38+
public Vehicle(Vector2D position)
39+
: base(position)
40+
{
41+
}
42+
public override void Update()
43+
{
44+
Console.WriteLine($"{base.Id} - Vehicle update operasyonu");
45+
}
46+
public override void Draw()
47+
{
48+
Console.WriteLine($"{base.Id} - Vehicle draw operasyonu");
49+
}
50+
}
51+
52+
public class Invader
53+
: GameEntity
54+
{
55+
public Invader(Vector2D position)
56+
: base(position)
57+
{
58+
}
59+
public override void Update()
60+
{
61+
Console.WriteLine($"{base.Id} - Invader update operasyonu");
62+
}
63+
public override void Draw()
64+
{
65+
Console.WriteLine($"{base.Id} - Invader draw operasyonu");
66+
}
67+
}
68+
69+
/*
70+
Örnekteki türetmeye dahil olan türlerin yönetileceği bir sınıfa ihtiyacımız olabilir.
71+
Mesela oyun sahasındaki tüm nesneler için draw ve update operasyonlarını çağıran fonksiyonellikler içerebilir
72+
*/
73+
public class World
74+
{
75+
public string Title { get; set; }
76+
// entities özelliği, GameEntity türünden n sayıda nesne içerebilecek bir koleksiyondur.
77+
private readonly List<GameEntity> entities = [];
78+
79+
// Bu metot sembolik olarak levelName isimli seviyeyi biryerden alıyor ve buna göre oyun nesnelerini sahaya yerleştiriyor
80+
// Saha dediğimiz yer aslında entitites isimli Liste.
81+
public void LoadLevel(string levelName)
82+
{
83+
/*
84+
Beginner
85+
86+
+ + + + + + + + + + + + + + +
87+
+ + + + + + + + + +
88+
+ + + + + + + + + + +
89+
+ V +
90+
+ S S P +
91+
+ +
92+
+ + + + + + +
93+
+ + + + + + + + + + + + + + +
94+
95+
Pro
96+
97+
+ + + + + + + + + + + + + + +
98+
+ + + V + S + + + +
99+
+ + + + + + + + + S +
100+
+ S V +
101+
+ S S +
102+
+ P S +
103+
+ + + + + S + S +
104+
+ + + + + + + + + + + + + + +
105+
106+
*/
107+
Console.WriteLine($"{levelName} is loading...");
108+
109+
var blueCar = new Vehicle(new Vector2D { X = 10, Y = 20 });
110+
var greenPlane = new Vehicle(new Vector2D { X = 100, Y = 200 });
111+
entities.AddRange([blueCar, greenPlane]);
112+
113+
var invaders = new Invader[10];
114+
for (int i = 0; i < 10; i++)
115+
{
116+
invaders[i] = new Invader(new Vector2D { X = i * 2, Y = 0 });
117+
}
118+
entities.AddRange(invaders);
119+
}
120+
121+
//TODO@Everyone Yeni bir level'a nasıl geçeceğiz?
122+
public void ChangeLevel(string levelName)
123+
{
124+
}
125+
126+
/*
127+
GameEntity kendisinden türeyen Vehicle ve Invader gibi nesneler için ortak davranışlar tanımlamıştır(Draw ve Update)
128+
Dolayısıla bu davranışlar üzerinen polimorfik hareket edebilir.
129+
Yani, T anında kendisine atanan nesne gibi davranış gösterebilir.
130+
*/
131+
public void DrawAll()
132+
{
133+
foreach (var entity in entities)
134+
{
135+
entity.Draw();
136+
}
137+
}
138+
public void UpdateAll()
139+
{
140+
foreach(var entity in entities)
141+
{
142+
entity.Update();
143+
}
144+
}
145+
146+
public void SaveGame()
147+
{
148+
//TODO@everyone Oyunun son durum bilgisi nereye kaydedilecek?
149+
// Dosya sistemine kayıt edilebilir.
150+
// Ama bu mobil uygulama olsun bu durumda Cloud'a da kayıt edebilirim
151+
// Veya text tabanlı dosya değil de bir veritabanına kayıt edebilirim
152+
// Ya da farklı bir kayıt sistemi olabilir(henüz icat edilmemiş)
153+
}
154+
}
155+
156+
public static class AbstractSampleApplication // statik sınıflar tanımlandıkları nesnenin örneğine ihtiyaç duymadan kullanılabilirler (Console.WriteLine gelsin aklınıza)
157+
{
158+
public static void Run()
159+
{
160+
var gameWorld = new World { Title = "Space Invaders Beginner Level" };
161+
gameWorld.LoadLevel("Beginner");
162+
for (; ; )
163+
{
164+
Thread.Sleep(5000); // Sembolik olarak 5 saniye duraklatma. Sanki bir oyun motoru döngüsündeymişçesine
165+
gameWorld.UpdateAll();
166+
gameWorld.DrawAll();
167+
// t+n zamanında oyunun o anki tüm içeriğini kaydedeceğiz
168+
}
169+
170+
//// GameEntity gameEntity = new GameEntity(); // GameEntity abstract sınıf olduğundan new operatörü ile örneklenemez
171+
//var blueCar = new Vehicle(new Vector2D { X = 10, Y = 20 });
172+
//var greenPlane = new Vehicle(new Vector2D { X = 100, Y = 200 });
173+
//var invaders = new Invader[10];
174+
//for (int i = 0; i < 10; i++)
175+
//{
176+
// invaders[i] = new Invader(new Vector2D { X = i * 2, Y = 0 });
177+
//}
178+
//// var car = new Vehicle(); // Vehicle ve Invader türleri base constructor'ı kullanmak zorunda olduklarından default constructor ile örneklenemezler
179+
}
180+
}
181+
}

‎Chapter04/Chapter04.csproj

+10
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,10 @@
1+
<Project Sdk="Microsoft.NET.Sdk">
2+
3+
<PropertyGroup>
4+
<OutputType>Exe</OutputType>
5+
<TargetFramework>net8.0</TargetFramework>
6+
<ImplicitUsings>enable</ImplicitUsings>
7+
<Nullable>enable</Nullable>
8+
</PropertyGroup>
9+
10+
</Project>

‎Chapter04/InterfaceSampleApplication.cs

+134
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,134 @@
1+
namespace Chapter04
2+
{
3+
/*
4+
Türeyen türlerin mutlaka uyması gereken kuralları söylemenin bir diğer yolu da Interface tipinden yararlanmaktır.
5+
Interface türü ile de çok biçimlilik sağlanabilir yani bir interface kendisini uygulayan nesneleri taşıyabilir,
6+
onlara tanımladığı davranışları işletebilir.
7+
*/
8+
public abstract class GameObject
9+
{
10+
protected Guid Id { get; private set; }
11+
public Vector2D Position { get; private set; }
12+
protected GameObject(Vector2D position)
13+
{
14+
Id = Guid.NewGuid();
15+
Position = position;
16+
}
17+
void GetSummary()
18+
{
19+
}
20+
}
21+
22+
/*
23+
abstract türlerden farklı olarak interface tipi sadece davranış tanımlar(Contract)
24+
yani hiçbir şekilde iş yapan kodlar içermez.
25+
IPlayable interface tipi Draw ve Update isimli iki metot tanımlar.
26+
Bu interface türünü uygulayan her tür bu metotları yazmak zorundadır.
27+
Interface türü, SOLID prensiplerinden Depdency Inversion içerisinde de sıklıkla geçer.
28+
Bağımlılıkları tersine çevirmek için kullanılır.
29+
*/
30+
interface IPlayable
31+
{
32+
void Draw(); // public, protected, private vb erişim belirleyicileri de(access modifiers) içermez çünkü doğal olarak herkese açıktır
33+
void Update();
34+
}
35+
36+
/*
37+
Wall sınıf hem bir GameObject türüdür hem de IPlayable davranışlarına sahiptir.
38+
Bir sınıfa birden fazla interface uyarlanabilir ama birden fazla sınıftan türetilemez.
39+
*/
40+
public class Player
41+
: GameObject, IPlayable
42+
{
43+
public string Name { get; set; }
44+
public Player(Vector2D position)
45+
: base(position)
46+
{
47+
}
48+
public void Draw()
49+
{
50+
Console.WriteLine($"{Id} player - is drawing...");
51+
}
52+
53+
public void Update()
54+
{
55+
Console.WriteLine($"{Id} player - is updating...");
56+
}
57+
}
58+
59+
public class Tower
60+
: GameObject, IPlayable
61+
{
62+
public int Health { get; set; }
63+
public Tower(Vector2D position)
64+
: base(position)
65+
{
66+
}
67+
public void Draw()
68+
{
69+
Console.WriteLine($"{Id} tower - is drawing...");
70+
}
71+
72+
public void Update()
73+
{
74+
Console.WriteLine($"{Id} tower - is updating...");
75+
}
76+
}
77+
78+
public class Wall
79+
: IPlayable
80+
{
81+
public string Color { get; set; }
82+
public void Draw()
83+
{
84+
Console.WriteLine($"Wall is drawing...");
85+
}
86+
87+
public void Update()
88+
{
89+
Console.WriteLine($"Wall is updating...");
90+
}
91+
}
92+
93+
public class Engine
94+
{
95+
private readonly List<IPlayable> playables = [];
96+
97+
// Bu fonksiyon aslında oyun motorunda olmaz(Eğitimde sadece simülasyon için kullandık)
98+
public void LoadLevel(string level)
99+
{
100+
Console.WriteLine($"{level} içeriği yükleniyor");
101+
102+
playables.Add(new Tower(new Vector2D { X = 10, Y = 4 }) { Health = 100 });
103+
playables.Add(new Player(new Vector2D { X = 5, Y = 5 }) { Name = "Prince of Persia" });
104+
playables.Add(new Wall() { Color = "Black" });
105+
playables.Add(new Wall() { Color = "Red" });
106+
}
107+
public void Run()
108+
{
109+
/*
110+
Abstract sınıflarda olduğu interface tipleri de new operatörü örneklenemez
111+
Hatta interface tamamen polimorfik(bukalemun) bir türdür. Kendisinde tanımlanan davranışları yazmış nesneler gibi hareket eder
112+
113+
Aşağıdaki döngüde GameEngine nesnesindeki playables isimli List<IPlayable> koleksiyonu dönülürken,
114+
playable değişkenine hangi türeyen nesne gelirse onun Update ve Draw metotları çağrılır.
115+
*/
116+
117+
foreach (IPlayable playable in playables)
118+
{
119+
playable.Update();
120+
playable.Draw();
121+
}
122+
}
123+
}
124+
125+
public static class InterfaceSampleApplication
126+
{
127+
public static void Run()
128+
{
129+
var gameEngine = new Engine();
130+
gameEngine.LoadLevel("Beginner");
131+
gameEngine.Run();
132+
}
133+
}
134+
}

0 commit comments

Comments
 (0)