C#反射

重写与多态

//1. 向上转型 与java 相同， 

class Vehicle{
        public virtual void Run() 
        {
            Console.WriteLine("VEL RUN");
        }

    }
class Car : Vehicle{
        public override void Run()
        {
            Console.WriteLine("Car RUN");
        }
　　　　}

 //重写与隐藏发生的条件

1. member function【method，property....】 2. protected public 3. 函数前面要一致

2.“抽象类”与“开放/关闭”原则 【本质上是不去写重复的代码】

3. 抽象类是为了复用而生，封装确定的内容，将不确定的推迟到合适的子类去实现。

//Relextion

//反射 reflex way1
            //一往都是 new obj
            // obj.method()...
            // 反射要求的是动态的追踪obj
            ITank tank = new HeaveTank();
            var t = tank.GetType();
            Console.WriteLine("TYPE:" + t);
            object o = Activator.CreateInstance(t);
            MethodInfo fireInfo = t.GetMethod("fire");
            MethodInfo runmInfo = t.GetMethod("run");
            //反向使用函数，更具类型creat一个obj，拿到类型的函数，再用函数调用obj....
            fireInfo.Invoke(o, null);
            runmInfo.Invoke(o, null);

            //反射 reflex way2
            ServiceCollection sc = new ServiceCollection();
            //arg1:实现的service接口类型    arg2:具体实现的class类型
            //如果service被重复实现，会覆盖之前的实现
            sc.AddScoped(typeof(ITank), typeof(HeaveTank));
            sc.AddScoped(typeof(ITank), typeof(LightTank));
            //Driver 需要一个veichle来构造,所有也需要注册Ivechile的interface
            sc.AddScoped(typeof(IVehicle), typeof(Truck));
            sc.AddScoped<Driver>();
            ServiceProvider sp = sc.BuildServiceProvider();
            //用已经注册好的函数来创建obj
            ITank tanker = sp.GetService<ITank>();
            tanker.fire();
            tanker.run();
            Driver driver = sp.GetService<Driver>();
            driver.Drive();

using System;
using System.Collections;
using System.Reflection;
using Microsoft.Extensions.DependencyInjection;

//一个class一次只做一件事情！---单一直则
namespace CSharp_Reflex
{
    public interface IVehicle
    {
        void run();
    }

    public class Car : IVehicle
    {
        public void run()
        {
            Console.WriteLine("Car run");
        }
    }

    public class Truck : IVehicle
    {
        public void run()
        {
            Console.WriteLine("tank run");
        }
    }

    //如果女孩想从car转换到tank的话这个接口就不行
    // 接口的拆分！！
    //interface Tank
    //{
    //    void fire();
    //    运行与开火可以分开
    //    void run();
    //}
    public interface IWeapon
    {
        void fire();
    }

    interface ITank : IVehicle, IWeapon
    {
    }

    //挂载俩插件
    public class HeaveTank : ITank
    {
        public void fire()
        {
            Console.WriteLine("BOOM!!!");
        }

        public void run()
        {
            Console.WriteLine("KAKAKAKA");
        }
    }



    public class LightTank : ITank
    {
        public void fire()
        {
            Console.WriteLine("Light BOOM!!!");
        }

        public void run()
        {
            Console.WriteLine("KAKA");
        }
    }

    public class Driver
    {
        private IVehicle _vehicle;
        public Driver(IVehicle vehicle)
        {
            _vehicle = vehicle;
        }

        public void Drive()
        {
            _vehicle.run();
        }

    }

    //IEnumerable vs ICollection
    // collection扩展了enumerable的功能，使其更fat，
    // foreach 需要实现Ienumerable接口
    class ReadOnlyCollection : IEnumerable
    {
        private int[] _array;
        public ReadOnlyCollection(int[] array)
        {
            _array = array;
        }

        public IEnumerator GetEnumerator()
        {
            return new Enumerator(this);
        }

        //————————————成员类
        public class Enumerator : IEnumerator
        {
            //composite 一个readonlyCollection
            private ReadOnlyCollection _collection;
            private int _head;

            public Enumerator(ReadOnlyCollection collection)
            {
                _collection = collection;
                _head = -1;
            }

            //读取当前
            public object Current
            {
                get { object o = _collection._array[_head]; return o; }
            }

            public bool MoveNext()
            {
                if (++_head < _collection._array.Length) return true;
                else return false;
            }

            public void Reset()
            {
                _head = -1;
            }
        }
    }

    //反射机制

    class Program
    {
        static void Main(string[] args)
        {
            //此时女孩可以自如的切换车🚗
            Driver girl = new Driver(new HeaveTank());
            girl.Drive();
            int[] sum1 = new int[] { 1, 2, 3, 4, 5 };
            //Collection 接口
            ReadOnlyCollection roc = new ReadOnlyCollection(sum1);
            Console.WriteLine(Sum(roc));

            //反射 reflex way1
            //一往都是 new obj
            // obj.method()...
            // 反射要求的是动态的追踪obj
            ITank tank = new HeaveTank();
            var t = tank.GetType();
            Console.WriteLine("TYPE:" + t); // "TYPE: HeaveTank";
            object o = Activator.CreateInstance(t);
            MethodInfo fireInfo = t.GetMethod("fire");
            MethodInfo runmInfo = t.GetMethod("run");
            //反向使用函数，更具类型creat一个obj，拿到类型的函数，在用函数调用obj....
            fireInfo.Invoke(o, null);
            runmInfo.Invoke(o, null);

            //反射 reflex way2
            ServiceCollection sc = new ServiceCollection();
            //arg1:实现的service接口类型    arg2:具体实现的class类型
            //如果service被重复实现，会覆盖之前的实现
            sc.AddScoped(typeof(ITank), typeof(HeaveTank));
            sc.AddScoped(typeof(ITank), typeof(LightTank));
            //Driver 需要一个veichle来构造,所有也需要注册Ivechile的interface
            sc.AddScoped(typeof(IVehicle), typeof(Truck));
            sc.AddScoped<Driver>();
            ServiceProvider sp = sc.BuildServiceProvider();
            //用已经注册好的函数来创建obj
            ITank tanker = sp.GetService<ITank>();
            tanker.fire();
            tanker.run();
            Driver driver = sp.GetService<Driver>();
            driver.Drive();
        }

        //service 并没有使用额外的collection的方法
        //如果用Icollection接口则无法使用实现IEnurable接口的class
        static int Sum(IEnumerable nums)
        {
            int sum = 0;
            //line:101 返回的obj就是n
            foreach (var n in nums)
            {
                sum += (int)n;
            }
            return sum;
        }
    }
}