.NET Lazy: Tembel Yüklemenin Sanatı ve Bilimi

Bir sınıfın başlatılması sırasında veya uygulama ilk açıldığında tüm bağımlılıkların ve kaynakların yüklenmesi şu somut problemlere yol açabilir:

• Yavaş Başlangıç (Slow Startup):
  • Kullanıcı Deneyimi Darbesi: Masaüstü veya mobil uygulamaların açılışının saniyelerce sürmesi, kullanıcı sabrını zorlar ve kötü bir ilk izlenim bırakır. Bu gecikmenin nedeni genellikle, henüz ekranda görünmeyen veya kullanıcı tarafından talep edilmeyen birçok bileşenin, verinin veya servisin arka planda başlatılmasıdır. Örneğin, bir e-posta istemcisinin tüm klasörleri, eklentileri ve ayarları açılışta senkronize etmeye çalışması.
  • Servis Başlatma Gecikmeleri: Web servisleri veya arka plan görevleri için başlangıç süresi, sistemin genel yanıt verme kapasitesini etkiler. Bir mikroservisin başlaması uzun sürüyorsa, ona bağımlı diğer servisler de beklemek zorunda kalabilir veya zaman aşımları yaşanabilir. Özellikle otomatik ölçeklendirme (auto-scaling) senaryolarında, yeni örneklerin hızla devreye girmesi kritikken, yavaş başlangıç ciddi bir engel teşkil eder.
• Kaynak İsrafı (Resource Waste):
  • Bellek Tüketimi: Büyük veri yapıları (örneğin, uygulama genelinde kullanılan ama nadiren erişilen lookup tabloları, önbellekler) veya çok sayıda küçük nesne, başlangıçta belleğe yüklenirse, uygulamanın bellek ayak izini gereksiz yere artırır. Bu nesneler hiç kullanılmazsa, o bellek alanı boşa harcanmış olur. Özellikle bellek kısıtlı ortamlarda (mobil cihazlar, IoT cihazları, konteynerler) bu durum kritikleşir.
  • CPU Döngüleri: Karmaşık hesaplamalar, şifreleme/çözme işlemleri veya veri dönüşümleri gerektiren nesnelerin oluşturulması, başlangıçta değerli CPU zamanını tüketir. Eğer bu sonuçlara daha sonra ihtiyaç duyulacaksa veya hiç duyulmayacaksa, bu CPU kullanımı israftır.
  • Ağ ve G/Ç (I/O) İşlemleri: Veritabanı bağlantıları kurmak, uzak API'leri çağırmak veya diskten büyük dosyaları okumak gibi işlemler hem zaman alır hem de ağ bant genişliği, veritabanı bağlantı havuzu gibi sınırlı kaynakları tüketir. Başlangıçta gereksiz yere yapılan bu işlemler, hem uygulamanın yavaşlamasına hem de altyapı kaynaklarının verimsiz kullanılmasına neden olur. Örneğin, bir uygulamanın başlangıçta, kullanıcının henüz talep etmediği tüm rapor şablonlarını veritabanından çekmesi.
  • Lisans Maliyetleri: Bazı kaynaklar (örneğin, belirli veritabanı sürücüleri, üçüncü parti servisler) bağlantı veya kullanım başına lisans maliyetine sahip olabilir. Gerekli olmayan bağlantıları veya servis çağrılarını başlangıçta yapmak, maliyeti artırabilir.
• Kırılganlık ve Hata Yayılımı (Brittleness & Error Propagation):
  • Tek Noktada Başarısızlık Riski: Eğer başlangıçta yüklenen kritik olmayan bir bileşen (örneğin, isteğe bağlı bir loglama servisi veya nadir kullanılan bir özellik modülü) başlatılamazsa (örneğin, konfigürasyon hatası, ağ sorunu), bu durum tüm uygulamanın veya ana bileşenin başlatılmasını engelleyebilir. Başarısızlık, ihtiyaç duyulmayan bir bileşenden kaynaklansa bile yayılabilir.
  • Maskelenmiş Hatalar: Başlatma sırasında oluşan ancak hemen fark edilmeyen hatalar (örneğin, yanlış yüklenen konfigürasyon verisi), uygulamanın ilerleyen aşamalarında, hatanın kaynağını tespit etmenin zor olduğu anlarda beklenmedik davranışlara yol açabilir.
• Artan Test Karmaşıklığı: Bir sınıfın yapıcısında çok fazla iş yapılması veya bağımlılığın yüklenmesi, o sınıfın birim testlerini (unit testing) yazmayı zorlaştırır. Tüm bu bağımlılıkların test ortamında sağlanması veya sahte (mock) nesnelerle değiştirilmesi gerekir, bu da testlerin karmaşıklığını ve kırılganlığını artırır.

Bu dezavantajlar, özellikle büyük ölçekli, modüler ve yüksek performans gerektiren uygulamalarda daha belirgin hale gelir. İşte bu noktada tembel yükleme ve Lazy devreye girer.

Tembel yükleme, "ihtiyaç anında başlatma" prensibiyle erken yüklemenin getirdiği sorunlara doğrudan çözümler sunar:

• Daha Hızlı Başlangıç: Sadece temel ve hemen gerekli olan bileşenler başlatılır. Maliyetli işlemler, ilgili nesneye veya değere ilk kez erişilene kadar ertelenir. Bu, uygulamanın veya servisin çok daha hızlı yanıt verir hale gelmesini sağlar.
• Optimize Edilmiş Kaynak Kullanımı: Bellek, CPU, ağ bağlantıları gibi kaynaklar sadece gerçekten ihtiyaç duyulduğunda tüketilir. Kullanılmayan nesneler için kaynak israfı ortadan kalkar. Bu, uygulamanın genel verimliliğini ve ölçeklenebilirliğini artırır.
• İzole Edilmiş Hatalar: Bir nesnenin başlatılması sırasındaki hata, sadece o nesneye ilk kez erişildiğinde ortaya çıkar. Bu, hatanın uygulamanın başlangıcını engellemesini önleyebilir ve hatanın etkisini, o nesneyi kullanmaya çalışan belirli bir iş akışıyla sınırlar. Hata yönetimi daha odaklı hale gelebilir.
• Basitleştirilmiş Bağımlılık Grafikleri (Başlangıçta): Başlangıç anında daha az nesne oluşturulduğu için, başlatma sırası karmaşıklığı azalabilir.

`Lazy`'nin Katkısı Nedir? Tembel yükleme mantığını manuel olarak uygulamak mümkündür (örneğin, null kontrolü yapıp ilk erişimde nesneyi oluşturmak ve bir alanda saklamak), ancak bu yaklaşım özellikle çoklu iş parçacıklı ortamlarda karmaşık ve hataya açıktır. İş parçacığı güvenliğini (yarış durumlarını - race conditions - önlemek) sağlamak, başlatma işleminin yalnızca bir kez yapılmasını garanti etmek ve istisnaları doğru yönetmek ciddi bir mühendislik çabası gerektirir.

Lazy, tüm bu karmaşıklığı bizim için yönetir:

