Unity-C#进阶——3.27更新中

文章目录

- 数据结构类
- - `ArrayList`
  - `Stack`
  - `Queue`
  - `Hashtable`
- 泛型
- - 泛型类、泛型方法、泛型接口
  - `List`
  - `Dictionary`
  - `LinkedList`
  - 泛型栈，泛型队列
- 委托和事件
- - 委托
  - 事件
  - 匿名函数
  - `Lambad` 表达式
  - **闭包**
- List 排序
- 逆变协变
- 多线程
- - 进程
  - 线程
  - 多线程
  - 方法：
  - 线程之间共享数据：加锁
- 反射和特性
- - 程序集
  - 元数据
  - 反射
  - - 获取Type
    - 获取程序集信息
    - `Activator`
    - `Assembly`

数据结构类

`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");