C#想要提升代码复用性与灵活性？泛型编程基础！！

请点个赞+收藏+关注支持一下博主喵！！！

之后会继续更新前端Vue的一些值得注意的实例，后期打算复习一下后端的内容，来个学生管理系统实战(springboot)吧！

之后代码+资料全部发到github里，希望大家能关注一下咱的Github

一、什么是泛型？

泛型是程序设计语言的一种特性，它允许程序员在类、接口或方法创建时，不指定具体的数据类型。在编译时或运行时将具体的数据类型作为参数传入。这样做的好处是，可以编写与数据类型无关的代码，同时保持类型安全。

在 C# 中，泛型类型（如类、接口、委托和结构体）通过将类型参数化来工作，这些类型参数在声明时未指定，但在实例化时会被具体的类型所替换。

二、泛型的好处

1. 类型安全：泛型集合类（如 List<T>）在编译时就能确保只存储特定类型的对象，避免了类型不匹配的错误。
2. 性能优化：由于类型在编译时已知，C# 编译器能够生成更高效的代码，避免了类型转换的开销。
3. 代码复用：通过泛型，你可以编写高度可复用的代码，而不必为每种数据类型都编写专门的代码。
4. 清晰性：使用泛型可以使代码更加清晰易懂，因为它直接表明了操作的数据类型。

三、泛型的基本用法

1. 泛型类

public class GenericClass<T>  
{  
    public T Value { get; set; }  
  
    public void SetValue(T value)  
    {  
        Value = value;  
    }  
  
    public T GetValue()  
    {  
        return Value;  
    }  
}  
  
// 使用  
var intClass = new GenericClass<int>();  
intClass.SetValue(123);  
Console.WriteLine(intClass.GetValue()); // 输出: 123  
  
var stringClass = new GenericClass<string>();  
stringClass.SetValue("Hello, World!");  
Console.WriteLine(stringClass.GetValue()); // 输出: Hello, World!

2. 泛型方法

public class Utility  
{  
    public static T Find<T>(T[] items, Func<T, bool> predicate)  
    {  
        foreach (var item in items)  
        {  
            if (predicate(item))  
                return item;  
        }  
        return default(T);  
    }  
}  
  
// 使用  
int[] numbers = { 1, 2, 3, 4, 5 };  
int found = Utility.Find(numbers, n => n > 3);  
Console.WriteLine(found); // 输出: 4  
  
string[] words = { "apple", "banana", "cherry" };  
string foundWord = Utility.Find(words, w => w.StartsWith("b"));  
Console.WriteLine(foundWord); // 输出: banana

四、泛型的应用场景

• 集合类：.NET Framework 中的 List<T>, Dictionary<TKey, TValue>, Queue<T> 等集合类都是泛型类的典型应用。
• 数据访问：在 ORM（对象关系映射）框架中，泛型常用于实现类型安全的数据库访问。
• 算法和数据结构：在实现各种算法和数据结构时，泛型可以提供灵活性和类型安全性。
• 泛型委托和事件处理器：通过泛型委托和事件处理器，可以创建更加通用和灵活的事件处理机制。

五、工作实例泛型

考虑一个场景：设计一个数据访问层（DAL），用于从数据库中检索和保存不同类型的数据实体。在这个例子中，我们将使用泛型来创建一个通用的数据访问类，这个类可以处理任何类型的数据实体，只要这些实体遵循一定的约定（比如继承自某个基类或实现某个接口）。

首先，我们定义一个数据实体接口，确保所有实体都包含一些基本属性（如ID）：

public interface IDataEntity  
{  
    int Id { get; set; }  
}  
  
// 示例实体类  
public class Product : IDataEntity  
{  
    public int Id { get; set; }  
    public string Name { get; set; }  
    public decimal Price { get; set; }  
}  
  
public class Category : IDataEntity  
{  
    public int Id { get; set; }  
    public string Name { get; set; }  
}

接下来，我们创建一个泛型数据访问类，该类使用ADO.NET（或任何ORM框架，但这里为了简单起见，我们使用ADO.NET）来执行数据库操作：

