Why compiler force me to specify unsafe in c# [duplicate]

Question

This question already has answers here:

C#: Benefit of explicitly stating "unsafe" / compiler option (9 answers)

Closed 8 years ago.

I know I've to compile with Unsafe Option to use unsafe code in C# Consider the following

static void foo()
{
    int a = 5;
    int* p = &a;
}

the above code won't compile unless I mark method as unsafe or wrap above statements inside unsafe block.

Am curious why compiler force me to do this? is there any technical reason behind this?

Answer 1

Found this article with nice detailed explanation -

In C and C++, developers have direct access to memory. When a piece of C or C++ code requests access to a block of memory, it is given the specific address of the allocated memory, and the code directly reads from and writes to that memory location. The advantage to this approach is that direct access to memory is extremely fast and made for efficient code. There are problems, however, that outweigh the benefits. The problem with this direct memory access is that it is easy to misuse, and misuse of memory causes code to crash. Misbehaving C or C++ code can easily write to memory that has already been deleted, or can write to memory belonging to another variable. These types of memory access problems result in numerous hard-to-find bugs and software crashes.

The architecture of the CLR eliminates all of these problems by handling memory management for you. This means that your C# code can work with variables without needing to know details about how and where the variables are stored in memory. Because the CLR shields your C# code from these memory-related details, your C# code is free from bugs related to direct access to memory.

Occasionally, however, you need to work with a specific memory address in your C# code. Your code may need that extra ounce of performance, or your C# code may need to work with legacy code that requires that you provide the address of a specific piece of memory. The C# language supports a special mode, called unsafe mode, which enables you to work directly with memory from within your C# code.

This special C# construct is called unsafe mode because your code is no longer safe from the memory-management protection offered by the CLR. In unsafe mode, your C# code is allowed to access memory directly, and it can suffer from the same class of memory-related bugs found in C and C++ code if you're not extremely careful with the way you manage memory.

Answer 2

The unsafe keyword denotes an unsafe context, which is required for any operation involving pointers.

You can use the unsafe modifier in the declaration of a type or a member. The entire textual extent of the type or member is therefore considered an unsafe context.

From the msdn

A good explanation is given here