DRY Prensibini Uzmanlaşmak: Daha Temiz Kod İçin C#'da Tasarım Kalıplarını Uygulamak
C#'da tasarım kalıpları, verimli, yeniden kullanılabilir ve sürdürülebilir kod yazmak için temel araçlardır. Bu kalıplar, yaygın yazılım tasarım problemleri için standart çözümler sağlar, en iyi uygulamaları teşvik eder ve geliştiricilerin gereksiz koddan kaçınmasına yardımcı olur. Tasarım kalıplarını uygularken, çekirdek ilkelerden biri, kodda tekrarları en aza indirerek okunabilirliği ve sürdürülebilirliği artıran DRY (Don't Repeat Yourself) prensibidir.
Bu makale, Tim Corey'nin C#'ta DRY prensibini derinlemesine inceleyen 'Tasarım Kalıpları: C#'ta Kendini Tekrarlama' başlıklı bilgilendirici videosundan ilham almıştır. Tim'in videosunda tartışılan anahtar kavramlar ve stratejileri keşfederek, bu makale DRY tasarım deseni ilkesini C# projelerinizde etkili bir şekilde uygulamak için kapsamlı bir rehber sunmayı amaçlamaktadır.
C#'ta DRY İlkesine Giriş
Tanıtım bölümünde, Tim Corey DRY prensibini açıklar, bu "Don't Repeat Yourself" anlamına gelir. Bu prensip, her bilginin veya mantığın kod içinde sadece bir yerde temsil edildiğinden emin olarak yinelemeden kaçınmayı vurgulayan programlamanın temel bir kavramıdır. Tim, bir dashboard formuna sahip basit bir WinForms uygulaması örneği ile prensibi gösterir. Form, bir ilk ad ve bir soyad girmek için alanlar ve bu alanlara dayanarak bir çalışan ID'si oluşturmak için bir buton içerir.
Kod Tekrarını Belirleme ve Tahmin Etme
(0:53)'te, Tim kodda tekrarları belirlemeye ve tahmin etmeye geçer. Tekrarların yöntemler yalnızca bir kez çağrılsa bile nasıl ortaya çıkabileceğini göstermek için WinForms uygulaması örneğini kullanır. Uygulamada, çalışan ID'si oluşturma mantığı, ilk ve soyad metin alanlarından alt diziler çıkartılmasını ve sonuna üç haneli bir kod eklenmesini içerir.

(1:31) üzerindeki yukarıdaki ekran görüntüsünde, Tim uygulamanın işlevselliğini gösteriyor, ilk ve soyadın ilk dört harfini üç haneli bir kodla birleştirerek bir çalışan ID'si nasıl oluşturduğunu gösteriyor. Kodun aynı mantığı açıkça tekrarlamadığı için DRY prensibine uyuyor gibi görünmesine rağmen, ele alınması gereken tekrar paterninde altında yatan sorunları vurgular.
(1:51)'de, kodun basit görünmesine rağmen, çalışan ID'si oluşturma mantığının düğmenin tıklama olayı ile sıkı sıkıya bağlı olması nedeniyle DRY ilkesine tam olarak uymadığını belirtir. Bu, müşteri kodunda başka bir yerde, örneğin yeni çalışanlar listesini işlerken (3:58) bu mantık gerekirse, kodun tekrar edilmesi veya uyarlanması gerekeceği anlamına gelir, bu da yinelemeye neden olur.
Bağımsız, Yeniden Kullanılabilir Metodlar Oluşturma
Bu bölümde Tim Corey, DRY ilkesine uymak için bağımsız ve yeniden kullanılabilir bir yöntemin nasıl oluşturulacağını gösterir. Olay işleyicisinden çalışan kimliği oluşturma mantığını ayrı bir metoda çıkararak başlar. Bu yeniden yapılandırma, GenerateEmployeeID adında özel bir metot oluşturmayı ve mevcut kodu bu metoda taşımayı içerir (5:15). Güncellenen olay işleyicisi kodu daha sonra yalnızca bu metodu çağırır.
Adımlar ve Örnek:
İlk Kod: Çalışan ID'si oluşturma mantığı bir düğmenin tıklama olay işleyicisindeydi.