using System;  
using System.Collections.Generic;  
using System.Data;  
using System.Data.SqlClient;  
  
public class GenericDataAccess<T> where T : IDataEntity, new()  
{  
    private string connectionString = "你的数据库连接字符串";  
  
    // 假设所有实体都通过Id来检索  
    public T GetById(int id)  
    {  
        string query = $"SELECT * FROM {typeof(T).Name} WHERE Id = @Id";  
          
        using (var connection = new SqlConnection(connectionString))  
        {  
            var command = new SqlCommand(query, connection);  
            command.Parameters.AddWithValue("@Id", id);  
  
            connection.Open();  
              
            using (var reader = command.ExecuteReader())  
            {  
                if (reader.Read())  
                {  
                    return MapReaderToEntity<T>(reader);  
                }  
            }  
        }  
  
        return default;  
    }  
  
    // 假设每个实体都有一个无参构造函数，并且所有属性都可通过DataReader映射  
    private T MapReaderToEntity<T>(SqlDataReader reader) where T : IDataEntity, new()  
    {  
        T entity = new T();  
  
        // 这里使用反射来动态映射属性，为了简化示例，不展示完整实现  
        // 实际应用中，你可能需要处理更复杂的映射逻辑，或者使用ORM框架来自动完成映射  
  
        // 示例：直接映射Id属性（假设所有实体都有Id属性）  
        var idProperty = typeof(T).GetProperty("Id");  
        idProperty.SetValue(entity, reader.GetInt32(reader.GetOrdinal("Id")));  
  
        // 注意：这里省略了其他属性的映射逻辑  
  
        return entity;  
    }  
  
    // 可以继续添加其他数据库操作方法，如Insert, Update, Delete等  
}  
  
// 使用示例  
class Program  
{  
    static void Main(string[] args)  
    {  
        var productDao = new GenericDataAccess<Product>();  
        var product = productDao.GetById(1); // 假设ID为1的Product存在  
  
        if (product != null)  
        {  
            Console.WriteLine($"Product Name: {product.Name}, Price: {product.Price}");  
        }  
  
        // 同理，可以创建Category的DAO并调用其方法  
    }  
}

注意：

1. 上述代码中的MapReaderToEntity方法使用了反射来动态映射属性，但仅作为示例。在实际应用中，你可能需要编写更复杂的逻辑来处理所有属性的映射，或者使用ORM框架（如Entity Framework, Dapper等）来自动完成这项任务。

2. 示例中的SQL查询字符串直接拼接了表名（typeof(T).Name），这在真实环境中可能存在SQL注入的风险。一个更安全的方法是使用一个预定义的表名映射或者确保类型名符合特定的命名约定。

3. 示例中省略了错误处理和事务管理的代码，这些在实际应用中是非常重要的。

通过泛型，我们创建了一个高度可复用的数据访问类，它可以处理任何实现了IDataEntity接口的数据实体。这减少了代码重复，提高了代码的可维护性和可扩展性。

就上面的例子，我们介绍一下用ORM框架（如Entity Framework, Dapper等）来自动完成这项任务。

六、ORM框架简介

1. 什么是ORM?
对象-关系映射（Object-Relational Mapping，简称ORM），面向对象的开发方法是当今企业级应用开发环境中的主流开发方法，关系数据库是企业级应用环境中永久存放数据的主流数据存储系统。对象和关系数据是业务实体的两种表现形式，业务实体在内存中表现为对象，在数据库中表现为关系数据。内存中的对象之间存在关联和继承关系，而在数据库中，关系数据无法直接表达多对多关联和继承关系。因此，对象-关系映射(ORM)系统一般以中间件的形式存在，主要实现程序对象到关系数据库数据的映射。

2.为什么使用ORM?
当我们实现一个应用程序时（不使用O/R Mapping），我们可能会写特别多数据访问层的代码，从数据库保存、删除、读取对象信息，而这些代码都是重复的。而使用ORM则会大大减少重复性代码。对象关系映射（Object Relational Mapping，简称ORM），主要实现程序对象到关系数据库数据的映射。

