readonly和const是兩種不同的常量，其中readonly是運(yùn)行時(shí)常量，而const是編譯時(shí)常量,。
     舉例：
    public static readonly int A = 2; //A為運(yùn)行時(shí)常量
    public const int B = 3; //B為編譯時(shí)常量
    注意,，const默認(rèn)為static類型，所以無需用static修飾,，如果強(qiáng)制用static進(jìn)行聲明將導(dǎo)致編譯錯(cuò)誤,。
    下面的表達(dá)式： int C = A + B;
    經(jīng)過編譯后與下面的形式等價(jià)：
    int C = A + 3;
    可以看到，其中的const常量B被替換成字面量3,，而readonly常量A則保持引用方式,。
    const常量只能被賦予數(shù)字(整數(shù)、浮點(diǎn)數(shù)),、字符串以及枚舉類型,。下面的代碼無法通過編譯：
  public const DateTime D = DateTime.MinValue;
    改成readonly就可以正常編譯：
public readonly DateTime D = DateTime.MinValue;
二、const常數(shù)表達(dá)式在編譯時(shí)是完全可以計(jì)算的,，因此不能通過一個(gè)變量的值來進(jìn)行初始化，比如：
public    const int A=b+1;
  此時(shí)的b是一個(gè)變量 ,，顯然,，在編譯時(shí)是不可以計(jì)算的。因此,，const常數(shù)表達(dá)式（變量）不可以用變量來初始化,。
 而 readonly可以把設(shè)定一個(gè)字段為常量，但由于它是運(yùn)行時(shí)計(jì)算的,，因此可以通過變量進(jìn)行初始化,。
三：兩者的區(qū)別之處：
1. const 字段只能在該字段的聲明中初始化。
    對(duì)于某個(gè)類來說：readonly常量是其實(shí)例成員,。因此readonly 字段可以在聲明或構(gòu)造函數(shù)中初始化,。
因此，根據(jù)所使用的構(gòu)造函數(shù),，readonly字段可能具有不同的值,。
2. const 字段是編譯時(shí)常數(shù)，而 readonly 字段可用于運(yùn)行時(shí)常數(shù),。
3. const 默認(rèn)就是靜態(tài)的,，而 readonly 如果設(shè)置成靜態(tài)的就必須顯示聲明。
4. const 對(duì)于引用類型的常數(shù),，可能的值只能是 string 和 null,。對(duì)于值類型的常數(shù)可以是數(shù)字(整數(shù)、浮點(diǎn)數(shù))以及枚舉類型
   readonly可以是任何類型

在迭代器塊中用于向枚舉數(shù)對(duì)象提供值或發(fā)出迭代結(jié)束信號(hào),。它的形式為下列之一：
yield return expression;
yield break;
參數(shù)
expression
進(jìn)行計(jì)算并以枚舉數(shù)對(duì)象值的形式返回,。expression 必須可以隱式轉(zhuǎn)換為迭代器的 yield 類型。
備注
yield 語句只能出現(xiàn)在 iterator 塊中，該塊可用作方法,、運(yùn)算符或訪問器的體,。這類方法、運(yùn)算符或訪問器的體受以下約束的控制：
不允許不安全塊,。
方法,、運(yùn)算符或訪問器的參數(shù)不能是 ref 或 out。
yield 語句不能出現(xiàn)在匿名方法中,。有關(guān)更多信息,，請(qǐng)參見匿名方法（C# 編程指南）。
當(dāng)和 expression 一起使用時(shí),，yield return 語句不能出現(xiàn)在 catch 塊中或含有一個(gè)或多個(gè) catch 子句的 try 塊中,。
示例
在下面的示例中，迭代器塊（這里是方法 Power(int number, int power)）中使用了 yield 語句,。
當(dāng)調(diào)用 Power 方法時(shí),，它返回一個(gè)包含數(shù)字冪的可枚舉對(duì)象。注意 Power 方法的返回類型是 IEnumerable（一種迭代器接口類型）,。
// yield-example.cs
using System;
using System.Collections;
public class List
{
    public static IEnumerable Power(int number, int exponent)
    {
        int counter = 0;
        int result = 1;
        while (counter++ < exponent)
        {
            result = result * number;
            yield return result;
        }
    }

    static void Main()
    {
        // Display powers of 2 up to the exponent 8:
        foreach (int i in Power(2, 8))
        {
            Console.Write("{0} ", i);
        }
    }
}
輸出
2 4 8 16 32 64 128 256
在沒有yield關(guān)鍵字之前,，我們實(shí)現(xiàn)Power方法也許要使用下面的方法：
    public static IEnumerable Power(int number, int exponent)
    {
        int counter = 0;
        int result = 1;
        dim al as new arraylist();
        while (counter++ < exponent)
        {
            result = result * number;
            al.add(result);
        }
        return al;
    }