Refaktörlenmiş Kod: Tim, metodu daha esnek hale getirerek geliştirir. Belirli UI elemanlarina bagli kalmak yerine, metot simdi
firstNamevelastNameparametrelerini kabul eder ve oluşturulan ID'yi geri dondurur. Bu değişiklik, metodun çeşitli bağlamlarda ve UI öğelerinde kullanılmasını sağlar:private string GenerateEmployeeID(string firstName, string lastName) { string employeeID = firstName.Substring(0, 4) + lastName.Substring(0, 4) + DateTime.Now.Millisecond.ToString(); return employeeID; }private string GenerateEmployeeID(string firstName, string lastName) { string employeeID = firstName.Substring(0, 4) + lastName.Substring(0, 4) + DateTime.Now.Millisecond.ToString(); return employeeID; }Tim daha sonra, bu metodun tıklama olayından nasıl çağrıldığını gösteriyor:
employeeIdText.Text = GenerateEmployeeID(firstNameText.Text, lastNameText.Text);employeeIdText.Text = GenerateEmployeeID(firstNameText.Text, lastNameText.Text);Ayrıca bu metodun, birden fazla çalışan kaydı içeren CSV dosyalarını işleme gibi uygulamanın diğer bölümlerinde kullanılabileceğini belirtiyor, böylece kodu tekrar etmeden.
Sınıf Kütüphanesi Oluşturma ve Kullanma
Tim Corey, kodun yeniden kullanımını ve sürdürülebilirliğini daha da artırmak amacıyla sınıf kütüphanesi kavramını ele alır. GenerateEmployeeID metodunun bir sınıf kütüphanesi içinde nasıl kapsülleneceğini ve bunun birden fazla projede kullanılabileceğini gösterir.
Saat (8:00)'de, Tim tasarımın grafikler ve animasyonlarla daha etkileşimli hale getirmek için kullanıcı gereksinimlerine veya şirket politikalarına göre sürekli değişir. Çözüm içinde tam alanlara sahip ve Çalışan ID'si Oluşturmak için bir düğmeye sahip bir WPF projesi tanıtır.
(9:15)'te Tim, bir sınıf kütüphanesi kullanmanın güçlü bir savunucusudur; tekrarlamaktan kaçınmalıyız derken, o zaman kodun yeni WPF projesine kopyalanarak yapıştırılmış olacağını söylüyor. Yani, DRY'yi muhafaza etmek için bir sınıf kütüphanesinde sınıflar oluşturmamız gerekiyor.
Adımlar ve Örnek:
Sınıf Kütüphanesi Oluşturulması:
Tim, (9:47)'de .NET Framework'te yeni bir sınıf kütüphanesi projesi oluşturarak adını DRYDemoLibrary koyuyor.
Bu kütüphane içinde
EmployeeProcessoradında genel bir sınıf tanımlar veGenerateEmployeeIDmetodunu bu sınıfa taşır:public class EmployeeProcessor { public string GenerateEmployeeID(string firstName, string lastName) { string employeeID = firstName.Substring(0, 4) + lastName.Substring(0, 4) + DateTime.Now.Millisecond.ToString(); return employeeID; } }public class EmployeeProcessor { public string GenerateEmployeeID(string firstName, string lastName) { string employeeID = firstName.Substring(0, 4) + lastName.Substring(0, 4) + DateTime.Now.Millisecond.ToString(); return employeeID; } }
Projelerde Sınıf Kütüphanesini Kullanma:
Tim, WinForms (13:18) ve WPF projelerinde (14:00), DRYDemoLibrary sınıf kütüphanesine bir referans ekler.
Daha sonra eski kodu, sınıf kütüphanesinden
GenerateEmployeeIDmetoduna yapılan çağrılarla değiştirir:EmployeeProcessor processor = new EmployeeProcessor(); employeeIDText.Text = processor.GenerateEmployeeID(firstNameText.Text, lastNameText.Text);EmployeeProcessor processor = new EmployeeProcessor(); employeeIDText.Text = processor.GenerateEmployeeID(firstNameText.Text, lastNameText.Text);- Bu yaklaşım, yöntemin artık tek bir yerde bakımı yapıldığından dolayı, tekrarı ortadan kaldırır. Tim, aynı sınıf kütüphanesinin farklı UI çerçeveleri (WinForms ve WPF) arasında tekrarlanmadan kullanılabileceğini gösterir.
Avantajları:
Tutarlılık: Mantığı bir sınıf kütüphanesinde merkezi hale getirerek, Tim, mantıktaki değişikliklerin (örneğin hata düzeltmeleri) tüm projelerde aynı şekilde uygulanmasını sağlar.
- Bakım Azalır: Yöntem değişiklikleri yalnızca sınıf kütüphanesinde yapılır, bu da tutarsızlıkları önler ve bakım yükünü azaltır.
Sınıf Kütüphanesinin Birden Fazla Projede Entegrasyonu
Tim Corey, DRYDemoLibrary sınıf kütüphanesini farklı proje türlerinde nasıl kullanabileceğini, özellikle kütüphaneyi yeni bir konsol uygulamasına entegre etmeye odaklanarak araştırmaya devam eder. Bu, kütüphanenin işlevselliğinin yalnızca bir örnek veya aynı çözüm içinde olanlar değil, çeşitli uygulamalar arasında nasıl yeniden kullanılabileceğini gösterir.
Adımlar ve Örnek:
Yeni Çözüm ve Proje Oluşturma:
Tim, (17:29)'da, bir konsol uygulaması için yeni bir çözüm oluşturarak, DRYDemoLibrary'yi Windows hizmeti veya konsol uygulaması gibi farklı projelerde kullanmanız gereken bir senaryoyu simüle eder.
Yeni projeye ConsoleUI adını verir ve temel bir konsol uygulaması kurmanın nasıl yapıldığını gösterir.
class Program { static void Main(string[] args) { Console.ReadLine(); } }class Program { static void Main(string[] args) { Console.ReadLine(); } }
Sınıf Kütüphanesine Referans Ekleme:
Tim, yeni projede DRYDemoLibrary DLL dosyasına nasıl referans ekleneceğini açıklar. Bu, sınıf kütüphanesi projesinin bin dizinindeki DLL dosyasına göz atmayı ve onu konsol uygulamasına eklemeyi içerir.
using DRYDemoLibrary;using DRYDemoLibrary;Referans eklendikten sonra, Tim (19:24), kütüphaneden EmployeeProcessor sınıfını kullanarak kullanıcı girdisine dayalı olarak bir çalışan ID'si oluşturur.
Console.WriteLine("What is your first name?"); string firstName = Console.ReadLine(); Console.WriteLine("What is your last name?"); string lastName = Console.ReadLine(); EmployeeProcessor processor = new EmployeeProcessor(); string employeeID = processor.GenerateEmployeeID(firstName, lastName); Console.WriteLine($"Your employee ID is {employeeID}");Console.WriteLine("What is your first name?"); string firstName = Console.ReadLine(); Console.WriteLine("What is your last name?"); string lastName = Console.ReadLine(); EmployeeProcessor processor = new EmployeeProcessor(); string employeeID = processor.GenerateEmployeeID(firstName, lastName); Console.WriteLine($"Your employee ID is {employeeID}");
Konsol Uygulamasını Çalıştırma:
Tim, kütüphaneyi kullanarak başarıyla çalışan ID'si oluşturduğunu göstermek için konsol uygulamasını çalıştırır. Bu, sınıf kütüphanesindeki aynı kodun farklı projelerde yeniden kullanılabileceğini doğrular.

