引用類型是類型安全的指針，它們的內存是分配在堆（保存指針地址）上的。
string、數組、類、接口和委托都是引用類型。
強制類型轉換與as類型轉換的區別：當類型轉換非法時，強制類型轉換將拋出一個system.invalidcastexception異常，
而as不會拋出異常，它返回一個null值。
用using創建別名：using console = system.console;
訪問限定符：
public  該成員可以被其他任何類訪問
protected 該成員只能被其派生類訪問
private  該成員只能被本類的其他成員訪問
internal 該成員只能在當前編譯單元的其他成員訪問
帶參數列表和返回值的main方法：
class test
{
  public static int main(string[] args)
  {
    foreach (string arg in args)
    {
    ...
    }
  }
}
構造函數（constructor）包括實例構造函數和靜態構造函數。
構造函數與類名相同，且不能有返回值。例：
class testclass
{
  testclass()  //實例構造函數：可以訪問靜態成員和實例成員，用于初始化實例成員
  {
  ...
  }

  static testclass() //靜態構造函數：只能訪問靜態成員，用于初始化靜態成員
  {
  ...
  }
}
類的靜態成員屬于類所有，不必生成實例就可以訪問，它是在載入包含類的應用程序時創建的，
但靜態方法不能訪問類的實例變量和方法。通常，靜態變量是在定義時就賦初始值的。
類的實例成員屬于類的實例所有，不創建實例對象就無法對其進行訪問，實例成員可以訪問類的
靜態成員和其它實例成員。
調用基類的析構函數：
class a
{
  public a()
  {
  ...
  }
}
class b
{
  public b(): base()  //調用基類的析構函數
  {
  ...
  }
}
常量：其值是在編譯時設定的，必須是數值文字。默認狀態下常量是靜態的。例：
class a
{
  public const double pi = 3.1415;
}
常量是編譯時就確定的值，只讀字段是在運行才能確定的值。比如運行時才能確定的屏幕分辨率。
只讀字段只能在類的析構函數中賦值。
靜態只讀字段：
class a
{
  public static readonly int screenwidth;  //靜態只讀字段
  static a()   //靜態析構函數
  {
    screenwidth = 1024;  //在靜態析構函數中初始化
  }
}
在類的繼承中，類的析構函數是不會被繼承的。
一個派生類只能從一個基類繼承，不能同時從多個基類繼承，但可以通過繼承多個接口來
達到相同目的。實現多繼承的唯一方法就是使用接口。例：
class myfancygrid: control, iserializable, idatabound
{
...
}
密封類是不能繼承的類，抽象類不能被定義為密封類，且密封類的私有成員不能用protected修飾，
只能用private。例：
sealed class a
{
...
}
關鍵字ref和out用于指定用引用方式傳遞方法的參數。
它們的區別是：ref參數必須初始化，而out參數不需要初始化。所以在方法處理代碼依賴參數的
初始化值時使用ref，不依賴初始化值時使用out。
對out參數即使在傳遞前對其進行了初始化，其值也不會傳遞到方法處理函數內部。傳遞時系統
會將其設為未初始化。所以在方法內部必須對out參數進行初始化。
方法重載時，必須參數數目和參數類型其中之一不同，返回值不同不能作為重載。
c#不支持方法的默認值，只能通過方法重載來實現。例：
class a
{
  int method(int a)
  {
  ...
  }

  void method(int a, int b) //參數數目不同
  {    //返回值不同不能作為重載
  ...
  }
}
params參數用于一個不定數目參數的方法，一般后面跟一個數組。例：
class a
{
  public void method(params int[] i)
  {
  ...
  }
}
方法的覆蓋：指派生類覆蓋基類的同名方法，有二種方法
1）第一種是在派生類要覆蓋的方法前面加new修飾，而基類不需要作任何改動。
這種方法的缺點是不能實現多態。例：
class a
{
  public void method()  //無需任何修飾
  {
  ...
  }
}

class b: a   //從基類繼承
{
  new public void method() //覆蓋基類的同名方法
  {
  ...
  }
}

class testclass
{
  a instance = new b();
  instance.method();  //這時將調用類a的method方法，而不是類b的method方法
}

2）第二種是在派生類要覆蓋的方法前面加override修飾，而基類的同名方法前面加virtual修飾。
這樣就能實現多態，例：

class a
{
  virtual public void method()   //基類定義虛方法
  {      //虛擬方法不能定義為private，因為private成員對派生類是無法訪問的
  ...
  }
}

class b: a     //從基類繼承
{
  override public void method()   //派生類覆蓋基類的同名虛方法
  {
  ...
  }
}

class testclass
{
  protected void test()
  {
    a instance = new b();   //定義一個實例，類型為基類，從派生類創建
      //派生類總是能夠向上轉換為其基類
    instance.method();    //將調用派生類b的method方法，而不是基類的，這就是多態
  }
}