• Standart ve Güvenilir Mekanizma: Tembel yüklemeyi uygulamak için kanıtlanmış, test edilmiş ve standart bir yol sunar.
• İş Parçacığı Güvenliği (Thread Safety): Farklı güvenlik seviyeleri (LazyThreadSafetyMode) sunarak, çoklu iş parçacıklı senaryolarda başlatma işleminin güvenli bir şekilde yapılmasını garanti eder (veya bilinçli olarak kapatılmasına izin verir). Elle yazılan çözümlerdeki potansiyel kilitlenme (deadlock) veya yarış durumu risklerini ortadan kaldırır.
• Yalnızca Bir Kez Başlatma Garantisi (Çoğu Modda): ExecutionAndPublication modunda, başlatma mantığının (fabrika metodu veya yapıcı) yalnızca bir kez çalıştırılacağı garanti edilir. PublicationOnly modunda bile, yalnızca bir sonuç yayınlanır.
• Sonuç Önbellekleme: Başlatma işlemi bir kez yapıldıktan sonra sonuç önbelleğe alınır ve sonraki tüm Value erişimlerinde bu önbelleğe alınan değer döndürülür.
• Kolay Kullanım: Karmaşık kilitleme veya senkronizasyon kodları yazmak yerine, Lazy'yi birkaç satır kodla kullanmak mümkündür. Bu, kodu daha okunabilir ve bakımı kolay hale getirir.

Kısacası, Lazy, tembel yüklemenin faydalarını, manuel implementasyonun zorlukları ve riskleri olmadan elde etmemizi sağlayan, .NET geliştiricisinin araç çantasında mutlaka bulunması gereken temel bir sınıftır.

Daha önce de belirtildiği gibi, LINQ'nun ertelenmiş yürütme (deferred execution) özelliği ile Lazy arasında bir kavramsal benzerlik olsa da (her ikisi de bir işi hemen yapmaz), temel farkları ve kullanım amaçları farklıdır. Bu ayrımı netleştirmek önemlidir:

Bu tablo, iki mekanizmanın farklı problemlere çözüm sunduğunu göstermektedir. LINQ, sorgu ifadesini optimize ederken, Lazy, bir nesnenin yaşam döngüsündeki başlatma anını optimize eder. Her ikisi de performansa katkıda bulunabilir ancak farklı yollarla ve farklı senaryolarda.

Bu, Lazy'nin en temel ve parametresiz yapıcı metodudur. Kullanımı son derece basittir ancak belirli varsayımlara dayanır.

• Çalışma Prensibi: Bu yapıcı ile oluşturulan bir Lazy örneği, T tipinin public ve parametresiz varsayılan yapıcı metodunu (new T()) kullanarak hedef nesneyi oluşturmak üzere yapılandırılır. Başlatma işlemi, Value özelliğine ilk kez erişilene kadar ertelenir.
• Önemli Gereksinim: Bu yapıcıyı kullanabilmek için, generic tip parametresi olan T'nin mutlaka erişilebilir (genellikle public) ve parametre almayan bir yapıcı metoda sahip olması gerekir. Eğer T böyle bir yapıcıya sahip değilse, Lazy örneği oluşturulur ancak Value özelliğine ilk erişimde System.MissingMemberException fırlatılır. Eğer yapıcı metot var ama erişim kısıtlamaları nedeniyle (örneğin private veya internal olması ve erişim hakkı olmaması) erişilemiyorsa, System.MemberAccessException fırlatılabilir.
• Varsayılan İş Parçacığı Güvenliği: Bu yapıcı metot, varsayılan olarak en güvenli mod olan LazyThreadSafetyMode.ExecutionAndPublication modunu kullanır. Bu, birden fazla iş parçacığı aynı anda Value özelliğine erişse bile, new T() işleminin yalnızca bir kez, güvenli bir şekilde çalıştırılacağını ve tüm iş parçacıklarının aynı nesne örneğini alacağını garanti eder.
• Kullanım Senaryoları:
  • Oluşturulacak nesnenin (T) basit bir varsayılan yapıcısı varsa ve ek başlatma mantığı gerekmiyorsa.
  • Nesne oluşturma maliyetli ise veya her zaman ihtiyaç duyulmuyorsa.
  • Çoklu iş parçacıklı bir ortamda çalışılıyorsa ve varsayılan güvenlik seviyesi yeterliyse.
• Dezavantajları: Parametreli yapıcıları veya daha karmaşık başlatma mantığını desteklemez. İş parçacığı güvenliği modunu değiştirmek için kullanılamaz.

public class ExpensiveService
{
    public ExpensiveService() // Public, parametresiz yapıcı
    {
        Console.WriteLine("ExpensiveService başlatılıyor... (Maliyetli işlem)");
        // Örneğin, veritabanı bağlantısı kur, konfigürasyon oku vb.
        System.Threading.Thread.Sleep(2000); // Simüle edilen gecikme
    }

    public void DoWork() => Console.WriteLine("ExpensiveService iş yapıyor.");
}

// Kullanım:
Lazy lazyService = new Lazy(); // Varsayılan yapıcı ve ExecutionAndPublication modu

Console.WriteLine($"Servis oluşturuldu mu? {lazyService.IsValueCreated}"); // False

Console.WriteLine("Value'ya ilk erişim...");
ExpensiveService serviceInstance = lazyService.Value; // Bu satırda ExpensiveService() yapıcısı çalışır
Console.WriteLine($"Servis oluşturuldu mu? {lazyService.IsValueCreated}"); // True

serviceInstance.DoWork();

Console.WriteLine("Value'ya ikinci erişim...");
ExpensiveService sameInstance = lazyService.Value; // Yapıcı tekrar çalışmaz, önbellekteki örnek döndürülür
sameInstance.DoWork();

// lazyService == sameInstance -> true
                    

Nesne oluşturma işlemi varsayılan yapıcıdan daha karmaşıksa veya belirli parametrelerle yapılması gerekiyorsa, bu yapıcı metot devreye girer.

• Çalışma Prensibi: Bu yapıcı, valueFactory adında bir Func delegesi alır. Bu delege, parametre almayan ve T tipinde bir nesne döndüren bir metodu (veya lambda ifadesini) işaret eder. Value özelliğine ilk kez erişildiğinde, Lazy bu valueFactory'yi çağırır, dönen değeri alır ve sonraki erişimler için önbelleğe alır.
• Func valueFactory Detayları: Func, `.NET`'in generic bir delegesidir. () -> T imzasına sahiptir. Yani, herhangi bir parametre almadan T türünde bir sonuç döndüren herhangi bir metodu temsil edebilir. Lambda ifadeleri (() => { /* mantık */ return new T(...); }) bu delegeye kolayca atanabilir.
• Önemli Gereksinim: Sağlanan valueFactory delegesi null olamaz. Eğer null ise, yapıcı metot hemen System.ArgumentNullException fırlatır. T tipinin varsayılan yapıcısı olması gerekmez, çünkü başlatma mantığı artık valueFactory tarafından sağlanmaktadır.
• Varsayılan İş Parçacığı Güvenliği: Bu yapıcı da varsayılan olarak LazyThreadSafetyMode.ExecutionAndPublication modunu kullanır. Yani, valueFactory'nin birden fazla iş parçacığı tarafından eş zamanlı erişim durumunda bile yalnızca bir kez çağrılacağı garanti edilir.
• Kullanım Senaryoları:
  • Parametre alan bir yapıcıyı çağırmak gerektiğinde.
  • Nesneyi oluşturmadan önce veya sonra ek yapılandırma veya başlatma adımları gerektiğinde.
  • Nesnenin bir fabrika metodundan (factory method) alınması gerektiğinde.
  • Oluşturma işleminin karmaşık bir hesaplama veya veri getirme işlemi içerdiği durumlarda.
  • Singleton deseni gibi özel başlatma senaryolarında.

