.Net中unsafe编程详解

发布日:2010-06-08 20:42:46.0 发布人:don 浏览量:151

类别: IT电脑开发

标签: .net unsafe 编程

以c#为例。

一，打开unsafe编程开关

工程中默认的配置是不支持代码的非安全性的，所以第一次使用你得：

解决方案管理器→→Properties→→生成选项卡→→允许不安全代码。

二，何时要用unsafe

1.一个原则

unsafe 关键字表示不安全上下文，该上下文是任何涉及指针的操作所必需的。我的想法就是一旦你得用指针就必须用unsafe。

2.什么时候用指针

msdn里说 “在 C# 中很少需要使用指针，但仍有一些需要使用的情况。例如，在下列情况中使用允许采用指针的不安全上下文是正确的：处理磁盘上的现有结构，涉及内部包含指针的结构的高级 COM 或平台调用方案，性能关键代码，对于第一和第二点，主要是调win32的api。”

总之，一条判断标准：当你使用C/C++能给带给你的利大于弊时都可以使用unsafe编程，呵呵。

三，unsafe的使用方法（几个例子）

1.unsafe一个方法体

1. class UnsafeTest1
2. {
3. unsafe static void AddParam(int *a)
4. {
5. *a = *a 10000;
6. } .
7. unsafe public static void Main()
8. {
9. int i = 10000;
10. AddParam (&i);
11. Console.WriteLine(i);
12. }
13. }

2.unsafe一段代码

private void button1_Click(object sender, EventArgs e)
{
unsafe
{
int *pInt;
}
}

3.网上找的一个较大unsafe例子

代码

   1. using System;
   2. using System.Collections.Generic;
   3. using System.Text;
   4. namespace UnsafeCode
   5. {
   6.   #region Unsafe types and members (just for testing purposes)
   7.   // This entire structure is 'unsafe' and can
   8.   // be used only in an unsafe context.
   9.   public unsafe struct Node
  10.   {
  11.     public int Value;
  12.     public Node* Left;
  13.     public Node* Right;
  14.   }
  15.   // This struct is safe, but the Node* members
  16.   // are not. Technically, you may access 'Value' from
  17.   // outside an unsafe context, but not 'Left' and 'Right'.
  18.   public struct Node2
  19.   {
  20.     public int Value;
  21.     // These can be accessed only in an unsafe context!
  22.     public unsafe Node2* Left;
  23.     public unsafe Node2* Right;
  24.   }
  25.   #endregion
  26.   #region Simple Point / PointRef
  27.   struct Point
  28.   {
  29.     public int x;
  30.     public int y;
  31.     public override string ToString()
  32.     { return string.Format("({0}, {1})", x, y); }
  33.   }
  34.   class PointRef
  35.   {
  36.     public int x;
  37.     public int y;
  38.     public override string ToString()
  39.     { return string.Format("({0}, {1})", x, y); }
  40.   }
  41.   #endregion
  42.   class Program
  43.   {
  44.     static void Main(string[] args)
  45.     {
  46.       Console.WriteLine("***** Fun with Pointers *****");
  47.       #region Swap 2 ints safely and unsafely
  48.       // Values for swap.
  49.       int i = 10, j = 20;
  50.       // Swap values 'safely'.
  51.       Console.WriteLine("\n***** Safe swap *****");
  52.       Console.WriteLine("Values before safe swap: i = {0}, j = {1}", i, j);
  53.       SafeSwap(ref i, ref j);
  54.       Console.WriteLine("Values after safe swap: i = {0}, j = {1}", i, j);
  55.       // Swap values 'unsafely'.
  56.       Console.WriteLine("\n***** Unsafe swap *****");
  57.       Console.WriteLine("Values before unsafe swap: i = {0}, j = {1}", i, j);
  58.       unsafe { UnsafeSwap(&i, &j); }
  59.       Console.WriteLine("Values after unsafe swap: i = {0}, j = {1}", i, j);
  60.       Console.WriteLine();
  61.       #endregion
  62.       UsePointerToPoint();
  63.       Console.WriteLine();
  64.       UseSizeOfOperator();
  65.       Console.ReadLine();
  66.     }
  67.     public static void SafeSwap(ref int i, ref int j)
  68.     {
  69.       int temp = i;
  70.       i = j;
  71.       j = temp;
  72.     }
  73.     #region Various unsafe methods
  74.     unsafe static void PrintValueAndAddress()
  75.     {
  76.       int myInt;
  77.       // Define an int pointer, and
  78.       // assign it the address of myInt.
  79.       int* ptrToMyInt = &myInt;
  80.       // Assign value of myInt using pointer indirection.
  81.       *ptrToMyInt = 123;
  82.       // Print some stats.
  83.       Console.WriteLine("Value of myInt {0}", myInt);
  84.       Console.WriteLine("Address of myInt {0:X}", (int)&ptrToMyInt);
  85.     }
  86.     unsafe static void SquareIntPointer(int* myIntPointer)
  87.     {
  88.       // Work with pointer types here!
  89.       // Square the value just for a test.
  90.       *myIntPointer *= *myIntPointer;
  91.     }
  92.     unsafe public static void UnsafeSwap(int* i, int* j)
  93.     {
  94.       int temp = *i;
  95.       *i = *j;
  96.       *j = temp;
  97.     }
  98.     unsafe static void UsePointerToPoint()
  99.     {
100.       // Access members via pointer.
101.       Point point;
102.       Point* p = &point;
103.       p->x = 100;
104.       p->y = 200;
105.       Console.WriteLine(p->ToString());
106.       // Access members via pointer indirection.
107.       Point point2;
108.       Point* p2 = &point2;
109.       (*p2).x = 100;
110.       (*p2).y = 200;
111.       Console.WriteLine((*p2).ToString());
112.     }
113.     unsafe static void UnsafeStackAlloc()
114.     {
115.       char* p = stackalloc char[256];
116.       for (int k = 0; k < 256; k++)
117.         p[k] = (char)k;
118.     }
119.     unsafe public static void UseAndPinPoint()
120.     {
121.       PointRef pt = new PointRef();
122.       pt.x = 5;
123.       pt.y = 6;
124.       // pin pt in place so it will not
125.       // be moved or GC-ed.
126.       fixed (int* p = &pt.x)
127.       {
128.         // Use int* variable here!
129.       }
130.       // pt is now unpinned, and ready to be GC-ed.
131.       Console.WriteLine("Point is: {0}", pt);
132.     }
133.     unsafe static void UseSizeOfOperator()
134.     {
135.       Console.WriteLine("The size of short is {0}.", sizeof(short));
136.       Console.WriteLine("The size of int is {0}.", sizeof(int));
137.       Console.WriteLine("The size of long is {0}.", sizeof(long));
138.       Console.WriteLine("The size of Point is {0}.", sizeof(Point));
139.     }
140.     #endregion
141.   }
142. }

