C#（六）：栈、队列、反射

落日映苍穹つ 2024-03-30 12:03 17阅读 0赞

#### 栈、队列、反射 ####

*   *  栈和队列
     *   *  区别
         *  栈
         *  队列
     *  反射
     *   *  利用反射实例化构造方法
         *  访问类中的字段和方法

### 栈和队列 ###

#### 区别 ####

*  `栈`：先进后出
 *  `队列`：先进先出

#### 栈 ####

*  引用声明
    
        using System.Collections;
        Stack s = new Stack();
 *  压栈处理
    
        // 压栈处理
        s.Push("Hello World ~");
        s.Push("A");
        s.Push("B");
        s.Push("C");
        
        foreach (object obj in s) {
              
            Console.WriteLine(obj); // C  B  A  Hello World ~
        }
 *  获取栈顶的元素
    
        // 获取栈顶的元素
        Console.WriteLine(s.Peek()); // C
 *  将栈顶元素出栈
    
        // 将栈顶元素出栈，出栈方法返回出栈的元素
        Console.WriteLine(s.Pop()); // C
        
        foreach (object obj in s) {
              
            Console.WriteLine(obj); // B  A  Hello World ~
        }

#### 队列 ####

*  引用声明
    
        using System.Collections;
        Queue q = new Queue();
 *  将元素放入队列
    
        q.Enqueue("Hello World ~");
        q.Enqueue("A");
        q.Enqueue("B");
        q.Enqueue("C");
        
        foreach (object obj in q)
        {
              
            Console.WriteLine(obj); // Hello World ~  A  B  C  
        }
 *  获取队列开始元素
    
        Console.WriteLine(q.Peek()); // Hello World ~
 *  将队列开始元素移除
    
        Console.WriteLine(q.Dequeue()); // Hello World ~
        
        foreach (object obj in q)
        {
              
            Console.WriteLine(obj); // A  B  C  
        }

### 反射 ###

#### 利用反射实例化构造方法 ####

***获取类的类型***

*  注意：如果获取对象存在在命名空间内，需要 `命名空间.类名`

using System;
    
    namespace ConsoleDemo
    {
        
        class Program
        {
        
            static void Main(string[] args)
            {
        
                Type t1 = Type.GetType("ConsoleDemo.Person1");
                Console.WriteLine(t1); // ConsoleDemo.Person1
            }
        }
    
        class Person1 {
         }
    }

***实例化public权限无参构造***

using System;
    
    namespace ConsoleDemo
    {
        
        class Program
        {
        
            static void Main(string[] args)
            {
        
                Type t1 = Type.GetType("ConsoleDemo.Person1");
                // 只能实例化 public 权限的无参构造
                Activator.CreateInstance(t1); // Person1 无参构造被调用~~~
            }
        }
    
        class Person1 {
        
            public Person1() 
            {
        
                Console.WriteLine("Person1 无参构造被调用~~~");
            }
        }
    }

***实例化private权限无参构造***

using System;
    
    namespace ConsoleDemo
    {
        
        class Program
        {
        
            static void Main(string[] args)
            {
        
                Type t2 = Type.GetType("ConsoleDemo.Person2");
                // 破解了单例 private 权限 Person2 被实例， 参数二为true，表示可以匹配任何权限的无参构造
                Activator.CreateInstance(t2, true); // Person2 无参构造被调用~~~
            }
        }
    
        class Person2
        {
        
            private Person2()
            {
        
                Console.WriteLine("Person2 无参构造被调用~~~");
            }
        }
    }

***实例化public权限有参构造***

using System;
    
    namespace ConsoleDemo
    {
        
        class Program
        {
        
            static void Main(string[] args)
            {
        
                Type t3 = Type.GetType("ConsoleDemo.Person3");
                Activator.CreateInstance(t3, "Lee", 23, '1'); // Lee - 23 - 1 Person3 有参构造被调用~~~
            }
        }
    
        class Person3
        {
        
            public Person3(string name, int age, char sex)
            {
        
                Console.WriteLine($"{
          name}-{
          age}-{
          sex} Person3 有参构造被调用~~~");
            }
        }
    }

***实例化private权限有参构造***

