C#数组,集合,异常学习

亦凉 2022-05-14 05:21 209阅读 0赞

# [C\#数组学习][C] #

http://www.cnblogs.com/tianhao960/articles/273425.html

## **数组概述** ##

C\# 数组从零开始建立索引，即数组索引从零开始。C\#中数组的工作方式与在大多数其他流行语言中的工作方式类似。但还有一些差异应引起注意。

声明数组时，方括号 (\[\])必须跟在类型后面，而不是标识符后面。在 C\#中，将方括号放在标识符后是不合法的语法。

int\[\] table; // not int table\[\];

另一细节是，数组的大小不是其类型的一部分，而在 C语言中它却是数组类型的一部分。这使您可以声明一个数组并向它分配 int对象的任意数组，而不管数组长度如何。

int\[\] numbers; // declare numbers as an int array of any size

numbers = new int\[10\]; // numbers is a 10-element array

numbers = new int\[20\]; // now it's a 20-element array

## **声明数组** ##

C\# 支持一维数组、多维数组（矩形数组）和数组的数组（交错的数组）。下面的示例展示如何声明不同类型的数组：

一维数组：

int[] numbers;

多维数组：

string[,] names;

数组的数组（交错的）：

byte[][] scores;

声明数组（如上所示）并不实际创建它们。在 C\#  中，数组是对象（本教程稍后讨论），必须进行实例化。下面的示例展示如何创建数组：

一维数组：

int[] numbers = new int[5];

多维数组：

string[,] names = new string[5,4];

数组的数组（交错的）：

byte[][] scores = new byte[5][];

for (int x = 0; x < scores.Length; x++)

{

scores[x] = new byte[4];

}

还可以有更大的数组。例如，可以有三维的矩形数组：

int[,,] buttons = new int[4,5,3];

甚至可以将矩形数组和交错数组混合使用。例如，下面的代码声明了类型为 **int**的二维数组的三维数组的一维数组。

int[][,,][,] numbers;

## **初始化数组** ##

C\# 通过将初始值括在大括号 (\{\})内为在声明时初始化数组提供了简单而直接了当的方法。下面的示例展示初始化不同类型的数组的各种方法。

**注意**如果在声明时没有初始化数组，则数组成员将自动初始化为该数组类型的默认初始值。另外，如果将数组声明为某类型的字段，则当实例化该类型时它将被设置为默认值 null。

一维数组

int[] numbers = new int[5] {1, 2, 3, 4, 5};

string[] names = new string[3] {"Matt", "Joanne", "Robert"};

可省略数组的大小，如下所示：

int[] numbers = new int[] {1, 2, 3, 4, 5};

string[] names = new string[] {"Matt", "Joanne", "Robert"};

如果提供了初始值设定项，则还可以省略 **new**运算符，如下所示：

int[] numbers = {1, 2, 3, 4, 5};

string[] names = {"Matt", "Joanne", "Robert"};

### 多维数组 ###

int[,] numbers = new int[3, 2] { {1, 2}, {3, 4}, {5, 6} };

string[,] siblings = new string[2, 2] { {"Mike","Amy"}, {"Mary","Albert"} };

可省略数组的大小，如下所示：

int[,] numbers = new int[,] { {1, 2}, {3, 4}, {5, 6} };

string[,] siblings = new string[,] { {"Mike","Amy"}, {"Mary","Albert"} };

如果提供了初始值设定项，则还可以省略 **new**运算符，如下所示：

int[,] numbers = { {1, 2}, {3, 4}, {5, 6} };

string[,] siblings = { {"Mike", "Amy"}, {"Mary", "Albert"} };

### 交错的数组（数组的数组） ###

可以像下例所示那样初始化交错的数组：

int[][] numbers = new int[2][] { new int[] {2,3,4}, new int[] {5,6,7,8,9} };

可省略第一个数组的大小，如下所示：

int[][] numbers = new int[][] { new int[] {2,3,4}, new int[] {5,6,7,8,9} };

－或－

int[][] numbers = { new int[] {2,3,4}, new int[] {5,6,7,8,9} };

请注意，对于交错数组的元素没有初始化语法。

## 访问数组成员 ##

访问数组成员可以直接进行，类似于在 C/C++ 中访问数组成员。例如，下面的代码创建一个名为`numbers`的数组，然后向该数组的第五个元素赋以 5：

