数据结构类

ArrayList

• 方法：

       // 申明：本质是object数组ArrayList array = new ArrayList();// 增array.Add(10);array.Insert(1, 100); // (下标，插入的元素)// 删array.Remove(10); // 删除指定元素，从下标0开始遍历找到第一个删除array.RemoveAt(0); // 删除指定下标的元素array.Clear(); // 清空// 改array[0] = 100;// 查object obj1 = array[0]; // 获得指定下标元素bool flag = array.Contains(123); // 查找元素是否存在int index1 = array.IndexOf(99); // 正向查找元素下标，不存在放回-1int index2 = array.LastIndexOf(100); // 方向查找元素下标，不存在返回-1// 长度 / 容量int count = array.Count; // 当前长度int capacity = array.Capacity; // 当前容量// 遍历foreach(object item in array) // (遍历的类型 变量名称 int 遍历的对象){Console.WriteLine(item);}

• 装箱拆箱

  ArrayList本质是一个可以自动扩容的object的数组，所以可能存在装箱拆箱

• ArrayList和数组的区别：

  ArrayList本质是 object 数组，可以存储任何类型

  ArrayList不是定长的有自己的容量，根据大小自动扩容，而数组是定长的

Stack

• 方法：

	// Stack:栈 先进后出// 申明Stack stack = new Stack();// 入栈stack.Push(1.2f);// 出站stack.Pop();// 查看object obj = stack.Peek(); // 看栈顶bool flag = stack.Contains(1.2f); // 查看元素是否在栈中// 清空栈stack.Clear();// 长度int count = stack.Count;// 不支持随机访问，所以不能用下标遍历// foreach 遍历foreach(Object item in stack){Console.WriteLine(item);}// 栈转数组object[] objs = stack.ToArray();// 也存在装箱拆箱

Queue

• 方法：

      // Queue: 队列 先进先出// 申明Queue queue = new Queue();// 进队列queue.Enqueue(1.2f);// 出队列queue.Dequeue();// 查Object obj = queue.Peek(); // 查对头bool flag = queue.Contains(1.2f); // 查看元素是否在队列中// 清队列queue.Clear();// 不支持随机访问，所以不能用下标遍历// foreach遍历foreach (Object item in queue){Console.WriteLine(item);}// 转数组Object[] objs = queue.ToArray();// 长度int count = queue.Count;// 存在装箱拆箱
  

Hashtable

• 方法：

      // Hashtable:哈希表 键/值对Hashtable hashtable = new Hashtable();// 增hashtable.Add(1, "123"); // 不能插入相同的键// 删hashtable.Remove(1);hashtable.Clear(); // 清空// 查Object obj = hashtable[1];bool f1 = hashtable.Contains(1); // 通过key查找bool f2 = hashtable.ContainsValue(1); // 通过value查找// 改hashtable[1] = 1.10f;// 遍历// 遍历所有键foreach (object item in hashtable.Keys){Console.WriteLine(item);Console.WriteLine(hashtable[item]); // 获得值}// 遍历所有值foreach (object item in hashtable.Values){Console.WriteLine(item);}// 遍历键与值foreach (DictionaryEntry item in hashtable){Console.WriteLine(item.Key + " " +item.Value);}
  

泛型

泛型类、泛型方法、泛型接口

• 泛型实现了类型参数化，达到代码重用的目的，泛型相对于类型占位符，定义类或者方法时使用替代符代表变量类型，当真正使用类或者方法时再具体指定类型

• 方法：

      // 泛型类class Calculate<T>{public T a, b;public T1 add<T1>(T1 x, T1 y) // 泛型方法{return x;}}// 泛型接口class ICalculate<T>{public T Value{get;set;}}// 继承的时候需要指名泛型
  

List

• 方法：

      // List:本质是泛型数组ArrayList// 申明List<int> list = new List<int>();// 增加list.Add(22);list.Insert(0, 99); // 指定下标插入// 删list.Remove(22);list.Clear(); // 清空// 查int i = list[0];bool f = list.Contains(22); // 正向查找、反向查找int index1 = list.IndexOf(22);int index2 = list.LastIndexOf(22);
  

Dictionary

