C#学习笔记--数据结构、泛型、委托事件等进阶知识点

無語勝言

C#进阶

简单数据结构类

ArrayList

元素类型以Object类型存储，支持增删查改的数组容器。
因而存在装箱拆箱操作，谨慎使用。

1. //ArrayList
2. ArrayList array=new ArrayList();
3. //增=================
4. array.Add("Hello");
5. array.Add(true);
6. array.Add("Tony");//添加单个元素
7. array.Add("Hello");
8. array.Add("World");
10. ArrayList array2=new ArrayList();
11. array2.Add("123");
12. array.AddRange(array2);//从数组添加元素
14. //插入
15. array.Insert(1,"456");
17. //删除==================
18. array.Remove("Hello");
19. array.RemoveAt(1);//根据索引移除元素
20. array.Clear();//清空
21. //查=================
22. array[0];
23. //查看元素是否存储在
24. if(array.Contains(true))
25. {
26.    
27. }
28. //正向查找某个元素
29. //返回索引  未找到则返回-1
30. array.IndexOf("Hello");
31. //反向查找元素位置
32. array.LastIndexOf("Hello");
33. //改=======================
34. array[2]="123";
36. //遍历======
37. //区别长度（已经使用的容量）和容量
38. //容量
39. array.Capacity;
40. for(int i=0;i<array.Count;i++)
41. {
42.     Console.WriteLine(array[i]);
43. }
44. //迭代器遍历
45. foreach(object obj in array)
46. {
47.     Console.WriteLine(item);
48. }
49. //装箱拆箱

复制代码

Queue

本质：也是一个object数组

1. //栈 先进后出
2. //声明
3. Stack stack=new Stack();
5. //========增===压栈
6. stack.Push(1);
7. stack.Push("23");
8. stack.Push("Tony");
9. stack.Push(66.6);
10. //=======取====弹栈
11. object o=stack.Pop();
12. //======查
13. //栈只能查看栈顶的内容，无索引器不可根据索引查看
14. Object look=stack.Peek();
15. //查看元素中有无内容
16. if(stack.Contains("Tony"))
17. {
18.         Console.WriteLine("该元素存在!");   
19. }
21. //清空
22. stack.Clear();
23. //遍历
24. foreach(object item in stack)
25. {
26.     Console.WriteLine(item);
27.     //从栈顶取元素
28. }
29. //将栈转换为数组
30. object[] stackArray=stack.ToArray();
31. //栈顶元素在数组前部分
32. //循环弹栈
33. while(stack.Count>0)
34. {
35.     object obj=stack.Pop();
36.     Console.WriteLine(obj);
37. }
38. //存在装箱拆箱

复制代码

Hashtable

本质：存储也是以object存储。散列表 ，基于hash代码组织起来的键值对
可以做到访问效率是O(1)

1. //队列  先进先出
2. //声明
3. Queue queue=new Queue();
5. //增
6. queue.Enqueue(1);
7. queue.Enqueue(3.15f);
8. queue.Enqueue("Tony");
9. //取
10. queue.Dequeue();
11. //查
12. queue.Peek();
13. if(queue.Contains(3.15f))
14. {
15.     //打印
16. }
17. //改 只能清空
18. queue.Clear();
19. //遍历
20. queue.Count();
21. foreach(object item in queue)
22. {
23.     Console.WriteLine(item);
24. }
25. //转成数组
26. object[] objs=queue.ToArray();
27. for(int i=0;i<objs.Length;i++)
28. {
29.     //打印
30.      Console.WriteLine(objs[i]);
31. }
32. //循环出列
33. while(queue.Count>0)
34. {
35.     object obj=queue.Dequeue();
36.     Console.WriteLine(obj);
37. }

复制代码

泛型

泛型

泛型实现了类型参数化，达到代码重用目的，通过类型参数化来实现同一份代码操作多种类想，
泛型相当于类型占位符，定义类或者方法时使用替代符代表变量类型，
当真正使用类或方法时候再具体指定类型
泛型分类：泛型类，泛型方法，泛型接口