int[] numbers = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};

numbers[4] = 5;

下面的代码声明一个多维数组，并向位于 `[1, 1]`的成员赋以`5`：

int[,] numbers = { {1, 2}, {3, 4}, {5, 6}, {7, 8}, {9, 10} };

numbers[1, 1] = 5;

下面声明一个一维交错数组，它包含两个元素。第一个元素是两个整数的数组，第二个元素是三个整数的数组：

int[][] numbers = new int[][] { new int[] {1, 2}, new int[] {3, 4, 5}

};

下面的语句向第一个数组的第一个元素赋以 58，向第二个数组的第二个元素赋以 667：

numbers[0][0] = 58;

numbers[1][1] = 667;

数组是对象

在 C\# 中，数组实际上是对象。**System.Array**是所有数组类型的抽象基类型。可以使用**System.Array**具有的属性以及其他类成员。这种用法的一个示例是使用“长度”(Length)属性获取数组的长度。下面的代码将`numbers`数组的长度（为`5`）赋给名为`LengthOfNumbers`的变量：

int[] numbers = {1, 2, 3, 4, 5};

int LengthOfNumbers = numbers.Length;

**System.Array** 类提供许多有用的其他方法/属性，如用于排序、搜索和复制数组的方法。

## 对数组使用 foreach ##

C\# 还提供 **foreach**语句。该语句提供一种简单、明了的方法来循环访问数组的元素。例如，下面的代码创建一个名为`numbers`的数组，并用**foreach**语句循环访问该数组：

int[] numbers = {4, 5, 6, 1, 2, 3, -2, -1, 0};

foreach (int i in numbers)

{

System.Console.WriteLine(i);

}

由于有了多维数组，可以使用相同方法来循环访问元素，例如：

int[,] numbers = new int[3, 2] {
       {9, 99}, {3, 33}, {5, 55}};

foreach(int i in numbers)

{

Console.Write("{0} ", i);

}

该示例的输出为：

9 99 3 33 5 55

不过，由于有了多维数组，使用嵌套 **for**循环将使您可以更好地控制数组元素。

# C\#的6种常用集合类大比拼    #

http://www.51cto.com/specbook/22/50217.htm

## **一、先来说说数组的不足（也可以说集合与数组的区别）** ##

1.数组是固定大小的，不能伸缩。虽然System.Array.Resize这个泛型方法可以重置数组大小，但是该方法是重新创建新设置大小的数组，用的是旧数组的元素初始化。随后以前的数组就废弃！而集合却是可变长的。

2.数组要声明元素的类型，集合类的元素类型却是object。

3.数组可读可写不能声明只读数组。集合类可以提供ReadOnly方法以只读方式使用集合。

4.数组要有整数下标才能访问特定的元素，然而很多时候这样的下标并不是很有用。集合也是数据列表却不使用下标访问。很多时候集合有定制的下标类型，对于队列和栈根本就不支持下标访问！

## **二、下面讲述6种常用集合** ##

### **1.ArrayList类** ###

