FluentData，它是一个轻量级框架，关注性能和易用性。

http://www.cnblogs.com/zengxiangzhan/p/3250105.html

FluentData，它是一个轻量级框架，关注性能和易用性。

利用T4模板，【MultipleOutputHelper.ttinclude】批量生成多文件

基本语法：

1. 初始化：获取MultipleOutputHelper.ttinclude文件模板在T4模板导入

  //导入MultipleOutputHelper.ttinclude文件 路径

      <#@include file="$(SolutionDir)\ORM.Model\T4\MultipleOutputHelper.ttinclude"#>

  //初始化Manager对象

      var manager = Manager.Create(Host, GenerationEnvironment);

2.文件块：使用代码标识区分生成的代码块的范围
          manager.StartNewFile(tb_name+".cs");
         //代码块
         manager.EndBlock();

3.编译执行：使用Process方法，进行文件分割

 manager.Process(true);

实践：

1.批量生成实体类

<#@ template debug="false" hostspecific="true" language="C#" #>

<#@ assembly name="System.Data" #>

<#@ assembly name="System.xml" #>

<#@ import namespace="System.Collections.Generic" #>

<#@ import namespace="System.Data.SqlClient" #>

<#@ import namespace="System.Data" #>

<#@ assembly name="System.Core" #>

<#@ import namespace="System.Linq" #>

//  导入MultipleOutputHelper.ttinclude文件

<#@include file="$(SolutionDir)\My.Model\T4\MultipleOutputHelper.ttinclude"#> 

<#

        string connectionString= "server=qq;database=db;uid=sa;pwd=sa;";

        SqlConnection conn = new SqlConnection(connectionString);

        conn.Open();

        string selectQuery ="SET FMTONLY ON; select * from @tableName; SET FMTONLY OFF;";

        SqlCommand command = new SqlCommand(selectQuery,conn);

        SqlDataAdapter ad = new SqlDataAdapter(command);

        System.Data.DataSet ds = new DataSet(); 

        var manager = Manager.Create(Host, GenerationEnvironment);  

        System.Data.DataTable schema = conn.GetSchema("Tables");

        foreach(System.Data.DataRow row in schema.Rows)

        {

            ds.Tables.Clear();

            string tb_name= row["TABLE_NAME"].ToString();

            command.CommandText = selectQuery.Replace("@tableName",row["TABLE_NAME"].ToString());

            ad.FillSchema(ds, SchemaType.Mapped,tb_name);

            manager.StartNewFile(tb_name+".cs");#>

using FluentData;

using System;

using System.Collections.Generic;

namespace My.Model

{

    /// <summary>

    /// 实体-<#=tb_name#>

    /// </summary>

    public partial class <#=tb_name#>

    {

        <#

        PushIndent("          ");

        foreach (DataColumn dc in ds.Tables[0].Columns)

        {

            WriteLine("public " + dc.DataType.Name+ (dc.AllowDBNull && dc.DataType.Name.ToLower() != "string" ? "? ": " ") + dc.ColumnName + " { get; set; }");

        }

        PopIndent();

        #>

    }

}

<#

        manager.EndBlock();

         }

        conn.Close();

       manager.Process(true);

        #>

2.批量生成基础业务逻辑

<#@ template debug="false" hostspecific="true" language="C#" #>

<#@ assembly name="System.Data" #>

<#@ assembly name="System.xml" #>

<#@ import namespace="System.Collections.Generic" #>

<#@ import namespace="System.Data.SqlClient" #>

<#@ import namespace="System.Data" #>

<#@ assembly name="System.Core" #>

<#@ import namespace="System.Linq" #>

//  导入MultipleOutputHelper.ttinclude文件

<#@include file="$(SolutionDir)\MY.Model\T4\MultipleOutputHelper.ttinclude"#> 

