Skip to content

Memory Management

Genel Bakış

C#'ta bellek yönetimi, .NET CLR (Common Language Runtime) tarafından otomatik olarak yapılır. Bu sistem, geliştiricilerin bellek yönetimiyle ilgili detaylarla uğraşmasını engelleyerek, daha güvenli ve verimli kod yazılmasını sağlar.

Stack ve Heap

  1. Stack (Yığın) 

    // Stack'te saklanan değerler
int number = 42;        // Value type
double pi = 3.14;       // Value type
bool isTrue = true;     // Value type

// Method çağrıları
void Method()
{
    int localVar = 10;  // Stack'te saklanır
}

  2. Heap (Yığın) 

    // Heap'te saklanan nesneler
string name = "Ahmet";  // Reference type
Person person = new Person(); // Reference type
int[] numbers = new int[10]; // Reference type

Garbage Collection (Çöp Toplama)

  1. GC Temelleri 

    // Nesne oluşturma
Person person = new Person();

// Referansı kaldırma
person = null; // GC tarafından toplanabilir

  2. GC Generations 

    // Generation 0 - Yeni nesneler
var obj1 = new object();

// Generation 1 - Hayatta kalan nesneler
GC.Collect(0); // Generation 0 temizlenir

// Generation 2 - Uzun süreli nesneler
GC.Collect(1); // Generation 1 temizlenir

IDisposable ve Dispose Pattern

  1. Temel Dispose Pattern 

    public class Resource : IDisposable
{
    private bool disposed = false;

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

    protected virtual void Dispose(bool disposing)
    {
        if (!disposed)
        {
            if (disposing)
            {
                // Yönetilen kaynakları serbest bırak
            }
            // Yönetilmeyen kaynakları serbest bırak
            disposed = true;
        }
    }

    ~Resource()
    {
        Dispose(false);
    }
}

  2. using Statement 

    using (var resource = new Resource())
{
    // Kaynak kullanımı
} // Otomatik olarak Dispose çağrılır

Memory Leaks (Bellek Sızıntıları)

  1. Event Handlers 

    // Bellek sızıntısı örneği
public class Publisher
{
    public event EventHandler SomethingHappened;
}

public class Subscriber
{
    public void Subscribe(Publisher publisher)
    {
        publisher.SomethingHappened += OnSomethingHappened;
    }

    private void OnSomethingHappened(object sender, EventArgs e)
    {
        // Event handler
    }
}

  2. Static References 

    // Statik referans örneği
public static class Cache
{
    private static List<object> items = new List<object>();

    public static void Add(object item)
    {
        items.Add(item);
    }
}

Memory Management Best Practices

  1. Value vs Reference Types 

    // Value type kullanımı (küçük, değişmez veriler için)
public struct Point
{
    public int X { get; }
    public int Y { get; }
}

// Reference type kullanımı (karmaşık, değişebilir veriler için)
public class Person
{
    public string Name { get; set; }
    public List<string> Addresses { get; set; }
}

  2. String Handling 

    // String birleştirme
string result = string.Concat("Hello", " ", "World");

// StringBuilder kullanımı
var builder = new StringBuilder();
builder.Append("Hello");
builder.Append(" ");
builder.Append("World");
string result = builder.ToString();

Memory Profiling

  1. Memory Profiler Kullanımı 

    // Memory snapshot alma
var snapshot1 = GC.GetTotalMemory(false);

// İşlemler
var list = new List<int>();
for (int i = 0; i < 1000000; i++)
{
    list.Add(i);
}

var snapshot2 = GC.GetTotalMemory(false);
var memoryUsed = snapshot2 - snapshot1;

  2. Weak References 

    // Weak reference kullanımı
var weakRef = new WeakReference(new object());

if (weakRef.IsAlive)
{
    var target = weakRef.Target;
}

Mülakat Soruları

  1. Bellek Yönetimi Temelleri
  2. Stack ve Heap arasındaki farklar nelerdir?
  3. Value type ve Reference type'lar bellekte nasıl saklanır?

  4. Garbage Collection nasıl çalışır?

  5. Garbage Collection

  6. GC Generations nedir ve nasıl çalışır?
  7. GC ne zaman tetiklenir?

  8. GC'nin performans etkileri nelerdir?

  9. IDisposable Pattern

  10. Dispose pattern nedir ve neden kullanılır?
  11. using statement nasıl çalışır?

  12. Finalizer ne zaman kullanılmalıdır?

  13. Memory Leaks

  14. Bellek sızıntıları nasıl oluşur?
  15. Event handler'lar nasıl bellek sızıntısına neden olur?

  16. Statik referansların riskleri nelerdir?

  17. Value vs Reference Types

  18. Value type ve Reference type ne zaman kullanılmalıdır?
  19. Struct ve Class arasındaki bellek yönetimi farkları nelerdir?

  20. Boxing/Unboxing'in bellek etkileri nelerdir?

  21. String Handling

  22. String immutability nedir?
  23. StringBuilder ne zaman kullanılmalıdır?

  24. String interning nedir?

  25. Memory Profiling

  26. Memory profiler nasıl kullanılır?
  27. Weak references ne işe yarar?

  28. Memory snapshot'lar nasıl analiz edilir?

  29. Best Practices

  30. Bellek yönetimi için en iyi uygulamalar nelerdir?
  31. Büyük nesneler nasıl yönetilmelidir?
  32. Bellek fragmentasyonu nasıl önlenir?

Örnek Kod Soruları

  1. Memory Efficient Cache 

    public class MemoryEfficientCache<TKey, TValue>
{
    // Implementasyon
}

  2. Resource Manager 

    public class ResourceManager : IDisposable
{
    // Implementasyon
}

  3. Memory Monitor 

    public class MemoryMonitor
{
    // Implementasyon
}

  4. Weak Reference Cache 

    public class WeakReferenceCache<T>
{
    // Implementasyon
}

  5. Memory Optimized Collection 

    public class MemoryOptimizedCollection<T>
{
    // Implementasyon
}

Kaynaklar