說明：new修飾的方法覆蓋不能實現多態的原因，是因為使用new時編譯器只會實現早期綁定（early binding）。
即調用的方法在編譯時就決定了：編譯器看到instance.method()而instance的類是a，就會調用類a的method()方法。
override修飾的方法覆蓋可以實現多態的原因，是因為實現了后期綁定（late binding）。
使用override時強制編譯器在運行時根據類的真正類型正確調用相應的方法，而不是在編譯時。
而基類的同名方法必須加virtual修飾。
類的靜態方法可能通過 類名.靜態方法名 這種格式來調用，不能使用 實例名.靜態方法名 這種方法調用。
因為類的靜態方法為類所有（是屬于類本身的），而非實例所有（不是屬于類的實例的）。
類的靜態方法可以訪問類的任何靜態成員，但不能訪問類的實例成員。
c#中類的變量稱為字段。類的public變量稱為類的公共字段。
類的屬性由一個protected（也可以是private）字段和getter和setter方法構成：
class address
{
  protected string zipcode; //protected字段，注意大小寫
  public string zipcode
  {
    get    //getter方法
    {
      return zipcode;
    }
    set    //setter方法
    {
      zipcode = value;  //被傳遞的值自動被在這個value變量中
    }
  };
}
只讀屬性是指省略setter方法的屬性，只讀屬性只能讀取，不能設置。
屬性也可以用限定符virtual，override和abstract修飾，功能同其他類的方法。
屬性有一個用處稱為懶惰的初始化（lazy initialization）。即在需要類成員時才對它們進行
初始化。如果類中包含了很少被引用的成員，而這些成員的初始化又會花費大量的時候和系統
資源的話，懶惰的初始化就很有用了。
c#中數組對象共同的基類是system.array。
將數組聲明為類的一個成員時，聲明數組與實例化數組必須分開，這是因為只能在運行時創建了
類的實例對象之后，才能實例化數組元素值。
聲明：
int[] intarray;  //一維數組
int[,,] int3array; //三維數組
初始化：
intarray = new int[3] {1,2,3};
int[,] int2array = new int[2,3] {{1,2,3},{4,5,6}}; //聲明時可以初始化
遍歷：
1）一維數組
for (int i = 0; i < intarray.length; i++); //array.length返回數組所有元素的個數
foreach (int i in intarray);
for (int i = 0; i < intarray.getlength(0); i++);//array.getlength(0)返回數組第一維的個數
2）多維數組
for (int i = 0; i < int3array.getlength(0); i++) //遍歷三維數組
  for (int j = 0; j < int3array.getlength(1); j++)
    for (int k = 0; k < int3array.getlength(2); k++)
    {
    ...
    }
數組的維數就是該數組的秩（rank）。array.rank可以返回數據的秩。
鋸齒數組（jagged array）是元素為數組的數組，例：
int[][] jaggedarray = new int[2][]; //包含二個元素，每個元素是個數組
jaggedarray[0] = new int[2];  //每個元素必須初始化
jaggedarray[1] = new int[3];
for (int i = 0; i < jaggedarray.length; i++) //遍歷鋸齒數組
  for (int j = 0; j < jaggedarray[i].length; j++)
  {
  ...
  }
類的屬性稱為智能字段，類的索引器稱為智能數組。由于類本身作數組使用，所以用
this作索引器的名稱，索引器有索引參數值。例：
using system;
using system.collections;
class mylistbox
{
  protected arraylist data = new arraylist();
  public object this[int idx]  //this作索引器名稱，idx是索引參數
  {
    get
    {
      if (idx > -1 && idx < data.count)
      {
        return data[idx];
      }
      else
      {
        return null;
      }
    }
    set
    {
      if (idx > -1 && idx < data.count)
      {
        data[idx] = value;
      }
      else if (idx = data.count)
      {
        data.add(value);
      }
      else
      {
        //拋出一個異常
      }
    }
  }
}
接口是二段不同代碼之間約定，通過約定實現彼此之間的相互訪問。
c#并不支持多繼承，但通過接口可實現相同功能。
當在接口中指定了實現這個接口的類時，我們就稱這個類“實現了該接口”或“從接口繼承”。
一個接口基本上就是一個抽象類，這個抽象類中除了聲明c#類的其他成員類型——例如屬性、
事件和索引器之外，只聲明了純虛擬方法。
接口中可以包含方法、屬性、索引器和事件——其中任何一種都不是在接口自身中來實現的。例：
interface iexampleinterface
{
  //property declaration
  int testproperty { get; }

  //event declaration
  event testevevnt changed;

  //mothed declaration
  function void testmothed();

  //indexer declaration
  string this[int index] { get; set; }
}
說明：定義接口時，在方法、屬性、事件和索引器所有這些接口成員都不能用public之類的訪問限定符，
因為所有接口成員都是public類型的。
因為接口定義了一個約定，任何實現一個接口的類都必須定義那個接口中每一個成員，否則將編譯失敗。例：
using system;
public class fancycontrol
{
  protected string data;
  public string data
  {
    get {return this.data;}
    set {data = value;}
  }
}

