C#中的泛型(Generics)是一种强大的编程特性,它允许你在编写代码时使用不特定数据类型,而在编译时确定这些数据类型。泛型使得代码更加灵活、可重用,并提高了类型安全性。
功能和原理
泛型允许你编写能够与不同数据类型一起工作的代码,而不需要针对每种数据类型编写重复的代码。其原理在于通过在编译时将类型参数替换为实际的数据类型,从而生成特定的代码实现。
简单使用
在 C# 中,泛型可以用于类、结构、接口、方法和委托。你可以使用 <> 括号定义泛型类型参数,例如:
public class GenericClass<T>
{public T GenericMethod(T value){return value;}
}
调用示例
class Program
{static void Main(string[] args){// 实例化泛型类,并指定类型参数为 intGenericClass<int> intGeneric = new GenericClass<int>();int intValue = intGeneric.GenericMethod(10);Console.WriteLine("GenericMethod returned: " + intValue);// 实例化泛型类,并指定类型参数为 stringGenericClass<string> stringGeneric = new GenericClass<string>();string stringValue = stringGeneric.GenericMethod("Hello, generics!");Console.WriteLine("GenericMethod returned: " + stringValue);Console.ReadLine();}
}
常用泛型
常用的泛型包括:
List<T>、Dictionary<TKey, TValue>、Queue<T>、Stack<T>
等。这些泛型类型可以在不指定具体数据类型的情况下,提供对数据的类型安全访问和操作。
使用泛型需要注意点
- 类型安全性: 使用泛型可以提高代码的类型安全性,避免了使用弱类型或者需要类型转换的情况。
- 性能: 泛型在编译时生成特定的代码实现,因此可以提高性能,避免了装箱和拆箱操作。
- 类型约束: 有时候需要对泛型参数进行约束,可以使用 where关键字来限制泛型参数的类型。
- 避免过度使用: 尽管泛型很强大,但也需要谨慎使用。过度使用泛型可能导致代码复杂度增加,降低可读性。
泛型类(Generic Class):
定义: 泛型类是使用一个或多个类型参数定义的类。这些类型参数在类内部被用于定义字段、属性、方法等。例如:
class MyClass<T> { /* 实现 */ }
示例:List<T>
是一个典型的泛型类,它允许你在集合中存储任意类型的元素。
泛型方法(Generic Method):
定义: 泛型方法是在方法声明中使用类型参数的方法。这些类型参数可以与类的类型参数不同,并且仅在方法内部可用。例如:
void MyMethod<T>(T value) { /* 实现 */ }
示例: LINQ 方法中的很多操作(如Where、Select)都是泛型方法。
泛型接口(Generic Interface):
定义: 泛型接口是使用类型参数定义的接口。与泛型类类似,类型参数在接口的成员中被使用。例如:
interface IMyInterface<T> { /* 成员 */ }
示例:IEnumerable<T>
是一个泛型接口,它定义了一系列用于枚举集合的方法。
类型参数(Type Parameter):
定义: 类型参数是未知类型的占位符,用于定义泛型类、方法或接口。这些参数由具体类型来替代,以实现泛型的灵活性和重用性。例如:
T
在List<T>
中就是一个类型参数。
示例: T 可以被替换为任何具体的数据类型,比如int、string
等。
泛型约束(Generic Constraints):
定义: 泛型约束用于限制泛型类型参数的行为或性质。通过约束,你可以确保泛型类型参数满足特定的条件,例如必须是某种类型、必须实现某个接口等。例如:
where T : IComparable
示例: 在泛型方法中,通过where T : struct
约束可以确保类型参数是一个值类型。
泛型委托(Generic Delegate):
定义: 泛型委托是具有泛型参数的委托类型。与普通委托不同,泛型委托可以用于操作任意类型的数据。例如:
delegate T MyDelegate<T>(T arg)
;
示例: LINQ 中的Func<T, TResult>
就是一个泛型委托类型。
泛型集合(Generic Collection):
定义: 泛型集合是使用泛型类型参数的集合类。它们允许你在集合中存储特定类型的元素,提供了类型安全性和性能优势。例如:
List<T>、Dictionary<TKey, TValue>
。
示例:List<int>
是一个泛型集合,用于存储整数类型的元素。
协变与逆变(Covariance and Contravariance):
定义: 协变和逆变是用于描述泛型类型参数在派生关系中的行为的概念。协变允许你将派生类作为基类使用,逆变允许你将基类作为派生类使用。这些概念通常与委托和接口一起使用,以提高灵活性。
示例: 使用 out 关键字可以实现协变,例如IEnumerable<out T>
接口中的 T 就是协变的。而使用 in 关键字可以实现逆变,例如IComparer <in T>
接口中的 T 就是逆变的。
泛型的装箱和拆箱(Boxing and Unboxing of Generics):
定义: 装箱和拆箱是用于在值类型和引用类型之间进行转换的过程。在泛型中,由于泛型类型参数可以是值类型或引用类型,因此在某些情况下会发生装箱和拆箱操作。
示例: 当将值类型装箱为引用类型时,会创建一个对象,其值类型的副本被存储在堆上。而当将引用类型拆箱为值类型时,会提取对象中的值类型数据。
泛型性能优化(Generics Performance Optimization):
定义: 泛型在编译时会生成特定的代码实现,这些代码实现可以提高性能,避免了类型转换的开销。但在某些情况下,使用泛型可能会导致装箱和拆箱操作,从而影响性能。
示例: 尽可能使用泛型集合类(如List<T>、Dictionary<TKey, TValue>
)而不是非泛型集合类(如ArrayList、Hashtable
),以获得更好的性能。
常用常问的概念专门说明
泛型约束专门说明
在C#中,泛型约束(Generic Constraints)允许你对泛型类型参数进行限制,以确保在使用泛型时满足特定的条件。泛型约束可以用于类、方法、委托等泛型声明中,它们有助于提高代码的类型安全性和可读性。
where T : struct
这种约束要求类型参数T
必须是值类型(比如结构体),这样可以避免使用引用类型。
public void Method<T>() where T : struct
{// 实现
}
where T : class
这种约束要求类型参数T
必须是引用类型(类),这通常用于要求泛型类型参数必须是引用类型的情况。
public void Method<T>() where T : class
{// 实现
}
where T : new()
这种约束要求类型参数 T 必须具有无参数的公共构造函数。这种约束允许在泛型方法或类中实例化 T 类型的对象。
public void Method<T>() where T : new()
{T instance = new T();// 实现
}
where T : <基类名>
这种约束要求类型参数 T 必须是指定基类或者实现指定接口的类型。
public void Method<T>() where T : MyBaseClass
{// 实现
}
where T : <接口名>
这种约束要求类型参数 T 必须实现指定的接口。
public void Method<T>() where T : IMyInterface
{// 实现
}
多个约束
: 可以组合多个约束,以逗号分隔。
public void Method<T>() where T : MyBaseClass, IMyInterface, new()
{// 实现
}
泛型约束专门说明
协变(covariance)和逆变(contravariance)通常与委托和接口一起使用。
协变示例代码:
协变允许你将派生类作为基类使用。在C#中,协变通常用于返回类型。在委托和接口中,可以使用 out
关键字来实现协变。
// 定义一个简单的基类
class Animal { }
// 定义一个派生类
class Dog : Animal { }// 定义一个接口,使用 out 关键字实现协变
interface IMyInterface<out T>
{T GetItem();
}// 实现协变接口
class MyImplementation : IMyInterface<Dog>
{public Dog GetItem(){return new Dog();}
}class Program
{static void Main(string[] args){// 创建实现了协变接口的对象IMyInterface<Animal> myInterface = new MyImplementation();// 调用方法返回派生类型Animal animal = myInterface.GetItem();Console.WriteLine(animal.GetType().Name); // 输出 DogConsole.ReadLine();}
}
IMyInterface<T>
接口中的 T
使用了 out
关键字,表示 T
是协变的。因此,IMyInterface<Dog>
可以隐式转换为 IMyInterface<Animal>
,并且 GetItem
方法可以返回 Dog 类型的实例。
逆变示例代码:
逆变允许你将基类作为派生类使用。在C#中,逆变通常用于参数类型。在委托和接口中,可以使用 in
关键字来实现逆变。
// 定义一个简单的基类
class Animal { }
// 定义一个派生类
class Dog : Animal { }// 定义一个接口,使用 in 关键字实现逆变
interface IMyInterface<in T>
{void ProcessItem(T item);
}// 实现逆变接口
class MyImplementation : IMyInterface<Animal>
{public void ProcessItem(Animal animal){Console.WriteLine($"Processing {animal.GetType().Name}");}
}class Program
{static void Main(string[] args){// 创建实现了逆变接口的对象IMyInterface<Dog> myInterface = new MyImplementation();// 调用方法传入派生类型myInterface.ProcessItem(new Dog());Console.ReadLine();}
}
IMyInterface<T>
接口中的 T
使用了 in
关键字,表示 T 是逆变的。因此,IMyInterface<Animal>
可以隐式转换为 IMyInterface<Dog>
,并且 ProcessItem
方法可以接受 Dog
类型的实例。