DLL Güncelleme:
- Tim, DLL değişirse, ona referans yapan projelerde güncelleme yapabileceğinizi kısaca belirtir. Bu videoda detaylarına değinilmese de, birden fazla projede DLL'lerin yönetimi ve güncellenmesi için NuGet paketleri kullanmanın önerilen bir yaklaşım olduğunu belirtir.
DLL'lerin Güncellenmesi ve NuGet Paketlerinin Yönetimi
Tim Corey, sınıf kütüphanelerini yönetmek ve güncellemek için NuGet paketlerini kullanma kavramını kısaca tanıtır. Bu yaklaşım, özellikle daha büyük projelerde veya organizasyonlarda, bağımlılıkların ve güncellemelerin yönetimi için daha ölçeklenebilir bir çözüm sunar.
Ana Noktalar:
Bir NuGet Paketi Oluşturma:
- DLL dosyalarını manuel olarak yönetmek yerine, Tim sınıf kütüphanesi için bir NuGet paketi oluşturmayı önerir. Bu, DLL'yi bir NuGet paketi olarak paketlemeyi ve bir NuGet sunucusuna (özel veya genel) yüklemeyi içerir.
Paketlerin Güncellenmesi:
- Bir NuGet paketi kullanarak, referans yapan tüm projelerde kütüphaneyi güncellemek için sadece paket sürümünü güncellemeniz yeterlidir. Bu yaklaşım, tutarlılığı sağlar ve sürüm uyuşmazlıkları veya eksik güncellemeler riskini azaltır.
Faydaları:
Merkezi Yönetim: NuGet paketleri, kütüphane sürümlerini ve bağımlılıklarını yönetmek için merkezi bir yol sağlar.
Güncelleme Kolaylığı: Kütüphaneyi birden fazla proje arasında güncellemek daha kolay ve güvenilir hale gelir.
- Entegrasyon: NuGet, çeşitli geliştirme araçları ve ortamları ile entegre olur, kütüphane bağımlılıklarını yönetme sürecini kolaylaştırır.
Ünite Testlerinde DRY İlkesi: Hızlı Bir Kurs
Bu bölümde, Tim Corey, DRY (Kendini Tekrarlama) ilkesini uygulamanın birim testlerini nasıl geliştirebileceğini gösterir. DRY ilkelerinin geliştirme işinde, özellikle birim testlerinde nasıl uygulanacağını gösterir.
İlk Test Kurulumu
Tim, bir hatadan dolayı şu anda başarısız olan bir birim testi çalıştırarak başlar. Kodu ana çözümün dışında olsa bile sorunları belirlemek için birim testlerinin önemini vurgular. Kod, 4 harfli bir girdi bekliyordu, ancak Tim bir 3 harfli isim geçerek çözümde doğrudan eklenmemiş olsa bile DLL dosyasında çökmeye neden oldu.

