C#入门经典学习笔记一

这篇主要讲C#的一些语法。

1、委托

委托类型声明的格式如下：

public delegate void TestDelegate(string message);

delegate 关键字用于声明一个引用类型，该引用类型可用于封装命名方法或匿名方法。委托类似于 C++ 中的函数指针；但是，委托是类型安全和可靠的。有关委托的应用，请参见委托和泛型委托。

委托是事件的基础。

通过将委托与命名方法或匿名方法关联，可以实例化委托。有关更多信息，请参见命名方法和匿名方法。

为了与命名方法一起使用，委托必须用具有可接受签名的方法进行实例化。有关方法签名中允许的方差度的更多信息，请参见委托中的协变和逆变。为了与匿名方法一起使用，委托和与之关联的代码必须一起声明。本节讨论这两种实例化委托的方法。

using System;
// Declare delegate -- defines required signature:
delegate void SampleDelegate(string message);

class MainClass
{
    // Regular method that matches signature:
    static void SampleDelegateMethod(string message)
    {
        Console.WriteLine(message);
    }

    static void Main()
    {
        // Instantiate delegate with named method:
        SampleDelegate d1 = SampleDelegateMethod;
        // Instantiate delegate with anonymous method:
        SampleDelegate d2 = delegate(string message)
        {
            Console.WriteLine(message);
        };

        // Invoke delegate d1:
        d1("Hello");
        // Invoke delegate d2:
        d2(" World");
    }
}

2、集合类

ArrayList

大小可按需动态增加的数组。

Capacity是指ArrayList的容量，默认大小是4，当Capacity不够时会申请更多空间，改变之后的Capacity是原来的2倍。

Count是指当前ArrayList中元素的个数。Count小于或等于Capacity。使用TrimToSizie（）可以使Count和Capacity相等。

ToArray方法返回元素的数组，其中ToArray(Type)可以返回Type类型的数组，返回类型都是System.Array。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

ArrayList al = new ArrayList(); Console.WriteLine(al.Capacity); Console.WriteLine(al.Count); al.Add(100);            //单个添加 Console.WriteLine(al.Capacity); Console.WriteLine(al.Count);   foreach (Int32 number in new Int32[6] { 9, 3, 7, 2, 4, 8 }) {     al.Add(number);    //集体添加方法一 }   Int32[] number2 = new Int32[2] { 11, 12 }; al.AddRange(number2);    //集体添加方法二 al.Remove(3);            //移除值为3的 al.RemoveAt(3);          //移除第3个 ArrayList al2 = new ArrayList(al.GetRange(1, 3)); //新ArrayList只取旧ArrayList一部份   Console.WriteLine("遍历方法一:"); foreach (Int32 i in al)       //不要强制转换 {      Console.WriteLine(i);  //遍历方法一 }   Console.WriteLine("遍历方法二:"); for (Int32 i = 0; i < al2.Count; i++)  //数组是length，ArrayList为Count {     Int32 number = (Int32)al2[i];        //一定要强制转换    Console.WriteLine(number);       //遍历方法二 }   Int32[] intArr = (Int32[])al.ToArray(typeof(Int32));

Queue

Queue：队列，表示对象的先进先出集合。Enqueue方法入队列，Dequeue方法出队列，Peek方法返回队首元素，但是不移除。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