interface ivalidate
{
  bool validate(); //接口方法
}

public class mycontrol: fancycontrol, ivalidate
{
  public mycontrol()
  {
    data = "my control data";
  }

  public bool validate()  //實現接口
  {
    if (data == "my control data")
      return true;
    else
      return false;
  }
}
class interfaceapp
{
  mycontrol mycontrol = new mycontrol();
 
  ivalidate val = (ivalidate)mycontrol;  //可以將一個實現某接口的類，轉換成該接口
  bool success = val.validate();  //然后可調用該接口的方法
}
也可以用：
bool success = mycontrol.validate();
這種方法來調用validate方法，因為validate在類mycontrol中是被定義成public的，如果去除public，validate方法被隱藏，
就不能用這種方法調用了，這樣隱藏接口方法稱為名字隱藏（name hiding）。
可以用：類實例 is 接口名 來判斷某個類是否實現了某接口，例：
mycontrol is ivalidate  //mycontrol類的實例mycontrol是否實現了ivalidate接口
當然，也可用as來作轉換，根據轉換結果是否為null來判斷某個類是否實現了某接口，例：
ivalidate val = mycontrol as ivalidate;
if (null == val)
{
...  //沒有實現ivalidate接口
}
else
{
...  //實現了ivalidate接口
}

如果一個類從多個接口繼承，而這些接口中如果定義的同名的方法，則實現接口的方法時，必須加接口名來區別，
寫成 接口名.方法名。假設test類從idatastore和iserializable二個接口繼承，而這二個接口都有savedata()方法，
實現savedata()方法時必須寫成：
class test: iserializable, idatastore
{
  void iserializable.savedata()
  {
  ...
  }

  void idatastore.savedata()
  {
  ...
  }
}

如果一個類從多個接口繼承，為了方便可以定義一個新的接口，這個接口繼續多個接口，然后類直接從這個接口繼承就
可以了，這個叫合并接口。例：
interface isavedata: iserializable, idatastore
{  //不需要定義任何方法或成員，只是用作合并
}
class test: isavedata  //只要繼承isavedata就可以了
{
...
}
c# 操作符優先級（從高到低）
初級操作符 () x.y f(x) a[x] x++ x-- new typeof sizeof checked unchecked
一元操作符 + - | ~ ++x --x (t)x
乘除操作符 * / %
加減操作符 + -
位移操作符 << >>
關系操作符 < > <= >= is
等于操作符 ==
邏輯與  &
邏輯異或 ^
邏輯或  |
條件與  &&
條件或  ||
條件操作符 ?:
賦值操作符 = *= /= %= += -= <<= >>= &= ^= |=
所有的二元操作符除賦值符外都是左聯合的，即從左到右計算。
typeof()運算符可以從一個類名得到一個system.type對象，而從system.object對象繼承來的gettype()方法
則可從一個類實例來得到一個system.type對象。例：
type t1 = typeof(apple); //apple是一個類名
apple apple = new apple(); //apple是apple類的一個實例
type t2 = apple.gettype(); //t1與t2是相同的
通過反射得到一個類的所有成員和方法：
type t = typeof(apple);
string classname = t.tostring(); //得到類名
methodinfo[] methods = t.getmethods(); //得到所有方法
foreach (methodinfo method in methods)
{
//用method.tostring()得到方法名
}
memberinfo[] members = t.getmembers(); //得到所有成員
foreach (memberinfo member in members)
{
//用member.tostring()得到成員名
}
sizeof()操作符用來計算值類型變量在內存中占用的字節數（bytes），并且它只能在unsafe（非安全）
代碼中使用。例：
static unsafe public void showsizes()
{
  int i, j;
  j = sizeof(short);
  j = sizeof(i);
}
盡可能使用復合賦值操作符，它比不用復合賦值操作符的效率高。
for語句的語法為：
for (initialization; boolean-expression; step)
  embedded-statement
在initialization和step部份還可以使用逗號操作符，例：
for (int i = '0', j = 1; i <= '/xff'; i++, j++)
for (int i = 1, j = 1; i < 1000; i += j, j = i - j) //輸出斐波那契數列
 console.write("{0} ", i);
在switch語句中執行一個分支的代碼后還想執行另一個分支的代碼，可以用：
goto case 分支;
操作符重載是為了讓程序更加自然，容易理解。想要為一個類重新定義一個操作符，使用以下語法：
public static 返回值 operator 操作符 (操作對象1[，操作對象2])
說明：
1)所有重載的操作符方法都必須定義為public和static
2)從技術上說返回值可以是任何類型，但通常是返回所定義方法使用的類型
3)操作對象的數目取決于重載是一元操作符還是二元操作符，一元操作符只要一個操作對象，二元操作符則需要二個。
4)不管重載是一元操作符還是二元操作符，第一個操作對象的類型都必須與返回值的類型一致；而對于二元操作符的第二個
操作對象的類型則可以是任何類型。
5)只有下列操作符可以被重載：
一元：+ - ! ~ ++ -- true false
二元：+ - * / % & | ^ << >> == != > < >= <=
賦值操作符（+=,-=,*-,/=,%=等等）無法被重載。
[]和()操作符也無法被重載。
6)操作符的優先級是無法改變的，運算優先級的規則是靜態的。