Hatalara Yönelik Kodu Yeniden Düzenleme
Ad yönetimiyle ilgili sorunu çözmek için Tim kodu yeniden düzenler. DRY'yi geliştirmenin bir yolu olarak yeni bir sınıf kütüphanesi projesi oluşturmayı (23:50) açıklar. Bu yaklaşım, birden fazla nesne üzerindeki değişikliklerin bir kez yapılmasını ve tekrar etmeksizin etkili bir şekilde test edilmesini sağlar.

Birim Testler Ekleme
Tim, sınıf kütüphanesi projesinde EmployeeProcessorTest adında yeni bir test sınıfı tanıtarak ve XUnit kullanarak birim testler kurar. Çalışan ID'leri oluşturmak için bir test metodu nasıl oluşturulacağını ve bağımlılıkların taklit edilmesinin önemini, gerçek değerlere güvenmek yerine tartışır.

Bir Test Metodu Yazma
Tim, GenerateEmployeeID_ShouldCalculate adında bir birim test metodu yazar. Yöntemin beklenen sonuçları döndürmesini sağlamak için farklı senaryoları test etmek amacıyla satır içi verilerle bir teori kurar. Çıktıyı doğrulamak için Assert.Equal nasıl kullanılır açıklamalar yapar.
public class EmployeeProcessorTest
{
[Theory]
[InlineData("Timothy", "Corey", "TimoCore")]
public void GenerateEmployeeID_ShouldCalculate(string firstName, string lastName, string expectedStart)
{
// Arrange
var processor = new EmployeeProcessor();
// Act
var actualStart = processor.GenerateEmployeeID(firstName, lastName).Substring(0, 8);
// Assert
Assert.Equal(expectedStart, actualStart);
}
}public class EmployeeProcessorTest
{
[Theory]
[InlineData("Timothy", "Corey", "TimoCore")]
public void GenerateEmployeeID_ShouldCalculate(string firstName, string lastName, string expectedStart)
{
// Arrange
var processor = new EmployeeProcessor();
// Act
var actualStart = processor.GenerateEmployeeID(firstName, lastName).Substring(0, 8);
// Assert
Assert.Equal(expectedStart, actualStart);
}
}Birim Testi Çalıştırma
Tim, dinamik verileri, örneğin tarih-saat değerlerini test koşullarını ve sonuçlarını kontrol etmek için taklit etmenin önemini vurgular. Dinamik dizelerle çalışmanın zorluğunu ve kontrol edilen değerler kullanarak farklı senaryoları test etmenin yollarını tartışır. Daha sonra birim testini çalıştırır; ancak bundan önce, testlerin çalışabilmesi için gerekli iki NuGet paketini ekler: xunit.runner.console ve xunit.runner.visualstudio.