從上面的比較可以看出：yield 只是部分簡化了我們的操作。

很多人對(duì)Volatile都不太了解,，其實(shí)Volatile是由于編譯器優(yōu)化所造成的一個(gè)Bug而引入的關(guān)鍵字,。
         int a = 10;
         int b = a;
         int c = a;
         理論上來講每次使用a的時(shí)候都應(yīng)該從a的地址來讀取變量值，但是這存在一個(gè)效率問題,，就
是每次使用a都要去內(nèi)存中取變量值,，然后再通過系統(tǒng)總線傳到CPU處理，這樣開銷會(huì)很大,。所以那些
編譯器優(yōu)化者故作聰明,，把a(bǔ)讀進(jìn)CPU的cache里，像上面的代碼,，假如a在賦值期間沒有被改變,，就直
接從CPU的cache里取a的副本來進(jìn)行賦值。但是bug也顯而易見,，當(dāng)a在賦給b之后,，可能a已經(jīng)被另一
個(gè)線程改變而重新寫回了內(nèi)存，但這個(gè)線程并不知道,，依舊按照原來的計(jì)劃從CPU的cache里讀a的副
本進(jìn)來賦值給c,，結(jié)果不幸發(fā)生了。
        于是編譯器的開發(fā)者為了補(bǔ)救這一bug,，提供了一個(gè)Volatile讓開發(fā)人員為他們的過失埋單
,，或者說提供給開發(fā)人員了一個(gè)選擇效率的權(quán)利,。當(dāng)變量加上了Volatile時(shí)，編譯器就老老實(shí)實(shí)的每
次都從內(nèi)存中讀取這個(gè)變量值,，否則就還按照優(yōu)化的方案從cache里讀,。

volatile的本意是一般有兩種說法--1.“暫態(tài)的”；2.“易變的”,。
這兩種說法都有可行,。但是究竟volatile是什么意思，現(xiàn)舉例說明（以Keil-c與a51為例
例子來自Keil FQA）,看完例子后你應(yīng)該明白volatile的意思了,，如果還不明白,，那只好
再看一遍了。
volatile 關(guān)鍵字指示一個(gè)字段可以由多個(gè)同時(shí)執(zhí)行的線程修改,。
聲明為 volatile 的字段不受編譯器優(yōu)化（假定由單個(gè)線程訪問）的限制,。
這樣可以確保該字段在任何時(shí)間呈現(xiàn)的都是最新的值。

volatile 修飾符通常用于由多個(gè)線程訪問但不使用 lock 語句對(duì)訪問進(jìn)行序列化的字段,。

volatile 關(guān)鍵字可應(yīng)用于以下類型的字段：

引用類型,。

指針類型（在不安全的上下文中）。
請(qǐng)注意,，雖然指針本身可以是可變的,，但是它指向的對(duì)象不能是可變的。
換句話說,，您無法聲明“指向可變對(duì)象的指針”。

整型,，如 sbyte,、byte、short,、ushort,、int、uint,、char,、float 和 bool。

具有整數(shù)基類型的枚舉類型,。

已知為引用類型的泛型類型參數(shù),。

IntPtr 和 UIntPtr。

可變關(guān)鍵字僅可應(yīng)用于類或結(jié)構(gòu)字段,。不能將局部變量聲明為 volatile,。

下面的示例說明如何將公共字段變量聲明為 volatile。

// csharp_volatile.cs
// Compile with: /target:library
class Test
{ 
 public volatile int i;
   Test(int _i)
  {    
 i = _i;
   }
}

operator 關(guān)鍵字用于在類或結(jié)構(gòu)聲明中聲明運(yùn)算符,。運(yùn)算符聲明可以采用下列四種形式之一：

1. public static result-type operator unary-operator ( op-type operand )

2. public static result-type operator binary-operator (
       op-type operand,
       op-type2 operand2
       )

3. public static implicit operator conv-type-out ( conv-type-in operand )

4. public static explicit operator conv-type-out ( conv-type-in operand )

參數(shù)：

1. result-type 運(yùn)算符的結(jié)果類型,。
2. unary-operator 下列運(yùn)算符之一：+ - ! ~ ++ — true false
3. op-type 第一個(gè)（或唯一一個(gè)）參數(shù)的類型,。
4. operand 第一個(gè)（或唯一一個(gè)）參數(shù)的名稱。
5. binary-operator 其中一個(gè)：+ - * / % & | ^ << >> == != > < >= <=
6. op-type2 第二個(gè)參數(shù)的類型,。
7. operand2 第二個(gè)參數(shù)的名稱,。
8. conv-type-out 類型轉(zhuǎn)換運(yùn)算符的目標(biāo)類型。
9. conv-type-in 類型轉(zhuǎn)換運(yùn)算符的輸入類型,。

注意：