using System;
    using System.Reflection;
    
    class Program
    {
        
        static void Main(string[] args)
        {
        
            Type t4 = Type.GetType("Person4");
            Activator.CreateInstance(t4, BindingFlags.NonPublic | BindingFlags.Instance, null, new object[] {
         "Lee", 23, '1' }, null); // Lee-23-1 Person4 有参构造被调用~~~
        }
    }
    
    class Person4
    {
        
        private Person4(string name, int age, char sex)
        {
        
            Console.WriteLine($"{
          name}-{
          age}-{
          sex} Person4 有参构造被调用~~~");
        }
    }

#### 访问类中的字段和方法 ####

***BindingFlags***

*  含义：定义访问方法或字段的权限描述（必须同时具备两个权限描述）
    
     *  1.  访问成员的访问权限描述
     *  1.  访问成员的归属  
            `BindingFlags.NonPublic | BindingFlags.Instance`

***通过反射访问类中的字段***

class Program
    {
        
        static void Main(string[] args)
        {
        
            Type t = Type.GetType("Person");
            object obj = Activator.CreateInstance(t, BindingFlags.NonPublic | BindingFlags.Instance, null, new object[] {
         "Lee", 23, '1' }, null);
        }
    }
    
    class Person
    {
        
        public string a = "ProsperLee";
        private int b = 230;
        public static int c = 123;
        private static bool d = true;
    
        private Person(string name, int age, char sex)
        {
        
            Console.WriteLine($"{
          name}-{
          age}-{
          sex} Person 有参构造被调用~~~");
        }
    }

*  1.  访问public权限非静态的字段
    
        FieldInfo a = t.GetField("a");
        Console.WriteLine(a.GetValue(obj));         // ProsperLee
        a.SetValue(obj, "Lee"); // 为a赋值
        Console.WriteLine(a.GetValue(obj));         // Lee
 *  1.  访问private权限非静态的字段
    
        FieldInfo b = t.GetField("b", BindingFlags.NonPublic | BindingFlags.Instance);
        Console.WriteLine(b.GetValue(obj));         // 230
        b.SetValue(obj, 23);
        Console.WriteLine(b.GetValue(obj));         // 23
 *  1.  访问public权限静态的字段
    
        FieldInfo c = t.GetField("c", BindingFlags.Public | BindingFlags.Static);
        Console.WriteLine(c.GetValue(obj));         // 123
        c.SetValue(null, 23); // 静态成员，访问主体采用null（规范）
        Console.WriteLine(c.GetValue(obj));         // 23
 *  1.  访问private权限静态的字段
    
        FieldInfo d = t.GetField("d", BindingFlags.NonPublic | BindingFlags.Static);
        Console.WriteLine(d.GetValue(obj));         // True
        d.SetValue(null, false);
        Console.WriteLine(d.GetValue(obj));         // False

***通过反射访问类中的方法***

> 获取没有参数的方法

*  1.  访问public权限非静态的方法
    
        MethodInfo funA = t.GetMethod("FunA");
        funA.Invoke(obj, null); // FunA
 *  1.  访问private权限非静态的方法
    
        MethodInfo funB = t.GetMethod("FunB", BindingFlags.NonPublic | BindingFlags.Instance);
        funB.Invoke(obj, null); // FunB
 *  1.  访问public权限静态的方法
    
        MethodInfo funC = t.GetMethod("FunC", BindingFlags.Public | BindingFlags.Static);
        funC.Invoke(null, null); // FunC
 *  1.  访问private权限静态的方法
    
        MethodInfo funD = t.GetMethod("FunD", BindingFlags.NonPublic | BindingFlags.Static);
        funD.Invoke(null, null); // FunD

> 获取有参数的方法

*  1.  访问public权限非静态的方法
    
        MethodInfo funAA = t.GetMethod("FunAA");
        funAA.Invoke(obj, new object[] {
               "Lee", 23 });      // FunAA Lee -> 23
 *  1.  访问private权限非静态的方法
    
        MethodInfo funBB = t.GetMethod("FunBB", BindingFlags.NonPublic | BindingFlags.Instance);
        funBB.Invoke(obj, new object[] {
               "Lee", 23 });      // FunBB Lee -> 23
 *  1.  访问public权限静态的方法
    
        MethodInfo funCC = t.GetMethod("FunCC", BindingFlags.Public | BindingFlags.Static);
        funCC.Invoke(null, new object[] {
               "Lee", 23 });      // FunCC Lee -> 23
 *  1.  访问private权限静态的方法
    
        MethodInfo funDD = t.GetMethod("FunDD", BindingFlags.NonPublic | BindingFlags.Static);
        funDD.Invoke(null, new object[] {
               "Lee", 23 });      // FunDD Lee -> 23

