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