public static void Main(string[] args)
        {
            int res = CalculateSum(1, 2, 3, 4, 5);
            Console.WriteLine(res);

        }
        static int CalculateSum(params int[] intArr)
        {
            int sum = 0;
            foreach (var item in intArr)
            {
                sum += item;
            }

            return sum;
        }

 public static void Main(string[] args){
            PrintInfo(name: "Aowu", age: 22);//具名参数
        }
        static void PrintInfo(string name, int age){
            Console.WriteLine("Name={0} ,Age={1}",name,age);
        }

public static void Main(string[] args)
{
    PrintInfo();//为空

}
static void PrintInfo(string name="Wuhu", int age=21)
{
    Console.WriteLine("Name={0} ,Age={1}",name,age);
}

  class Program
    {
        public static void Main(string[] args)
        {
            double x = 3.1415926;
            double y = x.Round(3); //只有一个参数
            Console.WriteLine(y);
        }
    }
    static class DoubleExtension
    {
        public static double Round( this double input/*this 修饰*/,int digits)
        {
            double result = Math.Round(input, digits);
            return result;
        }
    }

 class Program
    {
        public static void Main(string[] args)
        {
            Calculator calculator = new Calculator();
            Action action = new Action(calculator.Report);
            calculator.Report();//直接调用
            action.Invoke();//间接调用  
            action();//同上 间接调用 

            Func<int, int, int> add = new Func<int, int, int>(calculator.Add);
            Func<int, int, int> sub = new Func<int, int, int>(calculator.Sub);
            Console.WriteLine(add.Invoke(1,2));
            Console.WriteLine(sub.Invoke(2,1));
            Console.WriteLine(add(1,2));
            Console.WriteLine(sub(2,1));
        }
        
        
    }

    class Calculator
    {
        public void Report()
        {
            Console.WriteLine("I have 3 methods!");
        }

        public int Add(int a, int b)
        {
            return a + b;
        }
        public int Sub(int a, int b)
        {
            return a - b;
        }
    }

public delegate double Calc(double a, double b);//public:公有 delegate:委托  double:目标方法返回值类型 Calc:名  (...):参数列表
     class Program
    {
        public static void Main(string[] args)
        {
            Calculator calculator = new Calculator();
            Calc add = new Calc(calculator.Add);
            Calc sub = new Calc(calculator.Sub);
            Calc mul = new Calc(calculator.Mul);
            Calc div = new Calc(calculator.Div);
            
            Console.WriteLine(add(1,3));
            Console.WriteLine(sub(1,3));
            Console.WriteLine(mul(1,3));
            Console.WriteLine(div(1,3));
        }
    }
    class Calculator
    {
        public double Add(double a, double b)
        {
            return a + b;
        }
        public double Sub(double a, double b)
        {
            return a - b;
        }
        public double Mul(double a, double b)
        {
            return a * b;
        }
        public double Div(double a, double b)
        {
            return a / b;
        }
    }

            Action action1 = new Action(student1.DoHomework);
            Action action2 = new Action(student2.DoHomework);
            Action action3 = new Action(student3.DoHomework);
           
            action1 += action3;
            action1 += action2;
            action1.Invoke(); //多播 依次执行 1 ,2 ,3

  class Program
    {
        public static void Main(string[] args)
        {
            IProductFactory pizzaFactory = new PizzaFactory();
            IProductFactory toycarFactory = new ToycarFactory();
            WrapFactory wrapFactory = new WrapFactory();
            Box box1 = wrapFactory.WrapProduct(pizzaFactory);
            Box box2 = wrapFactory.WrapProduct(toycarFactory);
            Console.WriteLine(box1.Product.Name);
            Console.WriteLine(box2.Product.Name);
        }
    }

     interface IProductFactory
     {
         Product Make();
     }

     class PizzaFactory:IProductFactory
     {
         public Product Make()
         {
             Product product = new Product();
             product.Name = "Pizza";
             return product;
         }
     }

     class ToycarFactory:IProductFactory
     {
         public Product Make()
         {
             Product product = new Product();
             product.Name = "ToyCar";
             return product;
         }
     }
     class WrapFactory
     {
         public Box WrapProduct(IProductFactory productFactory)
         {
             Box box = new Box();
             Product product = productFactory.Make();
             box.Product = product;
             return box;
         }
     }

