目录
一、泛型(generic)
二、为什么需要泛型类
类型膨胀
成员膨胀
使用object类
三、泛型的定义
定义泛型类
使用泛型类
泛型接口
两种泛型接口的实现方法
泛型方法
成员膨胀
使用泛型
泛型委托
Action委托——只能引用没有返回值的方法
Func泛型委托——要有返回值
泛型委托和Lambda表达式的配合使用
一、泛型(generic)
泛型类是以实例化过程中提供的类型或类为基础建立的,可对对象进行强类型化
尖括号语法是把类型参数传送给泛型类型的方式
泛型并不限于类,还可以创建泛型接口、泛型方法(可以在非泛型类上定义),甚至泛型委托
泛化和特化是相对的
System.Collections.Generics名称空间的两个类型
类型:List<T> 说明:T类型对象的集合
类型:Dictionary<K,V> 说明:与K类型的键值相关的V类型的项的集合
前文已提及到:
C#集合、定义集合、索引符、List<T>、Dictionary<K,V>、键控集合(键值)和IDictionary_dlwlrma_516的博客-CSDN博客https://blog.csdn.net/dlwlrma_516/article/details/127139139?spm=1001.2014.3001.5501
二、为什么需要泛型类
场景:新百货商店开业,两个类,Chair类,Desk类
不同的货物要用不同的纸箱去装
类型膨胀
现在百货商店新开张,卖Chair和Desk,Chair需要用ChairCarton装,Desk需要用DeskCarton装;但是如果以后百货商店有1000种商品呢?要准备1000种纸箱吗?而且程序不好维护…
创建控制台项目
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApp1
{
internal class Program
{
static void Main(string[] args)
{
Chair chair = new Chair() { Color = "Red" };
ChairCarton chairCarton = new ChairCarton() { Cargo = chair };
Console.WriteLine(chairCarton.Cargo.Color);
Desk desk = new Desk() { Weight = "20kg" };
DeskCarton deskCarton = new DeskCarton() { Cargo = desk };
Console.WriteLine(deskCarton.Cargo.Weight);
Console.ReadKey();
}
}
class Chair
{
public string Color { get; set; }
}
class Desk
{
public string Weight { get; set; }
}
class ChairCarton
{
public Chair Cargo { get; set; }
}
class DeskCarton
{
public Desk Cargo { get; set; }
}
}
成员膨胀
只准备一种纸箱,填写不同的属性,carton1实例只用到了Chair属性,没有用到Desk属性,而carton2属性则相反
以后1000种商品呢?Carton类1000个对应属性,只有1个属性能用,每次增加或减少商品,都要修改Carton类
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApp1
{
internal class Program
{
static void Main(string[] args)
{
Chair chair = new Chair() { Color = "Red" };
Desk desk = new Desk() { Weight = "20kg" };
Carton carton1 = new Carton() { ChairCargo = chair };
Carton carton2 = new Carton() { DeskCargo = desk };
Console.WriteLine(carton1.ChairCargo.Color);
Console.WriteLine(carton2.DeskCargo.Weight);
Console.ReadKey();
}
}
class Chair
{
public string Color { get; set; }
}
class Desk
{
public string Weight { get; set; }
}
class Carton
{
public Chair ChairCargo { get; set; }
public Desk DeskCargo { get; set; }
}
}
使用object类
当把东西往盒子里装时是省事了,但是要把东西从盒子里拿出来时,访问盒子中装的东西就很麻烦
(chair实例赋值给Cargo属性,在Console.WriteLine(carton1.Cargo.时,系统在可选择下拉框中,就已经找不到chair实例下的有关属性Color,需要强制类型转换/as属性操作符)
使用?.的原因:若是个Chair类则打印Color属性,若是Desk类则不会打印Color属性
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApp1
{
internal class Program
{
static void Main(string[] args)
{
Chair chair = new Chair() { Color = "Red" };
Desk desk = new Desk() { Weight = "20kg" };
Carton carton1 = new Carton() { Cargo = chair };
Carton carton2 = new Carton() { Cargo = desk };
Console.WriteLine((carton1.Cargo as Chair)?.Color);
Console.WriteLine((carton2.Cargo as Desk)?.Weight);
Console.ReadKey();
}
}
class Chair
{
public string Color { get; set; }
}
class Desk
{
public string Weight { get; set; }
}
class Carton
{
public Object Cargo { get; set; }
}
}
三、泛型的定义
泛型的定义:泛型类、泛型接口、泛型方法、泛型委托
定义泛型类
<类型参数> 类型参数:标识符,代表泛化的类型
创建泛型类——需在类定义中包含尖括号
class GenericClass<T>
{
}
class Carton<TCargo>
TCargo类型是商品的类型(写的是类名!!)
声明属性——public TCargo Cargo{get;set;}
定义泛型Carton类
class Carton<TCargo>
{
public TCargo Cargo{get;set;}
}
使用泛型类
使用泛型Carton类
泛型编程实体都不能拿来编程,想要使用泛型实体之前都必须要进行特化
特化
先将泛型Carton类先特化为装Chair的Carton类型:
Carton<Chair>,相当于Chair类型替换了TCargo类型(TCargo-->Chair)
(属性:public TCargo-->public Chair TCargo类型变成了Chair类型)
在main函数中进行特化:
Carton<Chair> carton1= new Carton<Chair>(){Cargo = Chair};
凡是使用到了类型参数的地方都是强类型的
Cargo属性强类型,属性类型是Chair类型,Chair类型的实例有Color这个属性
Cargo属性强类型,属性类型是Desk类型,Desk类型的实例有Weight这个属性
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApp1
{
internal class Program
{
static void Main(string[] args)
{
Chair chair = new Chair() { Color = "Red" };
Desk desk = new Desk() { Weight = "20kg" };
Carton<Chair> carton1 = new Carton<Chair>() { Cargo = chair };
Carton<Desk> carton2 = new Carton<Desk>() { Cargo = desk };
Console.WriteLine(carton1.Cargo.Color);
Console.WriteLine(carton2.Cargo.Weight);
Console.ReadKey();
}
}
class Chair
{
public string Color { get; set; }
}
class Desk
{
public string Weight { get; set; }
}
class Carton<TCargo>
{
public TCargo Cargo { get; set; }
}
}
泛型接口
声明接口,保证对象的唯一——具有ID属性,ID属性的类型不确定,接口改为泛型接口
类型参数:TId——ID属性的类型
接口中不能够加public,因为默认就是public
interface IUnique<TId>
{
TId ID { get; set; }
}
Student类实现IUnique接口,派生自IUnique
类型参数:TId
如果一个类实现了泛型接口,那么它本身也是泛型的
实现接口,就必须把接口的全部成员都实现
泛型的Student类,TId类型参数只会影响到ID这个属性的类型
实现ID属性:
interface IUnique<TId>
{
TId ID { get; set; }
}
class Student<TId> : IUnique<TId>
{
public TId ID { get; set; }
}
给Student类添加字符串类型的名字Name
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApp1
{
internal class Program
{
static void Main(string[] args)
{
}
}
interface IUnique<TId>
{
TId ID { get; set; }
}
class Student<TId> : IUnique<TId>
{
public TId ID { get; set; }
public string Name { get; set; }
}
}
main函数中使用Student类
设置Student类的ID是整数:Student<int>
特化Student类后,使用Student类
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApp1
{
internal class Program
{
static void Main(string[] args)
{
Student<int> stu = new Student<int>();
stu.ID = 10000;
stu.Name = "Tom";
}
}
interface IUnique<TId>
{
TId ID { get; set; }
}
class Student<TId> : IUnique<TId>
{
public TId ID { get; set; }
public string Name { get; set; }
}
}
随着学校的扩张,ID需要从int改为无符号长整型
ulong作为类型参数传给泛型student类,id的类型就是ulong型
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApp1
{
internal class Program
{
static void Main(string[] args)
{
Student<ulong> stu = new Student<ulong>();
stu.ID = 10000000000000000;
stu.Name = "Tom";
}
}
interface IUnique<TId>
{
TId ID { get; set; }
}
class Student<TId> : IUnique<TId>
{
public TId ID { get; set; }
public string Name { get; set; }
}
}
两种泛型接口的实现方法
1、声明Student类时,实现IUnique泛型接口,这时Student类成为泛型类
(前面提及到的情况)
2、实行泛型接口时,实现的是特化后的泛型接口,类不再是泛型类
(下面提及到的情况)
实现IUnique接口时,不再用TId,确定ID的类型一定就是ulong,直接特化了接口,Student类不是泛型类了
当声明一个类时,在实现接口时,就已经把接口特化了,类实现的就是特化后的泛型接口
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApp1
{
internal class Program
{
static void Main(string[] args)
{
Student stu = new Student();
stu.ID = 10000000000000000;
}
}
interface IUnique<TId>
{
TId ID { get; set; }
}
class Student : IUnique<ulong>
{
public ulong ID { get; set; }
}
}
添加Name属性
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApp1
{
internal class Program
{
static void Main(string[] args)
{
Student stu = new Student();
stu.ID = 10000000000000000;
stu.Name = "Tom";
}
}
interface IUnique<TId>
{
TId ID { get; set; }
}
class Student : IUnique<ulong>
{
public ulong ID { get; set; }
public string Name { get; set; }
}
}
因为IList时泛型接口,而右边的List是泛型类,泛型类实现了泛型接口
带有一个类型参数的IList泛型接口,带有一个类型参数的List泛型类
C#的List就是ArrayList 长度可以改变,动态数组
运行结果:打印出来0-99
泛型接口IList用整型特化下,List泛型类
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApp1
{
internal class Program
{
static void Main(string[] args)
{
IList<int> list = new List<int>();
for (int i = 0; i < 100; i++)
{
list.Add(i);
}
foreach (int item in list)
{
Console.WriteLine(item);
}
Console.ReadLine();
}
}
}
类型参数为T,实现了IList泛型基接口、ICollection泛型基接口、IEnumerable泛型基接口……
List一定是可以被迭代的,因为实现了IEnumerable泛型基接口
ICollection泛型基接口——集合,可以往集合中增加新元素和删除元素
很多泛型类型带不止一个类型参数,如:IDictionary泛型接口
举例:IDictionary泛型接口
int类型特化TKey类型 string类型特化TValue类型
使用特化后的IDictionary接口类型变量 引用 特化后的Dictionary类型实例
多态:IDictionary接口类型的变量dict可以引用一个Dictionary类型的实例,Dictionary泛型类实现了IDictionary接口,类型参数都是TKey TValue
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApp1
{
internal class Program
{
static void Main(string[] args)
{
IDictionary<int, string> dict = new Dictionary<int, string>();
dict[1] = "Jack";
dict[2] = "Mary";
Console.WriteLine($"Student #1 is{dict[1]}");
Console.WriteLine($"Student #2 is{dict[2]}");
Console.ReadKey();
}
}
}
泛型方法
举例:两个整型数组合并一起
不使用泛型方法时,会出现以下情况:
成员膨胀
(方法也是类的成员)
更加容易出问题,两个方法都是静态的,类的静态成员,两个重载方法,除了类型不同以外,其他的逻辑都是相同的,万一修bug只修了其中一个方法,另一个方法忘记了就出问题了
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApp1
{
internal class Program
{
static void Main(string[] args)
{
int[] a1 = { 1, 2, 3, 4, 5 };
int[] a2 = { 1, 2, 3, 4, 5, 6 };
double[] a3 = { 1.1, 2.2, 3.3, 4.4, 5.5 };
double[] a4 = { 1.1, 2.2, 3.3, 4.4, 5.5, 6.6 };
var result = Zip(a1, a2);
Console.WriteLine(string.Join(",",result));
Console.ReadKey();
}
static int[] Zip(int[] a, int[] b)
{
int[] zipped = new int[a.Length + b.Length];
int ai = 0, bi = 0, zi = 0;
do
{
if (ai < a.Length) zipped[zi++] = a[ai++];
if (bi < b.Length) zipped[zi++] = b[bi++];
} while (ai < a.Length || bi < b.Length);
return zipped;
}
static double[] Zip(double[] a, double[] b)
{
double[] zipped = new double[a.Length + b.Length];
int ai = 0, bi = 0, zi = 0;
do
{
if (ai < a.Length) zipped[zi++] = a[ai++];
if (bi < b.Length) zipped[zi++] = b[bi++];
} while (ai < a.Length || bi < b.Length);
return zipped;
}
}
}
使用泛型
方法后面加<T>
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApp1
{
internal class Program
{
static void Main(string[] args)
{
int[] a1 = { 1, 2, 3, 4, 5 };
int[] a2 = { 1, 2, 3, 4, 5, 6 };
double[] a3 = { 1.1, 2.2, 3.3, 4.4, 5.5 };
double[] a4 = { 1.1, 2.2, 3.3, 4.4, 5.5, 6.6 };
var result = Zip(a1, a2); //可以不写Zip<int>(a1, a2);
Console.WriteLine(string.Join(",",result));
Console.ReadKey();
}
static T[] Zip<T>(T[] a, T[] b)
{
T[] zipped = new T[a.Length + b.Length];
int ai = 0, bi = 0, zi = 0;
do
{
if (ai < a.Length) zipped[zi++] = a[ai++];
if (bi < b.Length) zipped[zi++] = b[bi++];
} while (ai < a.Length || bi < b.Length);
return zipped;
}
}
}
可以无需显式写<T> <int>或<double> 泛型方法在调用时类型参数自动推断
var result = Zip(a1,a2); var result = Zip<int>(a1,a2);
泛型委托
Action委托——只能引用没有返回值的方法
静态方法Say/Mul,没有返回值
使用泛型委托分别引用参数类型完全不同的方法
类型参数:告诉Action委托未来要引用的方法的参数类型是什么,有多少个参数
Action委托引用Say方法,Say方法只有一个String类型参数
通过委托去调用一个方法叫间接调用
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApp1
{
internal class Program
{
static void Main(string[] args)
{
Action<string> a1 = Say;
a1.Invoke("Jack");
Console.ReadKey();
}
static void Say(string str)
{
Console.WriteLine($"Hello,{str}!");
}
static void Mul(int x)
{
Console.WriteLine(x * 100);
}
}
}
直接像一个方法一样调用,委托本身就是一种可调用的类型
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApp1
{
internal class Program
{
static void Main(string[] args)
{
Action<string> a1 = Say;
a1("Jack");
Console.ReadKey();
}
static void Say(string str)
{
Console.WriteLine($"Hello,{str}!");
}
static void Mul(int x)
{
Console.WriteLine(x * 100);
}
}
}
创建泛型委托实例,引用Mul函数,有一个int类型参数
调用a2委托,间接调用Mul方法
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApp1
{
internal class Program
{
static void Main(string[] args)
{
Action<string> a1 = Say;
a1("Jack");
Action<int> a2 = Mul;
a2(1);
Console.ReadKey();
}
static void Say(string str)
{
Console.WriteLine($"Hello,{str}!");
}
static void Mul(int x)
{
Console.WriteLine(x * 100);
}
}
}
Func泛型委托——要有返回值
Func<类型参数:引用的方法有多少个参数及参数类型,最后一个类型参数:函数返回值类型>
特化Func<double,double,double>泛型委托
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApp1
{
internal class Program
{
static void Main(string[] args)
{
Func<double, double, double> func1 = Add;
var result = func1(100.1, 200.2);
Console.WriteLine(result);
Console.ReadKey();
}
static double Add(double a,double b)
{
return a + b;
}
}
}
泛型委托和Lambda表达式的配合使用
对于逻辑简单的方法,不去声明,随调用去声明,匿名声明
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApp1
{
internal class Program
{
static void Main(string[] args)
{
Func<double, double, double> func1 = (double a, double b) => { return a + b; };
var result = func1(100.1, 200.2);
Console.WriteLine(result);
Console.ReadKey();
}
}
}
可以再简化
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApp1
{
internal class Program
{
static void Main(string[] args)
{
Func<double, double, double> func1 = (a, b) => { return a + b; };
var result = func1(100.1, 200.2);
Console.WriteLine(result);
Console.ReadKey();
}
}
}