public class DatabaseSettings
{
    public string ConnectionString { get; private set; }
    public int Timeout { get; private set; }

    // Parametreli yapıcı
    public DatabaseSettings(string connectionString, int timeout = 30)
    {
        Console.WriteLine("DatabaseSettings başlatılıyor...");
        ConnectionString = connectionString;
        Timeout = timeout;
        // ... belki başka başlatma işlemleri ...
    }
}

// Kullanım:
Lazy lazySettings = new Lazy(() =>
{
    Console.WriteLine("ValueFactory çalışıyor...");
    // Konfigürasyon dosyasından veya başka bir yerden değerleri oku
    string connStr = "Server=myServer;Database=myDataBase;Trusted_Connection=True;";
    int timeout = 60;
    return new DatabaseSettings(connStr, timeout); // Parametreli yapıcıyı çağır
});

Console.WriteLine($"Ayarlar oluşturuldu mu? {lazySettings.IsValueCreated}"); // False

Console.WriteLine("Value'ya ilk erişim...");
DatabaseSettings settings = lazySettings.Value; // Lambda ifadesi çalışır, DatabaseSettings(connStr, timeout) çağrılır
Console.WriteLine($"Ayarlar oluşturuldu mu? {lazySettings.IsValueCreated}"); // True
Console.WriteLine($"Connection String: {settings.ConnectionString}");

Console.WriteLine("Value'ya ikinci erişim...");
DatabaseSettings sameSettings = lazySettings.Value; // Fabrika metodu tekrar çalışmaz
Console.WriteLine($"Timeout: {sameSettings.Timeout}");
                    

Bu yapıcı, T'nin varsayılan yapıcısını kullanır ancak iş parçacığı güvenliğini basit bir bool değeri ile kontrol etme imkanı sunar. Modern kodlarda genellikle Lazy(LazyThreadSafetyMode mode) tercih edilir.

• Çalışma Prensibi: T'nin varsayılan yapıcısını (new T()) kullanır. isThreadSafe parametresi true ise LazyThreadSafetyMode.ExecutionAndPublication modunda, false ise LazyThreadSafetyMode.None modunda çalışır.
• Parametre (isThreadSafe):
  • true: Tam iş parçacığı güvenliği. Yapıcı bir kez çalışır.
  • false: İş parçacığı güvenliği yok. Yalnızca tek iş parçacıklı kullanım için güvenlidir.
• Gereksinim: T'nin public, parametresiz bir yapıcısı olmalıdır.
• Kullanım Senaryoları: Genellikle geriye dönük uyumluluk veya çok basit senaryolarda kullanılır. LazyThreadSafetyMode.PublicationOnly seçeneğini sunmaz. Eğer iş parçacığı güvenliğini None olarak ayarlamak istiyorsanız ve varsayılan yapıcı yeterliyse kullanılabilir, ancak Lazy(LazyThreadSafetyMode.None) daha açıklayıcıdır.

// Güvenlik yok, sadece tek thread kullanacak (dikkatli kullan!)
Lazy unsafeBuilder = new Lazy(false);

// Tam güvenlik (lazyService ile aynı davranışı gösterir)
Lazy safeService = new Lazy(true);
                    

Bu yapıcı, T'nin varsayılan yapıcısını kullanırken iş parçacığı güvenliği üzerinde tam kontrol sağlar ve genellikle Lazy(bool isThreadSafe)'e tercih edilir.

• Çalışma Prensibi: T'nin varsayılan yapıcısını (new T()) kullanır. İş parçacığı güvenliği davranışını, parametre olarak aldığı LazyThreadSafetyMode enum değeri (None, PublicationOnly, ExecutionAndPublication) belirler.
• Parametre (mode): Seçilen moda göre güvenlik ve performans dengesi ayarlanır. (Detayları bir sonraki bölümde ele alınacaktır).
• Gereksinim: T'nin public, parametresiz bir yapıcısı olmalıdır. mode için geçerli bir enum değeri sağlanmalıdır.
• Kullanım Senaryoları:
  • Varsayılan yapıcı yeterli olduğunda ancak iş parçacığı güvenliği üzerinde hassas kontrol gerektiğinde (örneğin, PublicationOnly modunu kullanmak veya None modunu açıkça belirtmek için).
  • Kodun okunabilirliğini artırmak için güvenlik modunu doğrudan belirtmek istendiğinde.

// Varsayılan yapıcı, tam güvenlik (en yaygın ve güvenli)
Lazy configMgr = new Lazy(LazyThreadSafetyMode.ExecutionAndPublication);

// Varsayılan yapıcı, yayınlama güvenliği (ConfigurationManager() yan etkisiz ve tekrar çalışması sorun değilse)
Lazy resourceProvider = new Lazy(LazyThreadSafetyMode.PublicationOnly);

// Varsayılan yapıcı, güvenlik yok (tek thread için)
Lazy sessionData = new Lazy(LazyThreadSafetyMode.None);
                    

Özel bir başlatma mantığı (valueFactory) ile bool tabanlı güvenlik ayarını birleştirir.

• Çalışma Prensibi: Belirtilen valueFactory'yi kullanır. isThreadSafe true ise ExecutionAndPublication, false ise None modunda çalışır.
• Gereksinimler: valueFactory null olamaz.
• Kullanım Senaryoları: Özel başlatma mantığı gerektiğinde ve güvenlik modu olarak sadece None veya ExecutionAndPublication arasında seçim yapmak yeterliyse kullanılır. PublicationOnly modunu desteklemez. Lazy(Func valueFactory, LazyThreadSafetyMode mode) genellikle daha esnek ve açıklayıcıdır.

// Güvenli, özel fabrika
Lazy profile = new Lazy(() => LoadUserProfile(userId), true);

// Güvensiz (tek thread), özel fabrika
Lazy tempFile = new Lazy(CreateTempFile, false);
                    

Bu yapıcı, hem özel başlatma mantığı (valueFactory) hem de ayrıntılı iş parçacığı güvenliği modu (LazyThreadSafetyMode) üzerinde tam kontrol sunar. Genellikle en çok tercih edilen ve en güçlü yapılandırıcıdır.

• Çalışma Prensibi: Belirtilen valueFactory delegesini kullanarak ve seçilen LazyThreadSafetyMode (None, PublicationOnly, ExecutionAndPublication) kurallarına göre nesneyi tembelce başlatır.
• Gereksinimler: valueFactory null olamaz. mode geçerli bir enum değeri olmalıdır.
• Kullanım Senaryoları: Neredeyse tüm Lazy kullanım durumları için uygundur. Özellikle:
  • Karmaşık veya özel başlatma mantığı gerektiğinde.
  • İş parçacığı güvenliği üzerinde tam kontrol istendiğinde (performans ve güvenlik arasında bilinçli bir denge kurmak için).
  • Kodun amacını en açık şekilde ifade etmek istendiğinde.

// Singleton deseni için thread-safe fabrika
private static readonly Lazy instance =
    new Lazy(() => new MySingleton(), LazyThreadSafetyMode.ExecutionAndPublication);

public static MySingleton Instance => instance.Value;

// Yan etkisiz fabrika ile PublicationOnly modu (performans odaklı)
Lazy data = new Lazy(
    LoadImmutableData, // Bu metodun tekrar çağrılması sorun yaratmamalı
    LazyThreadSafetyMode.PublicationOnly
);

