Unsafe Code

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace UnsafeCode
{  
    struct Point
    {
        public int x;
        public int y;

        public override string ToString()
        {
            return string.Format("({0}, {1})", x, y);
        }
    }

    class PointRef  
    {
        public int x;
        public int y;
        public override string ToString()
        {
            return string.Format("({0}, {1})", x, y);
        }
    }

    class Program
    {
        static void Main( string[] args )
        {
            Console.WriteLine("***** Calling method with unsafe code *****");
      
            int i = 10, j = 20;

            // 安全交换
            Console.WriteLine("
***** Safe swap *****");
            Console.WriteLine("Values before safe swap: i = {0}, j = {1}", i, j);
            SafeSwap(ref i, ref j);
            Console.WriteLine("Values after safe swap: i = {0}, j = {1}", i, j);

            // 不安全交换
            Console.WriteLine("
***** Unsafe swap *****");
            Console.WriteLine("Values before unsafe swap: i = {0}, j = {1}", i, j);
            unsafe { UnsafeSwap(&i, &j); }
            Console.WriteLine("Values after unsafe swap: i = {0}, j = {1}", i, j);

            UsePointerToPoint();
            PrintValueAndAddress();
            UseAndPinPoint();
            UseSizeOfOperator();

            Console.ReadLine();
        }

        unsafe static void UsePointerToPoint()
        {
            // 指针访问成员
            Point point;
            Point* p = &point;
            p->x = 100;
            p->y = 200;
            Console.WriteLine(p->ToString());

            // 指针间接寻址访问成员
            Point point2;
            Point* p2 = &point2;
            (*p2).x = 100;
            (*p2).y = 200;
            Console.WriteLine((*p2).ToString());
        }

        unsafe static void UnsafeStackAlloc()
        {
            char* p = stackalloc char[256];
            for (int k = 0; k < 256; k++)
                p[k] = (char)k;
        }

        // 静态方法或实例方法均可被标记为不安全
        unsafe static void SquareIntPointer( int* myIntPointer )
        {
            *myIntPointer *= *myIntPointer;
        }

        unsafe static void PrintValueAndAddress()
        {
            int myInt;          
            int* ptrToMyInt = &myInt;

            // 指针间接寻址为myInt赋值
            *ptrToMyInt = 123;
   
            Console.WriteLine("Value of myInt {0}", myInt);
            Console.WriteLine("Address of myInt {0:X}", (int)&ptrToMyInt);
        }

        unsafe public static void UnsafeSwap( int* i, int* j )
        {
            int temp = *i;
            *i = *j;
            *j = temp;
        }

        unsafe public static void UseAndPinPoint()
        {
            PointRef pt = new PointRef();
            pt.x = 5;
            pt.y = 6;
          
            // fixed 语句设置指向托管类型的指针并在代码执行过程中固定该变量
            // 固定pt
            fixed (int* p = &pt.x)
            {
                // 此处可使用 int* 变量
            }

            // pt未固定，该方法完成后可被GC清除
            Console.WriteLine("Point is: {0}", pt);
        }

        unsafe static void UseSizeOfOperator()
        {// 不安全关键字 sizeof
            Console.WriteLine("The size of short is {0}.", sizeof(short));
            Console.WriteLine("The size of int is {0}.", sizeof(int));
            Console.WriteLine("The size of long is {0}.", sizeof(long));
            Console.WriteLine("The size of Point is {0}.", sizeof(Point));
        }

        public static void SafeSwap( ref int i, ref int j )
        {
            int temp = i;
            i = j;
            j = temp;
        }
    }
}