1. 前兩種形式聲明了用戶定義的重載內(nèi)置運(yùn)算符的運(yùn)算符,。并非所有內(nèi)置運(yùn)算符都可以被重載（請(qǐng)參見可重載的運(yùn)算符）。op-type 和 op-type2 中至少有一個(gè)必須是封閉類型（即運(yùn)算符所屬的類型,，或理解為自定義的類型）,。例如，這將防止重定義整數(shù)加法運(yùn)算符,。
2. 后兩種形式聲明了轉(zhuǎn)換運(yùn)算符,。conv-type-in 和 conv-type-out 中正好有一個(gè)必須是封閉類型（即，轉(zhuǎn)換運(yùn)算符只能從它的封閉類型轉(zhuǎn)換為其他某個(gè)類型,，或從其他某個(gè)類型轉(zhuǎn)換為它的封閉類型）,。
3. 運(yùn)算符只能采用值參數(shù)，不能采用 ref 或 out 參數(shù),。
4. C# 要求成對(duì)重載比較運(yùn)算符,。如果重載了==，則也必須重載!=,，否則產(chǎn)生編譯錯(cuò)誤,。同時(shí)，比較運(yùn)算符必須返回bool類型的值,，這是與其他算術(shù)運(yùn)算符的根本區(qū)別,。
5. C# 不允許重載=運(yùn)算符，但如果重載例如+運(yùn)算符,，編譯器會(huì)自動(dòng)使用+運(yùn)算符的重載來執(zhí)行+=運(yùn)算符的操作,。
6. 運(yùn)算符重載的其實(shí)就是函數(shù)重載。首先通過指定的運(yùn)算表達(dá)式調(diào)用對(duì)應(yīng)的運(yùn)算符函數(shù),，然后再將運(yùn)算對(duì)象轉(zhuǎn)化為運(yùn)算符函數(shù)的實(shí)參,，接著根據(jù)實(shí)參的類型來確定需要調(diào)用的函數(shù)的重載，這個(gè)過程是由編譯器完成,。
7. 任何運(yùn)算符聲明的前面都可以有一個(gè)可選的屬性（C# 編程指南）列表,。

explicit

explicit 關(guān)鍵字用于聲明必須使用強(qiáng)制轉(zhuǎn)換來調(diào)用的用戶定義的類型轉(zhuǎn)換運(yùn)算符。

static explicit operator target_type { source_type identifier }

參數(shù)：

1. target_type 目標(biāo)類型
2. source_type 源類型,。
3. identifier Something,。

注意：

1. 轉(zhuǎn)換運(yùn)算符將源類型轉(zhuǎn)換為目標(biāo)類型。源類型提供轉(zhuǎn)換運(yùn)算符,。與隱式轉(zhuǎn)換不同,，必須通過強(qiáng)制轉(zhuǎn)換的方式來調(diào)用顯式轉(zhuǎn)換運(yùn)算符,。如果轉(zhuǎn)換操作可能導(dǎo)致異常或丟失信息,，則應(yīng)將其標(biāo)記為 explicit,。這可以防止編譯器無提示地調(diào)用可能產(chǎn)生無法預(yù)見后果的轉(zhuǎn)換操作。

implicit

implicit 關(guān)鍵字用于聲明隱式的用戶定義類型轉(zhuǎn)換運(yùn)算符,。

static implicit operator target_type { source_type identifier }

注意：

1. 隱式轉(zhuǎn)換可以通過消除不必要的類型轉(zhuǎn)換來提高源代碼的可讀性,。但是，因?yàn)榭梢栽诔绦騿T未指定的情況下發(fā)生隱式轉(zhuǎn)換,，因此必須注意防止令人不愉快的后果,。一般情況下，隱式轉(zhuǎn)換運(yùn)算符應(yīng)當(dāng)從不引發(fā)異常并且從不丟失信息,，以便可以在程序員不知曉的情況下安全使用它們,。如果轉(zhuǎn)換運(yùn)算符不能滿足那些條件，則應(yīng)將其標(biāo)記為 explicit,。

示例：

以下是一個(gè)綜合示例,，簡要展示用法。如要更具體細(xì)節(jié)的了解,，請(qǐng)參閱MSDN Library,。

// keywords_operator.cs

using System;

namespace Hunts.Keywords
{
    // 定義一個(gè)人民幣結(jié)構(gòu)。數(shù)據(jù)類型轉(zhuǎn)換的語法對(duì)于結(jié)構(gòu)和類是一樣的
    public struct RMB
    {
        // 注意:這些數(shù)的范圍可能不能滿足實(shí)際中的使用
        public uint Yuan;
        public uint Jiao;
        public uint Fen;