例：假設一個invoice發票類由多個invoicedetailline類（成員只有一個double類型的amount金額屬性）組成，
我們重載+操作符，使之可以將invoicedetailline類的內容（注意不是金額合計）加在一起。
class invoice
{
  public arraylist detailline;
 
  public invoice   //類的析構函數
  {
    detailline = new arraylist(); //arraylist存放多個invoicedetailline類的實例
  }

  public static invoice operator+ (invoice invoice1, invoice invoice2) //參數與返回值的類型一致
  {
    //invoice1與invoice2的內容合并
    invoice returninvoice = new invoice();
    foreach(invoicedetailline detailline in invoice1.detaillines)
      returninvoice.detailline.add(detailline);
    foreach(invoicedetailline detailline in invoice2.detaillines)
      returninvoice.detailline.add(detailline);
    return returninvoice;
  }
}

class invoiceaddapp  //調用示例
{
  public static void main()
  {
    invoice i1 = new invoice();
    for(int i = 0; i < 3; i++)
      i1.detailline.add(new invoicedetailline(i + 1));

    invoice i2 = new invoice();
    for(int i = 0; i < 3; i++)
      i2.detailline.add(new invoicedetailline(i + 1));

    invoice summaryinvoice = i1 + i2;  //調用重載的操作符+方法
  }
}

自定義類型轉換可以編寫代碼實際二個不同的類、結構體之間的轉換。
語法：public static implicite/explicite operator 輸出類型 (輸入類型)
說明：
1)轉換方法必須是靜態的。
2)implicite表示隱式轉換，explicite表示顯式轉換。
3)輸入類型和輸出類型其中之一必須與包含轉換的類或結構體類型。即轉換必須與本類相關。
例：
struct celisus
{
  public float t;

  public celisus(float t)
  {
    this.t = t;   //this.t是結構體的字段,t是參數
  }

  public static implicite operator celisus(float t) //float=>celisus
  {
    return new celisus(t);
  }

  public static implicite operator float(celisus c) //celisus=>float
  {
    return ((c.t - 32) / 9) * 5;
  }
}

代表的(delegate)目的與c++中的函數指針相同，代表不是在編譯時被定義的，而是在運行時被定義的。
代表主要有二個用途：回調(callback)和事件處理(event)
回調通常用于異步處理和自定義處理。例：
class dbmanager
{
  static dbconnection[] activeconnections;
  //聲明回調函數
  public void delegate enumconnectioncallback(dbconnection connection);

  public static void enumconnections(enumconnectioncallback callback)
  {
    foreach (dbconnection connection in activeconnections)
    {
      callback(connection);  //執行回調函數
    }
  }
}

//調用
class delegateapp
{
  public static void activeconncetioncallback(dbconnection connection) //處理函數
  {
  ...
  }

  public void main()
  {
    //創建指向具體處理函數的代表實例（新建一個代表，讓它指向具體的處理函數）
    dbmanager.emnuconnectioncallback mycallback = new dbmanager.emnuconnectioncallback(activeconncetioncallback);
    dbmanager.enumconnections(mycallback);
  }
}

//使用靜態代表，上面的調用改為
class delegateapp
{
  //創建一個指向處理函數的靜態代表
  public static dbmanager.emnuconnectioncallback mycallback
    = new dbmanager.emnuconnectioncallback(activeconncetioncallback);
  public static void activeconncetioncallback(dbconnection connection)
  {
  ...
  }

  public void main()
  {
    dbmanager.enumconnections(mycallback);
  }
}

//在需要時才創建代表，上面的調用改為
class delegateapp
{
  //將創建代表放在屬性的getter方法中
  public static dbmanager.emnuconnectioncallback mycallback
  {
    get
    {
      retun new dbmanager.emnuconnectioncallback(activeconncetioncallback);
    }
  }
  public static void activeconncetioncallback(dbconnection connection)
  {
  ...
  }

  public void main()
  {
    delegateapp app = new delegateapp(); //創建應用程序
    dbmanager.enumconnections(mycallback);
  }
}

可以將多個代表整合成單個代表，例：
class compositedelegateapp
{
  public static void logevent(part part)
  {
  ...
  }

  public static void emailpurchasingmgr(part part)
  {
  ...
  }