1. //HashTable
2. //声明
3. Hashtable hashtable=new  Hashtable();
5. //增加  键不能重复
6. hashtable.Add(1,"123");
7. hashtable.Add("name","TonyChang");
8. hashtable.Add(3,21);
9. //删除 --只能通过键来删除
10. hashtable.Remove(1);
11. hashtable.Remove("name");
13. //清空
14. hashtable.Clear();
16. //查看 找不到为空
17. hashtable[1];
18. hashtable["name"];
20. //验证是否存在
21. if(hashtable.Contains("name"))
22. {
23.    //根据键去查找
24. }
25. if(hashtable.ContainsKey("name"))
26. {
27.     //根据键去查找
28. }
29. if(hashtable.ContainsValue("TonyChang"))
30. {
31.     //根据值去查找
32. }
33. //只能通过键来找值，反之不行
35. //遍历
36. hashtable.Count;//键值对数
37. //不一定按照插入顺序打印
38. //元素是无序的
39. foreach(object item in hashtable.Keys)
40. {
41.     Console.WriteLine("键"+item);
42.     Console.WriteLine("值"+hashtable[item]);
43. }
44. //遍历值
45. foreach(object item in hashtable.Values)
46. {
47.     Console.WriteLine("值"+item);
48. }
49. //键值对遍历
50. foreach(DictionaryEntry item in hashtable)
51. {
52.     Console.WriteLine("键"+item.Key+" 值"+item.Value);
53. }
54. //迭代器遍历
55. IDictionaryEnumerator tcIDE=hashtable.GetEnumerator();
56. bool flag =tcIDE.MoveNext();
57. while(flag)
58. {
59.      Console.WriteLine("键"+tcIDE.Key+" 值"+tcIDE.Value);
60.      flag =tcIDE.MoveNext();
61. }
62. //存在装箱拆箱

复制代码

泛型约束

泛型约束：关键字 where

• 值类型  where  T :struct
  
• 引用类型  where T :class
  
• 存在无参公共构造函数 where T :new ()
  
• 某个类本身或者其派生类 where T:类名
  
• 某个接口的派生类型      where T:接口名
  
• 另一个泛型类型本身或者派生类型 where T:另一个泛型字符
  

注：这里的”T“ 可以换成其它的泛型字母

1. //泛型
2. class TestClass<T>
3. {
4.     public T value;
5. }
6. TestClass<int> t=new TestClass<int>();
7. t.value=666;
9. //泛型占位符可以有多个
10. class TestClass2<T1,T2,K,M>
11. {
12.     public T1 value1;
13.     public T2 value2;
14.     public K value3;
15.     public M value4;
16. }
17. interface ITest<T>
18. {
19.     T Value
20.     {
21.         get;
22.         set;
23.     }
24. }
25. //继承之后需要表明具体类类型
26. class Demo:ITest<int>
27. {
28.     public int Value
29.     {
30.         get;
31.         set;
32.     }
33. }
35. //泛型方法
36. class Test2
37. {
38.     public void TestFun<T>(T value)
39.     {
40.         Console.WriteLine(value);
41.     }
42.     public void TestFun<T>()
43.     {
44.         T t=default(T);
45.     }
46.     //作为返回值
47.     public T fun3<T>()
48.     {
49.         return default(T);
50.     }
51. }
53. Test2 tt=new Test2();
54. tt.TestFun<string>("Tony");
56. //泛型类中的泛型方法
57. class Test2<T>
58. {
59.     public T value;
60.     public void TestFun(T value)
61.     {
62.         //这是非泛型方法
63.     }
64.     //泛型方法
65.     //判断"<>"有无
66.     public void fun4<K>(K value)
67.     {
68.         //打印        
69.     }
70. }

复制代码

常用的泛型数据结构类

list

本质：泛型数组

1. //泛型类型的约束
2. class Test<T> where T:struct
3. {
4.     public void fun1<M> where M:struct
5.     {
6.         
7.     }
8. }
10. class Test1<T> where T:class
11. {
12.     public void fun1<M> where M:struct
13.     {
14.         
15.     }
16. }
17. //注意抽象类的无参公共构造函数
18. //也被允许
19. class Test2<T> where T:new()
20. {
21.     public void fun1<M> where M:struct
22.     {
23.         
24.     }
25. }
26. //······
27. //约束的组合使用
28. class Test7<T> where T:class,new ()
29. {
30.    
31. }
32. //多个泛型有有约束
33. class Test8<T,K> where T:class,new() where K:struct
34. {
35.    
36. }