• 方法：

  // Dictionary:本质是泛型的Hashtable
  // 申明
  Dictionary<int, string> dic = new Dictionary<int, string>();
  // 增
  dic.Add(1, "pap");
  // 删
  dic.Remove(1);
  dic.Clear(); // 清空
  // 查
  string s = dic[1]; // Hashtable找不到键返回空，Dictionary不运行查找不存在的键值
  bool f1 = dic.ContainsKey(1); // 根据键查找
  bool f2 = dic.ContainsValue("pap"); // 根据值查找
  // 改
  dic[1] = "mmm";
  // 遍历
  foreach (int item in dic.Keys)
  {Console.WriteLine(dic[item]);
  }
  foreach (string item in dic.Values)
  {Console.WriteLine(item);
  }
  foreach (KeyValuePair<int, string> item in dic)
  {Console.WriteLine(item.Key + " " + item.Value);
  }
  

LinkedList

• 方法：

      // LinkedList:本质泛型双向链表// 申明LinkedList<string> linked = new LinkedList<string>();// 增linked.AddLast("a"); // 尾插linked.AddFirst("b");  // 头插LinkedListNode<string> node = linked.Find("b"); linked.AddAfter(node, "66"); // 在指定结点的后插入linked.AddBefore(node, "66"); // 在指定结点的前面插入// 删linked.RemoveLast(); // 尾删linked.RemoveFirst(); // 头删linked.Remove("b"); // 删除指定元素linked.Clear(); // 清空// 查LinkedListNode<string> node1 = linked.First; // 头结点LinkedListNode<string> node2 = linked.Last; // 头结点LinkedListNode<string> node3 = linked.Find("c"); // 查找指定元素Console.WriteLine(node3.Value); // value值Console.WriteLine(node3.Next); // 下一个结点bool f = linked.Contains("a");// 改linked.First.Value = "500";// 遍历LinkedListNode<string> p = linked.First;while (p != null){Console.WriteLine(p.Value);p = p.Next;}LinkedListNode<string> p2 = linked.Last;while (p2 != null){Console.WriteLine(p.Value);p = p.Previous;}
  

泛型栈，泛型队列

• Stack与Queue是支持泛型使用的，方法参考object的栈和队列

委托和事件

委托

• 委托是一种数据类型，是存有对某个方法的引用的一种引用类型变量。委托是函数的容器，用来存储、传递函数

• 格式：

      public delegate void Print(string s); // 申明委托class Person{public Print print1; // 定义委托public Print print2;public Person(Print p1, Print p2){print1 = p1; // 委托赋值print2 = p2;}public void toTest(string s1, string s2){print1.Invoke("*"); // 调用委托Console.WriteLine("----------我是分割线----------");print2.Invoke("#"); // 调用委托}}
  

• 多播委托

  委托变量可以存储多个函数

      // 多播委托:委托变量可以存储多个函数public delegate void Fun(int x);class Program{static void Main(string[] args){Fun fun = f1;fun += f2; // 增加委托fun.Invoke(56); // 执行f1 、f2fun -= f2; // 移除委托}static void f1(int x){Console.WriteLine(x % 100);}static void f2(int x){Console.WriteLine(x % 10);}}
  

