1. 引言

Entity Framework (EF)是微软官方推出的.NET ORM框架，但.NET生态系统中还存在许多其他优秀的数据访问框架。本文将全面介绍EF的主要替代方案，包括Dapper、NHibernate、ServiceStack.OrmLite、LLBLGen Pro、PetaPoco等，深入分析它们的原理、架构设计、使用场景，并通过大量代码示例展示它们的实际应用。

2. Dapper

2.1 概述与设计原理

Dapper是由Stack Overflow团队开发的微型ORM框架，其核心设计理念是"轻量级"和"高性能"。与EF不同，Dapper不提供变更跟踪、延迟加载等复杂功能，而是专注于将SQL查询结果快速映射到对象。

Dapper的核心原理：

• 基于ADO.NET的扩展方法
• 动态生成IL代码实现高性能映射
• 无状态设计，不维护对象状态
• 直接使用SQL，不提供查询翻译层

2.2 核心功能与代码示例

基本查询

using var connection = new SqlConnection(connectionString);
var products = connection.Query<Product>("SELECT * FROM Products WHERE Price > @Price", 
    new { Price = 50 });

多映射查询

var sql = @"SELECT * FROM Orders o 
            INNER JOIN Customers c ON o.CustomerId = c.Id
            WHERE o.OrderDate > @Date";

var orders = connection.Query<Order, Customer, Order>(
    sql,
    (order, customer) => { order.Customer = customer; return order; },
    new { Date = DateTime.Now.AddDays(-30) },
    splitOn: "Id");

存储过程调用

var parameters = new DynamicParameters();
parameters.Add("@ProductId", 1);
parameters.Add("@Price", dbType: DbType.Decimal, direction: ParameterDirection.Output);

connection.Execute("sp_GetProductPrice", parameters, commandType: CommandType.StoredProcedure);

var price = parameters.Get<decimal>("@Price");

2.3 性能优化原理

Dapper的性能优势主要来自：

1. 动态编译：首次查询时会为特定类型生成优化的映射代码
2. 缓存机制：生成的映射代码会被缓存，避免重复编译
3. 最小化抽象：几乎不添加额外抽象层，直接操作ADO.NET

2.4 适用场景

• 需要极致性能的应用程序
• 已有良好SQL基础，希望直接控制SQL
• 简单CRUD操作为主的系统
• 微服务架构中的轻量级数据访问层

3. NHibernate

3.1 概述与架构设计

NHibernate是.NET平台上的成熟ORM框架，移植自Java的Hibernate。它提供了比EF更丰富的功能集和更灵活的配置选项。

NHibernate架构核心：

• ISession：工作单元模式的实现，管理对象生命周期
• 映射系统：支持XML、特性或Fluent配置
• 查询语言：HQL、Criteria API、LINQ
• 二级缓存：可插拔的缓存实现

3.2 映射配置示例

Fluent映射

public class ProductMap : ClassMap<Product>
{
    public ProductMap()
    {
        Id(x => x.Id);
        Map(x => x.Name);
        Map(x => x.Price);
        References(x => x.Category);
        HasMany(x => x.OrderItems)
            .Inverse()
            .Cascade.AllDeleteOrphan();
    }
}

XML映射

<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2">
    <class name="Product" table="Products">
        <id name="Id" column="ProductId">
            <generator class="identity"/>
        </id>
        <property name="Name" not-null="true"/>
        <property name="Price" type="decimal"/>
        <many-to-one name="Category" column="CategoryId"/>
        <bag name="OrderItems" inverse="true" cascade="all-delete-orphan">
            <key column="ProductId"/>
            <one-to-many class="OrderItem"/>
        </bag>
    </class>
</hibernate-mapping>

3.3 查询示例

HQL查询

var query = session.CreateQuery("FROM Product p WHERE p.Price > :price")
    .SetDecimal("price", 100m);
var products = query.List<Product>();

Criteria API

var products = session.CreateCriteria<Product>()
    .Add(Restrictions.Gt("Price", 100m))
    .AddOrder(Order.Asc("Name"))
    .SetMaxResults(10)
    .List<Product>();

LINQ提供程序

var products = session.Query<Product>()
    .Where(p => p.Price > 100m)
    .OrderBy(p => p.Name)
    .Take(10)
    .ToList();

3.4 高级特性

• 二级缓存：配置EhCache等实现
• 拦截器：实现IInterceptor自定义操作行为
• 事件系统：监听和处理持久化事件
• 批量处理：优化大批量数据操作

3.5 适用场景

• 复杂领域模型的企业应用
• 需要跨数据库平台的应用
• 已有Hibernate经验的团队
• 需要细粒度控制持久化行为的场景

4. ServiceStack.OrmLite

4.1 设计理念

ServiceStack.OrmLite是ServiceStack套件中的轻量级ORM，设计目标是提供简单、直观的API，同时保持高性能。它采用"约定优于配置"的原则，自动推断大部分映射关系。

核心特点：

• 基于POCO的无配置映射
• 支持多种数据库提供程序
• 简洁的LINQ-like API
• 与ServiceStack其他组件无缝集成