Bir satır içi veri için tüm testlerin başarılı bir şekilde çalıştırılmasının ardından çıktı şu şekilde gösterilir:

Şimdi (31:30)'da Tim başka bir satır içi veri ekledi ve alt dizi ikinci parametresini expectedStart.Length olarak değiştirdi:
public class EmployeeProcessorTest
{
[Theory]
[InlineData("Timothy", "Corey", "TimoCore")]
[InlineData("Tim", "Corey", "TimCore")]
public void GenerateEmployeeID_ShouldCalculate(string firstName, string lastName, string expectedStart)
{
var processor = new EmployeeProcessor();
var actualStart = processor.GenerateEmployeeID(firstName, lastName).Substring(0, expectedStart.Length);
Assert.Equal(expectedStart, actualStart);
}
}public class EmployeeProcessorTest
{
[Theory]
[InlineData("Timothy", "Corey", "TimoCore")]
[InlineData("Tim", "Corey", "TimCore")]
public void GenerateEmployeeID_ShouldCalculate(string firstName, string lastName, string expectedStart)
{
var processor = new EmployeeProcessor();
var actualStart = processor.GenerateEmployeeID(firstName, lastName).Substring(0, expectedStart.Length);
Assert.Equal(expectedStart, actualStart);
}
}(32:05)'te, yeni teori ile birim testi tekrar çalıştırdıktan sonra test başarısız oldu:

