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

發布日期：2022-10-05 21:16:52 瀏覽：

前沿拓展：

夏普空調TIMER亮黃燈怎么回

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

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

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

語法格式如下：

類修飾符 class 類名<類型參數T>

{

類體

}

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

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

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

例：使用泛型存儲不同類型的數據列表

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>();//實例化泛型類對象

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

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<參數類型T>:BaseClass<參數類型T>

舉例： class BStuInfo<T>

{

public T ID; //聲明學生編號字段

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; //聲明數學成績字段

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

}

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

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

{

方法體

}

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

namespace ArrayInfo

{

public partial class Form1 : Form

{

public Form1()

{

InitializeComponent();

}

public class Finder

{

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

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

{

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

{

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

{

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

}

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; };//聲明一個字符串類型的數組

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

}

private void button2_Click(object sender, EventArgs e)

{

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

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

}

private void button3_Click(object sender, EventArgs e)

{

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

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

}

例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);

}

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

例：通過泛型實現子窗體的不同的操作。

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)

{//實例化提示框中顯示圖標對象

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

}

private void button1_Click(object sender, EventArgs e)

{

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

}

private void button2_Click(object sender, EventArgs e)

{

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

}

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

常用的集合：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());

}

輸出結果：

ASsa

False

添加數組：

static void Main(string[] args)

{

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

ArrayList list=new ArrayList();

list.AddRange(arr);

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

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();//清除所有數據

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

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

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

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

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

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

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

}

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);//添加數據

object i = table[&34;1&34;];//根據Key，獲取對應的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;//返回元素的個數

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

foreach (object o in ic)

{

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

}

ic = table.Values;

foreach (object o in ic)

{

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

}

foreach (DictionaryEntry d in table)

{

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

}

//結果：

//1,10

//2,20

//3,30

棧是一種先進后出的一種數據結構，類似口向上的井

棧舉例：

Stack st = new Stack();

st.Push(1);

st.Push(2);//壓棧

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

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

隊列是一種先進先出的數據結構

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

q.Enqueue(1);

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

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

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

常用的泛型：

? List<數據類型>

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

? Dictionary<數據類型，數據類型>

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

? Stack<數據類型>

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

? Queue<數據類型>

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

舉例：從字典中同時取出，key和對應的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嵌套綜合應用：字典中嵌套List，按字典的key進行分類放入List中。比如按照名字進行分類

private void BindGrid()

{

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

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);//向字典中按姓名相同進行分類

}

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> 表示按照鍵進行的排序的鍵/值對的集合，鍵/值對是KeyValuePair<TKey,TValue>類型。泛型排序列表具有以下3個特點：

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

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

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

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的順序從小到大排序

}

輸出結果：

1,User01

2,User02

3,User03

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

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);

}

輸出結果：

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());

}//默認按照字典序排序、

輸出結果：

l IList和List的區別

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

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

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

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

3.接口實現松耦合...有利于系統的維護與重構...優化系統流程...鼓勵使用接口,這樣可以實現功能和具體實現的分離.

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

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(); }

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

但是，當我取的數據是1~500的時候， IList似乎效率還是要慢一些。

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

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

數組、ArrayList、List區別：

數組

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

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

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

ArrayList

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

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

泛型List

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

比如：

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

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

list[0] = “def”; //修改數據

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

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

總結：

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

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

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

可觀察集合

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

ObserableCollection<T>類派生自Collection<T>積累。該基類可以用于創建自定義集合，并在內部使用List<T>類。重寫了基類中的虛方法SetITem()和RemoveItem(),以出發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();

}

輸出結果：

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

拓展知識：