C# programlama dilinde, Clean code ve SOLID prensiplerinin önemi büyüktür Bu prensipler, kodun okunabilirliği ve bakımının kolaylaştırılması açısından önemlidir Clean code, kod tekrarının en aza indirgenmesine ve kodun daha az hata yapmasına olanak sağlayan DRY ilkesini de içerir SOLID prensipleri ise tek sorumluluk ilkesi SRP, açık kapalı ilkesi OCP, Liskov'un yerine koyma ilkesi LSP, arayüz ayırma ilkesi ISP ve bağımlılık tersine çevirme ilkesi DIP gibi prensiplerden oluşur Bu prensipler sayesinde, kod daha okunaklı, anlaşılır ve bakımı daha kolay bir hale gelir Tek sorumluluk prensibi örneğinde olduğu gibi, sınıfların yalnızca tek bir işlevi olması gerekmektedir Örnek bir uygulamada ise, e-ticaret sitesi tasarımında sınıfların kendi görevleriyle ilgili kodlara sahip ol
C# programlama dili ile clean code ve SOLID prensiplerine uygun yazılımlar geliştirmek oldukça önemlidir. Clean code, kod kalitesini arttırmayı ve güncelleştirmeleri kolaylaştırmayı amaçlar. Bu prensipler, kodun daha anlaşılır ve kolay bakım yapılabilir olmasını sağlar.
SOLID, yazılım tasarımını daha organize hale getiren 5 prensipten oluşan bir yapıdır. Single Responsibility Principle (SRP), Liskov Substitution Principle (LSP), Open/Closed Principle (OCP), Interface Segregation Principle (ISP) ve Dependency Inversion Principle (DIP) isimleriyle bilinen bu prensipler, yazılım tasarımının geliştirilmesinde büyük rol oynamaktadır.
Bu makale, clean code ve SOLID prensiplerinin C# kullanılarak nasıl uygulanabileceği hakkında önemli bilgiler içermektedir. İlerleyen bölümlerde her bir prensip detaylı bir şekilde incelenecek ve örnek uygulamalarla gösterilecektir. Bu sayede okuyucular, kod kalitesini arttırmanın ve daha esnek yazılımlar geliştirmenin inceliklerini öğreneceklerdir.
Clean Code Nedir?
Clean Code, programlama dilinde yapılan işlemlerin en etkili ve en doğru şekilde gerçekleştirilmesini sağlamak için belirlenmiş kurallar dizisidir. Temiz kod yazımı, kod okunabilirliğini artırır ve bakımı kolaylaştırır. Bu nedenle, yazılım tasarımından uygulamaya kadar her aşamada temiz kod yazmak büyük bir önem taşır.
Bir diğer önemli prensip olan DRY (Don't Repeat Yourself) ilkesi de temiz kod yazımında dikkate alınmalıdır. Bu prensip, kod tekrarını en aza indirerek, kodun daha az hata yapmasını ve daha az bakım gerektirmesini sağlar. Kod tekrarı yapmak, gereksiz kod blokları oluşturur ve kodun okunabilirliğini zorlaştırır. DRY ilkesi, kodun daha az tekrarını sağlayarak, daha önce yazılmış kodlarınızı yeniden kullanmanıza ve kodun daha az hata yapmasını sağlamak için birleştirilmiş basit ve anlaşılabilir modüllere ayrılmasına yardımcı olur.
SOLID Nedir?
SOLID, yazılım geliştirme için temel alınması gereken prensiplerin bir araya getirilmesi ile elde edilen bir prensip kümesidir. Bu prensipler, yazılım kodlarının daha kolay anlaşılabilir, bakımı daha kolay ve daha esnek hale geldiği bir yazılım mimarisinin hayata geçirilmesini sağlar. SOLID, her harfi farklı bir prensibi temsil etmektedir:
- S: SRP (Tek Sorumluluk Prensibi)
- O: OCP (Açık Kapalı İlkesi)
- L: LSP (Liskov'un Yerine Koyma Prensibi)
- I: ISP (Arayüz Ayırma Prensibi)
- D: DIP (Bağımlılık Tersine Çevirme Prensibi)
Bu prensipler, yazılımcıların yazılım kodlarını daha anlaşılır ve daha doğru hale getirmelerine olanak sağlar. Örneğin, SRP prensibi, her bir sınıfın yalnızca bir görev üzerine çalışmasını sağlar. OCP prensibi ise, yazılım kodunun açık olmasını ve kapalı olmasını sağlar. LSP prensibi, nesne tabanlı programlama kullanılıyorsa, nesnelerin yerine koyma prensibi üzerine kurulmuştur. ISP prensibi, yazılımdaki arayüzlerin gereksiz özelliklerden arındırılmasını ve sade bir yapıya dönüştürülmesini sağlar. DIP prensibi ise, bağımlılıkların tersine çevrilmesini sağlar, böylece tek bir hatada tüm sistemi çökertmeyen daha sağlam bir yapı elde edilir.
Bu prensiplerin tümü, kodun yazılması aşamasında uygulanabilir. SOLID prensipleri, bir yazılımın daha okunaklı ve anlaşılır olmasını sağlar, ayrıca yazılımın bakımını daha kolay hale getirir. Bu prensipleri uygulayan bir yazılım geliştirici, profesyonel bir yaklaşım sergilediğini ve yazılım dünyasındaki en son trendleri takip ettiğini gösterir.
SRP: Tek Sorumluluk Prensibi
Temiz kod yazımı esas alındığında, ilgili kod parçasının işlevini yerine getirmesi haricinde fazla kod kalabalığı getirmemesi beklenir. Tek Sorumluluk Prensibi (SRP), temiz kod yazımı için oldukça önemlidir. SRP prensibine göre bir özelliğin veya sınıfın sadece tek bir sorumluluğu olmalıdır. Bu, kodun daha anlaşılır ve daha kolay yönetilebilir hale gelmesine yardımcı olur.
Örneğin, bir kullanıcının kaydedildiği bir sınıf varsa, bu sınıfın sadece kullanıcı ile ilgili işlemleri gerçekleştiriyor olması gerekir. Bu sınıfın kullanıcı verileri dışında başka bir veri işlemesi yapmasının kod kalabalığına ve sınıfın bakımının zorlaşmasına neden olabilir. Bu nedenle SRP prensibine bağlı kalınarak, sınıfın başka bir işlevi için ayrı bir sınıf oluşturulması önerilir.
Bu prensibin kullanıldığı örnek projelerde kodun daha az tekrarlandığı ve daha modüler yapıya sahip olduğu gözlemlenmiştir. Daha az kod kalabalığı, bakımın daha kolay olmasını sağlar ve projelerin daha ölçeklenebilir hale gelmesine yardımcı olur.
Örnek Uygulama
SRP prensibinin kullanımının ne kadar önemli olduğunu bir örnek proje ile görmek mümkündür. Örneğimizde bir e-ticaret sitesi tasarlayabiliriz. Sitenin genel yapısı müşteri bilgileri, ürün listesi ve alışveriş sepetinden oluşmaktadır. Her bir bu bölümler, kendi sınıfları içerisinde yönetilmekte ve bu sayede kod karmaşası engellenmektedir.
Bunun yanı sıra, tasarım sırasında belirlenen sınıflar, sadece kendi görevleri ile ilgili kodlara sahip olacak şekilde yazılırlar. Örneğin, müşteri bilgileri sınıfı sadece müşteri bilgileriyle ilgili işlemleri yaparken, ürün listesi sınıfı sadece ürünlerle ilgili işlemleri yapar. Böylece kodların yeniden kullanılabilirliği arttırılmış olur.
Özetle, SRP prensibi bir projenin kod kalitesi ve yeniden kullanılabilirliği açısından oldukça önemlidir. Doğru kullanıldığında, kodun karmaşasını önleyerek, proje geliştirme sürecinde zaman ve emek tasarrufu sağlayabilir.
Faydaları
SRP (Tek Sorumluluk Prensibi) prensibinin uygulanması, yazılan kodun daha okunaklı, anlaşılır ve kolay bakım yapılabilir olmasını sağlar. Tek bir sınıfın ve yöntemin tek bir görevi vardır ve bu görevi kusursuz bir şekilde yerine getirir. Bu sayede sınıflar arasındaki bağımlılık azalır ve kodun yeniden kullanılabilirliği artar. SRP prensibi kullanıldığında, projeler daha kolay geliştirilebilir ve değiştirilebilir hale gelir. Ayrıca, hata ayıklama işlemleri de daha kolay hale gelir ve proje sürecinde zaman kazanılabilir.
SRP prensibi, yazılım mühendislerinin düşük aciliyetli görevleri birbirinden ayırmalarını ve kodlarını daha da optimize etmelerini sağlar. Bu prensip sayesinde, projelerin ölçeği ne kadar büyük olursa olsun, programlama ekibinin daha verimli bir şekilde çalışması garantilenir. SRP prensibinin kullanımı, geliştirici ekibin yanı sıra proje yöneticilerinin de iş yükünü azaltır. Bununla birlikte SRP prensibinin kullanımı, yazılım tasarımının daha iyi bir şekilde yapılmış olmasını sağlar ve yazılımın performansını arttırır.
OCP: Açık Kapalı İlkesi
OCP, açık kapalı prensibi anlamına gelir ve bir sınıfın davranışlarının değiştirilmeden açılıp kapatılabilir olması gerektiği anlamına gelir. Bu prensip, gelecekte yapılacak değişikliklere karşı dirençli bir kod yazmanın önemli bir parçasıdır.
Bir programlama dilinde, açık kapalı ilkesi başka bir sınıf veya nesnenin üzerinde değişiklik yapmadan aynı davranışı uygulama yeteneğini verir. Bu, değişikliklerin bir sınıfın koduna etkisi olmadan uygulanabilmesini sağlar.
C# yardımıyla açık kapalı prensibi, arayüzler veya soyut sınıflar gibi bazı özelleştirilmiş veri yapıları kullanılarak uygulanabilir. Bu özelleştirilmiş veri yapıları, yerine getirilmesi için gereken tüm davranışları belirleyen bir sözleşme gibi davranır. Bu, uygulama içinde belirli bir nesne veya sınıfla ilgili işlevlerde yapılan değişikliklerin, aynı sözleşmeye sahip diğer nesne veya sınıflara yayılmasını sağlar.
OCP prensibinin uygulanması, kodun daha az karmaşık hale gelmesine ve daha kolay bakım yapılmasına yardımcı olur. Bu, gelecekteki değişikliklere karşı dirençli bir program yapmanın anahtarıdır.
Örnek Uygulama
OCP prensibi, değiştirilme gerektirmeden yeni özelliklerin eklenebileceği bir kod yapısı oluşturarak, kodun değişik bölümlerinin birbirinden bağımsız olmasını sağlar. Bunun sağlanması, kodun daha esnek ve genişletilebilir olmasına yardımcı olur. Örnek bir uygulamada ise, bir e-ticaret sitesinin ödeme işlemleri modülü ele alınabilir.
Örnek uygulama, müşterilerin kredi kartı ile ödeme yapabileceği bir formda, ödeme bilgilerini istenilen bilgileri girerek gönderdiğinde, bu ödeme bilgilerinin bağımsız bir şekilde işlenmesini sağlayan bir yapı kullanmaktadır. Bu yapıda, alınan ödeme bilgileri, sistem içinde bağımsız bir şekilde işlenerek, müşterilere başarılı veya başarısız ödeme bildirimi yapmaktadır.
Bu uygulamada, ödeme işlemleri modülündeki değişiklikler, diğer modülleri etkilemeden ve herhangi bir kod değişikliği olmadan yapılabilir. Örneğin, yeni bir ödeme yöntemi eklemek için yapılan değişiklik, sadece ödeme işlemleri modülünde yapılır ve diğer modüllerde bir değişiklik yapılması gerekmez.
Faydaları
OCP (Açık Kapalı İlkesi) prensibi, kodun daha kolay okunabilir ve sürdürülebilir olmasını sağlar. Bu prensibe uygun kod, açık olan bir sınıfı veya metodunu bozmadan, kapalı olan diğer sınıflarda veya metodlarda değişiklikler yapılabilir. Bu şekilde, uygulama güncellendiğinde veya yeniden yapılandırıldığında, kodu değiştirmek daha kolay ve daha az riskli hale gelir.
OCP prensibinin uygulanması, kodun yeniden kullanılabilirliğini ve ölçülebilirliğini artırır. Ayrıca, kodun daha iyi test edilmesini ve hata ayıklanmasını kolaylaştırır. Yeni işlevler eklenirken veya mevcut işlevler değiştirilirken, bir dizi açık bir arayüz kullanılarak kod tabanındaki etkileri minimize edilebilir ve risk azaltılabilir.
LSP: Liskov'un Yerine Koyma Prensibi
Liskov'un Yerine Koyma Prensibi (LSP), nesne yönelimli programlamanın (OOP) temel prensiplerinden biridir. Bu prensip, alt sınıfların üst sınıfların yerine kullanılabileceği durumlarda uygulanabilirliğini korumasını gerektirir.
Bir sınıfın, üst sınıfları tarafından belirlenmiş davranışların tümünü yerine getirmesi gerektiği anlamına gelir. Yani, üst sınıfın tüm özellikleri alt sınıf tarafından yerine getirilmeli ve uygulanabilir bir şekilde kullanılmalıdır.
LSP prensibi, kodun daha okunaklı, anlaşılır ve yeniden kullanılabilir olmasını sağlar. Ayrıca kodun daha iyi bir şekilde test edilmesini ve bakımının kolaylaştırılmasını sağlar.
Bir örnek olarak, bir hayvan sınıfı ve bu sınıftan türetilmiş kuş sınıfı ele alalım. Kuş sınıfı, uçabilen bir hayvan olduğu için, Hayvan sınıfının uçamayan özelliklerini kullanmamalıdır. Bu durum, LSP prensibine uymayan bir kod örneğidir.
| Hayvan Sınıfı | Kuş Sınıfı |
|---|---|
| Yürüyebilir | Yürüyebilir |
| Koşabilir | Koşabilir |
| Uçamaz | Uçabilir |
Buna karşılık, LSP prensibine uyan bir örnek ise bir şekil sınıfı ve bu sınıftan türetilmiş bir dikdörtgen sınıfı olabilir. Dikdörtgen sınıfı, şekil sınıfının özelliklerini kullanarak, bir şekil olarak işlev görebilir.
- Daha anlaşılır, yeniden kullanılabilir ve ölçeklenebilir kod yapısı
- Kodun daha kolay test edilmesi ve bakımının kolaylaştırılması
- Alt sınıfların üst sınıfların yerine geçebilirliğinin sağlanması, kodun daha esnek ve genişletilebilir olmasını sağlar
Örnek Uygulama
LSP prensibinin uygulanması için hazırlanmış olan örnek bir C# projesi, Liskov'un yerine koyma prensibine uygun bir yapıya sahiptir. Proje, bir banka sistemi örneğini kullanarak, hesap işlemleri fonksiyonlarını içerir. Bu örnekte, LSP'nin temel özelliği olan herhangi bir nesnenin alt sınıfından türetilmiş bir nesne, üst sınıfın davranışlarına uygun olmalıdır.
Bu proje, hesap işlemlerinin merkezi bir class'ta tanımlanması ve daha sonra her türlü hesapların bu class'tan türetilmesiyle geliştirilmiştir. Örneğin, maaş hesabı ve kredi kartı hesabı class'ları, bu merkezi class'tan türetilirdi. Bu sayede, herhangi bir müşteri hesabı ile işlem yaparken, uygulamada kullanılacak nesne hangi hesap türü olursa olsun, aynı işlevleri yerine getirir ve sistemin düzgün çalışmasını sağlar.
Proje, LSP prensibinin kullanılması sayesinde, herhangi bir zamanda hesap türü eklenebilir veya değiştirilebilir. Örneğin, kredi hesabı veya yatırım hesabı, uygulamaya eklenirse, sadece söz konusu hesaba özgü işlevleri class olarak tanımlamak yeterlidir. Bu, LSP prensibi sayesinde, uygulamanın herhangi bir yerinde karmaşık değişiklikler yapılmasına gerek kalmadan, yeni işlevleri uygulamak için kolay bir yoldur.
Faydaları
Liskov'un Yerine Koyma Prensibi (LSP), kullanımı sayesinde kodun daha esnek hale gelmesini sağlar. Bu prensip uygulandığında, alt sınıfların üst sınıfların yerine geçebilmesi mümkün hale gelir. Bu şekilde, mevcut kodun yeniden kullanılabilirliği artar.
Bunun yanı sıra, LSP prensibinin kullanılması sayesinde sistemin bakımı da kolaylaşır. Çünkü alt sınıfların üst sınıfların yerine geçebilmesi, sistemde yapılan değişikliklerin sadece alt sınıflarla sınırlı kalmasını sağlar. Böylece, kodda yapılan değişikliğin geniş çapta etkisi olmadığından bakım süresi ve maliyeti de azalır.
LSP prensibinin faydalarından bir diğeri, kodun okunabilirliğinin artmasıdır. Prensibin uygulanması sayesinde, kodun nasıl çalıştığına ve hangi sınıfın veya metotun nerede kullanıldığına dair daha net bir anlayışa sahip olunabilir. Bu da, kodun daha kolay anlaşılmasına ve takibi yapılmasına yardımcı olur.
Sonuç olarak, LSP prensibinin kullanılması sayesinde, kodun yeniden kullanılabilirliği artar, bakım maliyetleri azalır, sistem daha esnek hale gelir ve kodun okunabilirliği artar. Bu nedenle, Liskov'un Yerine Koyma Prensibi, clean code ve SOLID ilkelerinin uygulanması sürecinde mutlaka göz önünde bulundurulmalıdır.
ISP: Arayüz Ayırma Prensibi
Arayüz Ayırma Prensibi (ISP), bir sınıfın yalnızca gerektiği arayüzleri kullanması gerektiğini vurgular. Yani bir sınıf, kendisiyle ilgili olmayan arayüzleri kullanmamalıdır. ISP, Kod Düzeyinde Sınıflar Arasındaki Bağımlılığı Azaltır (Reducing Dependency between Classes at Code Level) başlığıyla SOLID ilkelerinin bir parçasıdır.
Bir sınıf, aynı zamanda birden fazla arayüzü kullanabilir ve ISP, sınıfların daha özel ve farklı işlevlere sahip arayüzleri kullanmasını sağlar. Bu yöntem, gereksiz bağımlılıkların oluşmasına izin vermez ve kodların daha esnek ve değiştirilebilir olmasını sağlar.
ISP'nin en önemli faydalarından biri, sınıfların sadece kendi özelliklerine ihtiyaç duyduğu arayüzleri kullanması sayesinde, programın daha az karmaşık hale gelmesidir. ISP, ayrıca paralel yazılım geliştirmede de kullanımı kolay bir ilkedir. Birden fazla geliştiricinin çalıştığı büyük projeler için, sınıfların birbirinden bağımsız olması ve her geliştiricinin kendi arayüzleri üzerinde çalışması önemlidir.
Bir örnek yapmak gerekirse, bir müzik uygulaması yazarken, müzik çalar sınıfı ile veritabanı sınıfı arasında bağımlılık olmamalıdır. Bunun yerine, müzik çalar sınıfı yalnızca müziği çalmakla ilgilidir ve veritabanı sınıfı da yalnızca veritabanı işlemleri ile ilgilidir. Bu sayede, yazılımın daha esnek hale gelmesi sağlanabilir ve her sınıf kendi sorumluluk alanına odaklanabilir.
Örnek Uygulama
ISP prensibinin kullanıldığı bir örnek proje, arayüz ayırma prensibiyle geliştirilmiş bir yazılım üzerine kurulmuştur. Bu projede, müşterilerin siparişlerini online olarak vermeleri amaçlanmaktadır. Bu amaç doğrultusunda, müşteri sayfası, sipariş formu sayfası ve sipariş onay sayfası olmak üzere üç farklı arayüz geliştirilmiştir.
Sipariş sayfasında, müşteriler ürünlerin listesini görüntüleyebilir ve seçtikleri ürünleri sepete ekleyebilirler. Sepet sayfasında, müşteriler seçtikleri ürünleri görüntüleyebilir ve siparişlerini onaylayabilirler. Sipariş onay sayfasında ise müşterilere siparişlerinin özet bilgileri sunulur ve onayları alınır.
Bu örnek proje, arayüz ayırma prensibi sayesinde, her arayüzün değişikliği veya ekleme yapılması, diğer arayüzleri etkilemez. Ayrıca, bu prensip sayesinde diğer prensipler de daha kolay uygulanmaktadır. Bu proje, temiz kod yazmaya özen gösteren bir ekibin ortak çalışması sonucu oluşturulmuştur ve tüm SOLID prensiplerine uygun olarak tasarlanmıştır.
Faydaları
ISP prensibi, arayüzlerin kullanımı sayesinde bağımlılıkların minimize edilmesine ve kodun daha modüler hale gelmesine yardımcı olur. Bu prensip sayesinde, bir sınıfın veya bileşenin işlevselliği değiştiğinde, diğer sınıflarda veya bileşenlerdeki bir etkileşim minimuma indirilebilir.
Bu prensibin kullanılmasının sağladığı en büyük fayda, birbirleriyle bağlantılı olan bileşenlerin birbirinden bağımsız hale gelmesidir. Bu sayede, herhangi bir değişiklik yapmak istendiğinde, gereksiz veya istenmeyen değişiklikler olmaksızın diğer bileşenler etkilenmeden değişiklik yapılabilir. Bunun yanı sıra, arayüzler sayesinde bileşenler daha modüler ve yeniden kullanılabilir hale gelir.
Örneğin, bir web uygulaması düşünelim. Kullanıcı kaydı işlemini gerçekleştiren bir sınıfımız var ve bu sınıf, veritabanı bağlantısı için bir ORM (Object-Relational Mapping) kütüphanesi kullanıyor. Ancak ileride, veritabanı bağlantısı farklı bir kütüphane ile yapmak istediğimizde, bu değişiklik sadece ORM ile ilgili kodları etkileyecektir. Kayıt işlemi yapan sınıfın diğer kısımları, yani kullanıcı doğrulama gibi işlemler bu değişiklikten etkilenmez. Bu sayede, değişiklik yapmak daha kolay ve daha güvenli hale gelir.
Toparlayacak olursak, ISP prensibi kullanarak arayüzlerin kullanımı sayesinde bağımlılıklar minimize edilir ve kod daha modüler hale gelir. Bu sayede, değişiklik yapmak daha kolay hale gelir ve gereksiz değişiklikler önlenir. Uygulamanın daha güvenli ve yeniden kullanılabilir hale gelmesi sağlanabilir.
DIP: Bağımlılık Tersine Çevirme Prensibi
Bağımlılık Tersine Çevirme Prensibi, programlama kodlarının daha esnek, daha dayanıklı ve daha geliştirilebilir olmasını sağlayan SOLID prensiplerinden biridir. Bu prensip, programlama kodlarında bağımlılıkları azaltarak, ara yüzlerle çalışmayı ve kodları parçalara ayırmayı sağlar.
Bağımlılık Tersine Çevirme Prensibi, yüksek seviyeli modüllerin düşük seviyeli modüllere bağımlı olmamasını, ancak tam tersinin olması gerektiğini savunur. Yani, uygulama düzeyindeki yüksek seviyeli modüller, altyapı düzeyindeki düşük seviyeli modüllere bağımlı olmamalıdır.
Bu prensibi uygularken, düşük seviyeli modüller üst düzey modüllerin arayüzüne uyum sağlamalıdır. Bu sayede, herhangi bir değişiklik yapıldığında programlama kodlarına zarar vermeden, düşük seviyeli modüller değiştirilebilir.
Bağımlılık Tersine Çevirme Prensibi ile birlikte, kodların birbirinden ayrılması ve her bir modülün kendi başına test edilebilmesi de mümkün olur. Bu sayede, bakımı kolaylaşır ve manuel testlerin yanı sıra otomatik testler de yapılabilir.
Bağımlılık Tersine Çevirme Prensibi, özellikle büyük ölçekli projelerde ve takım çalışmasına dayalı geliştirme projelerinde oldukça önemlidir. Bu prensibi kullanarak, programlama kodlarında esneklik sağlanırken, hataların azaltılması ve zamanın optimize edilmesi mümkündür.
Örnek Uygulama
DIP prensibi (Dependency Inversion Principle) olarak da bilinen Bağımlılık Tersine Çevirme Prensibi, kodun daha esnek, kolay anlaşılır, test edilebilir ve sürdürülebilir olmasını sağlar. DIP prensibinin uygulanmasıyla, yüksek seviyeli modüller, düşük seviyeli modüllere bağımlı hale gelmez.
Bir örnek uygulama olarak, bir online mağaza sistemi düşünebiliriz. DIP prensibinin uygulanmadığı bir sistemde, bir sipariş oluşturulduğunda doğrudan bir ödeme modülüne bağlı kalınarak ödeme yapılır. Ancak, DIP prensibinin uygulandığı bir sistemde önce sipariş oluşturulur ve sonra ödeme modülüne bağlanarak ödeme yapılır. Böylece, ödeme modülü, sipariş modülünden bağımsız olarak geliştirilebilir.
Tablo kullanarak daha detaylı bir örnek uygulama yapabiliriz:
| Sipariş Modülü | Ödeme Modülü |
|---|---|
| Sipariş oluşturulur, bilgiler veritabanına kaydedilir | Ödeme isteği alınır |
| Fiyat hesaplaması yapılır | |
| Ödeme işlemi gerçekleştirilir | |
| Sipariş durumu güncellenir | Ödeme sonucu kaydedilir |
Bu örnekte, Sipariş Modülü ve Ödeme Modülü bağımsız olarak geliştirilebilir ve her biri kendi bağımlılıklarını yönetir.
Faydaları
DIP prensibinin kullanılmasının en büyük faydası, bağımlılıkların tersine çevrilmesiyle birlikte proje içindeki bileşenler arasındaki ilişkinin daha esnek hale gelmesidir. Bu prensip sayesinde, daha önce birbirine bağlı olan bileşenler arasındaki bağımlılık azaltılmakta ve bu sayede programlar daha az hata içeren, daha düzenli ve daha kolay değiştirilebilir hale gelmektedir. Bu prensip sayesinde, bir bileşenin bazı kısımlarındaki değişiklikler, diğer bileşenleri de etkilemeden yapılabilir.
DIP prensibi ayrıca, programın bakımının daha kolay olmasına da katkı sağlar. Bu prensibe uygun bir şekilde yazılmış bir programda, herhangi bir değişiklik veya yeniden yapılandırma gerektiğinde sadece etkilenen bileşenlerin üzerinde çalışmak yeterlidir. Bu da zaman ve kaynak tasarrufu sağlar.
Bunun yanı sıra DIP prensibi, kodun yeniden kullanımını da kolaylaştırır. Herhangi bir bileşenin değiştirilmesi gerektiğinde, bağımlılıkların tersine çevrilmesi sayesinde, programın diğer bileşenlerine zarar vermeden yeniden yapılandırılması mümkün olur. Bu da kodun yeniden kullanılabilir olmasını sağlar.