轻量级ORM-Fluentdata入门

Fluent Data 入门

由 Primates 根据互联网资源整理FluentData 是微型 ORM（micro-ORM）家族的一名新成员，旨在比大型 ORM（full ORM）更加易用。FluentData 于本月推出，它使用 fluent API 并支持 SQL Server、SQL Azure、Oracle和 MYSQL。

FluentData 的设计者 Lars-Erik Kindblad 谈到：

当前市面上的 ORM 框架，如 Entity Framework 和 NHibernate，都过于复杂而且难于学习。此外，由于这些框架自身抽象的查询语言以及从数据库到.NET 对象的映射太过麻烦，导致它们生成的 SQL 都很低效。FluentData 另辟蹊径，它是一个轻量级框架，拥有简单的 fluent API 并且很容易学会。与其他微型 ORM（如 Dapper 和 Massive）类似，FluentData 关注性能和易用性。它允许开发人员拥有对 SQL 较多的控制，而不是依赖 ORM 进行自动生成。它不仅可以使用 SQL 来执行查询、增添和更新操作，还可以支持使用存储过程和事务。根据文档描述，FluentData 可以在不改动已有结构的情况下，与任何业务对象一同工作。

以下是 FluentData 的一些其他特性：

• 多结果集（Multiple Result Set）：在一次数据库操作下返回多个数据集；
• 开发人员可使用强类型对象或动态对象；
• 可为创建时需要特殊处理的复杂对象自定义实体工厂（Custom Entity Factory）；
• 具有添加其他数据库支持的能力。

FluentData 需要 .NET 4.0，并支持 SQL Server、SQL Azure、SQL Server Compact 以及使用 .NET 驱动的 Oracle 和 MySQL。 想要了解进一步信息，如代码示例和免费下载，请访问CodePlex 站点上的 FluentData

二 创建 DbContext

初始化一个 DbContext

可以在*.config 文件中配置 connection string，将 connection string name 或者将整个 connection string作为参数传递给 DbContext 来创建 DbContext。

重要配置

IgnoreIfAutoMapFails – IDbContext.IgnoreIfAutoMapFails 返回一个 IDbContext，该实例中，如果自动映射失败时是否抛出异常

　　通过*.config 中配置的 ConnectionStringName 创建一个 DbContext

1： public IDbContext Context()

2： {

3：　　return new DbContext().ConnectionStringName("MyDatabase",

4：　　　　new SqlServerProvider());

5： }

　　调用 DbContext 的 ConnectionString 方法显示设置 connection string 来创建

1： public IDbContext Context()

2： {

3：　　return new DbContext().ConnectionString(

4：　　　　"Server=MyServerAddress;Database=MyDatabase;Trusted_Connection=True;", new SqlServerProvider());

5： }

　　其他可以使用的 Provider

　　只有通过使用不同的 Provider，就可以切换到不同类型的数据库服务器上，比如

　　AccessProvider, DB2Provider, OracleProvider, MySqlProvider, PostgreSqlProvider, SqliteProvider,SqlServerCompact, SqlAzureProvider, SqlServerProvider。

三 查询（Query）

返回单个对象

　　返回一个 dynamic 对象

1： dynamic product = Context.Sql(@"select * from Product where ProductId = 1").QuerySingle<dynamic>();

　　返回一个强类型对象：

1： Product product = Context.Sql(@"select * from Product where ProductId = 1").QuerySingle<Product>();

　　返回一个 DataTable：

1： DataTable products = Context.Sql("select * from Product").QuerySingle<DataTable>();

其 实 QueryMany<DataTable> 和 QuerySingle<DataTable> 都 可 以 用 来 返 回 DataTable ， 但 考 虑 到QueryMany<DataTable>返回的是List<DataTable>，所以使用 QuerySingle<DataTable>来返回 DataTable 更方便。

　　查询一个标量值

1： int numberOfProducts = Context.Sql(@"select count(*) from Product").QuerySingle<int>();

返回一组数据

　　返回一组 dynamic 对象(new in .NET 4.0)

1： List<dynamic> products = Context.Sql("select * from Product").QueryMany<dynamic>();

　　返回一组强类型对象

1： List<Product> products = Context.Sql("select * from Product").QueryMany<Product>();

　　返回一个自定义的 Collection

1： ProductionCollection products = Context.Sql("select * from Product").QueryMany<Product,ProductionCollection>();

　　返回一组标量值

1： List<int> productIds = Context.Sql(@"select ProductId from Product").QueryMany<int>();

参数化查询

　　索引顺序形式的参数

1： dynamic products = Context.Sql(@"select * from Product where ProductId = @0 or ProductId = @1", 1,

2).QueryMany<dynamic>();

　　或者