复制代码

闭包：
内层函数可以引用包含在它外层函数的变量，即便外层函数的执行已经终止。
注意：该变量的值并非创建变量时候的初始值，而是在外层函数处理过的最终值。

1. //List
2. List<int> list=new List<int>();
3. //添加
4. list.Add(1);
5. list.Add(2);
6. list.Add(3);
7. list.Add(4);
8. //查
9. list[0];
10. //清空
11. list.Clear();
12. //移除
13. list.RemoveAt(1);
14. //查看某个元素是否存在
15. if(list.Contains(1))
16. {
17.         //该元素存在   
18. }
19. //查找元素索引
20. //未找到返回-1
21. int index=list.IndexOf(4);
22. //反向查找
23. //未找到返回-1
24. index=list.LastIndexOf(4);
25. //改
26. list[2]=66;
28. //插入
29. list.Insert(0,666);
30. //遍历
31. //长度
32. list.Count;
33. //容量
34. list.Capacity;
35. for(int i=0;i<list.Count;i++)
36. {
37.     //打印
38.     Console.WriteLine(list[i]);
39. }
40. foreach(int item in list)
41. {
42.      Console.WriteLine(item);
43. }
44. //List指定类型 不存在装箱拆箱

复制代码

List排序

1. //Dictionary
2. //声明
3. Dictionary<int,string> dictionary=new Dictionary<int,string>();
4. //增
5. dictionary.Add(1,"Hello");
6. dictionary.Add(2,"World");
7. dictionary.Add(3,"Tony");
8. dictionary.Add(4,"Chang");
9. //删除
10. dictionary.Remove(1);
11. //清空
12. dictionary.Clear();
13. //查
14. //按键进行查
15. dictionary[3];
16. dictionary[5];//找不到则报错！！！
17. //查看是否存在
18. if(dictionary.ContainsKey(1))
19. {
20.     //存在
21. }
22. if(dictionary.ContainsValue("Tony"))
23. {
24.     //存在
25. }
26. //改
27. dictionary[1]="258";
28. //遍历
29. dictionary.Count;//元素个数
30. foreach(int item in dictionary.Keys)
31. {
32.     Console.WriteLine(item);
33.     Console.WriteLine(dictionary[item]);
34. }
35. //遍历所有类型的值
36. foreach(int item in dictionary.Values)
37. {
38.     Console.WriteLine(item);
39. }
40. //键值对一起查找
41. foreach(KeyValuePair<int,string> item in dictionary)
42. {
43.     Console.WriteLine("键："+item.Key+"值："+item.Value);
44. }

复制代码

多线程

进程？
进程是运行中的程序，系统进行资源分配和调度的基本单位，是操作系统的基础。
线程？
线程存在于进程中，是进程中的实际运作单位，是操作系统能够进行运算调度的最小单位。一个进程中可以并发多个线程，他们共享利用进程中的堆栈资源。
多线程？
一个进程中除了必要的主线程之外，可以开启其它的线程来完成一些计算处理。
一个进程中除了必要的主线程之外，可以开启其它的线程来完成一些计算处理。

1. //简单的单向链表
2. //节点类
3. class LinkedNode<T>
4. {
5.     public T value;
6.     public LinkedNode<T> nextNode;
7.     public LinkedNode(T value)
8.     {
9.         this.value=value;
10.     }
11. }
12. //单向链表的简单实现
13. class LinkdedList<T>
14. {
15.     public LinkedNode<T> head;
16.     public LinkedNode<T> last;
17.     public void Add(T value)
18.     {
19.         LinkedNode<T> node=new LinkedNode<T>(value);
20.         if(head==null)
21.         {
22.             head=node;
23.             last=node;
24.         }
25.         else
26.         {
27.             last.nextNode=node;
28.             last=node;
29.         }
30.     }
31.     public void Remove(T value)
32.     {
33.         if(head==null)
34.         {
35.             return;
36.         }
37.         if(head.value.Equals(value))
38.         {
39.             //如果只有一个节点
40.             //且还是要删除的节点
41.             head=head.nextNode;
42.             if(head==null)
43.             {
44.                 last==null;
45.             }
46.             return;
47.         }
48.         LinkedNode<T> node=head;//哨兵节点
49.         //走到目标节点前的一个节点
50.         while(node.nextNode!=null)
51.         {
52.             if(node.nextNode.value.Equals(value))
53.             {
54.                 break;
55.             }
56.             node=node.nextNode;
57.         }
58.         //进行移除
59.         node.nextNode=node.nextNode.nextNode;
60.     }
61. }

