C#学习第15天：泛型

什么是泛型？

---

• 定义：泛型允许您在类、接口和方法中定义占位符，这些占位符在使用时可以指定为具体的类型。
• 作用：通过减少重复代码和提供更强的类型检查，提高了代码的可重用性和性能。

泛型的核心概念 

---

1.泛型类

• 泛型类能够操作特定的数据类型，而不需要为每种数据类型写一个类。提高代码复用性。

using System;
using System.Collections.Generic;

public class GenericContainer<T>
{
    private T item;
    
    // 设置泛型项的值
    public void SetItem(T value) 
    {
        item = value;
    }
    
    // 获取泛型项的值
    public T GetItem()
    {
        return item;
    }
}

使用泛型类示例：

    public static void Demo()
    {
        // 使用int类型
        var intContainer = new GenericContainer<int>();
        intContainer.SetItem(10);
        
        // 使用string类型
        var stringContainer = new GenericContainer<string>();
        stringContainer.SetItem("Hello");
    }

2.泛型方法

可以在非泛型类中定义泛型方法，允许该方法独立于其所在类的参数类型。

public class GenericMethods
{
    // ref关键字表示参数按引用传递
    public void Swap<T>(ref T a, ref T b)
    {
        T temp = a;
        a = b;
        b = temp;
    }

    // 演示多个类型参数的泛型方法
    public TResult Convert<TInput, TResult>(TInput input) where TResult : new()
    {
        // 处理类型转换逻辑
        return new TResult();
    }
}

使用泛型方法的示例：

    public static void Demo()
    {
        var methods = new GenericMethods();
        
        // 演示Swap方法
        int x = 10, y = 20;
        Console.WriteLine($"交换前: x = {x}, y = {y}");
        methods.Swap(ref x, ref y);
        Console.WriteLine($"交换后: x = {x}, y = {y}");

        string str1 = "Hello", str2 = "World";
        Console.WriteLine($"交换前: str1 = {str1}, str2 = {str2}");
        methods.Swap(ref str1, ref str2);
        Console.WriteLine($"交换后: str1 = {str1}, str2 = {str2}");

        // 演示Convert方法
        int number = 42;
        string result = methods.Convert<int, string>(number);
        Console.WriteLine($"转换结果: {result}");
    }

 3.泛型接口

允许接口的方法和属性使用泛型类型参数。

public interface IRepository<T>
{
    void Add(T item);
    void Remove(T item);
    T GetById(int id);
    IEnumerable<T> GetAll();
}

使用示例：

public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
}

// 实现用户仓储类
public class UserRepository : IRepository<User>
{
    private List<User> users = new List<User>();

    public void Add(User item)
    {
        users.Add(item);
    }

    public void Remove(User item)
    {
        users.Remove(item);
    }

    public User GetById(int id)
    {
        return users.FirstOrDefault(u => u.Id == id);
    }

    public IEnumerable<User> GetAll()
    {
        return users;
    }
}

    // 演示仓储接口的使用
public static void Demo()
{
    var userRepo = new UserRepository();
        
    // 添加用户
    userRepo.Add(new User { Id = 1, Name = "张三" });
    userRepo.Add(new User { Id = 2, Name = "李四" });
        
    // 获取所有用户
    var allUsers = userRepo.GetAll();
    foreach (var user in allUsers)
    {
       Console.WriteLine($"用户ID: {user.Id}, 名称: {user.Name}");
    }
        
    // 根据ID获取用户
    var user1 = userRepo.GetById(1);
    Console.WriteLine($"查找到用户: {user1?.Name}");
        
     // 删除用户
    userRepo.Remove(user1);
}

高级主题

---

约束

限制泛型参数的类型以增加灵活性和安全性。

• where T : struct：T必须是值类型。
• where T : class：T必须是引用类型。
• where T : new()：T必须有一个无参构造函数。
• where T : BaseClass：T必须继承自BaseClass。
• where T : InterfaceName：T必须实现某接口。

public class Example<T> where T : new()
{
    public T CreateInstance()
    {
        return new T();
    }
}

public class GenericConstraints
{
    public T Sum<T>(T a, T b) where T : struct 
}

 泛型委托

泛型不仅适用于类和方法，还可以用于委托。

public delegate T Transformer<T>(T arg);

class Program
{
    static int Square(int x) => x * x;

    static void Main()
    {
        Transformer<int> transformer = Square;
        Console.WriteLine(transformer(3)); // 输出：9
    }
}

使用场景

---

1.集合类

• List<T>, Dictionary<TKey,TValue>, Queue<T>等都是泛型类的例子，可存储任何类型数据。

2.算法实现

• 可以创建通用的排序、搜索或其他算法，适用于任何类型。

3.类型安全事件处理

• 泛型委托用于事件系统中，确保类型匹配并提高安全性。

实践习题 

---

1.创建一个泛型栈类GenericStack<T>，实现基本的栈操作：Push、Pop和Peek。

using System;
using System.Collections.Generic;

public class GenericStack<T>
{
    private List<T> elements = new List<T>();
    // 将元素添加到栈顶的Push操作
    public void Push(T item)
    {
        elements.Add(item);
    }
    // 移除并返回栈顶元素的Pop操作
    public T Pop()
    {
        if (elements.Count == 0)
        {
            throw new InvalidOperationException("The stack is empty.");
        }
        T item = elements[^1]; // ^1 是C# 8.0语法，用于访问最后一个元素
        elements.RemoveAt(elements.Count - 1);
        return item;
    }
    // 返回栈顶元素但不移除的Peek操作
    public T Peek()
    {
        if (elements.Count == 0)
        {
            throw new InvalidOperationException("The stack is empty.");
        }
        return elements[^1];
    }
}

public class Program
{
    public static void Main()
    {
        GenericStack<int> stack = new GenericStack<int>();
        stack.Push(10);
        stack.Push(20);
        stack.Push(30);

        Console.WriteLine(stack.Peek()); // 输出：30
        Console.WriteLine(stack.Pop());  // 输出：30
        Console.WriteLine(stack.Pop());  // 输出：20
    }
}

2.编写一个泛型类LimitedType<T>，仅允许实现了IDisposable接口的类型作为参数，并包含一个释放资源的方法。

using System;

public class LimitedType<T> where T : IDisposable, new()
{
    private T resource;

    public LimitedType()
    {
        resource = new T();
    }

    public void UseResource()
    {
        Console.WriteLine($"Using resource of type {typeof(T).Name}");
        // 假装使用资源
    }

    public void ReleaseResource()
    {
        Console.WriteLine($"Releasing resource of type {typeof(T).Name}");
        resource.Dispose();
    }
}

public class MyResource : IDisposable
{
    public void Dispose()
    {
        Console.WriteLine("MyResource disposed");
    }
}

public class Program
{
    public static void Main()
    {
        LimitedType<MyResource> limitedResource = new LimitedType<MyResource>();
        limitedResource.UseResource();
        limitedResource.ReleaseResource();
    }
}

说明：

• LimitedType类使用where T : IDisposable, new()约束，这意味着T必须实现IDisposable接口，并且具有无参构造函数。
• UseResource模拟使用资源，而ReleaseResource负责正确地释放资源。
• MyResource类实现了IDisposable接口，用于演示如何正确地处置资源。

---

通过这些例子，我们展示了如何利用泛型提高代码的通用性和灵活性。如果有任何问题或需要进一步讲解，请随时告诉我！