4.2 基本操作示例

配置与连接

var dbFactory = new OrmLiteConnectionFactory(
    connectionString, 
    SqlServerDialect.Provider);

using var db = dbFactory.Open();
db.CreateTableIfNotExists<Product>();

CRUD操作

// 插入
var product = new Product { Name = "iPad", Price = 499 };
db.Insert(product);
var id = product.Id; // 自动获取自增ID

// 查询
var expensiveProducts = db.Select<Product>(p => p.Price > 1000);

// 更新
product.Price = 449;
db.Update(product);

// 删除
db.Delete<Product>(p => p.Price < 100);

高级查询

var results = db.Select<Product>(q => 
    q.Where(p => p.Price > 100)
     .OrderBy(p => p.Name)
     .Limit(10, 5)); // 分页

4.3 特性与扩展

• 模式迁移：通过Migrate()方法处理数据库变更
• 复杂类型支持：JSON/XML序列化存储复杂属性
• 存储过程支持：通过SqlProc方法调用
• 多数据库支持：同一代码可运行在不同数据库上

4.4 适用场景

• 使用ServiceStack构建的Web服务
• 需要简单快速开发的应用程序
• 偏好简洁API的项目
• 需要支持多种数据库的项目

5. LLBLGen Pro

5.1 框架概述

LLBLGen Pro是商业ORM框架，以其强大的设计器和高效运行时著称。它提供三种工作模式：

1. Adapter模式：类似传统ADO.NET的工作方式
2. SelfServicing模式：类似EF的主动记录模式
3. Entity Framework集成：作为EF提供程序

5.2 设计器与代码生成

LLBLGen Pro的核心是其可视化设计器，可以：

• 逆向工程现有数据库
• 设计实体关系模型
• 生成高度优化的数据访问代码
• 自定义模板控制生成结果

5.3 查询示例

Adapter模式

var adapter = new DataAccessAdapter();
var products = new EntityCollection<ProductEntity>();
var filter = (ProductFields.Price > 100m) & ProductFields.Name.Contains("Pro");
adapter.FetchEntityCollection(products, filter);

LINQ查询

var metaData = new LinqMetaData(adapter);
var query = from p in metaData.Product
            where p.Price > 100m
            orderby p.Name
            select p;
var results = query.ToList();

5.4 性能优化技术

LLBLGen Pro采用多种优化技术：

• 预编译查询计划
• 智能批处理
• 高效的变更跟踪
• 可配置的获取策略

5.5 适用场景

• 大型企业应用程序
• 已有复杂数据库结构的项目
• 需要可视化设计工具支持的团队
• 对性能有极高要求的场景

6. PetaPoco

6.1 微型ORM设计

PetaPoco是极简风格的ORM，核心只有一个C#文件。它提供自动POCO映射和基本的CRUD操作，同时支持原始SQL查询。

设计特点：

• 超轻量级（单个.cs文件）
• 自动POCO映射
• 智能参数绑定
• 简单分页支持

6.2 基本用法

var db = new Database("connectionString");

// 查询单个对象
var product = db.SingleOrDefault<Product>("SELECT * FROM Products WHERE Id=@0", 1);

// 查询列表
var products = db.Query<Product>("SELECT * FROM Products WHERE Price>@0", 50);

// 插入
var newProduct = new Product { Name = "New Product", Price = 99.99m };
db.Insert(newProduct);

// 分页
var page = db.Page<Product>(2, 10, "SELECT * FROM Products ORDER BY Name");

6.3 高级特性

• T4模板支持：生成强类型POCO
• 多结果集查询：处理存储过程的多个结果集
• 事务支持：简单的事务API
• 异步操作：全面的异步方法支持

6.4 适用场景

• 小型到中型项目
• 需要简单ORM功能的应用程序
• 资源受限的环境
• 快速原型开发

7. RepoDB

7.1 混合ORM设计

RepoDB是Dapper的替代品，结合了微型ORM和完整ORM的特性。它提供：

• 基于ADO.NET的原始性能
• 丰富的CRUD操作
• 批量操作和缓存支持
• 可扩展的映射系统

7.2 核心操作

基本CRUD

// 插入
var product = new Product { Name = "RepoDemo", Price = 49.99m };
var id = connection.Insert<Product, int>(product);

// 查询
var result = connection.Query<Product>(p => p.Price > 10m).ToList();

// 更新
product.Price = 59.99m;
connection.Update(product);

// 删除
connection.Delete<Product>(p => p.Name == "RepoDemo");

批量操作

var products = new List<Product>();
// 填充products...
connection.InsertAll(products);

7.3 性能特性

• 批处理：合并多个操作到单个调用
• 缓存：内置查询结果缓存
• 预编译：动态编译和缓存表达式树
• 混合模式：混合使用原始SQL和LINQ

7.4 适用场景

• 需要比Dapper更多功能但仍需高性能的项目
• 大量批处理操作的应用程序
• 需要灵活查询方式的场景

8. 框架比较与选型指南

8.1 功能对比表

