C# Memory Management

Memory management is a critical aspect of software development, ensuring that applications run efficiently without wasting system resources or causing leaks. In C#, memory management is largely handled by the Common Language Runtime (CLR) through mechanisms like the Garbage Collector (GC). Understanding how memory is managed in C# helps developers write optimized and reliable applications.

1. Overview of Memory Management

2. Stack vs. Heap

3. Value Types vs. Reference Types

using System;

struct Point
{
    public int X { get; set; }
    public int Y { get; set; }
}

class Program
{
    static void Main()
    {
        Point p1 = new Point { X = 10, Y = 20 };
        Point p2 = p1; // Copy of p1
        p2.X = 30;

        Console.WriteLine($"p1: X={p1.X}, Y={p1.Y}"); // Output: p1: X=10, Y=20
        Console.WriteLine($"p2: X={p2.X}, Y={p2.Y}"); // Output: p2: X=30, Y=20
    }
}

Output:
p1: X=10, Y=20
p2: X=30, Y=20

using System;

class Person
{
    public string Name { get; set; }
}

class Program
{
    static void Main()
    {
        Person person1 = new Person { Name = "Alice" };
        Person person2 = person1; // Reference copy
        person2.Name = "Bob";

        Console.WriteLine($"person1.Name: {person1.Name}"); // Output: person1.Name: Bob
        Console.WriteLine($"person2.Name: {person2.Name}"); // Output: person2.Name: Bob
    }
}

Output:
person1.Name: Bob
person2.Name: Bob

4. Garbage Collection (GC)

using System;

class Program
{
    static void Main()
    {
        CreateObjects();
        Console.WriteLine("Forcing garbage collection...");
        GC.Collect();
        GC.WaitForPendingFinalizers();
        Console.WriteLine("Garbage collection complete.");
    }

    static void CreateObjects()
    {
        for (int i = 0; i < 1000; i++)
        {
            string s = new string('a', 1000);
        }
    }
}

Output:
Forcing garbage collection...
Garbage collection complete.

5. IDisposable and the `using` Statement

using System;
using System.IO;

class Program
{
    static void Main()
    {
        using (StreamWriter writer = new StreamWriter("example.txt"))
        {
            writer.WriteLine("Hello, World!");
        }
        // StreamWriter is disposed here
    }
}

Output:
A file named "example.txt" is created with the content: Hello, World!

6. Memory Leaks in C#

using System;

class Publisher
{
    public event EventHandler OnChange;

    public void RaiseEvent()
    {
        OnChange?.Invoke(this, EventArgs.Empty);
    }
}

class Subscriber
{
    public Subscriber(Publisher publisher)
    {
        publisher.OnChange += HandleChange;
    }

    void HandleChange(object sender, EventArgs e)
    {
        Console.WriteLine("Event handled.");
    }
}

class Program
{
    static void Main()
    {
        Publisher publisher = new Publisher();
        Subscriber subscriber = new Subscriber(publisher);
        // Subscriber is still referenced by publisher's event
    }
}

Output:
(No output; potential memory leak as subscriber cannot be garbage collected)

7. Understanding the GC Heap

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Generation of 'a': " + GC.GetGeneration("a")); // Output: 0
        object b = new object();
        Console.WriteLine("Generation of 'b': " + GC.GetGeneration(b));   // Output: 0

        GC.Collect(); // Collect Gen 0
        Console.WriteLine("Generation of 'a' after GC: " + GC.GetGeneration("a")); // Output: 0 (still reachable)
        Console.WriteLine("Generation of 'b' after GC: " + GC.GetGeneration(b));   // Output: 0
    }
}

Output:
Generation of 'a': 0
Generation of 'b': 0
Generation of 'a' after GC: 0
Generation of 'b' after GC: 0

8. Finalizers and the `Finalize` Method

using System;

class Resource
{
    public Resource()
    {
        Console.WriteLine("Resource acquired.");
    }

    ~Resource()
    {
        Console.WriteLine("Resource finalized.");
    }
}

class Program
{
    static void Main()
    {
        Resource res = new Resource();
        res = null;
        GC.Collect();
        GC.WaitForPendingFinalizers();
        Console.WriteLine("Main method complete.");
    }
}

Output:
Resource acquired.
Resource finalized.
Main method complete.

9. Best Practices for Memory Management

10. Real-World Example: Managing Database Connections

using System;
using System.Data.SqlClient;

class Program
{
    static void Main()
    {
        string connectionString = "your_connection_string_here";

        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            connection.Open();
            // Perform database operations
            Console.WriteLine("Database connection opened.");
        }
        // SqlConnection is disposed here, closing the connection
        Console.WriteLine("Database connection closed.");
    }
}

Output:
Database connection opened.
Database connection closed.

11. Summary

Key points