//情况1  
public static void Main(string[] args)
        {
            Timer timer = new Timer();
            timer.Interval = 1000;
            Boy boy = new Boy();
            timer.Elapsed += boy.Action; //事件 += 事件响应者的事件处理器
            timer.Start();
            Console.ReadLine();
        }

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace EventFinal
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Customer customer = new Customer();
            Waiter waiter = new Waiter();
            customer.Order += waiter.Action;
            customer.Action();
            customer.PayBill();

        }
    }
    //确保访问级别一致
    public class OrderEventArgs: EventArgs//作为EventArgs(事件信息)时继承EventArgs类
    {
        public string DishName { get; set; }
        public string Size { get; set; }
    }
    public delegate void OrderEventHandler(Customer customer,OrderEventArgs e);//声明委托

   
    public class Customer
    {
        private OrderEventHandler orderEventHandler;
        public event OrderEventHandler Order//完整声明
        {
            add
            {
                this.orderEventHandler += value;
            }

            remove
            {
                this.orderEventHandler -= value;
            }
        }
        public double Bill { get; set; }
        public void PayBill()
        {
            Console.WriteLine("I will pay {0}!",this.Bill);
        }

        public void WalkIn()
        {
            Console.WriteLine("Walk into thee restaurant.");
        }
        public void SitDown()
        {
            Console.WriteLine("Sit down");
        }
        public void Think()
        {
            for (int i = 0; i < 5; i++)
            {
                Console.WriteLine("Let me think ...");
                Thread.Sleep(300);
            }
            if (this.orderEventHandler != null)
            {
                OrderEventArgs e=new OrderEventArgs();
                e.DishName = "Kongpao Chicken";
                e.Size = "large";
                this.orderEventHandler.Invoke(this, e);
            }
        }

        public void Action()
        {
            Console.ReadLine();
            this.WalkIn();
            this.SitDown();
            this.Think();
        }
    }

    public class Waiter
    {
        public void Action(Customer customer, OrderEventArgs e)
        {
            Console.WriteLine("I will server you the dish - {0}",e.DishName);
            double price = 10;
            switch (e.Size)
            {
                case "small":
                    price = price * 0.5;
                    break;
                case "large":
                    price *= 1.5;
                    break;
                default:
                    break;
            }
            customer.Bill+=price;
        }
    }
}

 public class Customer
    {
        
        public event OrderEventHandler Order;//字段式声明

        public double Bill { get; set; }
        public void PayBill()
        {
            Console.WriteLine("I will pay {0}!",this.Bill);
        }

        public void WalkIn()
        {
            Console.WriteLine("Walk into thee restaurant.");
        }
        public void SitDown()
        {
            Console.WriteLine("Sit down");
        }
        public void Think()
        {
            for (int i = 0; i < 5; i++)
            {
                Console.WriteLine("Let me think ...");
                Thread.Sleep(300);
            }
            if (this.Order != null)
            {
                OrderEventArgs e=new OrderEventArgs();
                e.DishName = "Kongpao Chicken";
                e.Size = "large";
                this.Order.Invoke(this, e);
            }
        }

        public void Action()
        {
            Console.ReadLine();
            this.WalkIn();
            this.SitDown();
            this.Think();
        }
    }

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace EventFinal
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Customer customer = new Customer();
            Waiter waiter = new Waiter();
            customer.Order += waiter.Action;
            customer.Action();
            customer.PayBill();

        }
    }
    //确保访问级别一致
    public class OrderEventArgs: EventArgs//作为EventArgs(事件信息)时继承EventArgs类
    {
        public string DishName { get; set; }
        public string Size { get; set; }
    }
    public delegate void OrderEventHandler(Customer customer,OrderEventArgs e);//声明委托

   
    public class Customer
    {
        
        public event EventHandler Order;//使用EventHandler类而不用自己声明

        public double Bill { get; set; }
        public void PayBill()
        {
            Console.WriteLine("I will pay {0}!",this.Bill);
        }

        public void WalkIn()
        {
            Console.WriteLine("Walk into thee restaurant.");
        }
        public void SitDown()
        {
            Console.WriteLine("Sit down");
        }
        public void Think()
        {
            for (int i = 0; i < 5; i++)
            {
                Console.WriteLine("Let me think ...");
                Thread.Sleep(300);
            }
            if (this.Order != null)
            {
                OrderEventArgs e=new OrderEventArgs();
                e.DishName = "Kongpao Chicken";
                e.Size = "large";
                this.Order.Invoke(this, e);
            }
        }

        public void Action()
        {
            Console.ReadLine();
            this.WalkIn();
            this.SitDown();
            this.Think();
        }
    }

    public class Waiter
    {
        public void Action(object sender, EventArgs e)//参数列表与EventHandler中一致
        {
            Customer customer1=sender as Customer;//类型转换
            OrderEventArgs orderInfo=e as OrderEventArgs;

            Console.WriteLine("I will server you the dish - {0}", orderInfo.DishName);
            double price = 10;
            switch (orderInfo.Size)
            {
                case "small":
                    price = price * 0.5;
                    break;
                case "large":
                    price *= 1.5;
                    break;
                default:
                    break;
            }
            customer1.Bill+=price;
        }
    }
}

 internal class Vehicle
    {
        public virtual void Run()
        {
            Console.WriteLine("Running");
        }
    }

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