• 系统提供委托

      static void Main(string[] args){// 系统自带委托// 无参无返回的委托Action action = f1;// 泛型委托Func<string> funcString = f2; // 返回值为泛型的无参委托Action<int,int> act = f3; // 传入n个参数的无返回值的委托Func<int,int> funcI = f4; // 前n个泛型是参数，最后一个泛型是返回值}static void f1 (){Console.WriteLine("我是无参无返回值的函数");}static string f2 (){return "我是有返回无的函数";}static void f3 (int x, int y){Console.WriteLine("我是有参无返回的函数");int sum = x + y;}static int f4 (int x){Console.WriteLine("我是有参有返回的函数");return x;}
  

事件

• 事件是基于委托存在，事件是委托的安全包裹。为了防止外部随意置空和调用事件，事件相对于对委托进行了一次封装，更加安全

• 格式：

  class Test
  {// 访问修饰符 event关键字 委托类型 事件名public event Action testEve;public Test(){testEve = fun; // 赋值testEve += fun;testEve -= fun;testEve(); // 调用testEve.Invoke(); }public void fun(){Console.WriteLine("我是无参无返回的函数");}
  }
  

• 注意：

  事件不能在类外部赋值和调用，只能在类内部封装和调用

  事件不可以作为临时变量

  class Program
  {static void Main(string[] args){// 事件不能在类外部赋值和调用，只能在类内部封装和调用Test t = new Test();// (X) t.testEve = null; 事件不能在类外部赋值// (X) t.testEve(); 事件不能在类外部调用t.testEve += Ftest;  // 事件可以在类外部增删// 事件不可以作为临时变量}public static void Ftest(){Console.WriteLine("我是测试函数");}
  }
  

匿名函数

• 没有函数名的的函数，需要配合委托和事件使用

• 格式

  // delegate (参数列表)
  // {
  //     函数体
  // };// 配合委托使用
  Action act = delegate ()
  {Console.WriteLine("无参无返回匿名函数");
  };
  Func<string> func = delegate()
  {return "有返回值的匿名函数";
  };
  

• 使用：

  public static void Test(int a, Action act) // 作为参数传入
  {Console.WriteLine(a);act.Invoke();
  }public static Action Test2() // 作为返回值
  {return delegate (){Console.WriteLine("匿名函数做返回值");};
  }
  static void Main(string[] args)
  {Test(10, delegate (){Console.WriteLine("匿名函数做参数");});// 看起来怪怪的写法Test2()(); // 调用Test2()函数，返回一个委托，调用委托Action()
  }      

• 匿名函数缺点：没有办法从委托或事件中指定移除函数

Lambad 表达式

• 是匿名函数的简写，配合委托或事件使用

• 格式

// (参数列表) =>
// {
//     // 函数体
// };// 有参
Action<int> a = (int value) =>
{Console.WriteLine(value);
};// Lambad表达式省略参数类型，类型与委托或事件容器一致
Action<string> a2 = (str) =>
{Console.WriteLine(str);
};

闭包

• 内层函数可以引用包含在它外层的函数变量，即使外层函数的执行已经终止

  class Test
  {public event Action a;public Test(){// 正常情况下value的生命周期为这个构造函数执行完，因为是一个临时变量int value = 10; // 形成闭包a = () =>{// 事件使用了这个变量，改变了临时变量的生命周期，当事件置空时释放Console.WriteLine("value临时变量：" + value); };}public void DoAction(){a.Invoke(); // 事件不能在类外使用，所以封装一层来使用}
  }static void Main(string[] args)
  {Test t = new Test(); // 执行构造函数，临时变量的生命周期被改变形成了闭包t.DoAction();
  }  
  

  打印： value临时变量：10

• 该变量的值并非创建时的值，而是在父函数范围内的最终值

  class Test
  {public event Action a;public Test(){int value = 10; for (int i = 0; i < 10; i++) // 为委托添加10个函数{a += () =>{Console.WriteLine(i); // 最后打印的是i的最终值10};}}public void DoAction(){a.Invoke();}
  }static void Main(string[] args)
  {Test t = new Test();t.DoAction();
  }  
  

  打印：10 10 10 10 10 10 10 10 10 10

• 利用临时变量

  class Test
  {public event Action a;public Test(){int value = 10; for (int i = 0; i < 10; i++) {// 这个临时变量每循环一次就释放并重新创建一次，所以指向的是不同的值int index = i; a += () =>{Console.WriteLine(index);};}}public void DoAction(){a.Invoke();}
  }static void Main(string[] args)
  {Test t = new Test();t.DoAction();
  }  
  

  打印：0 1 2 3 4 5 6 7 8 9

List 排序

• sort 排序

  List<int> list = new List<int>();
  list.Add(10);
  list.Add(1);
  list.Add(5);
  list.Sort();
  

• sort 自定义排序

class Item : IComparable<Item> // 继承IComparable泛型接口
{int value;public Item(int value){this.value = value;}public int CompareTo(Item other) // 实现接口的比较函数{// 返回值的含义：// 小于0，放在other前// 等于0，不变// 大于0，放在other后// 升序排列if (this.value < other.value)return -1;return 1;}
}

• sort 委托自定义排序

class Item
{public int value;public Item(int value){this.value = value;}
}class Program
{// 也可以写成匿名函数static int SortItem(Item item1, Item item2) // 返回类型参数列表参照委托{return item1.value < item2.value ? -1 : 1; // 升序排列}static void Main(string[] args){List<Item> list = new List<Item>();list.Add(new Item(10));list.Add(new Item(1));list.Add(new Item(6));list.Sort(SortItem); // 为委托添加函数}
}

逆变协变

• 协变：父类可以装载子类，是和谐的自然的变化

  逆变：子类不能装载父类，是逆变换不自然的变化

• 协变关键字out，逆变关键字in，用于泛型中修饰泛型字母

• 只有泛型接口和泛型委托能够使用

• 定义：

  // 协变 out
  // 用out修饰的泛型只能作为返回值类型，不能作为参数类型
  delegate T Fuc1<out T>();  // 可以作为返回值类型
  // delegate T Fuc1<out T>(T value);  不能作为参数类型// 逆变 in
  // 用in修饰的泛型只能作为参数类型，不能作为返回值类型
  delegate void Fuc2<in T>(T value); // 可以作为参数类型
  // delegate T Fuc2<in T>(T value); // 不能作为返回值类型
  

• 使用：

  // 协变
  // 泛型为Son的委托
  Fuc1<Son> f = () =>
  {return new Son();
  };
  // 委托的赋值需要返回值参数类型都一致才能成功
  // 而这里的返回值是不一样的，但是可以赋值成功
  // 因为Fuc1委托的泛型返回值类型定义了 协变out ，此时会自动判断返回值的父子类关系，父类能够转载子类 
  Fuc1<Father> f2 = f;
  // 返回的是Father对象，实际上装载的是Son对象
  Father father = f2(); // 逆变
  // 泛型为Father的委托，Lambad表达式省略参数类型
  Fuc2<Father> fn = (father) =>
  {};
  // 因为Fuc2委托的参数类型定义了 逆变 in，此时子类可以赋值父类
  Fuc2<Son> fn2 = fn;
  // 调用fn2传入子类类型，Fn2实际上是Father泛型，参数中父类可以装载子类，满足里氏替换原则
  fn2(new Son());
  

多线程

进程

• 一个应用程序就相对于开启了一个进程

• 进程之间可以相互独立运行、互不干扰

• 进程之间也可以相互访问、操作

线程

• 操作系统进行运算的最小调度单位，包含在进程之中，是进程的实际运作单位

• 一个进程中可以并发多个进程

• 编写在主函数中的程序为主线程

多线程

• 可以同时运行代码的多条“管道”就叫多线程

方法：

static void Main(string[] args)
{// 1.申明线程Thread thread = new Thread(NewThread); // 参数是一个无参无返回的委托// 2.开启线程thread.Start();// 3.设置为后台线程// 默认是前台线程，主线程结束了新开线程不会结束// 设置为后台线程后，主线程结束新开线程也会结束thread.IsBackground = true;// 4.关闭释放线程// 第一种方法thread = null;// 第二种方法：在.Net core版本中无法中止会报错thread.Abort();// 线程休眠// 单位是ms，在哪个线程中调用就是休眠哪一个线程，这里是休眠主线程Thread.Sleep (1000);
}static void NewThread()
{Console.WriteLine("我是一个新开的线程");
}

线程之间共享数据：加锁

多个线程之间使用的内存都是共享的，都属于该进程，所以当多线程同时操作同一片内存区域时可能会出现问题

下面这段代码如果不加锁的话会出现逻辑执行错误，两个线程间的逻辑语句出现混乱

class Program
{static object lockObj;static void Main(string[] args){// lock：当在多个线程中想要访问同一个东西时，避免逻辑顺序执行的差错// lock(引用类型)// 为引用类型加锁，此时会先锁住（等待）其他地方调用完在开锁进入while (true){lock(lockObj){Console.SetCursorPosition(0, 0);Console.ForegroundColor = ConsoleColor.Yellow;Console.Write("0");}}}static void NewThread(){while(true){lock(lockObj){Console.SetCursorPosition(10, 10);Console.ForegroundColor = ConsoleColor.Blue;Console.Write("1");}}}
}

反射和特性

程序集

• 程序集是由编译器编译得到，可供进一步编译执行的代码集合
• 在Windows操作系统中，一般表现为.dll的库文件和.exe的可执行文件

元数据

• 程序中的类，函数，变量等等信息就是程序的元数据
• 有关程序以及类型的数据被称为元数据，被保持在程序集中

反射

• 程序运行时，访问和查看其他程序集或自身的元数据就叫反射
• 反射可以在程序编译后获得信息，所以它提高了程序的拓展性和灵活性

获取Type

// Type类 （信息类）
// 用来获取有关类型声明的信息// 获取Type
// object中的GetType方法获取
int a = 32;
Type t1 = a.GetType(); // 这里得到的是int这个类的信息
// typeof方法获取，参数传入对应类
Type t2 = typeof(int);
// 通过Type静态方法获取，参数类名字符串必须包括命名空间
Type t3 = Type.GetType("System.Int32"); // 加上命名空间才能成功获取

t1、t2、t3指向的都是同一个内存空间

获取程序集信息

// 一、【获取类的所有公共成员】
Type t = typeof(int);
MemberInfo[] memInfos = t.GetMembers(); // 二、【获取类的公共构造函数并使用】
// 1.获取所有构造函数
ConstructorInfo[] ctors = t.GetConstructors();
// 2.获取一个构造函数 
// 参数Type数组，数组内容为按顺序的参数类型
// 获得无参构造
ConstructorInfo info1 = t.GetConstructor(new Type[0]);
// 获得有参构造
ConstructorInfo info2 = t.GetConstructor(new Type[1] {typeof(int)});
// 执行 
// 返回类型是 object
// 调用无参构造
int i = (int) info1.Invoke(null); // 无参构造需要传入null
// 调用有参构造：参数是object数组
object obj = info2.Invoke(new object[] {2});

// 三、【获取类的公共成员变量】
// 1.得到所有成员变量
FieldInfo[] fieldInfos = t.GetFields();
// 2.得到指定名称的公共成员变量
// 没有获取值，只是得到了这个成员变量名
FieldInfo fieldInfo = t.GetField("value"); // 变量传变量名
// 得到成员变量的值
int test = 10;
fieldInfo.GetValue(test); // 得到这个对象对应的成员变量
// 设置成员变量的值
fieldInfo.SetValue(test, 100);
;// 四、【获取类的公共成员方法】
// 1.得到所有成员方法
MethodInfo[] methods = t.GetMethods();
// 2.得到指定成员方法
// 参数：（函数名称，Type数组 参数类型）
MethodInfo method = t.GetMethod("CompareTo", new Type[] {typeof(int)}); 
// 调用函数
int v = 100;
// 参数：（对象，object数组）
method.Invoke(v, new object[] {10}); 

Activator

• 能够快速实例化对象的类

  // Activator
  // 用于快速实例化
  Type type = typeof(Test); // Test是一个类
  // 1.调用无参构造
  // 返回的是object
  Test test1 = Activator.CreateInstance(type) as Test;
  // 2.有参构造
  // 参数：（类，参数值[变长]）
  Activator.CreateInstance(type, 99); //调用int参数的构造函数
  

Assembly

• 程序集类

  主要用来加载其他程序集中的元数据，当要使用其他程序集的内容时需要先加载

  // Assembly
  // 三种加载程序集的函数
  // 1.一般用来加载在同一文件夹下的其他程序集
  Assembly assembly1 = Assembly.Load("程序集名称");
  // 2.一般用来加载不在同一文件夹下的其他程序集
  // 方法一：Assembly.LoadFrom("包含程序集清单的文件名称或路径");
  Assembly assembly2 = Assembly.LoadFrom("C:\\Users……"); // 注意是双斜杠
  Assembly assembly3 = Assembly.LoadFrom(@"C:\Users……"); // 或者用@取消转义字符
  // 方法二：Assembly assembly3 = Assembly.LoadFile("要加载的文件的完全限定路径");// 通过Assembly获得所有Type
  Type[] types = assembly1.GetTypes();
  // 通过Assembly得到指定类Type
  Type type1 = assembly1.GetType("Program.Test");