特性	EF Core	Dapper	NHibernate	OrmLite	LLBLGen Pro	PetaPoco	RepoDB
变更跟踪	✓	✗	✓	✗	✓	✗	✗
LINQ支持	✓	✗	✓	有限	✓	✗	有限
延迟加载	✓	✗	✓	✗	✓	✗	✗
原始SQL	有限	✓	✓	✓	✓	✓	✓
二级缓存	扩展	✗	✓	✗	✓	✗	✓
迁移工具	✓	✗	扩展	有限	✓	✗	✗
性能	中等	高	中等	高	高	高	高
学习曲线	中等	低	高	低	高	低	中等

8.2 性能基准

以下是各框架在常见操作上的相对性能比较（数值越小越好）：

操作	EF Core	Dapper	NHibernate	OrmLite	LLBLGen Pro	PetaPoco	RepoDB
单对象查询	1.2x	1.0x	1.5x	1.1x	1.1x	1.0x	1.0x
多对象查询(20)	1.3x	1.0x	1.6x	1.2x	1.2x	1.1x	1.1x
插入单对象	1.4x	1.0x	1.8x	1.1x	1.2x	1.0x	1.0x
批量插入(1000)	2.0x	1.2x	2.2x	1.3x	1.1x	1.2x	1.0x
复杂查询	1.5x	1.0x	1.7x	1.4x	1.3x	1.1x	1.1x

8.3 选型建议

1. 企业级复杂应用：

   • 首选：NHibernate或LLBLGen Pro
   • 理由：功能全面，支持复杂领域模型，有良好的工具支持

2. 高性能Web应用：

   • 首选：Dapper或RepoDB
   • 理由：接近原生ADO.NET的性能，适合大量简单查询

3. 快速开发中小型项目：

   • 首选：ServiceStack.OrmLite或PetaPoco
   • 理由：简单易用，开发效率高

4. 微服务架构：

   • 首选：Dapper或EF Core
   • 理由：Dapper适合简单服务，EF Core适合需要迁移和复杂查询的服务

5. 已有复杂数据库的项目：

   • 首选：LLBLGen Pro或NHibernate
   • 理由：强大的逆向工程和复杂查询支持

9. 高级主题与最佳实践

9.1 混合使用多个ORM

在实际项目中，可以混合使用多个ORM框架以发挥各自优势。例如：

// 使用Dapper处理大量简单查询
public IEnumerable<Product> GetFeaturedProducts()
{
    using var conn = new SqlConnection(_config.GetConnectionString("Default"));
    return conn.Query<Product>("SELECT TOP 10 * FROM Products WHERE IsFeatured=1");
}

// 使用EF Core处理复杂领域逻辑
public void UpdateProductInventory(int productId, int adjustment)
{
    using var context = new AppDbContext();
    var product = context.Products
        .Include(p => p.Inventory)
        .FirstOrDefault(p => p.Id == productId);
    
    product.Inventory.Stock += adjustment;
    product.Inventory.LastUpdated = DateTime.UtcNow;
    
    context.SaveChanges();
}

9.2 性能优化技巧

1. Dapper优化：

   • 使用Buffered=false处理大量数据
   • 预编译参数化查询
   • 合理使用多映射

2. NHibernate优化：

   • 配置适当的抓取策略
   • 使用二级缓存
   • 批处理写操作

3. 通用优化：

   • 限制查询字段（避免SELECT *）
   • 合理使用分页
   • 异步操作

9.3 事务管理

各框架的事务处理示例：

Dapper事务

using var connection = new SqlConnection(connectionString);
connection.Open();

using var transaction = connection.BeginTransaction();
try
{
    connection.Execute("INSERT INTO Orders...", parameters, transaction);
    connection.Execute("UPDATE Inventory...", parameters, transaction);
    
    transaction.Commit();
}
catch
{
    transaction.Rollback();
    throw;
}

NHibernate事务

using var session = sessionFactory.OpenSession();
using var transaction = session.BeginTransaction();
try
{
    session.Save(order);
    session.Update(inventory);
    
    transaction.Commit();
}
catch
{
    transaction.Rollback();
    throw;
}

9.4 迁移策略

从EF迁移到其他ORM的注意事项：

1. 数据模型调整：可能需要修改实体类以符合目标ORM约定
2. 查询重写：LINQ查询可能需要转换为SQL或其他查询语法
3. 事务处理：理解不同ORM的事务边界
4. 性能测试：迁移后进行全面性能测试

10. 结论

.NET生态系统提供了丰富的ORM选择，从全功能的NHibernate到超轻量级的PetaPoco，各有其适用场景。选择ORM时应考虑：

1. 项目复杂度：简单项目适合微型ORM，复杂领域模型需要全功能ORM
2. 团队技能：考虑团队对不同ORM的熟悉程度
3. 性能需求：高性能需求可能倾向Dapper等轻量方案
4. 长期维护：评估框架的活跃度和社区支持

无论选择哪个框架，理解其底层原理和正确使用模式都是实现高效数据访问的关键。建议从简单需求开始，随着项目复杂度增加逐步评估是否需要更强大的ORM功能。