        public RMB(uint yuan, uint jiao, uint fen)
        {
            if (fen > 9)
            {
                jiao += fen / 10;
                fen = fen % 10;
            }
            if (jiao > 9)
            {
                yuan += jiao / 10;
                jiao = jiao % 10;
            }
            this.Yuan = yuan;
            this.Jiao = jiao;
            this.Fen = fen;
        }

        public override string ToString()
        {
            return string.Format("￥{0}元{1}角{2}分", Yuan, Jiao, Fen);
        }

        // 一些操作
        public static RMB operator +(RMB rmb1, RMB rmb2)
        {
            return new RMB(rmb1.Yuan + rmb2.Yuan, rmb1.Jiao + rmb2.Jiao, rmb1.Fen + rmb2.Fen);
        }

        public static implicit operator float(RMB rmb)
        {
            return rmb.Yuan + (rmb.Jiao/10.0f) + (rmb.Fen/100.00f);
        }

        public static explicit operator RMB(float f)
        {
            uint yuan = (uint)f;
            uint jiao = (uint)((f - yuan) * 10);
            uint fen = (uint)(((f - yuan) * 100) % 10);
            return new RMB(yuan, jiao, fen);
        }

        // more
    }
    class App
    {
        static void Main()
        {
            RMB r1, r2, r3, r4;

            // 記得小學(xué)時(shí)的某次捐款,，我把口袋里藏好的一塊錢加6張一毛錢以及13個(gè)一分錢的硬幣都貢獻(xiàn)出去了：（
            r1 = new RMB(1, 6, 13);
            // 其實(shí)當(dāng)時(shí)其他人都已經(jīng)交過了,，他們總共交了：
            r2 = new RMB(46, 9, 3);
            // 那么加上我的就是：
            r3 = r1 + r2;
            Console.WriteLine("r3 = {0}", r3.ToString());

            // 隱式轉(zhuǎn)換
            float f = r3;
            Console.WriteLine("float f= {0}", f);

            // 顯式轉(zhuǎn)換
            r4 = (RMB)f;
            Console.WriteLine("r4 = {0}", r4.ToString());
            //如果不進(jìn)行顯示轉(zhuǎn)換,將出現(xiàn)錯(cuò)誤 CS0266: 無法將類型“float”隱式轉(zhuǎn)換為“Hunts.Keywords.RMB”。存在一個(gè)顯式轉(zhuǎn)換(是否缺少強(qiáng)制轉(zhuǎn)換?)

            Console.Read();
        }
    }
}

/*
控制臺(tái)輸出：
r3 = ￥48元6角6分
float f = 48.66
r4 = ￥48元6角5分
*/

我們會(huì)發(fā)現(xiàn)r4結(jié)果少了一分錢,！這是因?yàn)樵冢?/P>

uint fen = (uint)(((f - yuan) * 100) % 10);

這句中,，在將float轉(zhuǎn)換為uint時(shí)發(fā)生了圓整錯(cuò)誤（這與計(jì)算機(jī)以二進(jìn)制存儲(chǔ)有關(guān)）。解決這個(gè)錯(cuò)誤,，我們可以使用System.Convert類中用于處理數(shù)字的靜態(tài)方法：

uint fen = Convert.ToUInt32(((f - yuan) * 100) % 10);

不過使用System.Convert處理會(huì)有些性能的損失。

 

 

extern 修飾符用于聲明由程序集外部實(shí)現(xiàn)的成員函數(shù)
1 基本解釋
　　extern可以置于變量或者函數(shù)前,，以標(biāo)示變量或者函數(shù)的定義在別的文件中,，
提示編譯器遇到此變量和函數(shù)時(shí)在其他模塊中尋找其定義。
　　另外,，extern也可用來進(jìn)行鏈接指定,。

經(jīng)常用于系統(tǒng)API函數(shù)的調(diào)用（通過 DllImport ）。注意,，和DllImport一起使用時(shí)要加上 static 修飾符

也可以用于對(duì)于同一程序集不同版本組件的調(diào)用（用 extern 聲明別名）

不能與 abstract 修飾符同時(shí)使用

示例：

using System; 
using System.Collections.Generic; 
using System.Text; 
using System.Runtime.InteropServices; 
  
namespace Example03 
{ 
 class Program 
 { 
 //注意DllImport是一個(gè)Attribute Property,，在System.Runtime.InteropServices命名空間中定義 
 //extern與DllImport一起使用時(shí)必須再加上一個(gè)static修飾符 
 [DllImport("User32.dll")] 
 public static extern int MessageBox(int Handle, string Message, string Caption, int Type); 
  
 static int Main() 
 { 
 string myString; 
 Console.Write("Enter your message: "); 
 myString = Console.ReadLine(); 
 return MessageBox(0, myString, "My Message Box", 0); 
 } 
 } 
} 

 

發(fā)現(xiàn)時(shí)候已經(jīng)是中午了，先弄到這里吧,，有時(shí)間再總結(jié)一下……