public sealed class Singleton
{
    // Singleton instance'ı tutan statik değişken
    private static Singleton _instance;
    
    // Yapıcı(Constructor) metodun private olması dışarıdan instance oluşturulmasını engeller.
    private Singleton() { }

    // Singleton'a erişim sağlayan public statik metot
    public static Singleton Instance
    {
        get
        {
            // Instance yok ise yeni instance oluşturulur.
            if (_instance is null) _instance = new Singleton();
            return _instance;
        }
    }
}

// Kullanımı için:
Singleton singleton = Singleton.Instance;

if (singleton != null) Console.WriteLine("Singleton works!");

//# Output:
Singleton works!

public sealed class Singleton
{
    private static Singleton _instance;
    private static readonly object _lock = new object();

    private Singleton() { }
    public string? Value { get; set; }

    public static Singleton GetInstance(string value)
    {
    //Buradaki if değeri kilitleme işleminin her işlemde devreye girmesini engellemek için eklenmiştir.
    //Bu sayede instance null olmadığı durumlarda kilitleme işlemi devreye girmez.
       if (_instance is null)
        {
            // Thread-safe mekanizması
            lock (_lock)
            {
                if (_instance is null)
                {
                    _instance = new Singleton();
                    _instance.Value = value;
                }
            }
        }
        return _instance;
    }
}

// Kullanımı için:
Thread process1 = new Thread(() =>
{
    TestThreadSafeSingleton("Test-1");
});

Thread process2 = new Thread(() =>
{
    TestThreadSafeSingleton("Test-2");
});

process1.Start();
process2.Start();

process1.Join();
process2.Join();


static void TestThreadSafeSingleton(string value)
{
    Singleton singleton =  Singleton.GetInstance(value);
    Console.WriteLine(singleton.Value);
}

// Sonuçlarda aynı değerin çıktı olarak alınması singleton'ın tekrar kullanıldığı anlamına gelmektedir.
// Lock mekanizmasının çalıştığını göstermektedir.
//# Output:
Test-1
Test-1

public sealed class Singleton
{
    private static readonly Lazy<Singleton> lazy =
        new Lazy<Singleton>(() => new Singleton());

    public static Singleton Instance { get { return lazy.Value; } }

    private Singleton()
    {
    }
}

namespace SingletonPattern;

public sealed class Logger
{
    private static readonly Lazy<Logger> _logger = new Lazy<Logger>(() => new Logger());
    private string _filePath;

    private Logger()
    {
        _filePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "application_logs.txt");
    }

    public static Logger Instance => _logger.Value;

    public void Log(string message)
    {
        string logMessage = $"{DateTime.Now:yyyy-MM-dd HH:mm:ss} - {message}";

        try
        {
            using(StreamWriter writer = File.AppendText(_filePath))
            {
                writer.WriteLine(logMessage);
            }
            Console.WriteLine($"Logged: {logMessage}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error writing to log file: {ex.Message}");
        }
    }

    public string GetLogFilePath() => _filePath;
}


// Logger Sınıfının Kullanımı
Logger.Instance.Log("Application started!");
Logger.Instance.Log("Process finished!");
Logger.Instance.Log("Application closed!");

Console.WriteLine($"Log dosyası: {Logger.Instance.GetLogFilePath()}");