  public static void main()
  {
    //定義二個代表
    inventorymanager.outofstockexceptionmethod logeventcallback
      = new inventorymanager.outofstockexceptionmethod(logevent);
    inventorymanager.outofstockexceptionmethod emailpurchasingmgrcallback
      = new inventorymanager.outofstockexceptionmethod(emailpurchasingmgr);
    //整合為一個代表，注意后加的代表先執行（這里是先執行logeventcallback）
    inventorymanager.outofstockexceptionmethod onhandexceptioneventscallback
      = emailpurchasingmgrcallback + logeventcallback;
    //調用代表
    inventorymanager mgr = new inventorymanager();
    mgr.processinventory(onhandexceptioneventscallback);
    //inventorymanager類的processinventory方法的原型為：
    //public void processinventory(outofstockexceptionmethod exception);
  }
}

可以根據需要將多個代表自由地組合成單個代表，例：
class compositedelegateapp
{
  //代表指向的處理函數（三個代表三個函數）
  public static void logevent(part part)
  {
  ...
  }

  public static void emailpurchasingmgr(part part)
  {
  ...
  }

  public static void emailstoremgr(part part)
  {
  ...
  }

  public static void main()
  {
    //通過數組定義三個代表
    inventorymanager.outofstockexceptionmethod[] exceptionmethods
      = new inventorymanager.outofstockexceptionmethod[3];
    exceptionmethods[0] = new inventorymanager.outofstockexceptionmethod(logevent);
    exceptionmethods[1] = new inventorymanager.outofstockexceptionmethod(emailpurchasingmgr);
    exceptionmethods[2] = new inventorymanager.outofstockexceptionmethod(emailstoremgr);

    int location = 1;
    //再定義一個代表（用于組合成單代表）
    inventorymanager.outofstockexceptionmethod compositedelegate;
    //根據需要組合
    if (location = 2)
    {
      compositedelegate = exceptionmethods[0] + exceptionmethods[1];
    }
    else
    {
      compositedelegate = exceptionmethods[0] + exceptionmethods[2];
    }
    //調用代表
    inventorymanager mgr = new inventorymanager();
    mgr.processinventory(compositedelegate);
  }
}
c#的事件遵循“發布——預訂”的設計模式。在這種模式中，一個類公布能夠出現的所有事件，
然后任何的類都可以預訂這些事件。一旦事件產生，運行環境就負責通知每個訂戶事件已經發生了。
當代表作為事件的處理結果時（或者說定義具有代表的事件），定義的代表必須指向二個參數的方法：
一個參數是引發事件的對象（發布者），另一個是事件信息對象（這個對象必須從eventargs類中派生）。
例：
using system;

class inventorychangeeventargs: eventargs //事件信息對象，從eventargs類派生
{
... //假設定義二個public屬性string sku和int change
}

class inventorymanager    //事件的發布者
{
  //聲明代表
  public delegate void inventorychangeeventhander(object source, inventorychangeeventargs e);
  //發布事件，event關鍵字可將一個代表指向多個處理函數
  public event inventorychangeeventhandler oninventorychangehander;
 
  public void updateinventory(string sku, int change)
  {
    if (change == 0)
      return;
    inventorychangeeventargs e = new inventorychangeeventargs(sku, change);
    //觸發事件
    if (oninventorychangehandler != null) //如果有預訂者就觸發
      oninventorychangehandler(this, e); //執行代表指向的處理函數
  }
}

class inventorywatcher    //事件的預訂者
{
  public inventorywatcher(inventorymanager mgr) //mgr參數用于聯結發布者
  {
    this.inventorymanager = mgr;
    //預訂事件，用 += 調用多個處理函數
    mgr.oninventroychangehandler += new inventorymanager.inventorychangeeventhandler(oninventorychange);
    //事件處理函數
    void oninventroychange(object source, inventroychangeeventargs e)
    {
    ...
    }

    inventorymanager inventorymanager;
  }
}

class eventsapp     //主程序
{
  public static void main()
  {
    inventorymanager inventorymanager = new inventorymanager();
    inventorywatcher inventorywatcher = new inventorywatcher(inventorymanager);

    inventorymanager.updateinventory("111 006 116", -2);
    inventorymanager.updateinventory("111 006 116", 5);
  }
}

microsoft windows nt和ibm os/2等操作系統都支持占先型多任務。在占先型多任務執行中，處理器負責
給每個線程分配一定量的運行時間——一個時間片(timeslice)。處理器接著在不同的線程之間進行切換，
執行相應的處理。在單處理器的計算機上，并不能真正實現多個線程的同時運行，除非運行在多個處理器
的計算機上。操作系統調度的多線程只是根據分配給每個線程時間片進行切換執行，感覺上就像同時執行。

上下文切換(context switching)是線程運行的一部分，處理器使用一個硬件時間來判斷一個指定線程的時間片
何時結束。當這個硬件計時器給出中斷信號時，處理器把當前運行的線程所用的所有寄存器(registers)數據
存儲到堆棧中。然后，處理器把堆棧里那些相同的寄存器信息存放到一種被稱為“上下文結構”的數據結構中。
當處理器要切換回原來執行的線程時，它反向執行這個過程，利用與該線程相關的上下文結構，在寄存器里
重新恢復與這一線程相關的信息。這樣的一個完整過程稱為“上下文切換”。