// Tek thread'de çalışacak özel hesaplama, güvenlik gereksiz
Lazy result = new Lazy(
    DoExpensiveCalculation,
    LazyThreadSafetyMode.None
);
                    

Doğru yapıcı metodu seçmek, Lazy'nin davranışını uygulamanızın gereksinimlerine tam olarak uyacak şekilde ayarlamanıza olanak tanır.

Tanım: Bu mod, iş parçacığı güvenliği için hiçbir ek yük veya kontrol getirmez. Lazy örneği, sanki tek bir iş parçacığında çalışıyormuş gibi davranır.

Eş Zamanlı Erişimde Davranış: Eğer birden fazla iş parçacığı, henüz başlatılmamış (IsValueCreated == false) bir Lazy örneğinin Value özelliğine aynı anda erişirse, tam bir yarış durumu (race condition) ortaya çıkar. Kilitleme mekanizması olmadığı için, her iş parçacığı IsValueCreated kontrolünü geçebilir ve başlatma mantığını (fabrika metodu veya varsayılan yapıcı) çalıştırmaya başlayabilir. Bu durumda:

• Başlatma mantığı birden fazla kez çalıştırılabilir.
• Value özelliği, farklı iş parçacıkları için potansiyel olarak farklı nesne örneklerini döndürebilir (eğer fabrika metodu her çağrıldığında yeni bir örnek oluşturuyorsa).
• Eğer başlatma mantığı paylaşılan bir durumu değiştiriyorsa veya yan etkileri varsa, bu durumun tutarlılığı bozulabilir (data corruption).
• Beklenmedik istisnalar veya hatalar meydana gelebilir.

Performans: Hiçbir senkronizasyon (kilitleme vb.) ek yükü olmadığı için, teorik olarak en yüksek performansı sunar.

Ne Zaman Kullanılmalı? (Çok Dikkatli!): Bu mod, yalnızca ve yalnızca ilgili Lazy örneğine hayatı boyunca tek bir iş parçacığından erişileceğinden %100 emin olduğunuz durumlarda kullanılmalıdır. Bu garantiyi sağlamak çoğu zaman zordur. Potansiyel kullanım alanları şunlar olabilir:

• Bir metot içindeki yerel değişken olarak tanımlanan Lazy.
• Kesinlikle sadece UI iş parçacığı tarafından kullanılan bir sınıf üyesi.
• İş parçacığı güvenliğinin dışarıdan başka mekanizmalarla (örneğin, lock ifadeleriyle) sağlandığı özel durumlar (ancak bu genellikle Lazy'nin amacını bozar).

Tanım: Bu mod, başlatma işleminin birden fazla kez çalışmasına izin verir ancak sonucun yalnızca bir kez yayınlanmasını garanti eder.

Eş Zamanlı Erişimde Davranış: Henüz başlatılmamış bir Lazy örneğinin Value özelliğine birden fazla iş parçacığı aynı anda erişirse:

• Her iş parçacığı başlatma mantığını (fabrika metodu veya varsayılan yapıcı) çalıştırmaya başlayabilir. Yani, fabrika metodu potansiyel olarak birden fazla kez çağrılır.
• Ancak, Lazy sınıfı, bu yarışan başlatma işlemlerinden yalnızca ilk tamamlananın sonucunu atomik olarak kaydeder ve "yayınlar".
• Diğer iş parçacıklarının tamamladığı başlatma işlemlerinin sonuçları yok sayılır (atılır).
• Sonuç olarak, Value özelliğine erişen tüm iş parçacıkları, başlatma işlemini kimin yaptığına bakılmaksızın, sonunda aynı, tek bir yayınlanmış nesne örneğini veya değeri alırlar.

Performans: None modundan biraz daha yavaştır çünkü sonucun atomik olarak yayınlanması için bir miktar senkronizasyon gerekir. Ancak, ExecutionAndPublication modundaki tam kilitlemeye göre genellikle daha performanslıdır, çünkü başlatma işlemi sırasında diğer iş parçacıklarını bloke etmez (sadece sonuç yayınlama anında kısa bir senkronizasyon olabilir).

Ne Zaman Kullanılmalı? (Dikkatli Seçim): Bu modun güvenle kullanılabilmesi için kritik ön koşul, başlatma mantığının (fabrika metodu veya varsayılan yapıcı) tekrarlanabilir (idempotent) olması ve önemli yan etkilerden (side effects) arınmış olmasıdır. Yani:

• Metodun birden fazla kez çalıştırılması, uygulamanın genel durumunu bozmamalıdır (örneğin, aynı dosyayı tekrar tekrar oluşturmaya çalışmamalı, bir sayacı birden fazla kez artırmamalı, aynı veritabanı kaydını tekrar eklemeye çalışmamalıdır).
• Metot her çalıştığında temelde aynı veya eşdeğer bir sonuç üretmelidir (veya üretilen farklı sonuçların atılmasının bir zararı olmamalıdır).

• Başlatma işleminin kendisi çok maliyetli değilse ancak kilit çekişmesinin (lock contention) yüksek olabileceği ve ExecutionAndPublication modunun performans darboğazı yaratabileceği senaryolarda.
• Genellikle değişmez (immutable) nesneler oluşturulduğunda (çünkü bunların tekrar oluşturulmasının yan etkisi yoktur).
• Önbellek doldurma gibi işlemlerde, aynı verinin birden fazla iş parçacığı tarafından aynı anda getirilmeye çalışılması ancak sadece birinin sonucunun kullanılmasının kabul edilebilir olduğu durumlarda.

Tanım: Bu mod, hem başlatma işleminin yalnızca bir kez çalıştırılmasını hem de sonucun güvenli bir şekilde yayınlanmasını garanti eden en katı ve en güvenli moddur. Bu, Lazy'nin varsayılan davranışıdır.

Eş Zamanlı Erişimde Davranış: Henüz başlatılmamış bir Lazy örneğinin Value özelliğine birden fazla iş parçacığı aynı anda erişirse:

• Lazy sınıfı dahili bir kilitleme mekanizması kullanır.
• Yalnızca bir iş parçacığı kilidi alabilir ve başlatma mantığını (fabrika metodu veya varsayılan yapıcı) çalıştırmaya başlar.
• Diğer iş parçacıkları, kilidi alan iş parçacığı başlatma işlemini tamamlayana kadar bekletilir (bloke edilir).
• Başlatma işlemi tamamlandığında, sonuç önbelleğe alınır ve kilit serbest bırakılır.
• Hem başlatmayı yapan iş parçacığı hem de bekleyen diğer tüm iş parçacıkları, Value özelliğinden aynı, önbelleğe alınmış nesne örneğini veya değeri alırlar.

Performans: Kilitleme mekanizması nedeniyle diğer iki moda göre (özellikle None) bir miktar performans ek yükü getirir. Bu ek yük, özellikle kilit üzerinde yoğun çekişme (contention) olduğunda, yani çok sayıda iş parçacığı aynı anda başlatılmamış Lazy'ye erişmeye çalıştığında daha belirgin olabilir. Ancak, çoğu tipik uygulama senaryosunda bu ek yük genellikle kabul edilebilir düzeydedir. .NET implementasyonu genellikle optimize edilmiş kilitleme teknikleri (örneğin, double-checked locking'in dikkatli bir implementasyonu) kullanır.

Ne Zaman Kullanılmalı? (Genellikle En İyi Seçim):

