C#入门经典学习笔记一

2022-10-23 17:34:00

这篇主要讲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 命名空间包含接口和类，这些接口和类定义各种对象（如列表、队列、位数组、哈希表和字典）的集合。

类
  类 说明
C#入门经典学习笔记一 ArrayList 使用大小会根据需要动态增加的数组来实现 IList 接口。
C#入门经典学习笔记一 C#入门经典学习笔记一 C#入门经典学习笔记一 BitArray 管理位值的压缩数组，该值表示为布尔值，其中 true 表示位是打开的 (1)，false 表示位是关闭的 (0)。
C#入门经典学习笔记一 CaseInsensitiveComparer 比较两个对象是否相等，比较时忽略字符串的大小写。
C#入门经典学习笔记一 CaseInsensitiveHashCodeProvider 已过时。使用忽略字符串大小写的哈希算法，为对象提供哈希代码。
C#入门经典学习笔记一 CollectionBase 为强类型集合提供 abstract 基类。
C#入门经典学习笔记一 Comparer 比较两个对象是否相等，其中字符串比较是区分大小写的。
C#入门经典学习笔记一 DictionaryBase 为键/值对的强类型集合提供 abstract 基类。
C#入门经典学习笔记一 Hashtable 表示根据键的哈希代码进行组织的键/值对的集合。
C#入门经典学习笔记一 Queue 表示对象的先进先出集合。
C#入门经典学习笔记一 ReadOnlyCollectionBase 为强类型非泛型只读集合提供 abstract 基类。
C#入门经典学习笔记一 SortedList 表示键/值对的集合，这些键值对按键排序并可按照键和索引访问。
C#入门经典学习笔记一 Stack 表示对象的简单后进先出 (LIFO) 非泛型集合。
C#入门经典学习笔记一 C#入门经典学习笔记一 C#入门经典学习笔记一 StructuralComparisons 提供用于对两个集合对象执行结构比较的对象。
  结构 说明
C#入门经典学习笔记一 C#入门经典学习笔记一 C#入门经典学习笔记一 DictionaryEntry 定义可设置或检索的字典键/值对。
 
 
  接口 说明
C#入门经典学习笔记一 C#入门经典学习笔记一 C#入门经典学习笔记一 ICollection 定义所有非泛型集合的大小、枚举数和同步方法。
C#入门经典学习笔记一 C#入门经典学习笔记一 C#入门经典学习笔记一 IComparer 公开一种比较两个对象的方法。
C#入门经典学习笔记一 C#入门经典学习笔记一 C#入门经典学习笔记一 IDictionary 表示键/值对的非通用集合。
C#入门经典学习笔记一 C#入门经典学习笔记一 C#入门经典学习笔记一 IDictionaryEnumerator 枚举非泛型字典的元素。
C#入门经典学习笔记一 C#入门经典学习笔记一 C#入门经典学习笔记一 IEnumerable 公开枚举数，该枚举数支持在非泛型集合上进行简单迭代。
C#入门经典学习笔记一 C#入门经典学习笔记一 C#入门经典学习笔记一 IEnumerator 支持对非泛型集合的简单迭代。
C#入门经典学习笔记一 C#入门经典学习笔记一 C#入门经典学习笔记一 IEqualityComparer 定义方法以支持对象的相等比较。
C#入门经典学习笔记一 IHashCodeProvider 已过时。使用自定义哈希函数为对象提供哈希代码。
C#入门经典学习笔记一 C#入门经典学习笔记一 C#入门经典学习笔记一 IList 表示可按照索引单独访问的对象的非泛型集合。
C#入门经典学习笔记一 C#入门经典学习笔记一 C#入门经典学习笔记一 IStructuralComparable 支持集合对象的结构比较。
C#入门经典学习笔记一 C#入门经典学习笔记一 C#入门经典学习笔记一 IStructuralEquatable 定义方法以支持对象的结构相等性比较。
上一篇：python解析json数据


下一篇：Boost StateChart实现状态机----秒表例程