using System; using System.Collections.Generic; using System.Text; namespace UnsafeCode {   #region Unsafe types and members (just for testing purposes)   // This entire structure is 'unsafe' and can   // be used only in an unsafe context.   public unsafe struct Node   {     public int Value;     public Node* Left;     public Node* Right;   }   // This struct is safe, but the Node* members   // are not. Technically, you may access 'Value' from   // outside an unsafe context, but not 'Left' and 'Right'.   public struct Node2   {     public int Value;     // These can be accessed only in an unsafe context!     public unsafe Node2* Left;     public unsafe Node2* Right;   }   #endregion   #region Simple Point / PointRef   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); }   }     #endregion   class Program   {     static void Main(string[] args)     {       Console.WriteLine("***** Fun with Pointers *****");       #region Swap 2 ints safely and unsafely       // Values for swap.       int i = 10, j = 20;       // Swap values 'safely'.       Console.WriteLine("\n***** 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);       // Swap values 'unsafely'.       Console.WriteLine("\n***** 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);       Console.WriteLine();       #endregion       UsePointerToPoint();       Console.WriteLine();       UseSizeOfOperator();       Console.ReadLine();     }     public static void SafeSwap(ref int i, ref int j)     {       int temp = i;       i = j;       j = temp;     }     #region Various unsafe methods     unsafe static void PrintValueAndAddress()     {       int myInt;       // Define an int pointer, and       // assign it the address of myInt.       int* ptrToMyInt = &myInt;       // Assign value of myInt using pointer indirection.       *ptrToMyInt = 123;       // Print some stats.       Console.WriteLine("Value of myInt {0}", myInt);       Console.WriteLine("Address of myInt {0:X}", (int)&ptrToMyInt);     }     unsafe static void SquareIntPointer(int* myIntPointer)     {       // Work with pointer types here!       // Square the value just for a test.       *myIntPointer *= *myIntPointer;     }     unsafe public static void UnsafeSwap(int* i, int* j)     {       int temp = *i;       *i = *j;       *j = temp;     }     unsafe static void UsePointerToPoint()     {       // Access members via pointer.       Point point;       Point* p = &point;       p->x = 100;       p->y = 200;       Console.WriteLine(p->ToString());       // Access members via pointer indirection.       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 public static void UseAndPinPoint()     {       PointRef pt = new PointRef();       pt.x = 5;       pt.y = 6;       // pin pt in place so it will not       // be moved or GC-ed.       fixed (int* p = &pt.x)       {         // Use int* variable here!       }       // pt is now unpinned, and ready to be GC-ed.       Console.WriteLine("Point is: {0}", pt);     }     unsafe static void UseSizeOfOperator()     {       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));     }     #endregion   } }

四，使用unsafe时可能用到的fixed

1.为什么要用fixed

Unsafe的代码托管代码 (managed code)和非托管代码（Unmanaged Code）之间，它也是在CLR的环境中执行，但是可以用来直接操作内存。但由于代码是在CLR下托管执行，为了减少内存碎片C#的自动垃圾回收机制会允许已经分配的内存在运行时进行位置调整，所以如果我们多次调用的话就可能导致指针指向其他的变量。比如*pInt为指向一个变量的地址为1001，CLR在重新内存整理分配后该变量就存储在地址为5001的地方。而原来 1001的地方可能会被分配其他变量，要解决这个问题我们就需要使用Fixed关键字。