C#入门级——泛型、泛型类、泛型接口、泛型方法和泛型委托

dlwlrma_516

2024-06-27 帮助1人

一、泛型（generic）

Action委托——只能引用没有返回值的方法

Func泛型委托——要有返回值

泛型委托和Lambda表达式的配合使用

一、泛型（generic）

泛型类是以实例化过程中提供的类型或类为基础建立的，可对对象进行强类型化

尖括号语法是把类型参数传送给泛型类型的方式

泛型并不限于类，还可以创建泛型接口、泛型方法（可以在非泛型类上定义），甚至泛型委托

泛化和特化是相对的

System.Collections.Generics名称空间的两个类型

类型：List<T> 说明：T类型对象的集合

类型：Dictionary<K,V> 说明：与K类型的键值相关的V类型的项的集合

前文已提及到：

二、为什么需要泛型类

场景：新百货商店开业，两个类，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();
}
}
}

这篇好文章是转载于：学新通技术网

C#入门级——泛型、泛型类、泛型接口、泛型方法和泛型委托

一、泛型（generic）

二、为什么需要泛型类

类型膨胀

成员膨胀

使用object类

三、泛型的定义

定义泛型类

使用泛型类

泛型接口

两种泛型接口的实现方法

泛型方法

成员膨胀

使用泛型

泛型委托

Action委托——只能引用没有返回值的方法

Func泛型委托——要有返回值

泛型委托和Lambda表达式的配合使用

photoshop保存的图片太大微信发不了怎么办

word里面弄一个表格后上面的标题会跑到下面怎么办

photoshop扩展功能面板显示灰色怎么办

《学习通》视频自动暂停处理方法

Android 11 保存文件到外部存储，并分享文件

TikTok加速器哪个好免费的TK加速器推荐

微信公众号没有声音提示怎么办

excel下划线不显示怎么办

excel打印预览压线压字怎么办

微信运动停用后别人还能看到步数吗