多線程允許應用程序把任務分割為多個線程，它們彼此之間可以獨立地工作，最大限度地利用了處理器時間。

using system;
using system.threading;

class simplethreadapp
{
  public static void workerthreadmethod() //線程的執行體
  {
  ...      //執行一些操作
  }

  public static void main()
  {
    //創建一個線程代表指向線程的執行體，threadstart是創建新線程必須用到的代表
    threadstart worker = new threadstart(workerthreadmethod);
    thread t = new thread(worker);  //用線程代表創建線程
    t.start();     //執行線程
  }
}

可以通過兩種方式來得到一個thread對象：一種是通過創建一個新線程來得到，如上例；另一種在正在執行的線程調用
靜態的thread.currentthread方法。
靜態方法thread.sleep(int ms)可以讓當前線程（它自動調用thread.currentthread）暫停指定毫秒的時間。
如果使用thread.sleep(0)那么當前線程將一直處于等待中，直到另一個線程調用這個線程的實例方法thread.interrupt方法，
等待才會結束。
使用thread.suspend方法也能掛起線程，thread.suspend方法可以被當前線程或其他線程調用，而thread.sleep(0)
只能由當前線程在執行體中調用。當線程用thread.suspend掛起時，必須用thread.resume方法恢復。不論thread.suspend
方法調用了多少次，只要調用thread.resume方法一次就可以線程恢復執行。用thread.suspend方法并不會阻塞線程，
調用立即返回。而thread.sleep(0)則會阻塞線程。所以確切地說thread.sleep(0)暫停線程，而不是掛起線程。
使用thread.abort方法可以終止正在執行的線程。當thread.abort方法被調用時，線程不會立即終止執行。運行環境將會
等待，直到線程到達文檔中所描述的“安全點”。如果要確保線程已經完全停止，可以使用thread.join方法。這是一個同步
調用，同步調用意味著直到線程完全停止，調用才會返回。
thread.priority屬性用于設置的線程的優先級。其值是thread.threadpriority枚舉值，可以設為highest, abovenormal,
normal, belownormal, lowest。缺省值是thread.threadpriority.normal。
線程的同步是為了解決多個線程同時使用同一對象產生的一些問題。通過同步，可以指定代碼的臨界區(critical section)，
一次只有一個線程可以進入臨界區。
使用system.monitor類（鎖定與信號量）進行線程同步：
using system;
using system.threading;

public void savedata(string text) //線程執行函數或線程執行函數調用的對象的方法
{
  ...   //執行其他一些不需要同步的處理

  monitor.enter(this); //獲取對象的monitor鎖
  ...   //執行需要同步的處理
  monitor.exit(this); //釋放對象的monitor鎖

  ...   //執行其他一些不需要同步的處理
}
說明：當執行monitor.enter方法時。這個方法會試圖獲取對象上的monitor鎖，如果另一個線程已經擁有了
這個鎖，這個方法將會阻塞(block)，直到這個鎖被釋放。
也可用c#的lock語句來獲得和釋放一個monitor鎖。上面同步寫成：
public void savedata(string text) //線程執行函數或線程執行函數調用的對象的方法
{
  ...   //執行其他一些不需要同步的處理

  lock(this)  //獲取對象的monitor鎖，代碼塊執行完成后釋放monitor鎖
  {
  ...   //執行需要同步的處理
  }

  ...   //執行其他一些不需要同步的處理
}

也可以使用system.threading名稱空間的mutex類（互斥類）進行線程同步。與monitor鎖一樣，一次只有一個線程
能獲得一個給定的互斥。但mutex要慢得多，但它增加了靈活性。例：
using system;
using system.threading;
class database
{
  mutex mutex = new mutex(false); //創建一個互斥，但不立即獲得它
     //注意：創建互斥在需要同步的方法之外，實際上它只要創建一個實例
  public void savedata(string text) //需要同步的方法
  {
    mutex.waitone();  //等待獲得互斥
    ...    //需要同步的處理
    mntex.close();  //釋放互斥
  }
}

mutex類重載了三個構造函數：
mutex()       //創建并使創建類立即獲得互斥
mutex(bool initiallyowned)    //創建時可指定是否要立即獲得互斥
mutex(bool initiallyowned, string mutername)  //還可以指定互斥的名稱
mutex.waitone方法也重載了三次：
mutex.waitone()      //一直等待
mutex.waitone(timespan time, bool exitcontext)  //等待timespan指定的時間
mutex.waitone(int milliseconds, bool exitcontext) //等待指定的毫秒
線程的用法：
1)并發操作：比如一個程序監視多個com口，當每個com接到信息時執行一段處理時。
2)復雜長時間操作：一個長時間的復雜操作可能會使界面停滯，停止用戶響應，如果還允許用戶停止它，
或者顯示進度條、顯示操作執行進程信息時。
反射(reflection)就是能夠在運行時查找類型信息，這是因為.net編譯的可執行(pe)文件中包括msil和元數據(metadata)。
反射的中心是類system.type。system.type是一個抽象類，代表公用類型系統(common type system, cts)中的一種類型。
using system;
using system.reflection; //反射命名空間，必須引用