3.对象-关系映射解释：
A . 简单：ORM以最基本的形式建模数据。比如ORM会将MySQL的一张表映射成一个Java类（模型），表的字段就是这个类的成员变量 
B . 精确：ORM使所有的mysql数据表都按照统一的标准精确地映射成java类，使系统在代码层面保持准确统一 
C .易懂：ORM使数据库结构文档化。比如MySQL数据库就被ORM转换为了java程序员可以读懂的java类，java程序员可以只把注意力放在他擅长的java层面（当然能够熟练掌握MySQL更好） 
D.易用：ORM包含对持久类对象进行CRUD操作的API，例如create(), update(), save(), load(), find(), find_all(), where()等，也就是讲sql查询全部封装成了编程语言中的函数，通过函数的链式组合生成最终的SQL语句。通过这种封装避免了不规范、冗余、风格不统一的SQL语句，可以避免很多人为Bug，方便编码风格的统一和后期维护。  

4. ORM的优缺点：
优点： 
提高开发效率，降低开发成本 
使开发更加对象化 
可移植 
可以很方便地引入数据缓存之类的附加功能 
缺点： 
自动化进行关系数据库的映射需要消耗系统性能。其实这里的性能消耗还好啦，一般来说都可以忽略之。 
在处理多表联查、where条件复杂之类的查询时，ORM的语法会变得复杂。

七、用ORM框架来处理所有属性(包括动态)的映射

使用ORM（Object-Relational Mapping）框架如Entity Framework或Dapper可以极大地简化数据库操作，并且自动完成实体与数据库表之间的映射。以下是使用这两种ORM框架来完成类似前面示例中任务的简要说明。

#1ORM:使用Entity Framework

Entity Framework (EF) 是一个支持.NET的ORM框架，它允许你使用.NET对象来处理数据库数据，而无需编写大量的数据访问代码。EF支持Code First、Model First和Database First等多种开发模式。

步骤 1: 安装Entity Framework

首先，你需要在你的项目中安装Entity Framework。你可以通过NuGet包管理器来安装。

Install-Package EntityFramework

对于.NET Core或.NET 5/6/7等较新版本，你可能需要安装针对这些版本的Entity Framework Core。

Install-Package Microsoft.EntityFrameworkCore.SqlServer

步骤 2: 定义模型

确保你的实体类（如Product和Category）已经定义好，并且它们遵循Entity Framework的约定（比如，主键通常命名为Id）。

步骤 3: 创建DbContext

DbContext是Entity Framework中用于表示数据库上下文的主要类。你需要创建一个继承自DbContext的类，并在这个类中注册你的模型。

public class MyDbContext : DbContext  
{  
    public DbSet<Product> Products { get; set; }  
    public DbSet<Category> Categories { get; set; }  
  
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)  
    {  
        optionsBuilder.UseSqlServer("你的数据库连接字符串");  
    }  
}

步骤 4: 使用DbContext查询数据

现在，你可以使用DbContext来查询数据库了。

using (var context = new MyDbContext())  
{  
    var product = context.Products.Find(1); // 假设ID为1的Product存在  
  
    if (product != null)  
    {  
        Console.WriteLine($"Product Name: {product.Name}, Price: {product.Price}");  
    }  
}

Entity Framework会负责将DbContext中的查询转换为SQL语句，并执行它，然后将结果映射回Product对象。

#2ORM：使用Dapper

Dapper是一个简单的对象映射器，它扩展了IDbConnection对象，提供了一个简单的方法来执行SQL查询并将结果映射到.NET对象。

步骤 1: 安装Dapper

通过NuGet包管理器安装Dapper。

Install-Package Dapper

步骤 2: 使用Dapper查询数据

与Entity Framework不同，Dapper不需要你定义DbContext或模型配置。你只需要有一个数据库连接和SQL查询。

using (var connection = new SqlConnection("你的数据库连接字符串"))  
{  
    connection.Open();  
  
    var sql = "SELECT * FROM Products WHERE Id = @Id";  
    var product = connection.QuerySingle<Product>(sql, new { Id = 1 }); // 假设ID为1的Product存在  
  
    if (product != null)  
    {  
        Console.WriteLine($"Product Name: {product.Name}, Price: {product.Price}");  
    }  
}