Vehicle v = new Car(); //is a 
v.Run(); //Car is Running  由于Run方法被重写 所以输出为 Car is Running  

	interface IVehicle {//接口	
        void Stop();
        void Run();
        void Fill();
    }

    abstract class Vehicle:IVehicle{//抽象类
        public void Stop(){
        Console.WriteLine("Stopped!");
        }
        public void Fill() {
            Console.WriteLine("Refule!!");
        }
        public abstract void Run();
        
    }

class Program {
        public static void Main(string[] args) {
            int[] nums1 = new int[] { 1, 2, 3, 4, 5 };
            ArrayList nums2 = new ArrayList { 1, 2, 3, 4, 5 };
            Console.WriteLine(Sum(nums1));
            Console.WriteLine(Avg(nums1));
            Console.WriteLine(Sum(nums2));
            Console.WriteLine(Avg(nums2));   
        }
        static int Sum(IEnumerable nums) {
            int sum = 0;
            foreach (var num in nums) { sum += (int)num; }
            return sum;
        }
        static double Avg(IEnumerable nums) {
            int sum = 0;
            double count = 0;
            foreach (var item in nums) {
                sum += (int)item;
                count++;
            }

            return sum / count;
        }
    }

namespace InterfaceLearn.Tests;

public class DeskFanTests {
    [Fact]
    public void LowerThanZero() {
        DeskFan deskFan = new DeskFan(new BadPowerSupplyLowerThanZero());
        Assert.Equal(expected:"Wont work.",actual:deskFan.Work());
    }
    [Fact]
    public void HigherThan200() {
        DeskFan deskFan = new DeskFan(new BadPowerSupplyHigherThan200());
        Assert.Equal(expected:"Warning.",actual:deskFan.Work());
    } 
}

class BadPowerSupplyLowerThanZero : IPowerSupply {
    public int GetPower() {
        return 0;
    }
}
class BadPowerSupplyHigherThan200 : IPowerSupply {
    public int GetPower() {
        return 300;
    }
}

using Moq;
namespace InterfaceLearn.Tests;

public class DeskFanTests {
    [Fact]
    public void LowerThanZero() {
        var mock = new Mock<IPowerSupply>();
        mock.Setup(ps => ps.GetPower()).Returns(()=>0);//设置方法返回值
        DeskFan deskFan = new DeskFan(mock.Object); //传递实例
        Assert.Equal(expected:"Wont work.",actual:deskFan.Work());
    }
    [Fact]
    public void HigherThan200() {
        var mock = new Mock<IPowerSupply>();
        mock.Setup(ps => ps.GetPower()).Returns(()=>300);
        DeskFan deskFan = new DeskFan(mock.Object);
        Assert.Equal(expected:"Warning.",actual:deskFan.Work());
    }
}