> 获取有参数的重载方法

class Program
    {
        
        static void Main(string[] args)
        {
        
            Type t = Type.GetType("Person");
            object obj = Activator.CreateInstance(t, BindingFlags.NonPublic | BindingFlags.Instance, null, new object[] {
         "Lee", 23, '1' }, null);
        }
    }
    
    class Person
    {
        
        private Person(string name, int age, char sex)
        {
        
            Console.WriteLine($"{
          name}-{
          age}-{
          sex} Person 有参构造被调用~~~");
        }
    
        public void FunAA(string name, int age)
        {
        
            Console.WriteLine($"FunAA {
          name} -> {
          age}");
        }
    
        public void FunAA(string name, int age, char sex)
        {
        
            Console.WriteLine($"FunAA {
          name} -> {
          age} -> {
          sex}");
        }
    
        private void FunBB(string name, int age)
        {
        
            Console.WriteLine($"FunBB {
          name} -> {
          age}");
        }
        private void FunBB(string name, int age, char sex)
        {
        
            Console.WriteLine($"FunBB {
          name} -> {
          age} -> {
          sex}");
        }
    
        public static void FunCC(string name, int age)
        {
        
            Console.WriteLine($"FunCC {
          name} -> {
          age}");
        }
        public static void FunCC(string name, int age, char sex)
        {
        
            Console.WriteLine($"FunCC {
          name} -> {
          age} -> {
          sex}");
        }
    
        private static void FunDD(string name, int age)
        {
        
            Console.WriteLine($"FunDD {
          name} -> {
          age}");
        }
        private static void FunDD(string name, int age, char sex)
        {
        
            Console.WriteLine($"FunDD {
          name} -> {
          age} -> {
          sex}");
        }
    }

*  1.  访问public权限非静态的方法
    
        MethodInfo funAA = t.GetMethod("FunAA", BindingFlags.Public | BindingFlags.Instance, null, new Type[] {
               typeof(string), typeof(int) }, null);
        funAA.Invoke(obj, new object[] {
               "Lee", 23 });      // FunAA Lee -> 23
        MethodInfo funAAA = t.GetMethod("FunAA", BindingFlags.Public | BindingFlags.Instance, null, new Type[] {
               typeof(string), typeof(int), typeof(char) }, null);
        funAAA.Invoke(obj, new object[] {
               "Lee", 23, '1' });      // FunAA Lee -> 23 -> 1
 *  1.  访问private权限非静态的方法
    
        MethodInfo funBB = t.GetMethod("FunBB", BindingFlags.NonPublic | BindingFlags.Instance, null, new Type[] {
               typeof(string), typeof(int) }, null);
        funBB.Invoke(obj, new object[] {
               "Lee", 23 });      // FunBB Lee -> 23
        MethodInfo funBBB = t.GetMethod("FunBB", BindingFlags.NonPublic | BindingFlags.Instance, null, new Type[] {
               typeof(string), typeof(int), typeof(char) }, null);
        funBBB.Invoke(obj, new object[] {
               "Lee", 23, '1' });      // FunAA Lee -> 23
 *  1.  访问public权限静态的方法
    
        MethodInfo funCC = t.GetMethod("FunCC", BindingFlags.Public | BindingFlags.Static, null, new Type[] {
               typeof(string), typeof(int) }, null);
        funCC.Invoke(null, new object[] {
               "Lee", 23 });      // FunCC Lee -> 23
        MethodInfo funCCC = t.GetMethod("FunCC", BindingFlags.Public | BindingFlags.Static, null, new Type[] {
               typeof(string), typeof(int), typeof(char) }, null);
        funCCC.Invoke(null, new object[] {
               "Lee", 23, '1' });      // FunCC Lee -> 23 -> 1
 *  1.  访问private权限静态的方法
    
        MethodInfo funDD = t.GetMethod("FunDD", BindingFlags.NonPublic | BindingFlags.Static, null, new Type[] {
               typeof(string), typeof(int) }, null);
        funDD.Invoke(null, new object[] {
               "Lee", 23 });      // FunDD Lee -> 23
        MethodInfo funDDD = t.GetMethod("FunDD", BindingFlags.NonPublic | BindingFlags.Static, null, new Type[] {
               typeof(string), typeof(int), typeof(char) }, null);
        funDDD.Invoke(null, new object[] {
               "Lee", 23, '1' });      // FunDD Lee -> 23 -> 1