static void Main(string[] args)
{
IWorker[] workers = new IWorker[3]
{
new Managaer(), // bu yolla bir nesneye atama yapmadan kullanabileceğimiz çalışma işlemi başlattık.
new Worker(),
new Robot()
};
foreach (var worker in workers)
{
worker.Work(); // Manager,Worker,Robot interface den impemente ettikleri work metodunu kendi içlerinde çalıştırır.
}
IEat[] eats = new IEat[2]
{
new Managaer(),
new Worker() // Robot tanımlanamaz çünkü robot class'ını IEat interface ne implemente etmedik.
};
foreach (var eat in eats)
{
eat.Eat();
}
}
static void Main(string[] args)
{
//Bir Şirkette 3 tip çalışan var: işciler yöneticiler Robotlar bir class birden fazla interface implamantation yapılabilir.
IWorker[] workers = new IWorker[3]
{
new Manager(),
new worker(),
new Robot()
};
foreach (var worker in workers)
{
worker.Work();
}
IEat[] eats = new IEat[2]
{
new worker(),
new Manager()
};
foreach (var eat in eats)
{
eat.Eat();
}
Console.ReadKey();
}
static void Main(string[] args)
{
IWorker[] workers = new IWorker[3]
{
new Manager(),
new Worker(),
new Robot()
};
foreach (var worker in workers)
{
worker.Work();
}
IEat[] eats = new IEat[2]
{
new Manager(),
new Worker()
};
foreach (var eat in eats)
{
eat.Eat();
}
}
static void Main(string[] args)
{
IWorker[] workers = new IWorker[3]
{
new Worker(),
new Robot(),
new Manager()
};
foreach (IWorker worker in workers)
{
worker.Work();
}
IEat[] eats = new IEat[2]
{
new Worker(),
new Manager()
};
foreach (IEat eat in eats)
{
eat.Eat();
}
IGetSalary[] getSalary = new IGetSalary[2]
{
new Worker(),
new Manager()
};
foreach (IGetSalary getSalarys in getSalary)
{
getSalarys.GetSalary();
}
Console.ReadKey();
}
static void Main(string[] args)
{
IWorker[] worker = new IWorker[3]
{
new Worker(),
new Manager(),
new Robot()
};
foreach (var wrks in worker)
{
wrks.Work();
}
IEat[] eats = new IEat[2]
{
new Manager(),
new Worker()
};
foreach (var eat in eats)
{
eat.Eat();
}
Console.ReadLine();
}
static void Main(string[] args)
{
//C# method is Invariant
MusicCreater mu1 = musicCreater;
//MetalCreater me1 = mu1;
MetalCreater me2 = metalCreater;
//MusicCreater mu2 = me2;
//Convariance
//Creater<Music> mu3 = musicCreater;
//Creater<Metal> me3 = mu3;//get music include metal or classic or pop NG
Creater <Metal> me4 = metalCreater;
Creater <Music> mu4 = me4; //get metal, metal is music
MusicCreater mu5 = metalCreater; // (out is not nessary)
//MetalCreater me5 = musicCreater;
CreaterClass <Metal> me6 = new CreaterClass <Metal>();
ICreate <Music> imusic = me6;
//CreaterClass<Music> mu6 = new CreaterClass<Music>();
//ICreate<Metal> imetal = mu6;
//Contravariance
//Eater<Bamboo> ba1 = x => { };
//Eater<Food> fo1 = ba1; // dispose food, not only bamboo but also other thing is food too
Eater <Food> fo2 = x => { };
Eater <Bamboo> ba2 = fo2; // dispose bamboo, bamboo is food
//EaterClass<Bamboo> ba3 = new EaterClass<Bamboo>();
//IEat<Food> ifood = ba3;
EaterClass <Food> fo3 = new EaterClass <Food>();
IEat <Bamboo> ibamboo = fo3;
}
static void Main(string[] args)
{
IEat[] eats = new IEat[2]
{
new Manager(),
new Worker()
};
foreach (var eat in eats)
{
eat.Eat();
}
}
public virtual void ToEat(IEat eat)
{
if (AnimalState == AnimalState.Dead || IsFeedUp)
{
return;
}
eat.EatState = EatState.Eated;
IsFeedUp = true;
LifeTimeWithoutEat = maxLifeTimeWithoutEat;
TimeToHunger = maxTimeToHunger;
}
static void AtCafetearea(IEat worker)
{
Console.WriteLine("At Cafeate Area!");
try
{
worker.StartEat();
worker.StopEat();
}
catch (Exception e)
{
Console.WriteLine("Message:" + e.Message);
}
}
static void Main(string[] args)
{
IWorker[] workers = new IWorker[3]
{
new Manager(),
new Worker(),
new Robot()
};
IEat[] eats = new IEat[2]
{
new Manager(),
new Worker()
};
}
static void Main(string[] args)
{
int count = 6;
IEat[] eats = new IEat[count];
for (int i = 0; i < count / 2; i++)
{
eats[i] = new Mushroom((Mushroom.Mushrooms) i);
eats[i + count/2] = new Berry((Berry.Berries) i);
}
foreach (var eat in eats)
{
Console.WriteLine("{0} is {1}", eat.ToString(), eat.Eat());
}
Console.ReadLine();
}
static void Main(string[] args)
{
IWorker[] workers = new IWorker[] { new Manager(), new Worker(), new Robot() };
foreach (var worker in workers)
{
worker.Work();
}
IEat[] eats = new IEat[] { new Manager(), new Worker() };
foreach (var eat in eats)
{
eat.Eat();
}
IGetSalary[] getSalary = new IGetSalary[] { new Manager(), new Worker() };
foreach (var salary in getSalary)
{
salary.GetSalary();
}
}
static void Main(string[] args)
{
//SOLID
//Interface Segregation
IWorker[] workers = new IWorker[] { new Manager(), new Worker(), new Robot() };
foreach (IWorker worker in workers)
{
worker.Work();
}
IEat[] eats = new IEat[] { new Worker(), new Manager() };
foreach (IEat eat in eats)
{
eat.Eat();
}
}
static void Main(string[] args)
{
IWorker[] workers = new IWorker[] //müdür , çalışan ve robot çalışır
{
new Worker(),
new Manager(),
new Robot()
};
foreach (var worker in workers)
{
worker.Work(); //tüm çalışanlar çalışsın
}
IEat[] eats = new IEat[] //robot yemez
{
new Manager(),
new Worker() //robot gelmez çünkü yemez IEat olarak tanımlamadık.
};
}
static void Main(string[] args)
{
//SOLID => Interface Segregation
IWorker[] workers = new IWorker[]
{
new Manager(),
new Worker(),
new Robot()
};
foreach (var worker in workers)
{
worker.Work();
}
IEat[] eats = new IEat[]
{
new Manager(),
new Worker()
};
foreach (var eat in eats)
{
eat.Eat();
}
ISalary[] salaries = new ISalary[]
{
new Manager(),
new Worker()
};
foreach (var salary in salaries)
{
salary.GetSalary();
}
Console.ReadLine();
}
static void Main(string[] args)
{
IWorker[] workers = new IWorker[3]
{
new Manager(),
new Worker(), //çalışma emrini bütün çalışanlara verdik.
new Robot(),
};
foreach (var worker in workers)
{
worker.Work();
}
IEat[] eats = new IEat[2]
{
new Manager(),
new Worker(), // yeme emrini robotlar hariç hepsine verdik.
};
}
static void Main(string[] args)
{
IWorker[] workers = new IWorker[3]
{
new Manager(),
new Worker(),
new Robot()
};
foreach (var worker in workers)
{
worker.Work();
}
IEat[] eat = new IEat[2]
{
new Manager(),
new Worker()
//new Robot() tanımlı değil
};
}
static void Main(string[] args)
{
IWorker[] workers = new IWorker[3]
{
new Manager(),
new Worker(),
new Robot(),
};
foreach (var worker in workers)
{
worker.Work();
}
IEat[] eats = new IEat[]
{
new Manager(),
new Worker(),
// new Robot(), eat içinde tanımlı olmadığından çağırılamaz.
};
}
static void Main(string[] args)
{
IWorker[] workers = new IWorker[]
{
new Worker(),
new Manager(),
new Robot(),
};
foreach (var worker in workers)
{
worker.Work();
}
Console.WriteLine("---------------------------");
IEat[] eats = new IEat[]
{
new Manager(),
new Worker(),
};
foreach (var eat in eats)
{
eat.Eat();
}
Console.WriteLine("---------------------------");
ISalary[] salaries = new ISalary[]
{
new Manager(),
new Worker(),
};
foreach (var salary in salaries)
{
salary.GetSalary();
}
}
static void Main(string[] args)
{
Console.ReadLine();
IWorker[] workers = new IWorker[3]
{
new Manager(),
new Worker(),
new Robot()
};
foreach (var worker in workers)
{
worker.Work();
}
IEat[] eats = new IEat[2]
{
new Worker(),
new Manager()
};
}
/*Bilgi; Bir class birden fazla interface implamente edebiliri. Bunu kullanma nedenimiz bazı classların bazı interface
* araçlarına ihtiyaç duymamasıdır. Örneğin 1 robot yemek yiyemez.*/
public static void InterfaceImplamente()
{
IWorker[] workers = new IWorker[3]
{
new Worker(),
new Manager(),
new Robot()
};
foreach (var worker in workers)
{
worker.Work();
}
IEat[] eats = new IEat[2]
{
new Worker(),
new Manager()
};
foreach (var eat in eats)
{
eat.Eat();
}
}
static void Main(string[] args)
{
IWorker[] workers = new IWorker[3]
{
new Worker(),
new Manager(),
new Robot()
};
IEat[] eaters = new IEat[2]
{
new Worker(),
new Manager()
};
IGetSalary[] salaries = new IGetSalary[2]
{
new Worker(),
new Manager()
};
}
static void Main(string[] args)
{
//interface lerin doğru planlanması
IWorker[] workers = new IWorker[3]
{
new Manager(),
new Worker(),
new Robot()
};
foreach (var worker in workers)
{
worker.Work();
}
IEat[] eats = new IEat[2]
{
new Manager(),
new Worker()
};
foreach (var eat in eats)
{
eat.Eat();
}
}
static void Main(string[] args)
{
IWorker[] workers = new IWorker[]
{
new Manager(),
new Worker(),
new Robot()
};
foreach (var worker in workers)
{
worker.Work();
}
IEat[] eats = new IEat[] { new Worker(), new Manager() };
// SOLID
//Single responsibility principle: Bir sınıfın yapması gereken yalnızca BİR işi olması gerekir.
//Open/closed principle: Bir sınıf davranışını değiştirmemeli ve yeni özellikle kazanabiliyor olmalıdır.
//Liskov substitution principle: Kodlarda bir değişiklik yapmadan alt sınıfları üst sınıfların yerine kullanabilmeliyiz.
//Interface segregation principle: Sorumlulukları tek bir arayüze toplamak yerine birden fazla arayüz oluşturmalıyız.
//Dependency inversion principle: Sınıflar arası bağımlılık az olmalı, özellikle üst seviye sınıflar alt seviyelere bağımlı olmamalı.
Console.WriteLine("Hello World!");
}
static void Main(string[] args)
{
IWorker[] workers = new IWorker[3]
{
new Manager(),
new Worker(),
new Robot()
};
foreach (var worker in workers)
{
worker.Work(); // Tüm personle "work" emri verilmiş oluyor.
}
Console.WriteLine(" ");
IEat[] eats = new IEat[2]
{
new Worker(),
new Manager()
};
foreach (var eat in eats)
{
eat.Eat();
}
Console.WriteLine(" ");
ISalary[] salaries = new ISalary[2]
{
new Worker(),
new Manager()
};
foreach (var salary in salaries)
{
salary.GetSalary();
}
}
static void Main(string[] args)
{
IWorker[] workers = new IWorker[3]
{
new Manager(),
new Worker(),
new Robot()
};
foreach (var item in workers)
{
item.Work();
}
IEat[] eats = new IEat[2]
{
new Manager(),
new Worker()
};
foreach (var item2 in eats)
{
item2.Eat();
}
ISalary[] salaries = new ISalary[2]
{
new Manager(),
new Worker()
};
foreach (var item3 in salaries)
{
item3.GetSalary();
}
}
static void Main(string[] args)
{
//List<IWorker> workers = new List<IWorker> { new Manager(),new Worker(),new Robot()};
IWorker[] workers = new IWorker[3]
{
new Manager(),
new Worker(),
new Robot()
};
foreach (var worker in workers)
{
worker.Work();
}
IEat[] eats = new IEat[2]
{
new Worker(),
new Manager()
};
foreach (var eat in eats)
{
eat.Eat();
}
Console.ReadLine();
}
/*
*
* interfacenin doğru planması gerektiğini söyleyen S O L I D 'in "I" harfini yaptık.
* Yazılım geliştirmenin 5 temel prensibi vardır S O L I D
* S — Single-responsibility principle
* ÖZET: Bir sınıf (nesne) yalnızca bir amaç uğruna değiştirilebilir, o da o sınıfa yüklenen sorumluluktur, yani bir sınıfın(fonksiyona da indirgenebilir) yapması gereken yalnızca bir işi olması gerekir.
* O — Open-closed principle
* ÖZET: Bir sınıf ya da fonksiyon halihazırda var olan özellikleri korumalı ve değişikliğe izin vermemelidir. Yani davranışını değiştirmiyor olmalı ve yeni özellikler kazanabiliyor olmalıdır.
* L — Liskov substitution principle
* ÖZET: Kodlarımızda herhangi bir değişiklik yapmaya gerek duymadan alt sınıfları, türedikleri(üst) sınıfların yerine kullanabilmeliyiz.
* I — Interface segregation principle
* ÖZET: Sorumlulukların hepsini tek bir arayüze toplamak yerine daha özelleştirilmiş birden fazla arayüz oluşturmalıyız.
* D — Dependency Inversion Principle
* ÖZET: Sınıflar arası bağımlılıklar olabildiğince az olmalıdır özellikle üst seviye sınıflar alt seviye sınıflara bağımlı olmamalıdır.
*
*/
static void Main(string[] args)
{
IWorker[] workers = new IWorker[3]
{
new Worker(),
new Manager(),
new Robot()
};
foreach (var worker in workers)
{
worker.Work();
}
IEat[] eats = new IEat[2]
{
//burada robot gelmez çünkü biz robotu tanımlamadık!!!
new Manager(),
new Worker()
};
foreach (var eat in eats)
{
eat.Eat();
}
}
static void Main(string[] args)
{
//şirketin 3 tane çalışan olsun. işci, yönetici, robotlar hepsinin ortak özelliği worker olması. Ve ortak metotları Work,Eat,GetSalary
// Fakat robot eat ve GetSalary olmaz. Bu yüzden Çoklu İmplementasyon yapmamız gerekti.
Manager manager = new Manager();
Worker worker = new Worker();
Robot robot = new Robot();
IWorker[] workers = new IWorker[3] {
manager, worker, robot
};
foreach (var worker1 in workers)
{
worker1.Work();
}
IEat[] eats = new IEat[2] {
manager, worker
};
foreach (var eat in eats)
{
eat.Eat();
}
}
static void Main(string[] args)
{
//SOLID - Interface Segregation
IWorker[] workers = new IWorker[]
{
new Manager(),
new Worker(),
new Robot()
};
foreach (var item in workers)
{
item.Work();
}
IEat[] eats = new IEat[]
{
new Manager(),
new Worker()
};
foreach (var item in eats)
{
item.Eat();
}
}
private static void MultiImplementationOfInterfaces()
{
// Bir şirket : işçiler, yöneticiler, robotlar
IWorker[] workers = new IWorker[]
{
new Manager(),
new Employee(),
new Robot()
};
// Interfacelerin metodları tüm kullanıcıların kullanacağı şekilde doğru planlanmalıdır,
// İçi boş veya kullanılmayan metodu olmamalıdır.
// SOLID : Yazılım geliştirme prensipleridir.
// I: Interface Aggregation -- şuanki örneğimiz
// S: Single Responsibility
// O: Open-closed
// L: Liskow Substitution
// D: Dependency Inversion
foreach (var worker in workers)
{
worker.Work(); // Tüm personellere çalış emri verilmiş olur!
}
IEat[] eats = new IEat[] //IEat interface'inin Robot implement etmediği için, kullanılamaz.
{
new Manager(),
new Employee()
//new Robot()
};
foreach (var eat in eats)
{
eat.Eat(); // Robot dışındaki tüm personellere yeme emri verilir.
}
}