Özel Yöntemlerle Kodu İyileştirme
DRY ilkesine uymak için Tim, DRYDemoLibrary'deki EmployeeProcessor sınıfı altında GetPartOfName adında özel bir metot oluşturarak kodu daha da düzenledi. Bu yöntem, adın parçalarının çıkarılmasını ele alır, kodun yeniden kullanılabilirliğini ve okunabilirliğini artırır. Tim aşağıdaki değişiklikleri yaptı:
public string GenerateEmployeeID(string firstName, string lastName)
{
string employeeID = $@"{GetPartOfName(firstName, 4)}{GetPartOfName(lastName, 4)}{DateTime.Now.Millisecond.ToString()}";
return employeeID;
}
private string GetPartOfName(string name, int numberOfCharacters)
{
string output = name;
if (name.Length > numberOfCharacters)
{
output = name.Substring(0, numberOfCharacters);
}
return output;
}public string GenerateEmployeeID(string firstName, string lastName)
{
string employeeID = $@"{GetPartOfName(firstName, 4)}{GetPartOfName(lastName, 4)}{DateTime.Now.Millisecond.ToString()}";
return employeeID;
}
private string GetPartOfName(string name, int numberOfCharacters)
{
string output = name;
if (name.Length > numberOfCharacters)
{
output = name.Substring(0, numberOfCharacters);
}
return output;
}Birim Testlerini Güncelleme
Tim, koddaki değişiklikleri, örneğin alt dizelerin beklenen uzunluğunu değiştirmek gibi, yansıtmak için birim testlerini günceller. Bu testlerin çalıştırılmasının, sorunları hızla tanımlamaya yardımcı olduğunu ve kodun yeni gereksinimleri karşıladığını doğrulayan bir yol olduğunu açıklar. Tim, yeni teoriler ekleyip birim testleri çalıştırarak çıktının beklenilen gibi olup olmadığını doğrular:

.NET Standard Kütüphaneleri ile Esnekliği Artırma
Bir .NET Standard Kütüphanesi Oluşturma
Sınıf kütüphanenizin esnekliğini artırmak için, Tim Corey, .NET Framework sınıf kütüphanesinden .NET Standard sınıf kütüphanesine geçişi önerir. Bu değişiklik, kütüphanenin çeşitli platformlarda uyumlu olmasını sağlar, bunlar arasında:
- Windows Platformları: WinForms, WPF ve Konsol Uygulamaları
- Çapraz-Platform: .NET Core, Xamarin (iOS ve Android için), Linux ve macOS
Bir .NET Standard Kütüphanesi Oluşturmanın Adımları:
- Yeni Proje Ekleme: Çözümünüze sağ tıklayıp yeni bir proje eklemeyi seçin.
.NET Standard Seçme: .NET Framework sınıf kütüphanesi seçmek yerine, .NET Standard'ı seçin. Bu kütüphane türü, geniş bir platform yelpazesini destekler.