using System;

namespace ISPLearn {
    internal class Program {
        public static void Main(string[] args) {
            var driver = new Driver(new HeavyTank());//父类引用子类实例
            driver.Drive();
        }
    }

    class Driver {
        private IVehicle _vehicle;//违反接口隔离原则  应该设法分裂成俩个接口

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

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

    interface IVehicle {
        void Run();
    }

    class  Car:IVehicle {
        public void Run() {
            Console.WriteLine("Car is running...");
        }
    }
    
    class  Truck:IVehicle {
        public void Run() {
            Console.WriteLine("Truck is running...");
        }
    }


    interface IWeapon {//接口分离  武器开火 载具行驶
        void Fire();
    }
    
    interface ITank:IVehicle,IWeapon {
        void Fire();
        void Run();
    }//多基接口实现  此时实现父类IVehicle.Run 

    class LightTank:ITank {
        public void Fire() {
            Console.WriteLine("Boom!");
        }

        public void Run() {
            Console.WriteLine("Ka ka ka ...");
        }
    }
    
    class MediumTank:ITank {
        public void Fire() {
            Console.WriteLine("Boom!!");
        }

        public void Run() {
            Console.WriteLine("Ka! ka! ka! ...");
        }
    }
    
    class HeavyTank:ITank {
        public void Fire() {
            Console.WriteLine("Boom!!!");
        }

        public void Run() {
            Console.WriteLine("Ka!! ka!! ka!! ...");
        }
    }
    
    
}

using System;

namespace ISPLearn {
    public class ISP3 {
        public static void Main(string[] args) {
            //显式接口隔离
           var wk = new WarmKiller();
            wk.Love();
            
            IKiller wk2 = new WarmKiller();//只可访问Kill方法  不可访问Love方法
            wk2.Kill();

            var wk3 = wk2 as WarmKiller;//转换类型
            wk3.Kill();
            wk3.Love();

        }

        interface IGentleman {
            void Love();
        }

        interface IKiller {
            void Kill();
        }

        class WarmKiller:IGentleman,IKiller {
         //Usage 1
            /*private IKiller _killerImplementation;//显示接口隔离
            public void Kill() {
                 Console.WriteLine("Let me kill enemy ...");
            }*/
		//Usage 2  
            void IKiller.Kill() {
                Console.WriteLine("Let me kill enemy ...");
            }
            