public static void main(string[] args)
{
  int i = 6;
  type t = i.gettype();   //根據實例得到類型
  t = type.gettype("system.int32"); //根據類型的字符名稱得到類型
}

通過assembly類可以得到已經編譯.net framework程序的中所有類型，例：
using system;
using system.diagnostics;  //為了使用process類
using system.reflection;  //為了使用assembly類

class gettypesapp
{
  protected static string getassemblyname(string[] args)
  {
    string assemblyname;
    if (0 == args.length) //如果參數為空，取當前進程的名稱
    {
      process p = process.getcurrentprocess();
      assemblyname = p.processname + ".exe";
    }
    else
      assemblyname = args[0]; //取第一個參數，即當前運行程序名

    return assemblyname;
  }

  public static void main(string[] args)
  {
    string assemblyname = getassemblyname(args);
    assembly a = assembly.loadfrom(assemblyname); //調用編譯程序集
    type[] types = a.gettypes();   //得到多個類型
    foreach (type t in types)    //遍歷類型數組
    {
    ...  //取得t.fullname,t.basetype.fullname等類型信息
    }
  }
}
一個應用程序可以包括多個代碼模塊。若要將一個cs文件編譯一個模塊，只要執行下面的命令：
csc /target:module 要編譯的模塊.cs  //csc是c sharp compiler(c#編譯器)
然后在應用程序中using編譯的模塊.cs中的namespace即可應用了。
要反射應用程序中所有代碼模塊(module)，只要：
assembly a = assembly.loadfrom(assemblyname); //應用程序的物理文件名
module[] modules = a.getmodules();
foreach(module m in modules)
{
... //顯示m.name等
}
后期綁定(latebinding),例：
string[] filenames = directory.getfiles(environment.currentdirectory, "*.dll");
foreach (string filename in filenames)
{
  assembly a = assembly.loadfrom(filename);
  type[] types = a.gettypes();
  foreach(type t in types)
  {
    if (t.issubclassof(typeof(commprotocol)))  //判斷是否有commprotocol的派生類
    {
      object o = activator.createinstance(t);  //生成實例
      methodinfo mi = t.getmethod("displayname");
      mi.invoke(o, null);    //調用方法
    }
  }
}
//帶參數的例子
namespace programming_csharp
{
  using system;
  using system.reflection;
 
  public class tester
  {
    public static void main( )
    {
      type t = type.gettype("system.math");
      object o = activator.createinstance(t);

      // 定義參數類型
      type[] paramtypes = new type[1];
      paramtypes[0]= type.gettype("system.double");

      methodinfo cosineinfo = t.getmethod("cos", paramtypes);

      //設置參數數據
      object[] parameters = new object[1];
      parameters[0] = 45;

      //執行方法
      object returnval = cosineinfo.invoke(o, parameters);
      console.writeline("the cosine of a 45 degree angle {0}", returnval);
    }
  }
}
動態生成代碼和動態調用的完整例子：
//動態生成代碼的部分
using system;
using system.reflection;
using system.reflection.emit;  //動態生成代碼必須引用

namespace ilgenserver
{
  public class codegenerator
  {
    public codegenerator()
    {
      currentdomain = appdomain.currentdomain;  //得到當前域
      assemblyname = new assemblyname();  //從域創建一個程序集
      assemblyname.name = "tempassembly";
      //得到一個動態編譯生成器，assemblybuileraccess.run表示只在內存中運行，不能保存
      assemblybuilder = currentdomain.definedynamicassembly(assemblyname, assemblybuileraccess.run);
      //從編譯生成器得到一個模塊生成器
      modulebuilder = assemblybuilder.definedynamicmodule("tempmodule");
      //模塊生成器得到類生成器
      typebuilder = modulebuilder.definetype("tempclass", typeattributes.public);
      //為類添加一個方法
      methodbuilder = typebuilder.definemethod("helloword", methodattributes.public, null, null);
      //為方法寫入代碼，生成代碼必須使用到il生成器
      msil = methodbuilder.getilgenerator();
      msil.emitwriteline("hello world");
      msil.emit(opcodes.ret);
      //最后還需要編譯(build)一下類
      t = typebuilder.createtype();
    }
    appdomain currentdomain;
    assemblyname assemblyname;
    assemblybuilder assemblybuilder;
    modulebuilder modulebuilder;
    typebuilder typebuilder;
    methodbuilder methodbuilder;
    ilgenerator msil;
    object o;
    type t;
    public type t
    {
      get
      {
        return this.t;
      }
    }
  }
}
//動態調用的部分
using system;
using system.reflection;
using ilgenserver;  //引用動態生成代碼的類
public class ilgenclientapp
{
  public static void main(
  {
    codegenerator gen = new codegenerator(); //創建動態生成類
    type t = gen.t;
    if (null != t)
    {
      object o = activator.createinstance(t);
      methodinfo helloworld = t.getmethod("helloworld"); //為調用方法創建一個methodinfo
      if (null != helloworld)
      {
        helloworld.invoke(o, null);  //調用方法
      }
    }
  }
}
調用dll
using system;
using system.runtime.interopservices; //為了使用dllimport特性

class pinvokeapp
{
  [dllimport("user32.dll", charset=charset.ansi)] //charset.ansi指定ansi版本的函數(messageboxa),charset.unicode指定unicode版本的函數(messageboxw)
  static extern int messagebox(int hwnd, string msg, string caption, int type);  //聲明dll中的函數
 
