夏普空調(diào)TIMER亮黃燈怎么回事(夏普空調(diào)時鐘指示燈亮)

發(fā)布日期：2022-10-05 21:16:52 瀏覽：

前沿拓展：

夏普空調(diào)TIMER亮黃燈怎么回

一打開電視就總是自動關(guān)機(jī) 是電視機(jī)壞了吧？
on timer 功能是定時開機(jī)，與自動關(guān)機(jī)沒有關(guān)系的

概念：泛型編程是一種編程方式，它利用“參數(shù)化類型”將類型抽象化，從而實現(xiàn)更為靈活的服用，然后使用這些變量記錄不同類型的數(shù)據(jù)，這樣可以重復(fù)利用泛型來存儲不同類型的數(shù)據(jù)。

泛型用于處理算法，數(shù)據(jù)結(jié)構(gòu)的一種編程方法。泛型的目標(biāo)采用廣泛適用和可交互性的形式來表示算法和數(shù)據(jù)結(jié)構(gòu)，以使他們能夠直接用于軟件構(gòu)造。泛型類、結(jié)構(gòu)、接口、委托和方法可以根據(jù)他們存儲和操作的數(shù)據(jù)類型來進(jìn)行參數(shù)化。泛型能在編譯時提供強(qiáng)大的類型檢查，減少數(shù)據(jù)類型之間的顯示轉(zhuǎn)換、裝箱操作和運(yùn)行時的類型檢查等。泛型類和泛型方法同時具備可重用性、類型安全和效率高等特性。這是非泛型類和非泛型方法無法具備的。

語法格式如下：

類修飾符 class 類名<類型參數(shù)T>

{

類體

}

泛型類的聲明比普通類多一個類型參數(shù)T，類型參數(shù)T樂意看作是一個占位符，他不是一種類型，它僅僅代表了某種可能的類型。在定義泛型類，T出現(xiàn)的位置可以在使用時，用任何類型來代替。類型參數(shù)T的命名規(guī)則如下：

? 使用描述名稱命名泛型類型參數(shù)，除非單個字母名稱完全可以讓人了解它表示的含義，而面熟性名稱不會有更多的意義。

? 將T作為面熟性類型參數(shù)名的前綴。

例：使用泛型存儲不同類型的數(shù)據(jù)列表

namespace ExtensiveList