            public void Love() {
                Console.WriteLine("i love u forerver ...");
            }
        }
        
    }
}

//其余部分代码见  接口隔离原则部分
public static void Main(string[] args) {
            ITank tank = new HeavyTank();
            // 依赖注入
            // ======== 分割线 =====  以下不再使用静态类型
            var t = tank.GetType();
            object o = Activator.CreateInstance(t);
            MethodInfo fireMi = t.GetMethod("Fire");
            MethodInfo runMi = t.GetMethod("Run");
            fireMi.Invoke(o, null);
            runMi.Invoke(o, null);

        }

using System.IO;
using System.Runtime.Loader;

namespace ReflectDILearn; 

public class ReflectDILearn {
    public static void Main(string[] args) {
        var folder = Path.Combine(Environment.CurrentDirectory, "Animals");
        var files = Directory.GetFiles(folder);
        var animalTypes = new List<Type>();
        foreach (var f in files) {
            var assembly = AssemblyLoadContext.Default.LoadFromAssemblyPath(f);
            var types = assembly.GetTypes();
            foreach (var t in types) {
                if (t.GetMethod("Voice")!=null) {
                    animalTypes.Add(t);
                }
            }
        }

        while (true) {
            for (int i = 0; i < animalTypes.Count; i++) {
                Console.WriteLine($"{i+1}.{animalTypes[i].Name}");
            }

            Console.WriteLine("===================");
            Console.WriteLine("Please Choose animal:");
            int index = int.Parse(Console.ReadLine());
            if (index>animalTypes.Count||index<1) {
                Console.WriteLine("No such an animal.Try again!");
                continue;
            }

            Console.WriteLine("Times?");
            int times = int.Parse(Console.ReadLine());
            var t = animalTypes[index - 1];
            var m = t.GetMethod("Voice");
            var o = Activator.CreateInstance(t);
            m.Invoke(o, new object?[] { times });
        }
    }
}

namespace Animals.Lib;

public class Cat {
    public void Voice(int times) {
        for (int i = 0; i < times; i++) {
            Console.WriteLine("Meow!");
        }
    }
}

public static void Main(string[] args) {
            var sc = new ServiceCollection();//容器
            //ITank是静态类型  typeof(ITank)才是ITank动态的类型描述
            sc.AddScoped(typeof(IVehicle), typeof(Car));
            sc.AddScoped<Driver>();
            var sp = sc.BuildServiceProvider();
            // ==== 分割线==  以上为注册  以下为向ServiceProvider获取对象
            var Driver = sp.GetService<Driver>();
            Driver.Drive(); //AutoWire
        }

using System.Drawing;
namespace TemplateLearn;
class Program {
    public static void Main(string[] args) {
        Apple apple = new Apple(){Color = "Red"};
        Book book = new Book() { Name = "A Book" };

        Box<Apple> box1 = new Box<Apple>() { Cargo = apple };//使用泛型
        Box<Book> box2 = new Box<Book>() { Cargo = book };

        Console.WriteLine(box1.Cargo.Color);
        Console.WriteLine(box2.Cargo.Name);
    }
}
class Apple {
    public string Color { get; set; }   
}

class Book {
    public string Name { get; set; }
}

class Box<TCargo> { //<>中为类型参数  定义
    public TCargo Cargo { get; set; }    
}

namespace TemplateLearn;

class Program {
    public static void Main(string[] args) {
        Student<int> student = new Student<int>();//表示id为int类型的学生id  可以设置为其他类型如 ulong....
        student.ID = 1;
        student.Name = "Aowu";
        Console.WriteLine(student.ID);
    }
}

interface IUnique<Tid> {
    Tid ID { get; set; }
}

class Student<Tid> : IUnique<Tid> {//实现泛型接口的类 也是泛型类
    public Tid ID { get; set; }
    public string Name { get; set; }
}

class Student : IUnique<ulong> { //若指定泛型接口类型 则此类不是泛型类 实现的是特化之后的泛型接口
    public ulong ID { get; set; }
}

using System.Collections.Generic;

namespace TemplateLearn;
class Program {
    public static void Main(string[] args) {
        //Action委托只能引用没有返回值的方法  <>中的类型为方法入参类型列表
        Action<string> say = Say;//委托   
        say.Invoke("Aowu");
        say("Aowu!");
        Action<int> mul = Mul;
        mul.Invoke(10);

    }

    static void Say(string str) {//参数为string
        Console.WriteLine($"Hello,{str}!");
    }

    static void Mul(int x) {//参数为int
        Console.WriteLine(x*100);
    }
}

namespace TemplateLearn;
class Program {
    public static void Main(string[] args) {
        //类型参数为 入参类型列表, 最后一个参数为返回值类型
        Func<double, double, double> addInt = Add;
        var res = addInt.Invoke(100.2, 300.1);
        Console.WriteLine(res);
    }

