二刷：泛型+partial类

1.泛型

作用：减少成员膨胀或者类型膨胀

1.1认识泛型

假设，一个小卖部只有苹果卖且可以提供给客户打包苹果的服务

namespace ConsoleApp3
{
    class Program
    {
        static void Main(string[] args)
        {
            Apple objApple = new Apple() { Color = "Red" };
            Box box = new Box() { Cargo = objApple };
            Console.WriteLine(box.Cargo.Color);
            Console.ReadLine();
        }
    }
    class Apple
    {
        public string Color { get; set; }
    }

    class Box
    {
        public Apple Cargo { get; set; }
    }
}

• 随着业务逐渐庞大，小卖部开始卖其他产品，书，饮料...，此时，就需要给每个商品类，添加对应的盒子类，使得类型膨胀，解决这种问题，需要使用泛型
• 泛型的定义class Name<类型参数>

namespace ConsoleApp3
{
    class Program
    {
        static void Main(string[] args)
        {
            Apple apple1 = new Apple() { Color = "Red" };
            Book book1 = new Book() { BookName = "fxx" };
            //所以泛型都不直接使用，使用前续特化，转为具体的类
            Box box1 = new Box() { Cargo = apple1 };
            Box box2 = new Box() { Cargo = book1 };
            Console.WriteLine(box1.Cargo.Color);
            Console.WriteLine(box2.Cargo.BookName);
        }
    }
    class Apple
    {
        public string Color { get; set; }
    }
    class Book
    {
        public string BookName { get; set; }
    }
    class Box
    {
        public TCargo Cargo { get; set; }
    }
}

image.png

1.2 泛型方法

• 泛型用作参数

namespace ConsoleApp3
{
    class Program
    {
        static void Main(string[] args)
        {
            Show(1);
            Show("Fxx");
            Console.ReadKey();
        }

        public static void Show(T t)
        {
            Console.WriteLine(t.GetType().Name + ":" + t);
        }
    }
}
>>>
Int32:1
String:Fxx

• 可以为多个参数

namespace ConsoleApp3
{
    class Program
    {
        static void Main(string[] args)
        {
            Show("fxx", "jkk");
            Console.ReadKey();
        }

        public static void Show(T a ,T b)
        {
            Console.WriteLine(a);
            Console.WriteLine(b);
        }
    }    
}

• 用来做返回值

namespace ConsoleApp3
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(Show());
            Console.ReadKey();
        }

        public static T Show()
        {
            //default:用来返回默认值
            return default(T);
        }
    }        
}
>>>
0

• 用于当做局部变量

namespace ConsoleApp3
{
    class Program
    {
        static void Main(string[] args)
        {

            Console.ReadKey();
        }

        public static void Show(int a ,int b)
        {
            T t; //局部变量
        }
    }    
}

1.3 泛型约束

• 有两个主要的约束：class 引用约束和 struct 值类型约束

namespace ConsoleApp3
{
    class Program
    {
        static void Main(string[] args)
        {
            Show(); //值类型 报错
            Show();
            Console.ReadKey();
        }

        public static void Show() where T:class //规定传入的类型只能是引用类型
        {
            T temp = null;
        }
    }  
}

• new()约束：一定要有一个无参数的构造方法

namespace ConsoleApp3
{
    class Program
    {
        static void Main(string[] args)
        {
            
            Show(); //字符串无,报错
            Show();
            Show();
            Console.ReadKey();
        }

        public static void Show() where T:new () 
        {
        }
    }  
}
   

• 自定义约束

namespace ConsoleApp3
{
    class Program
    {
        static void Main(string[] args)
        {
            
            Show(); //不是指定的类报错
            Show();
            Console.ReadKey();
        }
        public static void Show() where T: MyClass //只能传递指定的类
        {
        }

    }  
    class Student
    {

    }
    class MyClass
    {
       
    }
}

• 接口约束

  
  
  image.png

1.3泛型接口

namespace ConsoleApp3
{
    class Program
    {
        static void Main(string[] args)
        {
            Student stu1= new Student();
            Student stu2 = new Student();
            stu1.Id = 101;
            stu1.Name = "fxx";
            stu2.Id = 10000001;
            stu2.Name = "hjj";
        }
    }

    //泛型接口：常用
    interface IUnique
    {
        T Id { get; set; }
    }
    //学生类实现接口,使用泛型接口，那么该类也需要改成泛
    class Student : IUnique
    {
        public T Id { get; set; }
        public string Name { get; set; }
    }
}

interface IUnique中，T是泛型参数，作为参数的，那么传入Student他表示的就是 Student Id，传入Book他表示的就是Book Id

• 方法二：直接规定类型

namespace ConsoleApp3
{
    class Program
    {
        static void Main(string[] args)
        {
            Student stu2 = new Student();
            stu2.Id = 10000001;
            stu2.Name = "hjj";
        }
    }

    //泛型接口
    interface IUnique
    {
        T Id { get; set; }
    }
    //直接规定学生接的形式
    class Student: IUnique
    {
        public ulong Id { get; set; }
        public string Name { get; set; }
    }
}

1.2

1.3 泛型委托

• 无返回值的泛型委托

namespace ConsoleApp3
{
    class Program
    {
        static void Main(string[] args)
        {
            Action a1 = Say;
            a1("fxxxx");
            Action a2 = Mul;
            a2(100);
            Console.ReadKey();

        }

        static void Say(string str)
        {
            Console.WriteLine(str);

        }
        static void Mul(int x)
        {   
            Console.WriteLine(x * 1000);
        }
    }
}