• Lazy örneğine birden fazla iş parçacığından erişilebilecek herhangi bir senaryo için en güvenli seçenektir.
• Başlatma mantığının (fabrika metodu veya yapıcının) kesinlikle yalnızca bir kez çalıştırılması gerekiyorsa (örneğin, yan etkileri varsa, kaynakları başlatıyorsa, Singleton deseni implemente ediyorsa veya işlem çok maliyetliyse).
• Hangi güvenlik modunun gerekli olduğundan emin değilseniz, varsayılan davranış olduğu için bu modla başlamak en doğrusudur.
• Performansın mutlak en üst düzeyde kritik olmadığı ve güvenliğin öncelikli olduğu durumlar için idealdir.

Bu salt okunur (read-only) özellik, Lazy tarafından yönetilen, tembel olarak başlatılan nesneye veya değere erişmenin tek yoludur. Davranışı, özelliğe ilk kez mi yoksa sonraki seferlerde mi erişildiğine bağlı olarak değişir:

• İlk Erişim (IsValueCreated == false iken):
  1. Seçilen LazyThreadSafetyMode'a göre gerekli senkronizasyon (kilitleme vb.) yapılır.
  2. Başlatma mantığı tetiklenir:
     • Eğer yapıcı metoda bir valueFactory (Func) sağlandıysa, bu delege çağrılır.
     • Eğer valueFactory sağlanmadıysa, T tipinin varsayılan parametresiz yapıcısı (new T()) çağrılır.
  3. Başlatma mantığının döndürdüğü değer (veya oluşturulan nesne) Lazy örneği içinde dahili olarak önbelleğe alınır.
  4. IsValueCreated bayrağı true olarak ayarlanır.
  5. Önbelleğe alınan değer veya nesne, özelliğin çağrıldığı yere döndürülür.
  6. Eğer başlatma mantığı sırasında bir istisna (exception) fırlatılırsa:
     • Bu istisna yakalanır ve Lazy örneği içinde saklanır.
     • IsValueCreated bayrağı false kalır (veya bazı implementasyonlarda özel bir "hatalı" duruma geçebilir).
     • Yakalanan istisna, Value özelliğine erişmeye çalışan koda yeniden fırlatılır (re-thrown).
     • Önemli: ExecutionAndPublication modunda, bu istisna önbelleğe alınır. Value özelliğine sonraki tüm erişimlerde, başlatma mantığı tekrar çalıştırılmaz; bunun yerine önbelleğe alınan aynı istisna tekrar tekrar fırlatılır. Bu, başlatma hatasının kalıcı olduğunu gösterir. Diğer modlarda davranış biraz farklı olabilir (örneğin, PublicationOnly modunda başka bir thread başarılı olabilir).
  7. Eğer T için varsayılan yapıcı kullanılıyorsa ve bu yapıcı bulunamazsa MissingMemberException, erişilemezse MemberAccessException fırlatılır.
  8. Eğer valueFactory kendi içinden yine aynı Lazy örneğinin Value özelliğine erişmeye çalışırsa (özyinelemeli - recursive - bir durum), System.InvalidOperationException fırlatılır.
• Sonraki Erişimler (IsValueCreated == true iken):
  • Başlatma mantığı (fabrika veya yapıcı) tekrar çalıştırılmaz.
  • Dahili olarak önbelleğe alınmış olan değer veya nesne doğrudan döndürülür.
  • Bu erişim son derece hızlıdır, çünkü sadece önbellekten okuma yapılır (minimal senkronizasyon maliyeti olabilir, moda bağlı olarak).

Value özelliği, Lazy'nin temel işlevselliğini sağlar: isteğe bağlı, güvenli ve önbelleğe alınmış başlatma.

Bu salt okunur özellik, Lazy örneği için bir değerin (veya nesnenin) başarılı bir şekilde oluşturulup oluşturulmadığını gösteren bir bool değeri döndürür.

• false Değeri: Value özelliğine henüz hiç erişilmemiş veya ilk erişim sırasında bir istisna fırlatılmış ve değer başarıyla oluşturulamamışsa false döndürür.
• true Değeri: Value özelliğine en az bir kez başarılı bir şekilde erişilmiş ve başlatma mantığı bir değer üretip bu değer önbelleğe alınmışsa true döndürür.
• Önemli Özellik: IsValueCreated özelliğine erişmek, başlatma işlemini tetiklemez. Bu, bir değerin oluşturulup oluşturulmadığını, onu oluşturma maliyetine katlanmadan kontrol etmek için güvenli bir yoldur.
• Kullanım Senaryoları:
  • Hata Ayıklama (Debugging): Bir Lazy örneğinin belirli bir noktada başlatılıp başlatılmadığını kontrol etmek için kullanışlıdır. Visual Studio'nun DebuggerDisplay özelliği de genellikle bu bilgiyi gösterir.
  • Duruma Bağlı Mantık (Nadir Kullanım): Çok nadiren, bir değerin zaten oluşturulmuş olup olmamasına bağlı olarak farklı bir mantık çalıştırmak isteyebilirsiniz. Ancak bu genellikle Lazy'nin amacına aykırıdır; Lazy'nin güzelliği, başlatma detaylarını soyutlamasıdır. Genellikle sadece Value'ya erişmek yeterlidir.
  • Kaynak Temizleme Senaryoları?: Bir Lazy tarafından oluşturulan nesne IDisposable ise ve bu nesnenin sadece oluşturulduysa temizlenmesi gerekiyorsa, IsValueCreated kontrol edilerek Value.Dispose() çağrısı yapılabilir. Ancak bu manuel yönetim gerektirir ve genellikle Lazy'nin kendisi IDisposable olmadığından dikkatli olunmalıdır.

Lazy lazyData = new Lazy(() => {
    Console.WriteLine("Veri yükleniyor...");
    return "Yüklenen Veri";
});

if (!lazyData.IsValueCreated) // Başlatmayı tetiklemez
{
    Console.WriteLine("Veri henüz yüklenmedi.");
}

string data = lazyData.Value; // Şimdi yüklenir

if (lazyData.IsValueCreated) // Başlatmayı tetiklemez
{
    Console.WriteLine("Veri şimdi yüklendi.");
}
                    

Lazy sınıfı, System.Object'ten miras aldığı ToString() metodunu, örneğin mevcut durumu hakkında bilgi verecek şekilde override eder.

• Değer Oluşturulmadıysa (IsValueCreated == false): Genellikle "Value is not created." (Değer oluşturulmadı) veya benzeri bir mesaj içeren bir string döndürür.
• Değer Oluşturulduysa (IsValueCreated == true): Önbelleğe alınan değerin (Value özelliğinin) kendi ToString() metodunu çağırır ve onun sonucunu döndürür.
• Önemli Not: Eğer değer oluşturulmuşsa, ToString() metodunu çağırmak, Value özelliğine erişmekle aynı etkiye sahip olabilir (eğer Value'nun ToString()'u önemli bir iş yapıyorsa). Ancak, değer henüz oluşturulmadıysa, ToString() başlatma işlemini tetiklemez.
• İstisna Durumu: Eğer Value null ise ve ToString() çağrılırsa NullReferenceException fırlatabilir. Eğer başlatma sırasında bir istisna oluşmuşsa, ToString()'un davranışı implementasyona göre değişebilir, ancak genellikle hatayı belirtir.
• Kullanım Amacı: Öncelikle hata ayıklama ve loglama amaçlıdır. Lazy örneğinin o anki durumu hakkında hızlı bir fikir verir.