1： dynamic products = Context.Sql(@"select * from Product where ProductId = @0 or ProductId =

@1").Parameters(1, 2).QueryMany<dynamic>();

　　名字形式的参数：

1： var command = Context.Sql(@"select @ProductName = Name from Product where ProductId=1")

2：　　　　.ParameterOut("ProductName", DataTypes.String, 100);

3： command.Execute();

4： string productName = command.ParameterValue<string>("ProductName");

5： List of parameters - in operator：

6： List<int> ids = new List<int>() { 1, 2, 3, 4 };

7： dynamic products = Context.Sql(@"select * from Product

8：　　　　where ProductId in(@0)", ids).QueryMany<dynamic>();

　　Output 参数：

1： dynamic products = Context.Sql(@"select * from Product

2：　　where ProductId = @ProductId1 or ProductId = @ProductId2")

3：　　.Parameter("ProductId1", 1)

4：　　.Parameter("ProductId2", 2)

5：　　.QueryMany<dynamic>();

四 映射（Mapping）

自动映射

　　在数据库对象和.Net object 自动进行1：1匹配

1： List<Product> products = Context.Sql(@"select * from Product").QueryMany<Product>();

　　自动映射到一个自定义的 Collection：

1： ProductionCollection products = Context.Sql("select * from Product").QueryMany<Product,ProductionCollection>();

　　如果数据库字段和 POCO 类属性名不一致，使用 SQL 别名语法 AS：

1： List<Product> products = Context.Sql(@"select p.*,

2：　　c.CategoryId as Category_CategoryId,

3：　　c.Name as Category_Name

4：　　from Product p

5：　　inner join Category c on p.CategoryId = c.CategoryId")

6：　　　　.QueryMany<Product>();

在这里 p.*中的 ProductId 和 ProductName 会自动映射到 Prodoct.ProductId 和 Product.ProductName，而Category_CategoryId 和Category_Name 将 映 射 到Product.Category.CategoryId 和Product.Category.Name.

　　使用 dynamic 自定义映射规则

1： List<Product> products = Context.Sql(@"select * from Product")

2：　　.QueryMany<Product>(Custom_mapper_using_dynamic);

3：

4： public void Custom_mapper_using_dynamic(Product product, dynamic row)

5： {

6：　　product.ProductId = row.ProductId;

7：　　product.Name = row.Name;

8： }

　　使用 datareader 进行自定义映射：

1： List<Product> products = Context.Sql(@"select * from Product")

2：.QueryMany<Product>(Custom_mapper_using_datareader);

4： public void Custom_mapper_using_datareader(Product product, IDataReader row)

5： {

6：　　product.ProductId = row.GetInt32("ProductId");

7：　　product.Name = row.GetString("Name");

8： }

　　或者，当你需要映射到一个复合类型时，可以使用 QueryComplexMany 或者 QueryComplexSingle。

1： var products = new List<Product>();

2： Context.Sql("select * from Product").QueryComplexMany<Product>(products, MapComplexProduct);

3：

4： private void MapComplexProduct(IList<Product> products, IDataReader reader)

5： {

6：　　var product = new Product();

7：　　product.ProductId = reader.GetInt32("ProductId");

8：　　product.Name = reader.GetString("Name");

9：　　products.Add(product);

10： }

五 多结果集

FluentData 支持多结果集。也就是说，可以在一次数据库查询中返回多个查询结果。使用该特性的时候，记得使用类似下面的语句对查询语句进行包装。需要在查询结束后把连接关闭。

1： using (var command = Context.MultiResultSql)

2： {

3：　　List<Category> categories = command.Sql(

4：　　　　@"select * from Category;

5：　　　　select * from Product;").QueryMany<Category>();

6：

7：　　List<Product> products = command.QueryMany<Product>();

8： }

执行第一个查询时，会从数据库取回数据，执行第二个查询的时候，FluentData 可以判断出这是一个多结果集查询，所以会直接从第一个查询里获取需要的数据.

六 分页

1： List<Product> products = Context.Select<Product>("p.*, c.Name as Category_Name")

2：　　.From(@"Product p

3：　　inner join Category c on c.CategoryId = p.CategoryId")

4：　　.Where("p.ProductId > 0 and p.Name is not null")

5：　　.OrderBy("p.Name")

6：　　.Paging(1, 10).QueryMany();

调用 Paging(1, 10)，会返回最先检索到的10个 Product

七 数据库操作（Insert, Update, Delete）

插入数据

　　使用 SQL 语句：

1： int productId = Context.Sql(@"insert into Product(Name, CategoryId)

2：　　values(@0, @1);")

3：　　.Parameters("The Warren Buffet Way", 1)

4：　　.ExecuteReturnLastId<int>();

　　使用 builder：

1： int productId = Context.Insert("Product")

2：　　.Column("Name", "The Warren Buffet Way")

3：　　.Column("CategoryId", 1)

4：　　.ExecuteReturnLastId<int>();

　　使用 builder，并且自动映射

1： Product product = new Product();

2： product.Name = "The Warren Buffet Way";

3： product.CategoryId = 1;

4：

5： product.ProductId = Context.Insert<Product>("Product", product)

6：　　.AutoMap(x => x.ProductId)

7：　　.ExecuteReturnLastId<int>();

将 ProductId 作为 AutoMap 方法的参数，是要指明 ProductId 不需要进行映射，因为它是一个数据库自增长字段。

更新数据

　　使用 SQL 语句：

1： int rowsAffected = Context.Sql(@"update Product set Name = @0 where ProductId = @1")

2：　　.Parameters("The Warren Buffet Way", 1)

3：　　.Execute();

　　使用 builder：

1： int rowsAffected = Context.Update("Product")

2：　　.Column("Name", "The Warren Buffet Way")

3：　　.Where("ProductId", 1)

4：　　.Execute();

使用 builder，并且自动映射：

1： Product product = Context.Sql(@"select * from Product

2：　　where ProductId = 1")

3：　　.QuerySingle<Product>();

4： product.Name = "The Warren Buffet Way";

5：

6： int rowsAffected = Context.Update<Product>("Product", product)

7：　　.AutoMap(x => x.ProductId)

8：　　.Where(x => x.ProductId)

9：　　.Execute();

　　将 ProductId 作为 AutoMap 方法的参数，是要指明 ProductId 不需要进行映射，因为它不需要被更新。

　　Insert and update - common Fill method

1： var product = new Product();

2： product.Name = "The Warren Buffet Way";

3： product.CategoryId = 1;

4：

5： var insertBuilder = Context.Insert<Product>("Product", product).Fill(FillBuilder);

6：

7： var updateBuilder = Context.Update<Product>("Product", product).Fill(FillBuilder);

8：

9： public void FillBuilder(IInsertUpdateBuilder<Product> builder)

10： {

11：　　builder.Column(x => x.Name);

12：　　builder.Column(x => x.CategoryId);

13： }

14：

15： Delete

删除数据

　　使用 SQL 语句：

1： int rowsAffected = Context.Sql(@"delete from Product

2：　　where ProductId = 1")

3：　　.Execute();

　　使用 builder：

1： int rowsAffected = Context.Delete("Product").Where("ProductId", 1)

2：　　.Execute();

八存储过程和事物

存储过程

　　使用 SQL 语句：

1： var rowsAffected = Context.Sql("ProductUpdate")

2：　　.CommandType(DbCommandTypes.StoredProcedure)

3：　　.        Parameter("ProductId", 1)

4：　　.Parameter("Name", "The Warren Buffet Way")

5：　　.Execute();

　　使用 builder：

1： var rowsAffected = Context.StoredProcedure("ProductUpdate")

2：　　.Parameter("Name", "The Warren Buffet Way")

3：　　.Parameter("ProductId", 1).Execute();

　　使用 builder，并且自动映射

1： var product = Context.Sql("select * from Product where ProductId = 1")

2：　　　　.QuerySingle<Product>();

3：

4： product.Name = "The Warren Buffet Way";

5：

6： var rowsAffected = Context.StoredProcedure<Product>("ProductUpdate", product)

7：　　.AutoMap(x => x.CategoryId).Execute();

　　使用 Lambda 表达式

1： var product = Context.Sql("select * from Product where ProductId = 1")

2：　　　　.QuerySingle<Product>();

3： product.Name = "The Warren Buffet Way";

4：

5： var rowsAffected = Context.StoredProcedure<Product>("ProductUpdate", product)

6：　　.Parameter(x => x.ProductId)

7：　　.Parameter(x => x.Name).Execute();

事务

　　FluentData 支持事务。如果使用事务，最好使用 using 语句将代码包起来，已保证连接会被关闭。默认的，如果查询过程发生异常，如事务不会被提交，会进行回滚。

1： using (var context = Context.UseTransaction(true))

2： {

3：　　context.Sql("update Product set Name = @0 where ProductId = @1")

4：　　　　.Parameters("The Warren Buffet Way", 1)

5：　　.Execute();

6：

7：　　context.Sql("update Product set Name = @0 where ProductId = @1")

8：　　　　.Parameters("Bill Gates Bio", 2)

9：　　　　.Execute();

10：

11：　　context.Commit();

12： }

13：

实体工厂

实体工厂负责在自动映射的时候生成 POCO 实例。如果需要生成复杂的实例，可以自定义实体工厂：

1： List<Product> products = Context.EntityFactory(new CustomEntityFactory())

2：　　.Sql("select * from Product")

3：　　.QueryMany<Product>();

4：

5： public class CustomEntityFactory ： IEntityFactory

6： {

7：　　public virtual object Resolve(Type type)

8：　　{

9：　　　　return Activator.CreateInstance(type);

10：　　}

11： }