  //[dllimport("user32.dll", entrypoint="messageboxa")] //用這種方法使用不同的函數名
  //static extern int msgbox(int hwnd, string msg, string caption, int type);
 
  //[dllimport("user32.dll", charset=charset.unicode)]  //調用unicode版的dll函數
  //static extern int messagebox(int hwnd, [marshalas(unmanagedtype.lpwstr)]string msg,
  // [marshalas(unmanagedtype.lpwstr)]string caption, int type); //將lpwstr翻譯為string型，缺省情況系統只將lpstr翻譯成string
  public static void main()
  {
    messagebox(0, "hello, world!", "captionstring", 0);  //調用dll中的函數
  }
}
例2，使用回調：
class callbackapp
{
  [dllimport("user32.dll")]
  static extern int getwindowtext(int hwnd, stringbuilder text, int count);

  delegate bool callbackdef(int hwnd, int lparam);

  [dllimport("user32.dll")]
  static extern int enumwindows(callbackdef callback, int lparam);

  static bool printwindow(int hwnd, int lparam)
  {
    stringbuilder text = new stringbuilder(255);
    getwindowtext(hwnd, text, 255);
    console.writeline("window caption: {0}", text);
    return true;
  }

  static void main()
  {
    callbackdef callback = new callbackdef(printwindow);
    enumwindows(callback, 0);
  }
}
關鍵字unsafe指定標記塊在非控環境中運行。該關鍵字可以用于所有的方法，包括構造函數和屬性，
甚至還有方法中的代碼塊。關鍵字fixed負責受控對象的固定(pinning)。pinning是一種動作，向
垃圾收集器(garbage collector, gc)指定一些不能被移動的對象。為了不在內存中產生碎片，.net
運行環境把對象四處移動，以便于最有效地利用內存。使用fixed后指定對象將不會被移動，所以就
可以用指針來訪問它。
c#中只能得到值類型、數組和字符串的指針。在數組的情況下，第一個元素必須是值類型，因為c#
實際上是返回一個指向數組第一個元素的指針，而不是返回數組自身。
& 取一個變量的內存地址（即指向該變量的指針）
* 取指針所指變量的值
-> 取成員
例：
using system;
class unsafeapp
{
  public static unsafe void getvalues(int* x, int* y)
  {
    *x = 6;
    *y = 42;
  }

  public static unsafe void main()
  {
    int a = 1;
    int b = 2;
    getvalues(&a, &b);
  }
}
fixed語法為：fixed(type* ptr = expression) statements
其中type也可以為非控類型，也可是void；expression是任何產生一個type指針的表達式；
statements是應用的代碼塊。例：
fixed (int* f = &foo.x)  //foo是foo類的一個實例，x是foo類的一個int屬性
{
  setfoovalue(f);  //setfoovalue方法的定義為unsafe static void setfoovalue(int* x)
}
傳統的com組件可以通過互操作層(com interop)與.net運行環境交互?；ゲ僮鲗犹幚碓谕泄苓\行環境和非托管區域
中的com組件操作之間傳遞所有的消息。
要使com組件能在.net環境中使用,必須為com組件生成元數據。.net運行環境用元數據層業判斷類型信息。在運行時刻
使用類型信息，以便生成rcw(runtime callable wrapper,運行時可調用包裝)。當.net應用程序與com對象交互時，
rcw處理對com對象的裝載和調用。rcw還完成許多其他的工作，如管理對象標識、對象生存周期以及接口緩沖區。
對象生存周期管理十分關鍵，因為.net gc把對象到處移動，并且當對象不再使用時，自動處理這些對象。rcw服務告訴
.net，應用程序正與托管.net組件交互，同時又使非托管com組件“覺得”com對象是被傳統的com客戶端調用的。
為了為com組件生成元數據包裝，必須使用tlbimp.exe(typelib importer)工具：
tlbimp some_com.tlb /out:som_com.dll