Lazy lazyInt = new Lazy(() => 123);

Console.WriteLine(lazyInt.ToString()); // Muhtemelen "Value is not created." yazar

int value = lazyInt.Value; // Başlatma tetiklenir

Console.WriteLine(lazyInt.ToString()); // "123" yazar (int'in ToString() sonucu)
                    

Singleton deseni, bir sınıftan yalnızca tek bir örnek (instance) oluşturulmasını ve bu örneğe global bir erişim noktası sağlanmasını amaçlar. Çoklu iş parçacıklı ortamlarda Singleton'ı doğru ve güvenli bir şekilde implemente etmek zor olabilir (double-checked locking gibi teknikler karmaşık ve hataya açıktır). Lazy, bu problemi son derece basit ve güvenilir bir şekilde çözer:

public sealed class MySingleton
{
    // Lazy örneğini static ve readonly olarak tanımla.
    // valueFactory olarak private yapıcıyı çağır.
    // Varsayılan mod (ExecutionAndPublication) tam thread güvenliği sağlar.
    private static readonly Lazy lazyInstance =
        new Lazy(() => new MySingleton());

    // Global erişim noktası. Value'ya ilk erişimde instance oluşturulur.
    public static MySingleton Instance => lazyInstance.Value;

    // Yapıcı metodu private yaparak dışarıdan 'new' ile örnek alınmasını engelle.
    private MySingleton()
    {
        Console.WriteLine("MySingleton instance oluşturuluyor...");
        // ... Başlatma işlemleri ...
    }

    public void Log(string message)
    {
        Console.WriteLine($"Singleton Log: {message}");
    }
}

// Kullanım:
MySingleton.Instance.Log("İlk mesaj");
MySingleton.Instance.Log("İkinci mesaj");
// Yapıcı metot sadece ilk Instance erişiminde bir kez çalışır.
                     

Bu implementasyon:

• Thread-Safe'dir: Lazy'nin varsayılan modu sayesinde, birden fazla iş parçacığı aynı anda Instance'a erişse bile yapıcı metot yalnızca bir kez çalıştırılır.
• Lazy'dir: Singleton örneği, Instance özelliğine ilk kez erişilene kadar oluşturulmaz. Bu, uygulama başlangıcını hızlandırabilir.
• Basittir: Karmaşık kilitleme kodları yazmaya gerek kalmaz.

Veritabanı bağlantıları, ağ servis istemcileri, büyük konfigürasyon nesneleri veya yüklenmesi uzun süren veri kümeleri gibi kaynakların başlatılması maliyetlidir ve her zaman hemen ihtiyaç duyulmayabilir.

public class DataAccessLayer
{
    private readonly Lazy _lazyConnection;
    private readonly string _connectionString;

    public DataAccessLayer(string connectionString)
    {
        _connectionString = connectionString;
        // Bağlantı, sadece gerçekten ihtiyaç duyulduğunda oluşturulacak.
        _lazyConnection = new Lazy(() => {
            Console.WriteLine("SqlConnection oluşturuluyor ve açılıyor...");
            var connection = new SqlConnection(_connectionString);
            connection.Open(); // Bağlantıyı açma işlemi de tembel olabilir
            return connection;
        }, LazyThreadSafetyMode.ExecutionAndPublication); // Thread-safe
    }

    public SqlConnection Connection => _lazyConnection.Value;

    public IEnumerable GetProductNames()
    {
        // Connection özelliğine ilk erişimde bağlantı oluşturulur ve açılır.
        using (var command = new SqlCommand("SELECT Name FROM Products", Connection))
        using (var reader = command.ExecuteReader())
        {
            while (reader.Read())
            {
                yield return reader.GetString(0);
            }
        }
        // Dikkat: Bağlantının ne zaman kapatılacağı yönetilmelidir!
        // Lazy IDisposable olmadığı için otomatik kapatmaz.
        // Belki ayrı bir Dispose metodu veya using bloğu gerekir.
    }

    // Belki IDisposable implementasyonu ile bağlantıyı kapatmak gerekir
    // public void Dispose() { if (_lazyConnection.IsValueCreated) _lazyConnection.Value.Dispose(); }
}

// Kullanım:
var dal = new DataAccessLayer("...");
Console.WriteLine("DataAccessLayer oluşturuldu."); // Bağlantı henüz kurulmadı

// Sadece bu çağrıda bağlantı kurulacak:
var names = dal.GetProductNames().ToList();
Console.WriteLine("Ürün adları alındı.");
                    

Önemli Not (IDisposable): Lazy'nin kendisi IDisposable arayüzünü implemente etmez. Eğer Lazy tarafından oluşturulan nesne (T) IDisposable ise (örneğimizdeki SqlConnection gibi), bu nesnenin kaynağını serbest bırakmak (yani Dispose() metodunu çağırmak) sizin sorumluluğunuzdadır. Lazy bunu otomatik olarak yapmaz. Bu genellikle, Lazy'yi içeren sınıfın kendisinin IDisposable olması ve Dispose metodunda if (lazyInstance.IsValueCreated) lazyInstance.Value.Dispose(); kontrolünü yapmasıyla yönetilir.

Bir uygulama, kullanıcının nadiren eriştiği ancak oluşturulması veya yüklenmesi bellek veya zaman açısından pahalı olan büyük veri yapılarına (örneğin, tüm ülke/şehir listesi, büyük bir rapor şablonu) sahip olabilir.

public class ApplicationSettings
{
    // Basit ayarlar hemen yüklenebilir
    public string Theme { get; set; } = "Default";

    // Tüm dünya ülkelerinin listesi - pahalı olabilir, tembel yükleyelim
    private readonly Lazy> _lazyCountries;

    public ApplicationSettings()
    {
        _lazyCountries = new Lazy>(() =>
        {
            Console.WriteLine("Ülke listesi veritabanından yükleniyor...");
            // ... Veritabanından veya dosyadan yükleme işlemi ...
            return LoadCountriesFromDataSource();
        });
    }

    // Ülke listesine sadece ihtiyaç duyulduğunda erişilir ve yüklenir.
    public List AllCountries => _lazyCountries.Value;

    private List LoadCountriesFromDataSource()
    {
        // Simüle edilmiş yükleme
        System.Threading.Thread.Sleep(1500);
        return new List { /* ... doldurulmuş liste ... */ };
    }
}

// Kullanım:
var settings = new ApplicationSettings();
Console.WriteLine($"Tema: {settings.Theme}"); // Ülke listesi henüz yüklenmedi

// Kullanıcı ülke seçme ekranını açtığında:
Console.WriteLine("Ülkeler yükleniyor...");
var countries = settings.AllCountries; // Bu satırda LoadCountriesFromDataSource çalışır
Console.WriteLine($"Toplam {countries.Count} ülke yüklendi.");
                     

Sonucu her zaman gerekmeyen ancak hesaplanması uzun süren matematiksel işlemler, veri analizleri veya simülasyonlar tembel olarak başlatılabilir.

public class FinancialReport
{
    private readonly Lazy _lazyComplexProjection;

    public FinancialReport(InputData data)
    {
        _lazyComplexProjection = new Lazy(() =>
        {
            Console.WriteLine("Karmaşık projeksiyon hesaplanıyor...");
            // ... Saatler sürebilecek bir hesaplama ...
            return CalculateComplexProjection(data);
        });
    }