{

public partial class Form1 : Form

{

public Form1()

{

InitializeComponent();

}

class Types<T>

{

public T Num; //聲明編號字段

public T Name; //聲明姓名字段

public T Sex; //聲明性別字段

public T Age; //聲明年齡字段

public T Birthday; //聲明生日字段

public T Salary; //聲明薪水字段

}

private void button1_Click(object sender, EventArgs e)

{

Types<object> Exte = new Types<object>();//實例化泛型類對象

//為泛型類中聲明的字段進(jìn)行賦值，存儲不同類型的值

Exte.Num = 1;

Exte.Name = &34;王老師&34;;

Exte.Sex = &34;男&34;;

Exte.Age = 25;

Exte.Birthday = Convert.ToDateTime(&34;19860608&34;);

Exte.Salary = 1500.45F;

//將泛型類中各字段的值顯示在文本框中

textBox1.Text = Exte.Num.ToString();

textBox2.Text = Exte.Name.ToString();

textBox3.Text = Exte.Sex.ToString();

textBox4.Text = Exte.Age.ToString();

textBox5.Text = Exte.Birthday.ToString();

textBox6.Text = Exte.Salary.ToString();

}

例2：泛型的繼承：泛型繼承類與普通類是類似的，只是在繼承的時候多個T，格式如下：

class DerivedClass<參數(shù)類型T>:BaseClass<參數(shù)類型T>

舉例： class BStuInfo<T>

{

public T ID; //聲明學(xué)生編號字段

public T Name; //聲明姓名字段

public T Sex; //聲明性別字段

public T Age; //聲明年齡字段

public T Birthday; //聲明生日字段

public T Grade; //聲明班級字段

}

class HStuInfo<T> : BStuInfo<T>//繼承自BStuInfo泛型類

{

public T Chinese; //聲明語文成績字段

public T Math; //聲明數(shù)學(xué)成績字段

public T English; //聲明英語成績字段

}

泛型方法是在聲明中包括了類型參數(shù)T的方法。泛型方法可以在類、結(jié)構(gòu)或接口中聲明，這些類、結(jié)構(gòu)或接口本身可以是泛型或非泛型。如果在泛型類型聲明中聲明泛型方法，則方法可以同時引用該方法的類型參數(shù)T和包含該方法聲明的類型參數(shù)T。泛型方法的語法如下：

[修飾符] [返回值類型] [方法名] <參數(shù)類型T>()

{

方法體

}

例：通過泛型查找不同的值

namespace ArrayInfo

{

public partial class Form1 : Form

{

public Form1()

{

InitializeComponent();

}

public class Finder

{

// 定義一個泛型方法，用來查找指定值在數(shù)組中的索引

public static int Find<T>(T[] items, T item)

{

for (int i = 0; i < items.Length; i++)//遍歷泛型數(shù)組

{

if (items[i].Equals(item))//判斷是否找到了指定值

{

return i;//返回指定值在數(shù)組中的索引

}

return 1;//如果沒有找到，返回1

}

private void button1_Click(object sender, EventArgs e)

{

string[] Str = new string[] { &34;一&34;, &34;二&34;, &34;三&34;, &34;四&34;, &34;五&34;, &34;六&34;, &34;七&34;, &34;八&34;, &34;九&34; };//聲明一個字符串類型的數(shù)組

MessageBox.Show(Finder.Find<string>(Str, &34;三&34;).ToString());//查找字符串“三”在數(shù)組中的索引

}

private void button2_Click(object sender, EventArgs e)

{

int[] IntArray = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };//聲明一個整數(shù)類型的數(shù)組

MessageBox.Show(Finder.Find<int>(IntArray, 5).ToString());//查找數(shù)字5在數(shù)組中的索引

}

private void button3_Click(object sender, EventArgs e)

{

bool[] IntArray = new bool[] { true, false};//聲明一個布爾類型的數(shù)組

MessageBox.Show(Finder.Find<bool>(IntArray, false).ToString());//查找false在數(shù)組中的索引

}

例2：泛型作為返回值，例如Spring.Net中獲取類的方法

public static T GetObject(string name)

{

try

{

IApplicationContext ctx = ContextRegistry.GetContext();

return ctx.GetObject(name) as T;

}

catch (Exception ex)

{

logger.Error(ex.Message);

return default(T);

}

泛型方法的重載：與普通的方法類似，只是聲明時，添加了一個類型參數(shù)T

例：通過泛型實現(xiàn)子窗體的不同的操作。

namespace FormDisOperate

{

public partial class Form1 : Form

{

public Form1()

{

InitializeComponent();

}

public void FormOperate<T>()

{

Form2 Frm_2 = new Form2();//實例化Form2窗體對象

Frm_2.ShowDialog();//以對話框形式顯示Form2窗體

}

public void FormOperate<T>(string strError)

{//實例化提示框中顯示圖標(biāo)對象

MessageBoxIcon messIcon = MessageBoxIcon.Error; MessageBox.Show(strError, &34;提示&34;, MessageBoxButtons.OK, messIcon);//顯示錯誤提示框

}

private void button1_Click(object sender, EventArgs e)

{

FormOperate<object>();//調(diào)用FormOperate方法的第一種重載形式對窗體操作

}

private void button2_Click(object sender, EventArgs e)

{

FormOperate<object>(&34;數(shù)據(jù)庫連接失敗。&34;);//調(diào)用FormOperate方法的第二種重載形式對窗體操作

}

使用泛型集合：通常情況下，建議開發(fā)人員使用泛型集合，因為這樣可以獲得類型安全的直接優(yōu)點，而不需要從基集合類型派生并實現(xiàn)類型特定的成員。此外，如果集合元素為值類型，泛型集合類型的性能通常優(yōu)于對應(yīng)的非泛型集合類型，并優(yōu)于從非泛型基集合類型派生的類型，因為使用泛型時不必對元素進(jìn)行封裝。

常用的集合：ArrayList、Hashtable、Stack、Queue。需要添加命名空間using System.Collections

ArrayList使用舉例：添加單個元素

static void Main(string[] args)

{

ArrayList list=new ArrayList();

list.Add(12);

list.Add(&34;ASsa&34;);

list.Add(false);

foreach(var i in list)

{

Console.WriteLine(i.ToString());

}

輸出結(jié)果：

ASsa

False

添加數(shù)組：

static void Main(string[] args)

{

int[] arr = { 1, 2, 3 };//第一種添加數(shù)組的方法

ArrayList list=new ArrayList();

list.AddRange(arr);

int[] arr1 = { 4, 5, 6 };//第二種添加數(shù)組的方法

ArrayList list1 = new ArrayList(arr1);

}

ArrayList常用的一些方法：

static void Main(string[] args)

{

int[] arr = { 1, 2, 3 };

ArrayList list=new ArrayList();

list.AddRange(arr);

list.Clear();//清除所有數(shù)據(jù)

list.Contains(2);//判斷是否包含這個數(shù)據(jù)，包含輸出true，不包含輸出false

int cap = list.Capacity;//得到目前最大容量

int num = list.Count;//得到實際元素的個數(shù)

int b = list.Count;//返回元素的下標(biāo)，從左向右查

list.Insert(0, 12);//在下邊為0處插入12，其后面的，后移一位，下標(biāo)不能超過list的最大長度

list.Remove(2);//刪除一個元素，存在則刪除，不存在就不執(zhí)行。

list.RemoveAt(0);//刪除下標(biāo)的元素，括號為下標(biāo)

}

HashTable常用的方法：

static void Main(string[] args)

{

Hashtable table = new Hashtable();

table.Add(&34;1&34;, 10);

table.Add(&34;2&34;, 20);

table.Add(&34;3&34;, 30);//添加數(shù)據(jù)

object i = table[&34;1&34;];//根據(jù)Key，獲取對應(yīng)的Value

table.Clear();//刪除表

bool key = table.Contains(&34;1&34;);//是否包含某個鍵，若包含則返回true

bool key1 = table.ContainsKey(&34;1&34;);//是否包含某個鍵，若包含則返回true

bool val = table.ContainsValue(10);//是否存在10.存在返回true

int ct = table.Count;//返回元素的個數(shù)

ICollection ic = table.Keys;//獲取所有的鍵值

foreach (object o in ic)

{

Console.WriteLine(0);//結(jié)果：1,2,3

}

ic = table.Values;

foreach (object o in ic)

{

Console.WriteLine(o);//結(jié)果：10、20、30

}

foreach (DictionaryEntry d in table)

{

Console.WriteLine(&34;{0},{1}&34;,d.Key,d.Value);

}

//結(jié)果：

//1,10

//2,20

//3,30

棧是一種先進(jìn)后出的一種數(shù)據(jù)結(jié)構(gòu)，類似口向上的井

棧舉例：

Stack st = new Stack();

st.Push(1);

st.Push(2);//壓棧

object o = st.Pop();//出棧，并把棧頂刪除

object ob = st.Peek();//出棧，并不刪除棧頂元素

隊列是一種先進(jìn)先出的數(shù)據(jù)結(jié)構(gòu)

隊列舉例： Queue q = new Queue();

q.Enqueue(1);

q.Enqueue(2);//添加數(shù)據(jù)

object o = q.Dequeue();//出隊，并把隊頂元素刪除

object ob = q.Peek();//出隊，并不刪除隊頂元素

常用的泛型：

? List<數(shù)據(jù)類型>

格式：List<s數(shù)據(jù)類型> list=new List<數(shù)據(jù)類型>();取代了集合中的ArrayList

? Dictionary<數(shù)據(jù)類型，數(shù)據(jù)類型>

格式：Dictionary<數(shù)據(jù)類型，數(shù)據(jù)類型> dic=new Dictionary<數(shù)據(jù)類型，數(shù)據(jù)類型>()；取代了集合中的HashTable

? Stack<數(shù)據(jù)類型>

格式Stack<數(shù)據(jù)類型> s=new Stack<數(shù)據(jù)類型>();取代了集合中Stack

? Queue<數(shù)據(jù)類型>

格式Queue <數(shù)據(jù)類型> s=new Queue <數(shù)據(jù)類型>();取代了集合中Queue

舉例：從字典中同時取出，key和對應(yīng)的value

Dictionary<int, string> dic = new Dictionary<int, string>();

dic.Add(1, &34;10&34;);

dic.Add(2, &34;20&34;);

string s = dic[1];//取出key為1的值。

Dictionary<int, string>.KeyCollection keys = dic.Keys;//獲取所有的鍵值

foreach (int i in keys)//遍歷Key

{

Console.WriteLine(i);

}

Dictionary<int, string>.ValueCollection vals = dic.Values;//獲取所有的Value值

foreach (string t in vals)//遍歷Value

{

Console.WriteLine(t);

}

foreach (KeyValuePair<int, string> k in dic)//遍歷鍵值對

{

Console.WriteLine(k.Key+&34;.....&34;+k.Value);

}

字典和List嵌套綜合應(yīng)用：字典中嵌套List，按字典的key進(jìn)行分類放入List中。比如按照名字進(jìn)行分類

private void BindGrid()

{

List<MemberInfo> memberList=_bll.getList();//獲取數(shù)據(jù)放入列表

Dictionary<string,List<MemberInfo>> memberNameDic=new Dictionary<string,List<MemberInfo>>();//建立嵌套List

Foreach(Member memberInfo in memberList)

{

if(memberNameDic.ContainsKey(memberInfo.MemberName)==false)

{

memberNameDic.Add(memberInfo.MemberName , new List<MemberInfo>())

}

memberNameDic[memberInfo.MemberName].Add(memberInfo);//向字典中按姓名相同進(jìn)行分類

}

Foreach( string key in memberNameDic.Keys)

{

GroupNameSame(key , memberNameDic[key]);

}

Private void GroupNameSame(string name,IList<MemberInfo> memberNameList)

{

Foreach(MemberInfo memberInfo in memberNameList)

{}//讀取List

}

泛型排序列表，SortList<Tkey,TValue> 表示按照鍵進(jìn)行的排序的鍵/值對的集合，鍵/值對是KeyValuePair<TKey,TValue>類型。泛型排序列表具有以下3個特點：

1) 、將添加到泛型排序的表的元素自動按照鍵進(jìn)行排序。

2) 、泛型排序列表中的鍵不能修改，不能為空，不能重復(fù)。

3) 、泛型排序列表的值樂意修改，可以為空，可以重復(fù)。

public class UserInfo

{

public int UserCode { get; set; }

public string UserName { get; set; }

public string PassWord { get; set; }

public UserInfo(int userCode, string userName, string passWord)

{

UserCode = userCode;

UserName = userName;

PassWord = passWord;

}

class Program

{

static void Main(string[] args)

{

SortedList<int, UserInfo> uses = new SortedList<int, UserInfo>();

uses.Add(2, new UserInfo(2, &34;User02&34;, &34;02&34;));

uses.Add(3, new UserInfo(3, &34;User03&34;, &34;03&34;));

uses.Add(1, new UserInfo(1, &34;User01&34;, &34;01&34;));

foreach (var item in uses)

{

Console.WriteLine(&34;{0},{1}&34;,item.Key,item.Value.UserName);

}//按照key的順序從小到大排序

}

輸出結(jié)果：

1,User01

2,User02

3,User03

利用比較器來定義排序規(guī)則，將排序規(guī)則改為大到小順序：

public class ListComparer : IComparer<int>

{

region IComparer<int> 成員

public int Compare(int x, int y)

{

if (x > y)

{

return 1;

}

else

{

return 1;

}

endregion

}

public class UserInfo

{

public int UserCode { get; set; }

public string UserName { get; set; }

public string PassWord { get; set; }

public UserInfo(int userCode, string userName, string passWord)

{

UserCode = userCode;

UserName = userName;

PassWord = passWord;

}

class Program

{

static void Main(string[] args)

{

SortedList<int, UserInfo> uses = new SortedList<int, UserInfo>(new ListComparer());

uses.Add(2, new UserInfo(2, &34;User02&34;, &34;02&34;));

uses.Add(3, new UserInfo(3, &34;User03&34;, &34;03&34;));

uses.Add(1, new UserInfo(1, &34;User01&34;, &34;01&34;));

foreach (var item in uses)

{

Console.WriteLine(&34;{0},{1}&34;,item.Key,item.Value.UserName);

}

輸出結(jié)果：

3,User03

2,User02

1,User01

泛型排序字典

SortedDictionary<string, string> sortDic = new SortedDictionary<string, string>();

sortDic.Add(&34;qw&34;, &34;1qwa&34;);

sortDic.Add(&34;as&34;, &34;sdfsa&34;);

foreach (var i in sortDic.Keys)

{

Console.WriteLine(i.ToString());

}//默認(rèn)按照字典序排序、

輸出結(jié)果：

l IList和List的區(qū)別

首先IList 泛型接口是 ICollection 泛型接口的子代，并且是所有泛型列表的基接口。它僅僅是所有泛型類型的接口，并沒有太多方法可以方便實用，如果僅僅是作為集合數(shù)據(jù)的承載體，確實，IList可以勝任。

其次, IList <> 是在 .net framework 2.0里面才支持的

1. 不過，更多的時候，我們要對集合數(shù)據(jù)進(jìn)行處理，從中篩選數(shù)據(jù)或者排序。這個時候IList就不太好使了。因為他的效率要慢。后面會一一講到。

2、IList <>是個接口,定義了一些操作方法這些方法要你自己去實現(xiàn)，List <>是泛型類,它已經(jīng)實現(xiàn)了IList <>定義的那些方法IList IList11 =new List ();List List11 =new List ();這兩行代碼，從操作上來看，實際上都是創(chuàng)建了一個List對象的實例，也就是說，他們的操作沒有區(qū)別。只是用于保存這個操作的返回值變量類型不一樣而已。那么，我們可以這么理解，這兩行代碼的目的不一樣。List List11 =new List ();是想創(chuàng)建一個List，而且需要使用到List的功能，進(jìn)行相關(guān)操作。而IList IList11 =new List ();只是想創(chuàng)建一個基于接口IList的對象的實例，只是這個接口是由List實現(xiàn)的。所以它只是希望使用到IList接口規(guī)定的功能而已。

3.接口實現(xiàn)松耦合...有利于系統(tǒng)的維護(hù)與重構(gòu)...優(yōu)化系統(tǒng)流程...鼓勵使用接口,這樣可以實現(xiàn)功能和具體實現(xiàn)的分離.

這些說的都是有道理的，那么接剛才第一點的話題說，為什么說用到數(shù)據(jù)處理，或者排序IList就不太好使了呢。這個也是要根據(jù)數(shù)據(jù)量來的。我做了如下測試

public class TestClass { public int Id { get; set; } public string Name { get; set;} }

static void Main(string[] args) { ListTest(); }

private static void ListTest() { Stopwatch timer = new Stopwatch(); timer.Start(); List<TestClass> list1 = new List<TestClass>(); for (int i = 0; i < 10000000; i++) { TestClass tc = new TestClass(); tc.Id = i; tc.Name = &34;Test Data&34; + i; list1.Add(tc); } int count = 0; foreach (var tc in list1) { if (tc.Id >= 1 && tc.Id < 1000) { count++; } } //list1.OrderBy(i => i.Id); timer.Stop(); Console.Write(&34;Count:&34; + count + &34;, List time:&34;); Console.WriteLine(timer.Elapsed.Ticks); timer = new Stopwatch(); timer.Start(); IList<TestClass> list2 = new List<TestClass>(); for (int i = 0; i < 10000000; i++) { TestClass tc = new TestClass(); tc.Id = i; tc.Name = &34;Test Data&34; + i; list2.Add(tc); } int count2 = 0; foreach (var tc in list2) { if (tc.Id >= 1 && tc.Id < 1000) { count2++; } } //list2.OrderBy(i => i.Id); timer.Stop(); Console.Write(&34;Count:&34; + count2 + &34;, IList time:&34;); Console.WriteLine(timer.Elapsed.Ticks); Console.Read(); }

當(dāng)我們都去遍歷IList和List的時候，注意我取的數(shù)據(jù)是1~1000之間，經(jīng)過反復(fù)測試，IList的效率確實是要低一些。那就更不用說數(shù)據(jù)量更大的時候，請看輸出框：

但是，當(dāng)我取的數(shù)據(jù)是1~500的時候， IList似乎效率還是要慢一些。

另外，可能有的朋友會說，你把前面的for循環(huán)放在外面比較呢，這個我也做過測試，結(jié)果還是一樣，List效率要好于IList

同樣的方法，我測試了，IList和List的OrderBy的效率，List均有勝面，高效一籌。所以，什么時候用IList和List自己去斟酌，當(dāng)你用到設(shè)計的時候當(dāng)然是IList合理一些。用做數(shù)據(jù)容器遍歷或者排序，還是選擇List好一點。

數(shù)組、ArrayList、List區(qū)別：

數(shù)組

數(shù)組在C中最早出現(xiàn)的。在內(nèi)存中是連續(xù)存儲的，所以它的索引速度非常快，而且賦值與修改元素也很簡單。

但是數(shù)組存在一些不足的地方。在數(shù)組的兩個數(shù)據(jù)間插入數(shù)據(jù)是很麻煩的，而且在聲明數(shù)組的時候必須指定數(shù)組的長度，數(shù)組的長度過長，會造成內(nèi)存浪費，過段會造成數(shù)據(jù)溢出的錯誤。如果在聲明數(shù)組時我們不清楚數(shù)組的長度，就會變得很麻煩。

針對數(shù)組的這些缺點，C中最先提供了ArrayList對象來克服這些缺點。

ArrayList

ArrayList是命名空間System.Collections下的一部分，在使用該類時必須進(jìn)行引用，同時繼承了IList接口，提供了數(shù)據(jù)存儲和檢索。ArrayList對象的大小是按照其中存儲的數(shù)據(jù)來動態(tài)擴(kuò)充與收縮的。所以，在聲明ArrayList對象時并不需要指定它的長度。

ArrayList中插入不同類型的數(shù)據(jù)是允許的。因為ArrayList會把所有插入其中的數(shù)據(jù)當(dāng)作為object類型來處理，在我們使用ArrayList處理數(shù)據(jù)時，很可能會報類型不匹配的錯誤，也就是ArrayList不是類型安全的。在存儲或檢索值類型時通常發(fā)生裝箱和取消裝箱操作，帶來很大的性能耗損。

泛型List

因為ArrayList存在不安全類型與裝箱拆箱的缺點，所以出現(xiàn)了泛型的概念。List類是ArrayList類的泛型等效類，它的大部分用法都與ArrayList相似，因為List類也繼承了IList接口。最關(guān)鍵的區(qū)別在于，在聲明List集合時，我們同時需要為其聲明List集合內(nèi)數(shù)據(jù)的對象類型。

比如：

List<string> list = new List<string>();

list.Add(“abc”); //新增數(shù)據(jù)

list[0] = “def”; //修改數(shù)據(jù)

list.RemoveAt(0); //移除數(shù)據(jù)

上例中，如果我們往List集合中插入int數(shù)組123，IDE就會報錯，且不能通過編譯。這樣就避免了前面講的類型安全問題與裝箱拆箱的性能問題了。

總結(jié)：

數(shù)組的容量是固定的，您只能一次獲取或設(shè)置一個元素的值，而ArrayList或List<T>的容量可根據(jù)需要自動擴(kuò)充、修改、刪除或插入數(shù)據(jù)。

數(shù)組可以具有多個維度，而 ArrayList或 List< T> 始終只具有一個維度。但是，您可以輕松創(chuàng)建數(shù)組列表或列表的列表。特定類型（Object 除外）的數(shù)組的性能優(yōu)于 ArrayList的性能。這是因為 ArrayList的元素屬于 Object 類型；所以在存儲或檢索值類型時通常發(fā)生裝箱和取消裝箱操作。不過，在不需要重新分配時（即最初的容量十分接近列表的最大容量），List< T> 的性能與同類型的數(shù)組十分相近。

在決定使用 List<T> 還是使用ArrayList 類（兩者具有類似的功能）時，記住List<T> 類在大多數(shù)情況下執(zhí)行得更好并且是類型安全的。如果對List< T> 類的類型T 使用引用類型，則兩個類的行為是完全相同的。但是，如果對類型T使用值類型，則需要考慮實現(xiàn)和裝箱問題。

可觀察集合

如果需要集合中的元素合適刪除或添加的信息，就可以使用ObserVableCollection<T>類。這樣UI就可以知集合的變化。這個類的名命空間SystemCollections.ObjectModel.

ObserableCollection<T>類派生自Collection<T>積累。該基類可以用于創(chuàng)建自定義集合，并在內(nèi)部使用List<T>類。重寫了基類中的虛方法SetITem()和RemoveItem(),以出發(fā)CollectionChanged事件。這個類的用戶可以使用InotifyCollectionChanged接口注冊事件。

using System.Collections.ObjectModel;

namespace Wrox.ProCSharp.Collections

{

class Program

{

static void Main()

{

var data = new ObservableCollection<string>();

data.CollectionChanged += Data_CollectionChanged;

data.Add(&34;One&34;);

data.Add(&34;Two&34;);

data.Insert(1, &34;Three&34;);

data.Remove(&34;One&34;);

}

static void Data_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)

{

Console.WriteLine(&34;action: {0}&34;, e.Action.ToString());

if (e.OldItems != null)

{

Console.WriteLine(&34;starting index for old item(s): {0}&34;, e.OldStartingIndex);

Console.WriteLine(&34;old item(s):&34;);

foreach (var item in e.OldItems)

{

Console.WriteLine(item);

}

if (e.NewItems != null)

{

Console.WriteLine(&34;starting index for new item(s): {0}&34;, e.NewStartingIndex);

Console.WriteLine(&34;new item(s): &34;);

foreach (var item in e.NewItems)

{

Console.WriteLine(item);

}

Console.WriteLine();

}

輸出結(jié)果：

action: Add

starting index for new item(s): 0

new item(s):

One

action: Add

starting index for new item(s): 1

new item(s):

Two

action: Add

starting index for new item(s): 1

new item(s):

Three

action: Remove

starting index for old item(s): 0

old item(s):

One

拓展知識：