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

by

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.

More Related Contents:

  1. True Unsafe Code Performance
  2. What is the fastest way to convert a float[] to a byte[]?
  3. C# unsafe value type array to byte array conversions
  4. When to use pointers in C#/.NET?
  5. Add to a List from two Classes in C# [closed]
  6. Using non-literal strings in different methods in C#
  7. Is there a reason for C#’s reuse of the variable in a foreach?
  8. Create code first, many to many, with additional fields in association table
  9. Nesting await in Parallel.ForEach [duplicate]
  10. How To Accept a File POST
  11. How do I clean SqlDependency from SQL Server memory?
  12. When is a static constructor called in C#?
  13. Why Interface Layer/Abstract classes required in our project? [closed]
  14. How to use .NET reflection to check for nullable reference type
  15. How to update the value stored in Dictionary in C#?
  16. C#: Custom assembly directory
  17. Adding and Removing Anonymous Event Handler
  18. Expression-bodied function members efficiency and performance in C# 6.0
  19. How to pass a table-value parameter
  20. How to solve circular reference?
  21. Async threadsafe Get from MemoryCache
  22. When is using the C# ref keyword ever a good idea?
  23. Event handlers not thread safe? [duplicate]
  24. Difference between lock(locker) and lock(variable_which_I_am_using)
  25. Best way to check if a Data Table has a null value in it
  26. Sql Bulk Copy/Insert in C#
  27. Calling SQL Defined function in C#
  28. Remove empty/blanks elements in collection of XML nodes
  29. Is it possible to switch rows and columns in a datagridview?
  30. How to set a text box for inputing password in winforms?

Leave a Comment