    // Projeksiyon sonucuna sadece istendiğinde erişilir.
    public decimal ComplexProjection => _lazyComplexProjection.Value;

    private decimal CalculateComplexProjection(InputData data)
    {
        // ... Hesaplama mantığı ...
        System.Threading.Thread.Sleep(5000); // Simülasyon
        return 1234567.89m;
    }
}

// Kullanım:
var report = new FinancialReport(someData);
Console.WriteLine("Rapor nesnesi oluşturuldu."); // Hesaplama henüz başlamadı

// Sadece kullanıcı "Detaylı Projeksiyon Göster" butonuna tıklarsa:
Console.WriteLine("Projeksiyon hesaplanıyor...");
decimal projection = report.ComplexProjection; // Hesaplama burada yapılır
Console.WriteLine($"Projeksiyon Sonucu: {projection}");
                     

Lazy öncesinde veya basit senaryolarda geliştiriciler tembel yüklemeyi manuel olarak implemente edebilirlerdi:

public class ManualLazyService
{
    private ExpensiveService _serviceInstance;
    private readonly object _lock = new object(); // Kilitleme için nesne

    public ExpensiveService Service
    {
        get
        {
            // Double-Checked Locking (Dikkat: Doğru implementasyonu zor!)
            if (_serviceInstance == null) // İlk kontrol (kilitsiz)
            {
                lock (_lock) // Kilit al
                {
                    if (_serviceInstance == null) // İkinci kontrol (kilitliyken)
                    {
                        Console.WriteLine("Manuel olarak başlatılıyor...");
                        _serviceInstance = new ExpensiveService();
                    }
                }
            }
            return _serviceInstance;
        }
    }
}
                    

Karşılaştırma:

