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);//遍历方法二
}
}
}
}|
|
| 图1 |
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);
}
}
}
}
|
|
| 图2 |
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);
}
}
}
}
|
|
| 图3 |
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();
}
}
}
|
|
| 图4 |
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);
}
}
}
}|
|
| 图5 |
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());
}
}
}
}
C# 集合类
http://www.cnblogs.com/moss_tan_jun/archive/2010/09/20/1831867.html说起集合类，我们都不陌生，因为在项目中经常会用到。记得每次遇到要存储键值对时，都会想到HashTable，可以在用的过程中却不是很懂，不懂装懂，结果最后还是不会。今天中午正好有时间，就整理了一下相关的类，主要包括：列表、队列、位数组、哈希表和字典。
（一）ArrayList类：使用大小可按需动态增加的数组。
代码
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方法出队列。
代码
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方法出栈。
代码
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存储桶两倍的最小质数。
代码
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数组是排好序的。
代码
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>集合类来存储数据就方便多了。
代码
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 继承。因此，在异常层次结构、异常名称以及异常包含的信息中可以找到有关异常的最重要信息。
扫一扫
346
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
