What is a managed code in C#?

Managed code in C# is code whose execution is managed by the Common Language Runtime (CLR). The CLR provides automatic memory management, type safety, exception handling, and garbage collection. When you write C# code, it gets compiled into Intermediate Language (IL) code, which is then executed by the CLR.

Unlike unmanaged code (such as C/C++), managed code runs within the .NET runtime environment, which handles low-level operations automatically. This makes development safer and more efficient by reducing common programming errors like memory leaks and buffer overflows.

How Managed Code Works

The execution process of managed code follows these steps −

Example of Managed Code

Basic Managed Code Example

using System;

class ManagedCodeExample {
   public static void Main() {
      // Memory allocation handled by CLR
      string message = "Hello, Managed World!";
      int[] numbers = new int[5] {1, 2, 3, 4, 5};
      
      Console.WriteLine(message);
      Console.WriteLine("Array elements:");
      
      foreach(int num in numbers) {
         Console.WriteLine(num);
      }
      
      // Garbage collection happens automatically
      Console.WriteLine("Memory management is handled by CLR");
   }
}

The output of the above code is −

Hello, Managed World!
Array elements:
1
2
3
4
5
Memory management is handled by CLR

Managed vs Unmanaged Code

Using Unsafe Context for Unmanaged Operations

C# allows unmanaged constructs like pointers using the unsafe keyword. This sets a piece of code for which execution is not fully managed by the CLR −

Example

using System;

class UnsafeExample {
   public static void Main() {
      unsafe {
         int number = 42;
         int* ptr = &number;
         
         Console.WriteLine("Value: " + number);
         Console.WriteLine("Address: " + (long)ptr);
         Console.WriteLine("Value via pointer: " + *ptr);
      }
   }
}

The output of the above code is −

Value: 42
Address: 140727740681508
Value via pointer: 42

Benefits of Managed Code

• Automatic Memory Management: The CLR handles memory allocation and deallocation through garbage collection.

• Type Safety: The runtime prevents type-related errors and buffer overflows.

• Exception Handling: Structured exception handling across different languages.

• Cross-Language Integration: Different .NET languages can work together seamlessly.

Conclusion

Managed code in C# runs under the supervision of the Common Language Runtime, providing automatic memory management, type safety, and cross-platform compatibility. While it offers less direct control compared to unmanaged code, it significantly reduces development complexity and improves application security and reliability.