泛型，泛型约束

什么是泛型？

泛型（Generics） 是一种编程技术，广泛应用于面向对象编程（OOP）中，特别是在C#、Java等现代编程语言中。泛型的核心思想是创建可以在多种数据类型上工作的类、接口和方法，而不需要为每种数据类型单独编写代码。这不仅提高了代码的重用性，还增强了类型安全性，减少了运行时错误。

泛型的主要优点

1. 类型安全性：
   • 泛型在编译时进行类型检查，确保类型的一致性，减少运行时类型转换错误。
2. 代码重用：
   • 通过泛型，可以编写适用于多种数据类型的通用代码，而不需要为每种数据类型编写单独的实现。
3. 性能提升：
   • 泛型避免了装箱（boxing）和拆箱（unboxing）操作，提高了性能，特别是在处理值类型时。
4. 可读性和可维护性：
   • 泛型代码更易于阅读和维护，因为类型信息在编译时就已经明确。

泛型的实现

1. 泛型类：
   定义一个类，使其可以处理多种数据类型的实例。

    public class Box<T>
    {
    	private T _content;
   
    	public void SetContent(T content)
    	{
    		_content = content;
    	}
   
    	public T GetContent()
    	{
    		return _content;
    	}
    }
   
    public class Program
    {
    	public static void Main()
    	{
    		Box<int> intBox = new Box<int>();
    		intBox.SetContent(42);
    		Console.WriteLine(intBox.GetContent()); // 输出: 42
   
    		Box<string> stringBox = new Box<string>();
    		stringBox.SetContent("Hello, World!");
    		Console.WriteLine(stringBox.GetContent()); // 输出: Hello, World!
    	}
    }
   

2. 泛型接口：
   定义一个接口，使其可以处理多种数据类型的实例。

    public interface IStorage<T>
    {
    	void Store(T item);
    	T Retrieve();
    }
   
    public class Storage<T> : IStorage<T>
    {
    	private T _item;
   
    	public void Store(T item)
    	{
    		_item = item;
    	}
   
    	public T Retrieve()
    	{
    		return _item;
    	}
    }
   
    public class Program
    {
    	public static void Main()
    	{
    		IStorage<int> intStorage = new Storage<int>();
    		intStorage.Store(100);
    		Console.WriteLine(intStorage.Retrieve()); // 输出: 100
   
    		IStorage<string> stringStorage = new Storage<string>();
    		stringStorage.Store("Generic Storage");
    		Console.WriteLine(stringStorage.Retrieve()); // 输出: Generic Storage
    	}
    }
   

3. 泛型方法：
   定义一个方法，使其可以处理多种数据类型的参数和返回值。

    public class GenericMethods
    {
    	public static T GetDefault<T>() where T : new()
    	{
    		return new T();
    	}
   
    	public static void Print<T>(T item)
    	{
    		Console.WriteLine(item);
    	}
    }
   
    public class Program
    {
    	public static void Main()
    	{
    		int defaultInt = GenericMethods.GetDefault<int>();
    		Console.WriteLine(defaultInt); // 输出: 0
   
    		string defaultString = GenericMethods.GetDefault<string>();
    		Console.WriteLine(defaultString); // 输出: (空字符串)
   
    		GenericMethods.Print(42); // 输出: 42
    		GenericMethods.Print("Hello, World!"); // 输出: Hello, World!
    	}
    }
   

4. 泛型约束：
   可以为泛型类、接口和方法添加约束，以限制泛型参数的类型。
   常见的约束包括：

   • where T : new()：要求泛型参数必须有一个无参构造函数。

   • where T : class：要求泛型参数必须是引用类型。

   • where T : struct：要求泛型参数必须是值类型。

   • where T : IInterface：要求泛型参数必须实现特定的接口。

   • where T : BaseClass：要求泛型参数必须继承自特定的基类。

       public class GenericConstraint<T> where T : new()
       {
       	public T CreateInstance()
       	{
       		return new T();
       	}
       }
     
       public class MyClass
       {
       	public void MyMethod()
       	{
       		Console.WriteLine("MyClass instance created.");
       	}
       }
     
       public class Program
       {
       	public static void Main()
       	{
       		GenericConstraint<MyClass> constraint = new GenericConstraint<MyClass>();
       		MyClass instance = constraint.CreateInstance();
       		instance.MyMethod(); // 输出: MyClass instance created.
       	}
       }
     

5. 泛型的应用场景
   1.集合类：
   泛型集合类（如List<T 、Dictionary<TKey, TValue）提供了类型安全的集合操作。

    	List <int numbers = new List <int();
    	numbers.Add(1);
    	numbers.Add(2);
    	numbers.Add(3);
   
    	foreach (int number in numbers)
    	{
    		Console.WriteLine(number); // 输出: 1 2 3
    	}
   

2.算法和数据结构：
算法和数据结构：

	public class Stack<T>
	{
		private List<T> _elements = new List<T>();

		public void Push(T item)
		{
			_elements.Add(item);
		}

		public T Pop()
		{
			if (_elements.Count == 0)
			{
				throw new InvalidOperationException("Stack is empty.");
			}
			T item = _elements[_elements.Count - 1];
			_elements.RemoveAt(_elements.Count - 1);
			return item;
		}

		public T Peek()
		{
			if (_elements.Count == 0)
			{
				throw new InvalidOperationException("Stack is empty.");
			}
			return _elements[_elements.Count - 1];
		}
	}

	public class Program
	{
		public static void Main()
		{
			Stack<int> intStack = new Stack<int>();
			intStack.Push(1);
			intStack.Push(2);
			Console.WriteLine(intStack.Pop()); // 输出: 2

			Stack<string> stringStack = new Stack<string>();
			stringStack.Push("Hello");
			stringStack.Push("World");
			Console.WriteLine(stringStack.Pop()); // 输出: World
		}
	}

3.工厂模式
泛型可以用于实现工厂模式，创建不同类型的对象。

	public class Factory<T> where T : new()
	{
		public T Create()
		{
			return new T();
		}
	}

	public class Product
	{
		public void Display()
		{
			Console.WriteLine("Product displayed.");
		}
	}

	public class Service
	{
		public void Execute()
		{
			Console.WriteLine("Service executed.");
		}
	}

	public class Program
	{
		public static void Main()
		{
			Factory<Product> productFactory = new Factory<Product>();
			Product product = productFactory.Create();
			product.Display(); // 输出: Product displayed.

			Factory<Service> serviceFactory = new Factory<Service>();
			Service service = serviceFactory.Create();
			service.Execute(); // 输出: Service executed.
		}
	}