在这个例子中，QuerySingle方法用于执行查询并期望返回单个结果。如果查询结果匹配多个行，Dapper将抛出异常。如果查询结果为空，则返回null。

Dapper的Query方法则用于执行查询并返回结果的集合。

emm，这两个ORM框架都挺好的，看你咋用吧，网上都有参数手册，详细的各类库可以自己去找找哦！

#3 小例子

场景描述

假设我们有一个电商平台，其中包含了Product（产品）和Order（订单）两个实体。每个Order可以包含多个OrderDetail（订单详情），每个OrderDetail关联到一个特定的Product和该产品的购买数量。此外，每个Product都属于一个Category（类别）。

我们需要查询某个特定类别的所有产品，以及这些产品的所有订单详情和订单信息。

实体定义

public class Product  
{  
    public int Id { get; set; }  
    public string Name { get; set; }  
    public decimal Price { get; set; }  
    public int CategoryId { get; set; }  
    public Category Category { get; set; }  
  
    // 导航属性到OrderDetails  
    public ICollection<OrderDetail> OrderDetails { get; set; } = new List<OrderDetail>();  
}  
  
public class Category  
{  
    public int Id { get; set; }  
    public string Name { get; set; }  
  
    // 导航属性到Products  
    public ICollection<Product> Products { get; set; } = new List<Product>();  
}  
  
public class Order  
{  
    public int Id { get; set; }  
    public DateTime OrderDate { get; set; }  
  
    // 导航属性到OrderDetails  
    public ICollection<OrderDetail> OrderDetails { get; set; } = new List<OrderDetail>();  
}  
  
public class OrderDetail  
{  
    public int Id { get; set; }  
    public int OrderId { get; set; }  
    public int ProductId { get; set; }  
    public int Quantity { get; set; }  
  
    // 导航属性  
    public Order Order { get; set; }  
    public Product Product { get; set; }  
}  
  
// DbContext  
public class EcommerceDbContext : DbContext  
{  
    public DbSet<Product> Products { get; set; }  
    public DbSet<Category> Categories { get; set; }  
    public DbSet<Order> Orders { get; set; }  
    public DbSet<OrderDetail> OrderDetails { get; set; }  
  
    // 配置数据库连接等  
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)  
    {  
        optionsBuilder.UseSqlServer("你的数据库连接字符串");  
    }  
  
    // 可以在这里配置实体关系等  
}

复杂查询示例

使用Entity Framework Core的LINQ查询来获取特定类别的所有产品及其订单详情和订单信息。

using (var context = new EcommerceDbContext())  
{  
    var categoryId = 1; // 假设我们要查询的类别ID为1  
  
    var query = from product in context.Products  
                where product.CategoryId == categoryId  
                select new  
                {  
                    Product = product,  
                    OrderDetails = from orderDetail in product.OrderDetails  
                                   join order in context.Orders on orderDetail.OrderId equals order.Id  
                                   select new  
                                   {  
                                       OrderId = order.Id,  
                                       OrderDate = order.OrderDate,  
                                       ProductId = orderDetail.ProductId,  
                                       Quantity = orderDetail.Quantity  
                                   }  
                };  
  
    foreach (var item in query)  
    {  
        Console.WriteLine($"Product: {item.Product.Name}");  
        foreach (var detail in item.OrderDetails)  
        {  
            Console.WriteLine($"  Order ID: {detail.OrderId}, Date: {detail.OrderDate}, Quantity: {detail.Quantity}");  
        }  
    }  
}

请注意，上述示例中的select new语句用于创建匿名类型，它包含了所需的产品信息和相关的订单详情。在实际应用中，你可能会将这些信息映射到一个具体的DTO（数据传输对象）类中，以便在应用程序的不同层之间传递数据。

此外，对于更复杂的查询，如包含多层嵌套关系、分组、筛选等，Entity Framework Core的LINQ查询功能非常强大，能够处理几乎所有常见的数据库查询需求。

请点个赞+收藏+关注支持一下博主喵！！！

之后代码+资料全部发到github里，希望大家能关注一下咱的Github