Queue qu = new Queue(); Queue qu2 = new Queue(); foreach (Int32 i in new int[4] { 1, 2, 3, 4 }) {      qu.Enqueue(i);//入队     qu2.Enqueue(i); } foreach (Int32 i in qu) {      Console.WriteLine(i); //遍历 } qu.Dequeue(); //出队 Console.WriteLine("Dequeue"); foreach (Int32 i in qu) {      Console.WriteLine(i); } qu2.Peek(); //返回位于 Queue 开始处的对象但不将其移除。 Console.WriteLine("Peek"); foreach (Int32 i in qu2) {     Console.WriteLine(i); }

Stack

栈，表示对象的简单的后进先出非泛型集合。Push方法入栈，Pop方法出栈，Peek方法返回栈顶元素，但是不移除。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

Stack sk = new Stack(); Stack sk2 = new Stack(); foreach (Int32 i in new int[4] { 1, 2, 3, 4 }) {      sk.Push(i); //入栈     sk2.Push(i); } foreach (Int32 i in sk) {       Console.WriteLine(i); //遍历 从栈顶开始 } sk.Pop(); //出栈 Console.WriteLine("Pop"); foreach (Int32 i in sk) {     Console.WriteLine(i); } sk2.Peek();  //弹出最后一项不删除 Console.WriteLine("Peek"); foreach (Int32 i in sk2) {     Console.WriteLine(i); }

Hashtable

哈希表，键值对的集合，键值不能重复。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

Hashtable ht = new Hashtable();   for (Int32 i = 0; i < 10; i++) {     ht.Add(i, (char)('a' + i)); // 同 ht[i] = (char)('a' + i); } //添加已经存在的键值时会发生异常 if (ht.Contains(2))     //同ContainsKey  判断是否含有某个键       Console.WriteLine("The hashtable contains 2"); if (ht.ContainsValue('c'))      //判断是否含有某个值       Console.WriteLine("The hashtable contains c");    ht.Remove(5);   //删除键值为5的键值对  foreach (DictionaryEntry de in ht)    //遍历方法一  {       Console.WriteLine(de.Key + "    " + de.Value + "    ");  }    ICollection keys = ht.Keys;         foreach (Int32 k in keys)          //遍历方法二  {       Console.WriteLine(k + "    " + ht[k] + "    ");   }

SortedList

1 2 3 4 5 6 7 8 9 10 11

SortedList sl = new SortedList(); sl["c"] = 41;   //同 sl.add(“c”,41); sl["a"] = 42; sl["d"] = 11; sl["b"] = 13; foreach (DictionaryEntry element in sl) {     String s = (String)element.Key;     Int32 i = (Int32)element.Value;     Console.WriteLine("{0},{1}", s, i); }

Dictionary

泛型集合   键值不能重复

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73

Dictionary<String, String> myDic = new Dictionary<String, String>(); myDic.Add("aaa", "111"); myDic.Add("bbb", "222"); myDic.Add("ccc", "333"); myDic.Add("ddd", "444"); //如果添加已经存在的键，add方法会抛出异常 try {     myDic.Add("ddd","ddd"); } catch (ArgumentException ex) {     Console.WriteLine("此键已经存在：" + ex.Message); } //解决add()异常的方法是用ContainsKey()方法来判断键是否存在 if (!myDic.ContainsKey("ddd")) {     myDic.Add("ddd", "ddd"); } else {     Console.WriteLine("此键已经存在：");   }   //而使用索引器来赋值时，如果键已经存在，就会修改已有的键的键值，而不会抛出异常 myDic ["ddd"]="ddd"; myDic["eee"] = "555";   //使用索引器来取值时，如果键不存在就会引发异常 try {     Console.WriteLine(myDic["fff"]); } catch (KeyNotFoundException ex) {     Console.WriteLine("没有找到键引发异常：" + ex.Message); } //解决上面的异常的方法是使用ContarnsKey() 来判断时候存在键，如果经常要取健值得化最好用 TryGetValue方法来获取集合中的对应键值 string value = ""; if (myDic.TryGetValue("fff", out value)) {     Console.WriteLine(value); } else {         Console.WriteLine("没有找到对应键的键值"); }   //下面用foreach 来遍历键值对 //泛型结构体 用来存储健值对 foreach ( KeyValuePair<String, String> kvp in myDic ) {     Console.WriteLine("key={0},value={1}", kvp.Key, kvp.Value); }     //获取键的集合 foreach(String s in myDic.Keys) {     Console.WriteLine("key={0}",s); } //获取值的集合 foreach (String s in myDic.Values) {     Console.WriteLine("value={0}", s); } //获取值得另一种方式 Dictionary<String, String>.ValueCollection values = myDic.Values; foreach (String s in values) {     Console.WriteLine("value={0}", s); }

泛型集合

泛型最常见的用途是泛型集合，命名空间System.Collections.Generic 中包含了一些基于泛型的集合类，使用泛型集合类可以提供更高的类型安全性，还有更高的性能，避免了非泛型集合的重复的装箱和拆箱。 
    很多非泛型集合类都有对应的泛型集合类，下面是常用的非泛型集合类以及对应的泛型集合类：
非泛型集合类     泛型集合类 
ArrayList         List<T> 
HashTable       Dictionary<T> 
Queue            Queue<T> 
Stack             Stack<T> 
SortedList      SortedList<T>

System.Collections 命名空间

System.Collections 命名空间包含接口和类，这些接口和类定义各种对象（如列表、队列、位数组、哈希表和字典）的集合。

类

---

	类	说明
	ArrayList	使用大小会根据需要动态增加的数组来实现 IList 接口。
	BitArray	管理位值的压缩数组，该值表示为布尔值，其中 true 表示位是打开的 (1)，false 表示位是关闭的 (0)。
	CaseInsensitiveComparer	比较两个对象是否相等，比较时忽略字符串的大小写。
	CaseInsensitiveHashCodeProvider	已过时。使用忽略字符串大小写的哈希算法，为对象提供哈希代码。
	CollectionBase	为强类型集合提供 abstract 基类。
	Comparer	比较两个对象是否相等，其中字符串比较是区分大小写的。
	DictionaryBase	为键/值对的强类型集合提供 abstract 基类。
	Hashtable	表示根据键的哈希代码进行组织的键/值对的集合。
	Queue	表示对象的先进先出集合。
	ReadOnlyCollectionBase	为强类型非泛型只读集合提供 abstract 基类。
	SortedList	表示键/值对的集合，这些键值对按键排序并可按照键和索引访问。
	Stack	表示对象的简单后进先出 (LIFO) 非泛型集合。
	StructuralComparisons	提供用于对两个集合对象执行结构比较的对象。

结构

---

	结构	说明
	DictionaryEntry	定义可设置或检索的字典键/值对。

接口

---

 

 

	接口	说明
	ICollection	定义所有非泛型集合的大小、枚举数和同步方法。
	IComparer	公开一种比较两个对象的方法。
	IDictionary	表示键/值对的非通用集合。
	IDictionaryEnumerator	枚举非泛型字典的元素。
	IEnumerable	公开枚举数，该枚举数支持在非泛型集合上进行简单迭代。
	IEnumerator	支持对非泛型集合的简单迭代。
	IEqualityComparer	定义方法以支持对象的相等比较。
	IHashCodeProvider	已过时。使用自定义哈希函数为对象提供哈希代码。
	IList	表示可按照索引单独访问的对象的非泛型集合。
	IStructuralComparable	支持集合对象的结构比较。
	IStructuralEquatable	定义方法以支持对象的结构相等性比较。