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。

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方法返回队首元素，但是不移除。

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方法返回栈顶元素，但是不移除。

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

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

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

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

泛型集合键值不能重复

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	定义方法以支持对象的结构相等性比较。