复制代码

预处理器指令

预处理是在源程序编译成目标指令之前,可以简单的帮助选择一些条件是否要编译执行。
常见的预处理指令：

1. //双向链表
2. LinkedList<int> linkedList=new LinkedList<int>();
4. //增
5. //从尾部添加
6. linkedList.AddLast(10);
7. //从头部加
8. linkedList.AddFirst(5);
10. //移除
11. linkedList.RemoveFirst();//移除头节点
12. linkedList.RemoveLast();//移除尾节点
13. //移除元素
14. linkedList.Remove(5);
16. //清空
17. linkedList.Clear();
19. //查
20. //头节点
21. LinkedListNode<int> first=linkedList.First;
22. //尾节点
23. LinkedListNode<int> last=linkedList.Last;
25. //找到某个节点
26. LinkedListNode<int> node=linkedList.Find(5);//找不到返回为null
27. //在某个节点之后添加一个节点
28. linkedList.AddAfter(node,15);
29. //在某个节点之后前添加一个节点
30. linkedList.AddBefore(node,12);
32. //判断某一元素是否存在
33. if(linkedList.Contains(5))
34. {
35.     //链表中存在5
36. }
38. //改
39. //找到某一节点
40. //改变其数值
41. //找到某个节点
42. LinkedListNode<int> node1=linkedList.Find(5);//找不到返回为null
43. node1.Value=15;
45. //遍历
46. foreach(int item in linkedList)
47. {
48.     //打印节点
49.     Console.WriteLine(item);
50. }
52. //从头节点进行遍历查找
53. LinkedListNode<int> curNode=linkedList.First;
54. while(curNode!=null)
55. {
56.         Console.WriteLine(curNode.Value);  
57.     curNode=curNode.Next;
58. }
59. //从尾部节点进行遍历查找
60. LinkedListNode<int> curNode=linkedList.Last;
61. while(curNode!=null)
62. {
63.         Console.WriteLine(curNode.Value);  
64.     curNode=curNode.PreVious;
65. }

复制代码

反射和特性

反射：

程序正在运行时候，可以查看其它程序集或者自身的元数据。一个运行的程序查看本身或者其它程序的元数据的行为就叫反射。
我们知道，程序=数据+算法，程序在执行过程中需要不断地给它“投喂”数据养料，而反射就是获取养料（类、函数，变量等）的过程。有了反射，在运行时候可以动态的获取自身所需要的资源，可以提高程序的拓展性和灵活性。
程序集：
程序集是经由编译器编译得到的，供进一步编译执行的那个中间产物。在WINDOWS系统中，它一般表现为后缀为·dll（库文件）或者是·exe（可执行文件）的格式。
也就是说程序集是我们开发的项目中程序的集合，工程文件编译运行所需要执行的所有文件资源都算作程序集中的内容。
元数据：
元数据就是用来描述数据的数据，例如在程序中，类、函数、变量等等信息就是程序的元数据，她们保存在程序集中。
Type:
它是反射功能的基础，访问元数据的主要方式.
Assembly
[code]//Type//获取Type//1 objet中的方法int a=45;Type type=a.GetType();//2通过typeof获取Type type2=typeof(int);//3通过类名字//要说明类所在的命名空间Type type3=Type.GetType("System.Int32");//====三个访问方式得到的Type类型相同//得到类的程序集的信息 AssemblyConsole.WriteLine(type.Assembly);Console.WriteLine(type2.Assembly);Console.WriteLine(type3.Assembly);//===========================class Test{    private int i=1;    private int j=2;    private string name;    public Test(int i)    {        this.i=i;    }    public Test(int i,string str):this(i)    {        this.name=str;    }    public void Talk()    {        Console.WriteLine("123");    }}//获取类中所有的公共成员Type type=typeof(Test);MemeberInfo[] infos=type.GetMembers();for (int i = 0; i < infos.Length; i++){    Console.WriteLine(infos);}//获取所有的构造函数ConstructorInfo[] ctors=type.GetConstructors();for(int i=0;i