• Karmaşıklık: Manuel implementasyon, özellikle iş parçacığı güvenliği (double-checked locking'in doğru yapılması gibi) açısından Lazy'den çok daha karmaşık ve hataya açıktır.
• Güvenilirlik: Lazy, .NET ekibi tarafından test edilmiş ve optimize edilmiş, kanıtlanmış bir çözümdür. Manuel kodda hata yapma riski daha yüksektir.
• Esneklik: Lazy'nin farklı thread güvenlik modları gibi özellikleri manuel olarak sağlamak daha zordur.
• Okunabilirlik: Lazy kullanımı kodu daha kısa ve anlaşılır kılar.

System.Threading.LazyInitializer sınıfı, Lazy'ye benzer şekilde tembel başlatma için statik yardımcı metotlar sunar. Özellikle mevcut bir alanı (field) tembel olarak başlatmak için kullanılır.

public class UsingLazyInitializer
{
    private ExpensiveService _service;
    private object _syncLock = null; // Veya önceden oluşturulmuş bir kilit nesnesi

    public ExpensiveService Service
    {
        get
        {
            // EnsureInitialized metodu, _service null ise fabrika metodunu çağırır.
            // Thread güvenliğini yönetir (dahili kilit veya spin-wait kullanabilir).
            LazyInitializer.EnsureInitialized(ref _service, ref _syncLock, () => {
                 Console.WriteLine("LazyInitializer ile başlatılıyor...");
                 return new ExpensiveService();
            });
            return _service;
        }
    }
}
                    

Karşılaştırma:

• Amaç: LazyInitializer, özellikle mevcut bir referans tipindeki alanı (genellikle null ile başlar) güvenli bir şekilde başlatmak için tasarlanmıştır. Lazy ise değerin kendisini veya nesneyi sarmalar.
• Kullanım: LazyInitializer doğrudan alan üzerinde çalışır, Lazy ise bir sarmalayıcı nesne oluşturur. LazyInitializer kullanımı biraz daha düşük seviyeli hissettirebilir.
• Esneklik: Lazy'nin farklı güvenlik modları ve IsValueCreated gibi özellikleri daha fazla esneklik sunar. LazyInitializer'ın seçenekleri daha sınırlıdır.
• Önbellekleme: Her ikisi de sonucu önbelleğe alır.

Lazy'nin önemli bir sınırlaması, başlatma işleminin (fabrika metodunun) senkron olması gerektiğidir. Eğer başlatma işlemi asenkron bir işlem içeriyorsa (örneğin, await kullanarak bir ağ çağrısı yapmak), Lazy doğrudan kullanılamaz. Func içinde async/await kullanamazsınız ve senkron bir metot içinde .Result veya .Wait() kullanmak kilitlenmelere (deadlocks) yol açabilir.

Bu sorunu çözmek için AsyncLazy kavramı ortaya çıkmıştır. Ancak AsyncLazy, .NET Base Class Library'nin (BCL) standart bir parçası değildir. Geliştiriciler genellikle kendi AsyncLazy implementasyonlarını yazarlar veya güvenilir kütüphanelerden (örneğin, Stephen Toub'un blog yazılarındaki örnekler veya Stephen Cleary'nin AsyncEx kütüphanesi) faydalanırlar.

Tipik bir AsyncLazy implementasyonu şuna benzer (kavramsal olarak):

// Not: Bu BCL'de yer alan bir sınıf DEĞİLDİR! Örnek bir yapı.
public class AsyncLazy : Lazy> // Genellikle Lazy> üzerine kurulur
{
    public AsyncLazy(Func> taskFactory)
        : base(taskFactory, LazyThreadSafetyMode.ExecutionAndPublication) { }

    public TaskAwaiter GetAwaiter()
    {
        return Value.GetAwaiter(); // Lazy>'nin Value'su olan Task'ı await edilebilir yapar
    }
}

// Kullanım:
private readonly AsyncLazy _lazyData = new AsyncLazy(async () => {
    Console.WriteLine("Asenkron veri yükleniyor...");
    await Task.Delay(1000); // Asenkron işlem simülasyonu
    return await LoadDataFromApiAsync();
});

public async Task GetDataAsync()
{
    Console.WriteLine("Veriye erişiliyor...");
    // AsyncLazy doğrudan await edilebilir. Fabrika metodu ilk await'te çalışır.
    MyData data = await _lazyData;
    Console.WriteLine("Veri alındı.");
    return data;
}
                      

Karşılaştırma (Lazy vs AsyncLazy):

• Lazy senkron başlatma içindir.
• AsyncLazy asenkron (async/await) başlatma içindir.
• Lazy.Value doğrudan T döndürür.
• AsyncLazy genellikle await edilerek T sonucunu verir (arka planda Task yönetir).
• AsyncLazy BCL'de yoktur, harici olarak sağlanmalıdır.

Daha önce de belirtildiği gibi, eğer valueFactory (veya varsayılan yapıcı) Value'ya ilk erişim sırasında bir istisna fırlatırsa, ExecutionAndPublication modunda bu istisna önbelleğe alınır. Bu şu anlama gelir:

• Value özelliğine yapılan sonraki tüm erişimler, başlatma mantığını tekrar çalıştırmak yerine, önbelleğe alınan aynı istisnayı tekrar fırlatacaktır.
• Bu davranış, başlatma işleminin kalıcı olarak başarısız olduğunu gösterir. "Bir dahaki sefere belki çalışır" mantığı burada işlemez.
• Eğer başlatma işleminin tekrar denenebilmesini istiyorsanız (örneğin, geçici bir ağ hatası nedeniyle başarısız olduysa), Lazy'yi doğrudan kullanamazsınız. Bu durumda, Lazy'yi yeniden oluşturmanız veya başlatma mantığını tekrar deneyen özel bir sarmalayıcı (wrapper) sınıf yazmanız gerekebilir.
• Value erişimini her zaman bir try-catch bloğu içine almak, özellikle başlatmanın başarısız olma olasılığı varsa (dış bağımlılıklar vb.), iyi bir pratiktir.

Lazy lazyClient = new Lazy(() => {
    Console.WriteLine("WebClient oluşturuluyor...");
    // Simüle edilmiş ağ hatası
    throw new System.Net.WebException("Bağlantı kurulamadı!");
    // return new WebClient(); // Bu satıra ulaşılamaz
});

try
{
    WebClient client1 = lazyClient.Value; // İlk erişim, WebException fırlatır
}
catch (System.Net.WebException ex)
{
    Console.WriteLine($"İlk Hata: {ex.Message}");
}

try
{
    // İstisna önbelleğe alındığı için fabrika metodu tekrar çalışmaz.
    WebClient client2 = lazyClient.Value; // İkinci erişim, aynı WebException'ı tekrar fırlatır
}
catch (System.Net.WebException ex)
{
    Console.WriteLine($"İkinci Hata: {ex.Message}");
}

Console.WriteLine($"Değer oluşturuldu mu? {lazyClient.IsValueCreated}"); // False
                    

Tekrar vurgulamak gerekirse, Lazy kendisi IDisposable değildir. Eğer T tipi IDisposable ise (örneğin FileStream, SqlConnection, HttpClient), Lazy tarafından oluşturulan bu nesnenin kaynağının serbest bırakılması (yani Dispose() metodunun çağrılması) tamamen sizin sorumluluğunuzdadır.

• Lazy'yi içeren sınıfın kendisini IDisposable yapın.
• Bu sınıfın Dispose() metodunda, lazyInstance.IsValueCreated kontrolü yaparak, eğer nesne oluşturulduysa lazyInstance.Value.Dispose() çağrısını yapın.

public class ResourceManager : IDisposable
{
    private readonly Lazy _lazyWriter;
    private bool _disposed = false;

    public ResourceManager(string filePath)
    {
        _lazyWriter = new Lazy(() =>
        {
            Console.WriteLine("StreamWriter oluşturuluyor...");
            return new StreamWriter(filePath, append: true);
        });
    }

    public void WriteData(string data)
    {
        // Value'ya ilk erişimde StreamWriter oluşturulur.
        _lazyWriter.Value.WriteLine(data);
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (!_disposed)
        {
            if (disposing)
            {
                // Yönetilen kaynakları serbest bırak
                if (_lazyWriter.IsValueCreated) // Sadece oluşturulduysa Dispose et
                {
                    Console.WriteLine("StreamWriter Dispose ediliyor...");
                    _lazyWriter.Value.Dispose();
                }
            }
            // Yönetilmeyen kaynaklar burada serbest bırakılır (varsa)
            _disposed = true;
        }
    }
}

// Kullanım:
using (var manager = new ResourceManager("log.txt"))
{
    // manager henüz StreamWriter'ı oluşturmadı.
    manager.WriteData("İlk log mesajı."); // Şimdi oluşturulur ve yazılır.
    manager.WriteData("İkinci log mesajı.");
} // using bloğu bittiğinde manager.Dispose() çağrılır ve StreamWriter kapatılır.
                     

LazyThreadSafetyMode.PublicationOnly modunu kullanırken çok dikkatli olunmalıdır. Eğer valueFactory metodunun yan etkileri varsa (örneğin, global bir durumu değiştiriyorsa, dosyaya yazıyorsa, bir API'yi çağırıyorsa), bu metot birden fazla kez çalıştırılabileceği için beklenmedik ve hatalı sonuçlar ortaya çıkabilir. Bu mod, yalnızca fabrikanın tekrar tekrar çalıştırılmasının güvenli olduğu ve yan etkisiz olduğu durumlarda tercih edilmelidir.

Bir valueFactory delegesi, kendi tanımlandığı Lazy örneğinin Value özelliğine doğrudan veya dolaylı olarak erişmeye çalışırsa, bu sonsuz bir döngüye yol açacağı için System.InvalidOperationException fırlatılır.

Lazy recursiveLazy = null; // Önce null ata
recursiveLazy = new Lazy(() => {
    Console.WriteLine("Recursive factory çalışıyor...");
    // HATA: Kendi Value'suna erişmeye çalışıyor!
    return "Değer: " + recursiveLazy.Value; // InvalidOperationException fırlatır
});

try
{
    string value = recursiveLazy.Value;
}
catch(InvalidOperationException ex)
{
    Console.WriteLine($"Hata: {ex.Message}");
}
                    

valueFactory olarak kullanılan lambda ifadeleri, tanımlandıkları kapsamdaki değişkenleri yakalar (closure). Bu genellikle kullanışlıdır, ancak dikkatli olunması gereken durumlar vardır:

• Değişken Ömrü: Yakalanan değişkenlerin ömrü, Lazy örneğinin ömrü kadar (veya daha fazla) uzayabilir. Bu, beklenenden daha fazla belleğin tutulmasına neden olabilir.
• Değişen Değerler: Eğer yakalanan değişkenin değeri, valueFactory çalıştırılmadan önce değişirse, fabrika çalıştığında bu değişmiş değeri kullanır. Bu, beklenen davranış olabilir ancak bazen kafa karıştırıcı olabilir.

int counter = 5;
Lazy lazyWithClosure = new Lazy(() => {
    Console.WriteLine("Factory çalışıyor, counter = " + counter);
    return $"Sayaç değeri: {counter}";
});

counter = 10; // Değişkenin değeri factory çalışmadan önce değişti

Console.WriteLine(lazyWithClosure.Value); // Çıktı: "Factory çalışıyor, counter = 10" ve "Sayaç değeri: 10"
                    

Daha önce belirtildiği gibi, Lazy'nin getirdiği ek yük (özellikle ExecutionAndPublication modunda) çoğu uygulama için ihmal edilebilir düzeydedir. Ancak, saniyede milyonlarca kez erişilen çok yüksek performans gerektiren kod yollarında (hot paths) bu ek yük fark yaratabilir.

• Önce Ölçün: Performans konusunda endişeleriniz varsa, varsayımlara dayanmak yerine bir profil aracı (profiler) kullanarak uygulamanızdaki gerçek darboğazları tespit edin. Sorunun gerçekten Lazy'nin ek yükünden kaynaklandığından emin olun.
• Modu Gözden Geçirin: Eğer Lazy bir darboğaz ise ve koşullar uygunsa (None için tek thread garantisi veya PublicationOnly için yan etkisiz fabrika), güvenlik modunu değiştirmeyi düşünebilirsiniz.
• Alternatifleri Değerlendirin: Çok ekstrem durumlarda LazyInitializer veya dikkatle yazılmış manuel bir mekanizma daha iyi performans verebilir, ancak bu genellikle son çare olmalıdır ve güvenlik riskleri göz önünde bulundurulmalıdır.
• Genellikle Sorun Başka Yerde: Çoğu zaman performans sorunları, Lazy'nin kendisinden ziyade, valueFactory'nin yaptığı işin (algoritma, G/Ç, veritabanı sorgusu vb.) verimsiz olmasından kaynaklanır. Optimizasyona oradan başlamak genellikle daha etkilidir.