using System;
    using System.Collections.Generic;
    using System.Text;
    using System.Collections;
    namespace ConsoleApplication1
    {
        class Program
        {
            static void Main(string[] args)
            {
                ArrayList al = new ArrayList();
                al.Add(100);//单个添加
                foreach (int number in new int[6] ...{ 9, 3, 7, 2, 4, 8 })
                {
                    al.Add(number);//集体添加方法一
                }
                int[] number2 = new int[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 (int i in al)//不要强制转换
                {
                    Console.WriteLine(i);//遍历方法一
                }
    
                Console.WriteLine("遍历方法二:");
                for (int i = 0; i != al2.Count; i++)//数组是length
                {
                    int number = (int)al2[i];//一定要强制转换
                    Console.WriteLine(number);//遍历方法二
                }
            }
        }
    }

### **2.Stack类** ###

栈，后进先出。push方法入栈，pop方法出栈。

using System;
    using System.Collections.Generic;
    using System.Text;
    using System.Collections;
    namespace ConsoleApplication1
    {
        class Program
        {
            static void Main(string[] args)
            {
                Stack sk = new Stack();
                Stack sk2 = new Stack();
                foreach (int i in new int[4] ...{ 1, 2, 3, 4 })
                {
                    sk.Push(i);//填充
                    sk2.Push(i);
                }
               
                foreach (int i in sk)
                {
                    Console.WriteLine(i);//遍历
                }
    
                sk.Pop();
                Console.WriteLine("Pop");
                foreach (int i in sk)
                {
                    Console.WriteLine(i);
                }
               
                sk2.Peek();//弹出最后一项不删除
                Console.WriteLine("Peek");
                foreach (int i in sk2)
                {
                    Console.WriteLine(i);
                }
    
                while (sk2.Count != 0)
                {
                    int i = (int)sk2.Pop();//清空
                    sk2.Pop();//清空
                }
                Console.WriteLine("清空");
                foreach (int i in sk2)
                {
                    Console.WriteLine(i);
                }
            }
        }
    }

### **3.Queue类** ###

队列，先进先出。enqueue方法入队列，dequeue方法出队列。

using System;
    using System.Collections.Generic;
    using System.Text;
    using System.Collections;
    namespace ConsoleApplication1
    {
        class Program
        {
            static void Main(string[] args)
            {
                Queue qu = new Queue();
                Queue qu2 = new Queue();
                foreach (int i in new int[4] ...{ 1, 2, 3, 4 })
                {
                    qu.Enqueue(i);//填充
                    qu2.Enqueue(i);
                }
               
                foreach (int i in qu)
                {
                    Console.WriteLine(i);//遍历
                }
    
                qu.Dequeue();
                Console.WriteLine("Dequeue");
                foreach (int i in qu)
                {
                    Console.WriteLine(i);
                }
               
                qu2.Peek();//弹出最后一项不删除
                Console.WriteLine("Peek");
                foreach (int i in qu2)
                {
                    Console.WriteLine(i);
                }
    
                while (qu2.Count != 0)
                {
                    int i = (int)qu2.Dequeue();//清空
                    qu2.Dequeue();//清空
                }
                Console.WriteLine("清空");
                foreach (int i in qu2)
                {
                    Console.WriteLine(i);
                }
            }
        }
    }

### **4.Hashtable类** ###

哈希表，名-值对。类似于字典(比数组更强大)。哈希表是经过优化的，访问下标的对象先散列过。如果以任意类型键值访问其中元素会快于其他集合。GetHashCode()方法返回一个int型数据，使用这个键的值生成该int型数据。哈希表获取这个值最后返回一个索引，表示带有给定散列的数据项在字典中存储的位置。

using System;
    using System.Collections.Generic;
    using System.Text;
    using System.Collections;
    namespace ConsoleApplication1
    {
        class Program
        {
            public static void Main()
            {
                // Creates and initializes a new Hashtable.
                Hashtable myHT = new Hashtable();
                myHT.Add("one", "The");
                myHT.Add("two", "quick");
                myHT.Add("three", "brown");
                myHT.Add("four", "fox");
    
                // Displays the Hashtable.
                Console.WriteLine("The Hashtable contains the following:");
                PrintKeysAndValues(myHT);
            }
    
            public static void PrintKeysAndValues(Hashtable myHT)
            {
                foreach (string s in myHT.Keys)
                    Console.WriteLine(s);
    
                Console.WriteLine(" -KEY- -VALUE-");
                foreach (DictionaryEntry de in myHT)
                    Console.WriteLine(" {0}: {1}", de.Key, de.Value);
                Console.WriteLine();
            }
        }
    }

### **5.SortedList类** ###

与哈希表类似，区别在于SortedList中的Key数组排好序的。

using System;
    using System.Collections.Generic;
    using System.Text;
    using System.Collections;
    namespace ConsoleApplication1
    {
        class Program
        {
            public static void Main()
            {
                SortedList sl = new SortedList();
                sl["c"] = 41;
                sl["a"] = 42;
                sl["d"] = 11;
                sl["b"] = 13;
    
                foreach (DictionaryEntry element in sl)
                {
                    string s = (string)element.Key;
                    int i = (int)element.Value;
                    Console.WriteLine("{0},{1}",s,i);
                }
            }
        }
    }

### **6.NameValueCollection类** ###

官方给NameValueCollection定义为特殊集合一类，在System.Collections.Specialized下。

System.Collections.Specialized下还有HybridDicionary类，建议少于10个元素用HybridDicionary，当元素增加会自动转为HashTable。

System.Collections.Specialized下还有HybridDicionary类，字符串集合。

System.Collections.Specialized下还有其他类大家可以各取所需！

言归正转主要说NameValueCollection，HashTable 和 NameValueCollection很类似但是他们还是有区别的，HashTable 的KEY是唯一性，而NameValueCollection则不唯一！

using System;
    using System.Collections.Generic;
    using System.Collections;
    using System.Collections.Specialized;
    namespace ConsoleApplication1
    {
        class Program
        {
            static void Main(string[] args)
            {
                System.Collections.Hashtable ht = new System.Collections.Hashtable();
                ht.Add("DdpMDisplaySeq".Trim(), "Display Sequence".Trim());
                ht.Add("DdpMNameChi".Trim(), "Name (Chinese)".Trim());
                ht.Add("DdpMNameEng".Trim(), "Name (English)".Trim());
                ht.Add("Comment".Trim(), "Comment".Trim());
                ht.Add("DdpMMarketCode".Trim(), "Market Code".Trim());
                foreach (object key in ht.Keys)
                {
                    Console.WriteLine("{0}/{1}{2},{3}", key, ht[key],key.GetHashCode(), ht[key].GetHashCode());
                }
                Console.WriteLine(" ");
                NameValueCollection myCol = new NameValueCollection();
                myCol.Add("DdpMDisplaySeq".Trim(), "Display Sequence".Trim());
                myCol.Add("DdpMNameChi".Trim(), "Name (Chinese)".Trim());
                myCol.Add("DdpMNameChi".Trim(), "Name (English)".Trim());
                myCol.Add("Comment".Trim(), "Comment".Trim());
                myCol.Add("DdpMMarketCode".Trim(), "Market Code".Trim());
                foreach (string key in myCol.Keys)
                {
                    Console.WriteLine("{0}/{1} {2},{3}", key, myCol[key],key.GetHashCode(), myCol[key].GetHashCode());
                }
            }
        }
    }

![164201519.gif][]

# [C\# 集合类][C_] #

http://www.cnblogs.com/moss\_tan\_jun/archive/2010/09/20/1831867.html

说起集合类，我们都不陌生，因为在项目中经常会用到。记得每次遇到要存储键值对时，都会想到HashTable，可以在用的过程中却不是很懂，不懂装懂，结果最后还是不会。今天中午正好有时间，就整理了一下相关的类，主要包括：列表、队列、位数组、哈希表和字典。

## （一）ArrayList类：使用大小可按需动态增加的数组。 ##

![ExpandedBlockStart.gif][] 代码

class
        
          Program 
        { 
            
        
         static
        
          
        
         void
        
          Main(
        
         string
        
         [] args) 
            { 
                ArrayList al 
        
         =
        
          
        
         new
        
          ArrayList(); 
                al.Add(
        
         100
        
         );
        
         //
        
         单个添加 
        
         
    
        
                     
        
         foreach
        
          (
        
         int
        
          number 
        
         in
        
          
        
         new
        
          
        
         int
        
         [
        
         6
        
         ] { 
        
         9
        
         , 
        
         3
        
         , 
        
         7
        
         , 
        
         2
        
         , 
        
         4
        
         , 
        
         8
        
          }) 
                { 
                    al.Add(number);
        
         //
        
         集体添加方法一 
        
         
    
        
                     } 
                
        
         int
        
         [] number2 
        
         =
        
          
        
         new
        
          
        
         int
        
         [
        
         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
        
          (
        
         int
        
          i 
        
         in
        
          al)
        
         //
        
         不要强制转换 
        
         
    
        
                     { 
                    Console.WriteLine(i);
        
         //
        
         遍历方法一 
        
         
    
        
                     } 
                Console.WriteLine(
        
         "
        
         遍历方法二:
        
         "
        
         ); 
                
        
         for
        
          (
        
         int
        
          i 
        
         =
        
          
        
         0
        
         ; i 
        
         <
        
          al2.Count; i
        
         ++
        
         )
        
         //
        
         数组是length 
        
         
    
        
                     { 
                    
        
         int
        
          number 
        
         =
        
          (
        
         int
        
         )al2[i];
        
         //
        
         一定要强制转换 
        
         
    
        
                         Console.WriteLine(number);
        
         //
        
         遍历方法二 
        
         
    
        
                     } 
            } 
        }

上面的代码对ArrayList类中的方法都有详细的注释，对这些方法如果有不明白的地方，可以到MSDN上去查。后面的介绍基本上都是以代码加注释来讲解。

## （二）Queue类：队列，表示对象的先进先出集合。Enqueue方法入队列，Dequeue方法出队列。    ##

![ExpandedBlockStart.gif][] 代码

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

## （三）Stack类：栈，表示对象的简单的后进先出非泛型集合。Push方法入栈，Pop方法出栈。 ##

![ExpandedBlockStart.gif][]代码

class
        
          Program 
        { 
            
        
         static
        
          
        
         void
        
          Main(
        
         string
        
         [] args) 
            { 
                Stack sk 
        
         =
        
          
        
         new
        
          Stack(); 
                Stack sk2 
        
         =
        
          
        
         new
        
          Stack(); 
                
        
         foreach
        
          (
        
         int
        
          i 
        
         in
        
          
        
         new
        
          
        
         int
        
         [
        
         4
        
         ] { 
        
         1
        
         , 
        
         2
        
         , 
        
         3
        
         , 
        
         4
        
          }) 
                { 
                    sk.Push(i);
        
         //
        
         入栈 
        
         
    
        
                         sk2.Push(i); 
                } 
                
        
         foreach
        
          (
        
         int
        
          i 
        
         in
        
          sk) 
                { 
                    Console.WriteLine(i);
        
         //
        
         遍历 
        
         
    
        
                     } 
                sk.Pop();
        
         //
        
         出栈 
        
         
    
        
                     Console.WriteLine(
        
         "
        
         Pop
        
         "
        
         ); 
                
        
         foreach
        
          (
        
         int
        
          i 
        
         in
        
          sk) 
                { 
                    Console.WriteLine(i); 
                } 
                sk2.Peek();
        
         //
        
         弹出最后一项不删除 
        
         
    
        
                     Console.WriteLine(
        
         "
        
         Peek
        
         "
        
         ); 
                
        
         foreach
        
          (
        
         int
        
          i 
        
         in
        
          sk2) 
                { 
                    Console.WriteLine(i); 
                } 
            } 
        }

## （四）哈希表 ##

HashTable就相当于一个容器，用于处理和表现类似key/value的键值对，其中key通常可用来快速查找，同时key是区分大小写；vlaue用于存储对应于key的值。每个元素都是一个存储在DictionaryEntry对象中的键值对。键不能为空引用，但值可以。当把某个元素添加到HashTable时，将根据键的哈希代码将元素放入存储桶中。该键的后续查找将使用键的哈希代码只在一个特定存储桶中搜索，这就大大减少为查找一个元素所需的键比较的次数。

HashTable的加载因子确定元素与存储桶的最大比率。加载因子越小，平均查找速度越快，但消耗的内存也增加。默认的加载因子1.0通常提供速度与大小之间的最佳平衡。当创建Hashtable时，也可以指定其他加载因子。

当向HashTable中添加元素时，HashTable的实际加载因子将增加。当实际加载因子达到指定的加载因子时，HashTable中存储桶的数目自动增加到大于当前HashTable存储桶两倍的最小质数。

![ExpandedBlockStart.gif][]代码

class
        
          hashtable 
    { 
         
        
         public
        
          
        
         static
        
          
        
         void
        
          Main() 
         { 
         Hashtable ht
        
         =
        
         new
        
          Hashtable(); 
        
         //
        
         创建一个Hashtable实例 
        
         
    
        
              ht.Add(
        
         "
        
         E
        
         "
        
         ,
        
         "
        
         e
        
         "
        
         );
        
         //
        
         添加key/value键值对 
        
         
    
        
              ht.Add(
        
         "
        
         A
        
         "
        
         ,
        
         "
        
         a
        
         "
        
         ); 
         ht.Add(
        
         "
        
         C
        
         "
        
         ,
        
         "
        
         c
        
         "
        
         ); 
         ht.Add(
        
         "
        
         B
        
         "
        
         ,
        
         "
        
         b
        
         "
        
         ); 
         
        
         string
        
          s
        
         =
        
         (
        
         string
        
         )ht[
        
         "
        
         A
        
         "
        
         ]; 
         
        
         if
        
         (ht.Contains(
        
         "
        
         E
        
         "
        
         )) 
        
         //
        
         判断哈希表是否包含特定键,其返回值为true或false 
        
         
    
        
                Console.WriteLine(
        
         "
        
         the E key:exist
        
         "
        
         ); 
         ht.Remove(
        
         "
        
         C
        
         "
        
         );
        
         //
        
         移除一个key/value键值对 
        
         
    
        
              Console.WriteLine(ht[
        
         "
        
         A
        
         "
        
         ]);
        
         //
        
         此处输出a 
        
         
    
        
              ht.Clear();
        
         //
        
         移除所有元素 
        
         
    
        
              Console.WriteLine(ht[
        
         "
        
         A
        
         "
        
         ]); 
        
         //
        
         此处将不会有任何输出 
        
         
    
        
              } 
    }

遍历哈希表

for
       
        (DictionaryEntry de 
       
        in
       
         ht) 
       
        //
       
        ht为一个Hashtable实例 
       
        
    
       
        { 
        Console.WriteLine(de.Key);
       
        //
       
        de.Key对应于key/value键值对key 
       
        
    
       
            Console.WriteLine(de.Value);
       
        //
       
        de.Key对应于key/value键值对value 
       
        
    
       
        }

对HashTable进行排序在这里定义的是对key/value键值对中的key按一定规则重新排列，但实际上这个定义是不能实现的。因为我们无法直接在HashTable进行对key进行重新排列，如果需要HashTable提供某种规则的输出，可以采用一种变通的做法：

ArrayList akeys
       
        =
       
        new
       
         ArrayList(ht.Keys);
    akeys.Sort(); 
       
        //
       
        按字母顺序进行排序 
       
        
    
       
        foreach
       
        (
       
        string
       
         skey 
       
        in
       
         akeys) 
    { 
        Console.Write(skey 
       
        +
       
         
       
        "
       
        :
       
        "
       
        ); 
        Console.WriteLine(ht[skey]);
       
        //
       
        排序后输出 
       
        
    
       
        }

## （五）SortedList类：表示键/值对的集合，与哈希表类似，区别在于SortedList中的Key数组是排好序的。 ##

![ExpandedBlockStart.gif][]代码

class
        
          Program 
        { 
            
        
         public
        
          
        
         static
        
          
        
         void
        
          Main() 
            { 
                SortedList sl 
        
         =
        
          
        
         new
        
          SortedList(); 
                sl[
        
         "
        
         c
        
         "
        
         ] 
        
         =
        
          
        
         41
        
         ; 
                sl[
        
         "
        
         a
        
         "
        
         ] 
        
         =
        
          
        
         42
        
         ; 
                sl[
        
         "
        
         d
        
         "
        
         ] 
        
         =
        
          
        
         11
        
         ; 
                sl[
        
         "
        
         b
        
         "
        
         ] 
        
         =
        
          
        
         13
        
         ; 
                
        
         foreach
        
          (DictionaryEntry element 
        
         in
        
          sl) 
                { 
                    
        
         string
        
          s 
        
         =
        
          (
        
         string
        
         )element.Key; 
                    
        
         int
        
          i 
        
         =
        
          (
        
         int
        
         )element.Value; 
                    Console.WriteLine(
        
         "
        
         {0},{1}
        
         "
        
         , s, i); 
                } 
            } 
        }

## （六）Dictionary泛型集合 ##

泛型最常见的用途是泛型集合，命名空间System.Collections.Generic中包含了一些基于泛型的集合类，使用泛型集合类可以提高更高类型安全性，还有更高的性能，避免了非泛型集合的重复装箱和拆箱。

很多非泛型集合类都有对应的泛型集合类。

非泛型集合类 泛型集合类

ArrayList List<T>

HashTable Dictionary<T>

Queue Queue<T>

Stack Stack<T>

SortedList SortedList<T>

一般用的最多我认为有ArrayList和HashTable。我们经常用HashTable来存储要写入到数据库或者返回的信息，在这之间要不断的进行类型的转化，增加了系统装箱和拆箱的负担。如果我们操纵的数据类型相对确定的话，用Dictionary<TKey, TValue>集合类来存储数据就方便多了。

![ExpandedBlockStart.gif][] 代码

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(
        
         "
        
         不存在的键\
        
         "
        
         fff\
        
         "
        
         的键值为：
        
         "
        
          
        
         +
        
          myDic[
        
         "
        
         fff
        
         "
        
         ]); 
        } 
        
        
         catch
        
          (KeyNotFoundException ex) 
        { 
            Console.WriteLine(
        
         "
        
         没有找到键引发异常：
        
         "
        
          
        
         +
        
          ex.Message); 
        } 
        
        
         //
        
         解决上面的异常的方法是使用ContarnsKey() 来判断时候存在键，如果经常要取健值得化最好用 TryGetValue方法来获取集合中的对应键值 
        
         
    
        
             
        
         string
        
          value 
        
         =
        
          
        
         ""
        
         ; 
        
        
         if
        
          (myDic.TryGetValue(
        
         "
        
         fff
        
         "
        
         , 
        
         out
        
          value)) 
        { 
            Console.WriteLine(
        
         "
        
         不存在的键\
        
         "
        
         fff\
        
         "
        
         的键值为：
        
         "
        
          
        
         +
        
          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.Values) 
        { 
            Console.WriteLine(
        
         "
        
         value={0}
        
         "
        
         , s); 
        } 
        
        
         //
        
         获取值得另一种方式 
        
         
    
        
             Dictionary
        
         <
        
         string
        
         , 
        
         string
        
         >
        
         .ValueCollection values 
        
         =
        
          myDic.Values; 
        
        
         foreach
        
          (
        
         string
        
          s 
        
         in
        
          values) 
        { 
            Console.WriteLine(
        
         "
        
         value={0}
        
         "
        
         , s); 
        }

整理了一个多小时，终于把基本的整理完了。回头看看自己写的笔记，其实还是挺欣慰的。以前看到大师的博客，总是佩服他们的执着，对技术的渴望表现的淋漓尽致。“让书写成为一种习惯”的确成为他们生活中的一部分，我多么希望自己能够跟随他们的脚步，让自己成长、进步！

# C\#异常类和属性 #

http://www.csharpwin.com/csharpspace/9756r9046.shtml

Exception 类是异常从其进行继承的基类。大多数异常对象都是 **Exception** 的某个派生类的实例，不过，任何从Object 类派生的对象都可以作为异常引发。请注意，并非所有语言都支持引发和捕捉不从**Exception** 派生的对象。在几乎任何情况下，都建议仅引发和捕捉**Exception** 对象。

**Exception** 类的若干属性使了解异常更容易。这些属性包括：

*  StackTrace 属性。
    
    此属性包含可用来确定错误发生位置的堆栈跟踪。如果有可用的调试信息，则堆栈跟踪包含源文件名和程序行号。
 *  InnerException 属性。
    
    此属性可用来在异常处理过程中创建和保留一系列异常。可使用此属性创建一个新异常来包含以前捕捉的异常。原始异常可由 **InnerException** 属性中的第二个异常捕获，这使处理第二个异常的代码可以检查附加信息。
    
    例如，假设有一个读取文件并格式化相应数据的方法。代码试图从文件读取，但引发 FileException。该方法捕捉 FileException 并引发 BadFormatException。在此情况下，FileException 可保存在 BadFormatException 的**InnerException** 属性中。
    
    为提高调用方确定异常引发原因的能力，有时可能需要方法捕捉帮助器例程引发的异常，然后引发一个进一步指示已发生的错误的异常。可以创建一个更有意义的新异常，其中内部异常引用可以设置为原始异常。然后可以针对调用方引发这种更有意义的异常。请注意，使用此功能，可以创建以最先引发的异常作为结束点的一系列相链接的异常。
 *  Message 属性。
    
    此属性提供有关异常起因的详细信息。**Message** 用引发异常的线程的  Thread.CurrentUICulture 属性所指定的语言表示。
 *  HelpLink 属性。
    
    此属性可保存某个帮助文件的 URL（或 URN），该文件提供有关异常起因的大量信息。
 *  Data 属性
    
    此属性是可以保存任意数据（以键值对的形式）的 IDictionary。

大多数从 **Exception** 继承的类都不实现其他成员或提供附加功能；它们只是从 **Exception** 继承。因此，在异常层次结构、异常名称以及异常包含的信息中可以找到有关异常的最重要信息。

[C]: http://www.cnblogs.com/tianhao960/articles/273425.html
[164201519.gif]: /images/20220514/f90a5b9f018d4739b842f55e6822c5fa.png
[C_]: http://www.cnblogs.com/moss_tan_jun/archive/2010/09/20/1831867.html
[ExpandedBlockStart.gif]: /images/20220514/e757c71a3f24407c82bb1eb9103a765c.png