<#

        string connectionString= "server=QQ;database=DB;uid=sa;pwd=sa;";

        SqlConnection conn = new SqlConnection(connectionString);

        conn.Open();

        string selectQuery ="SET FMTONLY ON; select * from @tableName; SET FMTONLY OFF;";

        SqlCommand command = new SqlCommand(selectQuery,conn);

        SqlDataAdapter ad = new SqlDataAdapter(command);

        System.Data.DataSet ds = new DataSet(); 

        var manager = Manager.Create(Host, GenerationEnvironment);  

        System.Data.DataTable schema = conn.GetSchema("Tables");

        foreach(System.Data.DataRow row in schema.Rows)

        {

            ds.Tables.Clear();

            string tb_name= row["TABLE_NAME"].ToString();

            command.CommandText = selectQuery.Replace("@tableName",row["TABLE_NAME"].ToString());

            ad.FillSchema(ds, SchemaType.Mapped,tb_name);

            manager.StartNewFile(tb_name+"Action.cs");#>

using System;

using System.Collections.Generic;

using MY.Model;

using FluentData;

namespace MY.BLL

{    

    /// <summary>

    /// <#=tb_name#> 操作类

    /// </summary>

    public partial class <#=tb_name#>Action

    {<#

        string fkQuery = " SELECT f.name AS ForeignKey,";

        fkQuery += " OBJECT_NAME(f.parent_object_id) AS TableName, ";

        fkQuery += " COL_NAME(fc.parent_object_id, fc.parent_column_id) AS ColumnName, ";

        fkQuery += " OBJECT_NAME (f.referenced_object_id) AS ReferenceTableName, ";

        fkQuery += " COL_NAME(fc.referenced_object_id, fc.referenced_column_id) AS ReferenceColumnName ";

        fkQuery += " FROM ";

        fkQuery += " sys.foreign_keys AS f ";

        fkQuery += " INNER JOIN sys.foreign_key_columns AS fc ON f.OBJECT_ID = fc.constraint_object_id ";

        fkQuery += " where OBJECT_NAME(f.parent_object_id) = '" +tb_name +"'";

        List<string> fkColumnNames = new List<string>();

        Dictionary<string, string> parentTables = new Dictionary<string, string>();

        SqlCommand command2 = new SqlCommand(fkQuery,conn);

        using(var dr = command2.ExecuteReader())

        {

            while(dr.Read())

            {

                fkColumnNames.Add(dr["ColumnName"].ToString());

                parentTables.Add(dr["ColumnName"].ToString(), dr["ReferenceTableName"].ToString());

            }

            dr.Close();

        }

        List<DataColumn> fkColumns = new List<DataColumn>();

        foreach(string fkColumnName in fkColumnNames)

        {

            foreach (DataColumn dc in ds.Tables[0].Columns)

            {

                if(dc.ColumnName == fkColumnName)

                    fkColumns.Add(dc);

            }

        }

        List<string> primaryKeyParamsWithTypes = new List<string>();

        List<string> primaryKeyParams = new List<string>();

        List<string> whereItems = new List<string>();

        List<string> automapItems = new List<string>();

        foreach(DataColumn pk in ds.Tables[0].PrimaryKey)

        {

            primaryKeyParamsWithTypes.Add(string.Format("{0} {1}", pk.DataType.Name, this.ToCamelCase(pk.ColumnName)));

            primaryKeyParams.Add(pk.ColumnName);

            whereItems.Add(string.Format("{0} = @{1}", pk.ColumnName, pk.ColumnName.ToLower()));

            automapItems.Add(string.Format("x.{0}", pk.ColumnName));

        }

        string updateAutomap = string.Empty;

    if(automapItems.Count > 0){

        if(automapItems.Count > 1)

            updateAutomap = "new { " + string.Join(", ", automapItems.ToArray()) + " }";

        else

            updateAutomap = automapItems[0];

            }

        #>

        public static <#=tb_name#> Select(<#=string.Join(", ", primaryKeyParamsWithTypes.ToArray())#>)

        {

            using(var context = db.Context())

            {

                return context.Sql(" SELECT * FROM <#=tb_name#> WHERE <#=string.Join(" AND ", whereItems.ToArray())#> ")

                    <#foreach(string pkp in primaryKeyParams)

                    {

                        WriteLine(".Parameter(\"" + pkp.ToLower() + "\", " + this.ToCamelCase(pkp) + ")");

                    }

                    #>

                    .QuerySingle<<#=tb_name#>>();

            }

        }

        public static List<<#=tb_name#>> SelectAll()

        {

            return SelectAll(string.Empty);

        }

        public static List<<#=tb_name#>> SelectAll(string sortExpression)

        {

            return SelectAll(0, 0, sortExpression);

        }

        public static List<<#=tb_name#>> SelectAll(int startRowIndex, int maximumRows, string sortExpression)

        {

            using (var context = db.Context())

            {

                var select = context.Select<<#=tb_name#>>(" * ")

                    .From(" <#=tb_name#> ");

                if (maximumRows > 0)

                {

                    if (startRowIndex == 0)

                        startRowIndex = 1;

                    select.Paging(startRowIndex, maximumRows);

                }

                if (!string.IsNullOrEmpty(sortExpression))

                    select.OrderBy(sortExpression);

                return select.QueryMany();

            }

        }

        public static int CountAll()

        {

            using (var context = db.Context())

            {

                return context.Sql(" SELECT COUNT(*) FROM <#=tb_name#> ")

                    .QuerySingle<int>();

            }

        }

        <#

        foreach(DataColumn dc in fkColumns)

        {

        #>

        public static List<<#=tb_name#>> SelectBy<#=parentTables[dc.ColumnName]#>(<#=dc.DataType.Name#> <#=this.ToCamelCase(dc.ColumnName)#>)

        {

            return SelectBy<#=parentTables[dc.ColumnName]#>(<#=this.ToCamelCase(dc.ColumnName)#>, string.Empty);

        }

        public static List<<#=tb_name#>> SelectBy<#=parentTables[dc.ColumnName]#>(<#=dc.DataType.Name#> <#=this.ToCamelCase(dc.ColumnName)#>, string sortExpression)

        {

            return SelectBy<#=parentTables[dc.ColumnName]#>(<#=this.ToCamelCase(dc.ColumnName)#>, 0, 0, sortExpression);

        }

        public static List<<#=tb_name#>> SelectBy<#=parentTables[dc.ColumnName]#>(<#=dc.DataType.Name#> <#=this.ToCamelCase(dc.ColumnName)#>, int startRowIndex, int maximumRows, string sortExpression)

        {

            using (var context = db.Context())

            {

                var select = context.Select<<#=tb_name#>>(" * ")

                    .From(" <#=tb_name#> ")

                    .Where(" <#=dc.ColumnName#> = @<#=dc.ColumnName.ToLower()#> ")

                    .Parameter("<#=dc.ColumnName.ToLower()#>", <#=this.ToCamelCase(dc.ColumnName)#>);

                if (maximumRows > 0)

                {

                    if (startRowIndex == 0)

                        startRowIndex = 1;

                    select.Paging(startRowIndex, maximumRows);

                }

                if (!string.IsNullOrEmpty(sortExpression))

                    select.OrderBy(sortExpression);

                return select.QueryMany();

            }

        }

        public static int CountBy<#=parentTables[dc.ColumnName]#>(<#=dc.DataType.Name#> <#=this.ToCamelCase(dc.ColumnName)#>)

        {

            using (var context = db.Context())

            {

                return context.Sql(" SELECT COUNT(*) FROM <#=tb_name#> WHERE <#=dc.ColumnName#> = @<#=dc.ColumnName.ToLower()#>")

                    .Parameter("<#=dc.ColumnName.ToLower()#>", <#=this.ToCamelCase(dc.ColumnName)#>)

                    .QuerySingle<int>();

            }

        }

        <#}#>

<#if(ds.Tables[0].PrimaryKey != null && ds.Tables[0].PrimaryKey.Length == 1 && ds.Tables[0].PrimaryKey[0].AutoIncrement) {#>

        public static bool Insert(<#=tb_name#> <#=this.ToCamelCase(tb_name)#>)

        {

            using (var context = db.Context())

            {

                int id = context.Insert<<#=tb_name#>>("<#=tb_name#>", <#=this.ToCamelCase(tb_name)#>)

                    .AutoMap(x => x.<#=primaryKeyParams[0]#>)

                    .ExecuteReturnLastId<int>();

                <#=this.ToCamelCase(tb_name)#>.<#=primaryKeyParams[0]#> = id;

                return id > 0;

            }

        }

<#

}

else

{

#>

        public static bool Insert(<#=tb_name#> <#=this.ToCamelCase(tb_name)#>)

        {

            using (var context =db.Context())

            {

                return context.Insert<<#=tb_name#>>("<#=tb_name#>", <#=this.ToCamelCase(tb_name)#>)

                    .Execute() > 0;

            }

        }

<#}#>

        public static bool Update(<#=tb_name#> <#=this.ToCamelCase(tb_name)#>)

        {

            using (var context = db.Context())

            {

                return context.Update<<#=tb_name#>>("<#=tb_name#>", <#=this.ToCamelCase(tb_name)#>)

                    .AutoMap(x => <#=updateAutomap#>)

                    <#foreach(string pkp in primaryKeyParams){#>

                    .Where("<#=pkp#>", <#=this.ToCamelCase(tb_name)#>.<#=pkp#>)

                    <#}#>

                    .Execute() > 0;

            }

        }

        public static bool Delete(<#=tb_name#> <#=this.ToCamelCase(tb_name)#>)

        {

            return Delete(<#=string.Join(", ", primaryKeyParams.Select(x=> this.ToCamelCase(tb_name) + "." + x).ToArray())#>);

        }

        public static bool Delete(<#=string.Join(", ", primaryKeyParamsWithTypes.ToArray())#>)

        {

            using (var context = db.Context())

            {

                return context.Sql(" DELETE FROM Product WHERE <#=string.Join(" AND ", whereItems.ToArray())#> ")

                    <#foreach(string pkp in primaryKeyParams) {

                        WriteLine(".Parameter(\"" + pkp.ToLower() + "\", " + this.ToCamelCase(pkp) + ")");

                    }#>

                    .Execute() > 0;

            }

        }

    }

}

<#

        manager.EndBlock();

         }

        conn.Close();

       manager.Process(true);

        #> 

<#+

    public string ToCamelCase(string value)

    {

        if(string.IsNullOrEmpty(value))

            return string.Empty;

        string firstLetter = value.Substring(0, 1);

        string rest = value.Substring(1, value.Length - 1);

        return firstLetter.ToLower() + rest;

    }

#>

CTRL+S 自动生成

下载地址：FlunenData.Model

完成！即可快速开发了！

FluentData，它是一个轻量级框架，关注性能和易用性。的更多相关文章

如何评价一个RPC框架的性能
协议:数据传输的格式,通信双方的契约. 传输:使用何种传输通道传输数据. 线程:接收到数据,如何分发数据进行处理.
FluentData，一个轻量级开源的.NET ORM数据持久化框架
FluentData:一种使用Fluent API的新型轻量级ORM模型 FluentData 是微型 ORM(micro-ORM)家族的一名新成员,旨在比大型 ORM(full ORM)更加易用. ...
初步了解学习flask轻量级框架,
关于flask我有话说 flask作为一个轻量级框架,它里面有好多扩展包需要下载,比较麻烦,而且有的时候flask需要在虚拟环境下运行,但是他的优点还是有滴 ,只要是用过Django的人,都会觉得fl ...
一个轻量级分布式RPC框架--NettyRpc
1.背景最近在搜索Netty和Zookeeper方面的文章时,看到了这篇文章<轻量级分布式 RPC 框架>,作者用Zookeeper.Netty和Spring写了一个轻量级的分布式RPC ...
C++11实现一个轻量级的AOP框架
AOP介绍 AOP(Aspect-Oriented Programming,面向方面编程),可以解决面向对象编程中的一些问题,是OOP的一种有益补充.面向对象编程中的继承是一种从上而下的关系,不适合定 ...
一个轻量级分布式 RPC 框架 — NettyRpc
原文出处: 阿凡卢 1.背景最近在搜索Netty和Zookeeper方面的文章时,看到了这篇文章<轻量级分布式 RPC 框架>,作者用Zookeeper.Netty和Spring写了一个 ...
如何在Java生态圈选择一个轻量级的RESTful框架？
在微服务流行的今天,我们会从纵向和横向分解代码的逻辑,将一些独立的无状态的代码单元实现为微服务,可以将它们发布到一些分布式计算单元或者Docker中,并在性能需要的时候及时地创建更多的服务单元.微服务 ...
基于Netty和SpringBoot实现一个轻量级RPC框架-Server篇
前提前置文章: Github Page:<基于Netty和SpringBoot实现一个轻量级RPC框架-协议篇> Coding Page:<基于Netty和SpringBoot实现 ...
Objection, 一个轻量级的Objective-C依赖注入框架
简介项目主页:https://github.com/atomicobject/objection 实例下载: https://github.com/ios122/ios122 Objection 是 ...

随机推荐

ralitive absolute
3.relative与absolute的主要区别: 首先,是上面已经提到过的在正常流中的位置存在与否. 其次,relative定位的层总是相对于其最近的父元素,无论其父元素是何种定位方式.如图3: 图 ...
android实现点击背景图片不同区域实现不同事件
有时候我们拿到一张背景图片,客户要求点击图片的不同区域去跳转或者实现不同的操作事件.我们首先要确认图片的点击区域,往往我们会在布局文件那里下手,但是这样不好做适配,所以我实现了以下方法,基本功能可以实 ...
Linux考试易忘命令
这是为了考试而做的笔记 mv命令可以移动可以改名 mv a /test //移动a到test文件夹下 mv a b //把a改名为b 软链接和硬链接的创建 ln -s profile a //prof ...
memcached协议
memcached协议旧版:http://code.sixapart.com/svn/memcached/trunk/server/doc/protocol.txt 新版:https://githu ...
联想Y50p预装win8系统改为win7
&1 修改OS Optimized Defaults 开机,按[F2]进入BIOS设置,按右方向键选择到EXIT上面,按下方向键选择OS Optimized Defaults,回车,将Win8 ...
Caffe学习系列(18): 绘制网络模型
python/draw_net.py, 这个文件,就是用来绘制网络模型的.也就是将网络模型由prototxt变成一张图片. 在绘制之前,需要先安装两个库 1.安装GraphViz # sudo apt ...
GDB深入研究——20135308芦畅
GDB深入研究一.GDB代码调试 (一)GDB调试实例在终端中编译一个示例C语言小程序,保存到文件 gdb-sample.c 中,用GCC编译之 #include <stdio.h> ...
20135328信息安全系统设计基础第一周学习总结（Linux应用）
学习计时:共xxx小时读书: 代码: 作业: 博客: 一.学习目标 1. 能够独立安装Linux操作系统 2. 能够熟练使用Linux系统的基本命令 3. 熟练使用Linux中用户管理命令/ ...
超全！iOS 面试题汇总
之前看了很多面试题,感觉要不是不够就是过于冗余,于是我将网上的一些面试题进行了删减和重排,现在分享给大家.(题目来源于网络,侵删) 1. Object-c的类可以多重继承么?可以实现多个接口么?Cat ...
使用git推送代码到开源中国以及IDEA环境下使用git
使用git推送代码到开源中国以及IDEA环境下使用git 在学习Java的过程中我们会使用到git这个工具来将我们本周所编写的代码上传到开源中国进行代码托管,而在使用git的时候有很多的同学由于不会操 ...

FluentData，它是一个轻量级框架，关注性能和易用性。

FluentData，它是一个轻量级框架，关注性能和易用性。的更多相关文章

随机推荐

热门专题