C# unsafe code

Pointer Variables

A pointer is a variable whose value is the address of another variable, that is, the direct address of a memory location. Just like other variables or constants, you must declare a pointer before using it to store the address of another variable.

The general form of pointer variable declaration is:

type *var-name;

The following is a valid pointer declaration:

int    *ip;    /* 指向一个整数 */
double *dp;    /* 指向一个双精度数 */
float  *fp;    /* 指向一个浮点数 */
char   *ch     /* 指向一个字符 */

The following example illustrates the use of unsafe## in C# # Usage of pointers when modifier:

using System;
namespace UnsafeCodeApplication
{
    class Program
    {
        static unsafe void Main(string[] args)
        {
            int var = 20;
            int* p = &var;
            Console.WriteLine("Data is: {0} ",  var);
            Console.WriteLine("Address is: {0}",  (int)p);
            Console.ReadKey();
        }
    }
}

When the above code is compiled and executed, it will produce the following results:

Data is: 20
Address is: 99215364

You can also avoid declaring the entire method as unsafe code, Only part of the method needs to be declared as unsafe code. The following example illustrates this point.

Retrieving data values ​​using pointers

You can use the

ToString() method to retrieve data stored at the location referenced by a pointer variable. The following example demonstrates this:

using System;
namespace UnsafeCodeApplication
{
   class Program
   {
      public static void Main()
      {
         unsafe
         {
            int var = 20;
            int* p = &var;
            Console.WriteLine("Data is: {0} " , var);
            Console.WriteLine("Data is: {0} " , p->ToString());
            Console.WriteLine("Address is: {0} " , (int)p);
         }
         Console.ReadKey();
      }
   }
}

When the above code is compiled and executed, it produces the following results:

Data is: 20
Data is: 20
Address is: 77128984

Passing a pointer as a method parameter

You can pass pointer variables to methods as parameters of the method. The following example illustrates this:

using System;
namespace UnsafeCodeApplication
{
   class TestPointer
   {
      public unsafe void swap(int* p, int *q)
      {
         int temp = *p;
         *p = *q;
         *q = temp;
      }

      public unsafe static void Main()
      {
         TestPointer p = new TestPointer();
         int var1 = 10;
         int var2 = 20;
         int* x = &var1;
         int* y = &var2;
         
         Console.WriteLine("Before Swap: var1:{0}, var2: {1}", var1, var2);
         p.swap(x, y);

         Console.WriteLine("After Swap: var1:{0}, var2: {1}", var1, var2);
         Console.ReadKey();
      }
   }
}

When the above code is compiled and executed, it produces the following results:

Before Swap: var1: 10, var2: 20
After Swap: var1: 20, var2: 10

Using pointers to access array elements

In In C#, an array name and a pointer to the same data type as the array data are different variable types. For example, int *p and int[] p are different types. You can increment the pointer variable p because it is not fixed in memory, but the array address is fixed in memory so you cannot increment the array p.

So, if you need to access array data using a pointer variable, you can fix the pointer using the

fixed keyword as we usually do in C or C++.

The following example demonstrates this:

using System;
namespace UnsafeCodeApplication
{
   class TestPointer
   {
      public unsafe static void Main()
      {
         int[]  list = {10, 100, 200};
         fixed(int *ptr = list)

         /* 显示指针中数组地址 */
         for ( int i = 0; i < 3; i++)
         {
            Console.WriteLine("Address of list[{0}]={1}",i,(int)(ptr + i));
            Console.WriteLine("Value of list[{0}]={1}", i, *(ptr + i));
         }
         Console.ReadKey();
      }
   }
}

When the above code is compiled and executed, it produces the following results:

Address of list[0] = 31627168
Value of list[0] = 10
Address of list[1] = 31627172
Value of list[1] = 100
Address of list[2] = 31627176
Value of list[2] = 200

Compiling unsafe code

In order to compile unsafe code, you must switch to the command line compiler specifying the

/unsafe command line.

For example, to compile a program named prog1.cs that contains unsafe code, enter the command at the command line:

csc /unsafe prog1.cs

If you are using the Visual Studio IDE, then you need Enable unsafe code in project properties.

The steps are as follows:

• Open

  project properties## by double-clicking the properties node in Solution Explorer #.

Click on the
• Build

  tab.

Select the option "
• Allow unsafe code

  ".