    static int Add(int a, int b) {
        return a + b;
    }
    static double Add(double a, double b) {
        return a + b;
    }
}

public static void Main(string[] args) {
    // (参数列表)=>{方法体}   应该就是匿名函数吧 
    Func<double, double, double> addInt = (a,b) => { return a + b;};
    var res = addInt.Invoke(100.2, 300.1);
    Console.WriteLine(res);
}

namespace mynamespace;
public partial class ClassPartial{}//partial修饰的类为部分类
//... 部分类其余部分的命名空间需要保持一致

using System.Collections.Generic;

namespace TemplateLearn;
class Program {
    public static void Main(string[] args) {
        Person bigBoss = new Person();
        bigBoss.Level = Level.BigBoss;
        Person employee = new Person();
        employee.Level = Level.BigBoss;
        
        Console.WriteLine(bigBoss.Level>employee.Level);//可以比较大小
        
        //======== 比特位用法 ↓ ===
        //可以同时选择多个枚举值
        bigBoss.Skill = Skill.Drive | Skill.Cook | Skill.Program | Skill.Teach;//按位取或   =相加
        Console.WriteLine(bigBoss.Skill); //15  1111 
        Console.WriteLine((bigBoss.Skill & Skill.Cook)>0);//若大于0 则表示会做饭
       	Console.WriteLine((bigBoss.Skill & Skill.Cook)==Skill.Cook);//若相等 则表示会做饭
    }
}
enum Skill {
    Drive=1, //0001        //这四个数各位1错开
    Cook=2, //0010
    Program=4,//0100
    Teach=8,//1000
}
enum Level {
    Employee=100,
    //可以手动指定对应值  如果只赋值了一个 则后面的依次+1
    //如现在Employee=100,则Manager=101  Boss=102 ...
    Manager,
    Boss,
    BigBoss,
}

class Person {
    public Level Level { get; set; }
}

class Program {
    public static void Main(string[] args) {
        Student stu = new Student(){ID=101,Name = "Aowu"};
        object obj = stu;//装箱 obj引用堆内存中的 Student实例
        Student student = (Student)obj;//拆箱
        Console.WriteLine($"{student.Name},{student.ID}");//Aowu,101

        Student stu2 = stu;
        Console.WriteLine($"{stu2.Name},{stu2.ID}"); //Aowu,101
        stu2.ID = 102;
        stu2.Name = "Wuhu";
        Console.WriteLine($"{stu2.Name},{stu2.ID}");//Wuhu,102
        
        stu2.Speak(); //Wuhu is speaking...
        
        Student stu3 = new Student(1, "Oyo");
        Console.WriteLine($"{stu3.Name},{stu3.ID}");//Oyo,1

    }
}
interface ISpeak {
    void Speak();
}
struct Student:ISpeak {
    public int ID { get; set; }
    public string Name { get; set; }
    public Student(int id, string name) {
        ID = id;
        Name = name;
    }
    public void Speak() {
        Console.WriteLine($"{this.Name} is speaking...");
    }
}

class Program {
    public static void Main(string[] args) {
        //使用委托类型
        //包裹Add方法
        MyDele dele1 = new MyDele(Add);
        //可以包裹多个方法
        //多播委托:一次调用多个方法
        //dele1 += Method1;
        //通过委托实例间接调用此方法
        Console.WriteLine(dele1.Invoke(1,2)); //也可使用dele1();
    }
    static int Add(int x,int y) {
        return x + y;
    }
}
delegate int MyDele(int a,int b);//声明委托类型  返回类型为:int  参数列表为: int int

class Program {
    public static void Main(string[] args) {
        //泛型委托
        //特化为int 特化:指定泛型的类型
        MyDele<int> deleAdd = new MyDele<int>(Add);
        Console.WriteLine(deleAdd(100,210));//Console:310
        MyDele<double> deleMul = new MyDele<double>(Mul);
        Console.WriteLine(deleMul(1.3,21.0));//Console:27.3
        //委托是一种类类型
        Console.WriteLine(deleAdd.GetType().IsClass);//Console:True
    }
    static int Add(int a, int b) {
        return a + b;
    }
    static double Mul(double a, double b) {
        return a * b;
    }
}
delegate T MyDele<T>(T a, T b);

public static void Main(string[] args) {
    //泛型委托的类型推断,由于输入的 100,200 都是标准的int类型所以认定T类型为int
    DoSomeCalc(((a, b) => { return a * b;}),100,200);
}
static void DoSomeCalc<T>(Func<T, T, T> func,T x,T y) {
    
    Console.WriteLine(func(x, y));
}