- Kod Göçü: Mevcut kodunuzu (örn. EmployeeProcessor sınıfı) yeni .NET Standard kütüphanesine kopyalayıp yapıştırın. Bu işlem küçük ayarlamalar içerebilir, ancak temel mantık tutarlıdır.
.NET Standard'a dönüştürerek, kütüphanenizi çeşitli platformlardan erişilebilir hale getirir, farklı uygulama türlerinde kod tekrarı azaltır ve geliştirme çabası tasarrufu sağlarsınız.
Kod ve Testte Tekrarı Önleme
Geliştirmede Tekrarı Azaltma
Tim Corey, bir .NET Standard kütüphanesini benimseyerek, yalnızca kod tabanınızda değil, aynı zamanda geliştirme sürecinde de kod tekrarını en aza indirdiğinizi vurgular. Farklı platforma özgü projelerde kodu çoğaltmak yerine, onu birden fazla ortamda çalışan tek bir kütüphanede merkezsizleştirirsiniz.
Faydaları:
- Birleştirilmiş Kod Tabanı: Çeşitli platformlar için tek bir kod tabanı, kodunuzu korumak ve güncellemek için gereken çabayı azaltır.
- Basitleştirilmiş Test Yapma: Bir .NET Standard kütüphanesi ile, birim testleri bir kez yazabilir ve bunların tüm desteklenen platformlara uygulanmasını sağlayabilirsiniz.
Test ve Hata Ayıklama: Tim, çabayı ve tekrarları daha da azaltmak için birim testleri tanıtır. Otomatik testler kodunuzun doğruluğunu manuel olarak her uygulama yinelemesini test etmeye gerek kalmadan doğrular.
DRY İlkesini Uygulama İpuçları: Ne Zaman Duracağınızı Bilmek
Tim Corey, DRY (Kendini Tekrarlama) ilkesine uymak sürdürülebilir kod yazmanın anahtarı olsa da, bunu ne zaman ve nerede uygulayacağını bilmenin önemli olduğunu vurgular. Her senaryo aynı yaklaşımı gerektirmez, bu yüzden Tim'in içgörülerinden ilham alınarak bazı pratik ipuçları burada:
Kod-arkasında ve UI'de Koddan Kaçının: Tim, mantığın doğrudan kod-arka dosyalarına veya kullanıcı arabirimlerine yerleştirilmemesini önerir. Örneğin, iş mantığı bir formda veya düğme tıklama olayında gömülü olmamalıdır. Bunun yerine, bu tür mantığı ayrı sınıf veya kütüphanelerde tutun. Bu ayrım, temiz bir mimariyi sürdürmeye yardımcı olur ve kodunuzu farklı kullanıcı arayüzleri arasında daha yeniden kullanılabilir hale getirir.
.NET Standard Kütüphanelerinden Yararlanın: Kütüphane oluştururken, Tim mümkün olduğunda .NET Framework kütüphaneleri yerine .NET Standard kütüphanelerini kullanmayı önerir. .NET Standard kütüphaneleri daha esnektir, kodunuzun .NET Core, Xamarin ve daha fazlası dahil olmak üzere farklı platformlarda kullanılmasına olanak tanır. Bu yaklaşım, kodun tekrarını azaltır ve kodun taşınabilirliğini artırır.
Platforma Özgü Kodu Ayırın: Bazı kodlar, platforma özgü gereksinimler nedeniyle bir .NET Standard kütüphanesine uymayabilir, örneğin dosya işleme veya yapılandırma yönetimi. Tim bu gibi durumlarda iki kütüphane oluşturmayı önerir: biri .NET Standard kodu için, diğeri platforma özgü kod için. Bu şekilde, platforma özgü ihtiyaçları karşılarken temel mantığı yeniden kullanabilirsiniz.
Birim Testine Vurgu Yapın: Tim, kodunuz için birim testleri yazmayı şiddetle teşvik eder. Birim testleri, hataları erken tespit etmeye yardımcı olur ve kodunuzun beklenildiği gibi davrandığını garanti eder. Manuel olarak tüm uygulamayı test etmeden değişiklikleri hızlıca doğrulayabildiğiniz için hata ayıklama sürecini önemli ölçüde hızlandırabilirler.
- Proje Boyutunu Düşünün: Tim, çok küçük veya deneysel projeler için, ayrı kütüphaneler oluşturmanın ve kapsamlı birim testlerinin oluşturmanın gereksiz olabileceğini kabul eder. Ancak, üretim uygulamaları için temiz bir mimariyle başlamak ve birim testi yapmak tavsiye edilir, çünkü küçük projeler genellikle zamanla büyür ve evrim geçirir.
Bu ipuçlarını takip ederek, DRY ilkesini etkili bir şekilde uygulayabilir ve kodun yeniden kullanılabilirliği ile sürdürülebilirliğinin gereksinimlerini pratik düşüncelerle dengeleyebilirsiniz.
Sonuç
Tasarım kalıpları aracılığıyla DRY ilkesini ustalıkla uygulamak, temiz ve sürdürülebilir C# kodu yazmak için esastır. Tim Corey tarafından gösterildiği gibi, DRY'ı etkili bir şekilde uygulamak, yeniden kullanılabilir metodlar oluşturmak, sınıf kütüphanelerini kullanmak ve daha geniş bir uyumluluk için .NET Standard'ı benimsemek anlamına gelir. Bu uygulamaların ne zaman ve nasıl uygulanacağını anlayarak, kodunuzun kalitesini ve esnekliğini önemli ölçüde artırabilirsiniz.
Daha derin içgörüler için, Tim Corey'nin bu konuyla ilgili videosunu buradan izleyin. Tim'in en son içeriğiyle güncel kalmak için YouTube kanalını ziyaret edin.



