C#-数据库帮助类

　　一. 数据库简要介绍

　　数据库就不做详细介绍了，简单的说，就是为了存储数据，进行查看的，总之用的随处可见。

　　二. C#三层架构

　　我们这里也用到了，三层架构分为：表现层（UI（User Interface））、业务逻辑层（BLL（Business Logic Layer））、数据访问层（DAL（Data Access Layer）），再加上实体类库（Model），只不过是只用到了最下面三层，表现层在咱们这就当做调用BLL层吧，测试用例用。

　　三. Model层生成实体的前提

　　我们这里以MySQL为例，SQLserver的直接建立实体模板就可以了，但是MySQL需要做下配置，否则在实体来源这儿是找不到MySQL的相关信息的，我这里是已经添加了所以存在，本机配置VS2019专业版，Win10操作系统。

 

 

　　两个安装包需要安装下，mysql-connector-net-6.9.12.msi和mysql-for-visualstudio-1.2.8.msi，Nuget包选择MySql.Data 6.9.12、MySql.Data.Entity 6.9.12、EntityFramework 6.2.0，这些配置不好，造成的结构就是建立实体模板的时候链接不上数据库，或者闪退等现象，也有其他的配置可以成功生成。操作数据库的NuGet包选择Dapper 2.0.35和Dapper.SimpleCRUD 2.2.0.1，配置完毕看下项目的一个结构。

 

　　我这里也分为了三层，展开的三层，相对较为明显，DataBaseTest是启动项目，Common是一个通用类，里面没什么具体的东西，DBHelp是数据库操作帮助类，LogManager是写日志帮助类。

  首先生成实体类模板，右键点击SqlModel，右键添加新建项，ANO.NET实体数据模型，输入你的MySQL数据库IP，用户名、密码，选择库，点击确定，

　　选择要生成的表，点击完成，之后就是点击确定，确定，

　　之后就会生成相应的文件，打开.cs文件就是生成的实体模板类，这样就会对应数据库的表结构生成相应的.cs文件，相当方便了。

 

 

　　SqlModel层就生成好了，接下来是DAL，接下来的就是用到了T4模板了，DAL中添加一个IObjectDAL接口，因为所有的表操作用到的方法都是一样的，只是实体模板类不一样而已，右键DAL项目，添加运行时文本模板DALTemplate.tt，之后ctrl+s保存就会自动生成相应的代码啦。

 

 

    interface IObjectDAL<TEntity>
    {
        /// <summary>
        /// 获取所有实体对象
        /// </summary>
        /// <returns></returns>
        List<TEntity> GetAll();

        /// <summary>
        /// 根据条件获取实体
        /// </summary>
        /// <returns></returns>
        List<TEntity> GetObjectByCondition(string whereCondition);

        /// <summary>
        /// 根据多条件获取实体
        /// </summary>
        /// <param name="whereCondition"></param>
        /// <returns></returns>
        List<TEntity> GetObjectByCondition(object whereCondition);

        /// <summary>
        /// 更具ID判断是否存在
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        bool Exists(string id);

        /// <summary>
        /// 插入列表信息
        /// </summary>
        /// <param name="objectIQuery"></param>
        /// <returns></returns>
        List<TEntity> InsertObjectList(List<TEntity> objectList,
            IDbTransaction transaction = null, int? commandTimeout = null);

        /// <summary>
        /// 插入对象信息
        /// </summary>
        /// <param name="objectInfo"></param>
        /// <returns></returns>
        int? InsertObject(TEntity objectInfo,
            IDbTransaction transaction = null, int? commandTimeout = null);

        /// <summary>
        /// 更新对象信息
        /// </summary>
        /// <param name="objectInfo"></param>
        /// <returns></returns>
        bool UpdateObject(TEntity objectInfo,
            IDbTransaction transaction = null, int? commandTimeout = null);

        /// <summary>
        /// 更新对象信息
        /// </summary>
        /// <param name="objectInfo"></param>
        /// <returns></returns>
        bool UpdateObjectList(List<TEntity> objectList,
            IDbTransaction transaction = null, int? commandTimeout = null);

        /// <summary>
        /// 删除对象列表信息
        /// </summary>
        /// <param name="objectList"></param>
        /// <param name="transaction"></param>
        /// <param name="commandTimeout"></param>
        /// <returns></returns>
        bool DeleteObjectList(List<TEntity> objectList,
            IDbTransaction transaction = null, int? commandTimeout = null);

        /// <summary>
        /// 根据ID删除对象
        /// </summary>
        /// <param name="id"></param>
        /// <param name="transaction"></param>
        /// <param name="commandTimeout"></param>
        bool DeleteObjectByID(object id,
            IDbTransaction transaction = null, int? commandTimeout = null);

        /// <summary>
        /// 删除对象列表信息
        /// </summary>
        /// <param name="objectList"></param>
        /// <param name="transaction"></param>
        /// <param name="commandTimeout"></param>
        /// <returns></returns>
        bool DeleteObjectListByCondition(string whereCondition,
            IDbTransaction transaction = null, int? commandTimeout = null);

        /// <summary>
        /// 通过条件删除对象信息
        /// </summary>
        /// <param name="whereConditions"></param>
        /// <param name="transaction"></param>
        /// <param name="commandTimeout"></param>
        /// <returns></returns>
        bool DeleteObjectListByCondition(object whereConditions,
            IDbTransaction transaction = null, int? commandTimeout = null);

        /// <summary>
        /// 删除选定的对象
        /// </summary>
        /// <param name="ObjectInfo"></param>
        /// <returns></returns>
        bool Delete(TEntity objectInfo, IDbTransaction transaction = null, int? commandTimeout = null);

        /// <summary>
        /// 执行SQL
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="whereCondition"></param>
        /// <param name="transaction"></param>
        /// <returns></returns>
        IEnumerable<T> Query<T>(string sql, object whereCondition = null, IDbTransaction transaction = null);
    }

 

<#@ template language="C#" debug="false" hostspecific="true"#>
<#@ include file="EF6.Utility.CS.ttinclude"#>
<#@ output extension=".cs"#>

<#
const string inputFile = @"..\SqlModel\Model.edmx";
var textTransform = DynamicTextTransformation.Create(this);
var code = new CodeGenerationTools(this);
var ef = new MetadataTools(this);
var typeMapper = new TypeMapper(code, ef, textTransform.Errors);
var    fileManager = EntityFrameworkTemplateFileManager.Create(this);
var itemCollection = new EdmMetadataLoader(textTransform.Host, textTransform.Errors).CreateEdmItemCollection(inputFile);
var codeStringGenerator = new CodeStringGenerator(code, typeMapper, ef);

if (!typeMapper.VerifyCaseInsensitiveTypeUniqueness(typeMapper.GetAllGlobalItems(itemCollection), inputFile))
{
    return string.Empty;
}

foreach (var entity in typeMapper.GetItemsToGenerate<EntityType>(itemCollection))
{
    fileManager.StartNewFile(entity.Name + "DAL.cs");
#>
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks; 
using SqlModel;
using DBHelp;
using Dapper;
using System.Data.SqlClient;
using System.Data;
namespace DAL
{
    [Table("<#=entity.Name#>")]
    public partial class <#=entity.Name#>DAL : IObjectDAL<<#=entity.Name#>>
    {
        DbHelper DBHelper { get; set; }

        public <#=entity.Name#>DAL(DbHelper dbHelper)
        {
            DBHelper = dbHelper;
        }

        /// <summary>
        /// 获取所有实体对象
        /// </summary>
        /// <returns></returns>
        public List<<#=entity.Name#>> GetAll()
        {
            try
            {
                return DBHelper.GetList<<#=entity.Name#>>().ToList();
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        /// <summary>
        /// 根据ID获取实体
        /// </summary>
        /// <returns></returns>
        public List<<#=entity.Name#>> GetObjectByCondition(string whereCondition)
        {
            try
            {
                return DBHelper.GetList<<#=entity.Name#>>(whereCondition).ToList();
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        /// <summary>
        /// 根据多条件获取实体
        /// </summary>
        /// <param name="whereCondition"></param>
        /// <returns></returns>
        public List<<#=entity.Name#>> GetObjectByCondition(object whereCondition)
        {
            try
            {
                return DBHelper.GetList<<#=entity.Name#>>(whereCondition).ToList();
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        /// <summary>
        /// 更具ID判断是否存在
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public bool Exists(string id)
        {
            try
            {
                <#=entity.Name#> alarm = DBHelper.Get<<#=entity.Name#>>(id);
                if (alarm == null)
                    return false;
                else
                    return true;
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        /// <summary>
        /// 插入列表信息
        /// </summary>
        /// <param name="objectList"></param>
        /// <returns></returns>
        public List<<#=entity.Name#>> InsertObjectList(List<<#=entity.Name#>> objectList, 
            IDbTransaction transaction = null, int? commandTimeout = null)
        {
            try
            {
                List<<#=entity.Name#>> errorList = new List<<#=entity.Name#>>();
                foreach (<#=entity.Name#> objectInfo in objectList)
                {
                    int? key = DBHelper.Insert(objectInfo, transaction, commandTimeout);
                    if (key == null)
                    {
                        errorList.Add(objectInfo);
                    }
                }
                return errorList;
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        /// <summary>
        /// 插入对象信息
        /// </summary>
        /// <param name="objectInfo"></param>
        /// <returns></returns>
        public int? InsertObject(<#=entity.Name#> objectInfo,
            IDbTransaction transaction = null, int? commandTimeout = null)
        {
            try
            {
                return DBHelper.Insert(objectInfo, transaction,commandTimeout );
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        /// <summary>
        /// 更新对象信息
        /// </summary>
        /// <param name="objectInfo"></param>
        /// <returns></returns>
        public bool UpdateObject(<#=entity.Name#> objectInfo,
            IDbTransaction transaction = null, int? commandTimeout = null)
        {
            try
            {
                int effectrows = DBHelper.Update(objectInfo, transaction, commandTimeout);
                if (effectrows == 0)
                    return false;
                else
                    return true;
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }


        /// <summary>
        /// 更新列表对象信息
        /// </summary>
        /// <param name="objectInfo"></param>
        /// <returns></returns>
        public bool UpdateObjectList(List<<#=entity.Name#>> objectList, 
            IDbTransaction transaction = null, int? commandTimeout = null)
        {
            try
            {
                int rowCount = 0;
                foreach (Object entity in objectList)
                { 
                    rowCount += DBHelper.Update(entity, transaction, commandTimeout);
                }
                return true;
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        /// <summary>
        /// 删除对象列表信息
        /// </summary>
        /// <param name="objectList"></param>
        /// <param name="transaction"></param>
        /// <param name="commandTimeout"></param>
        /// <returns></returns>
        public bool DeleteObjectList(List<<#=entity.Name#>> objectList,
            IDbTransaction transaction = null, int? commandTimeout = null)
        {
            try
            {
                int rowCount = 0;
                foreach (Object entity in objectList)
                { 
                    rowCount += DBHelper.Deleted(entity, transaction, commandTimeout);
                }
                return true;
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        /// <summary>
        /// 删除对象列表信息
        /// </summary>
        /// <param name="objectList"></param>
        /// <param name="transaction"></param>
        /// <param name="commandTimeout"></param>
        /// <returns></returns>
        public bool DeleteObjectByID(object id,
            IDbTransaction transaction = null, int? commandTimeout = null)
        {
            try
            {
                DBHelper.Deleted(id, transaction, commandTimeout);
                return true;
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        /// <summary>
        /// 删除对象列表信息
        /// </summary>
        /// <param name="whereCondition"></param>
        /// <param name="transaction"></param>
        /// <param name="commandTimeout"></param>
        /// <returns></returns>
        public bool DeleteObjectListByCondition(string whereCondition,
            IDbTransaction transaction = null, int? commandTimeout = null)
        {
            try
            {
                DBHelper.DeletedList<<#=entity.Name#>>(whereCondition, transaction, commandTimeout);
                return true;
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        /// <summary>
        /// 删除对象列表信息
        /// </summary>
        /// <param name="whereCondition"></param>
        /// <param name="transaction"></param>
        /// <param name="commandTimeout"></param>
        /// <returns></returns>
        public bool DeleteObjectListByCondition(object whereCondition,
            IDbTransaction transaction = null, int? commandTimeout = null)
        {
            try
            {
                DBHelper.DeletedList<<#=entity.Name#>>(whereCondition, transaction, commandTimeout);
                return true;
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        /// <summary>
        /// 删除选定的对象
        /// </summary>
        /// <param name="ObjectInfo"></param>
        /// <returns></returns>
        public bool Delete(<#=entity.Name#> objectInfo,
            IDbTransaction transaction = null, int? commandTimeout = null)
        {
            try
            {
                int effectrows = DBHelper.Deleted(objectInfo, transaction, commandTimeout);
                if (effectrows == 0)
                    return false;
                else
                    return true;
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }


        /// <summary>
        /// 执行SQL
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="whereCondition"></param>
        /// <param name="transaction"></param>
        /// <returns></returns>
        public IEnumerable<T> Query<T>(string sql, 
            object whereCondition = null, IDbTransaction transaction = null)
        {
            try
            {
                return DBHelper.Query<T>(sql, whereCondition, transaction);
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }
    }
}
<# 
    fileManager.EndBlock();
}
fileManager.Process();  
#>
    
<#+
public const string TemplateId = "CSharp_DbContext_Types_EF6";

public class CodeStringGenerator
{
    private readonly CodeGenerationTools _code;
    private readonly TypeMapper _typeMapper;
    private readonly MetadataTools _ef;

    public CodeStringGenerator(CodeGenerationTools code, TypeMapper typeMapper, MetadataTools ef)
    {
        ArgumentNotNull(code, "code");
        ArgumentNotNull(typeMapper, "typeMapper");
        ArgumentNotNull(ef, "ef");

        _code = code;
        _typeMapper = typeMapper;
        _ef = ef;
    }

    public string Property(EdmProperty edmProperty)
    {
        return string.Format(
            CultureInfo.InvariantCulture,
            "{0} {1} {2} {{ {3}get; {4}set; }}",
            Accessibility.ForProperty(edmProperty),
            _typeMapper.GetTypeName(edmProperty.TypeUsage),
            _code.Escape(edmProperty),
            _code.SpaceAfter(Accessibility.ForGetter(edmProperty)),
            _code.SpaceAfter(Accessibility.ForSetter(edmProperty)));
    }

    public string NavigationProperty(NavigationProperty navProp)
    {
        var endType = _typeMapper.GetTypeName(navProp.ToEndMember.GetEntityType());
        return string.Format(
            CultureInfo.InvariantCulture,
            "{0} {1} {2} {{ {3}get; {4}set; }}",
            AccessibilityAndVirtual(Accessibility.ForNavigationProperty(navProp)),
            navProp.ToEndMember.RelationshipMultiplicity == RelationshipMultiplicity.Many ? ("ICollection<" + endType + ">") : endType,
            _code.Escape(navProp),
            _code.SpaceAfter(Accessibility.ForGetter(navProp)),
            _code.SpaceAfter(Accessibility.ForSetter(navProp)));
    }
    
    public string AccessibilityAndVirtual(string accessibility)
    {
        return accessibility + (accessibility != "private" ? " virtual" : "");
    }
    
    public string EntityClassOpening(EntityType entity)
    {
        return string.Format(
            CultureInfo.InvariantCulture,
            "{0} {1}partial class {2}{3}",
            Accessibility.ForType(entity),
            _code.SpaceAfter(_code.AbstractOption(entity)),
            _code.Escape(entity),
            _code.StringBefore(" : ", _typeMapper.GetTypeName(entity.BaseType)));
    }
    
    public string EnumOpening(SimpleType enumType)
    {
        return string.Format(
            CultureInfo.InvariantCulture,
            "{0} enum {1} : {2}",
            Accessibility.ForType(enumType),
            _code.Escape(enumType),
            _code.Escape(_typeMapper.UnderlyingClrType(enumType)));
        }
    
    public void WriteFunctionParameters(EdmFunction edmFunction, Action<string, string, string, string> writeParameter)
    {
        var parameters = FunctionImportParameter.Create(edmFunction.Parameters, _code, _ef);
        foreach (var parameter in parameters.Where(p => p.NeedsLocalVariable))
        {
            var isNotNull = parameter.IsNullableOfT ? parameter.FunctionParameterName + ".HasValue" : parameter.FunctionParameterName + " != null";
            var notNullInit = "new ObjectParameter(\"" + parameter.EsqlParameterName + "\", " + parameter.FunctionParameterName + ")";
            var nullInit = "new ObjectParameter(\"" + parameter.EsqlParameterName + "\", typeof(" + TypeMapper.FixNamespaces(parameter.RawClrTypeName) + "))";
            writeParameter(parameter.LocalVariableName, isNotNull, notNullInit, nullInit);
        }
    }
    
    public string ComposableFunctionMethod(EdmFunction edmFunction, string modelNamespace)
    {
        var parameters = _typeMapper.GetParameters(edmFunction);
        
        return string.Format(
            CultureInfo.InvariantCulture,
            "{0} IQueryable<{1}> {2}({3})",
            AccessibilityAndVirtual(Accessibility.ForMethod(edmFunction)),
            _typeMapper.GetTypeName(_typeMapper.GetReturnType(edmFunction), modelNamespace),
            _code.Escape(edmFunction),
            string.Join(", ", parameters.Select(p => TypeMapper.FixNamespaces(p.FunctionParameterType) + " " + p.FunctionParameterName).ToArray()));
    }
    
    public string ComposableCreateQuery(EdmFunction edmFunction, string modelNamespace)
    {
        var parameters = _typeMapper.GetParameters(edmFunction);
        
        return string.Format(
            CultureInfo.InvariantCulture,
            "return ((IObjectContextAdapter)this).ObjectContext.CreateQuery<{0}>(\"[{1}].[{2}]({3})\"{4});",
            _typeMapper.GetTypeName(_typeMapper.GetReturnType(edmFunction), modelNamespace),
            edmFunction.NamespaceName,
            edmFunction.Name,
            string.Join(", ", parameters.Select(p => "@" + p.EsqlParameterName).ToArray()),
            _code.StringBefore(", ", string.Join(", ", parameters.Select(p => p.ExecuteParameterName).ToArray())));
    }
    
    public string FunctionMethod(EdmFunction edmFunction, string modelNamespace, bool includeMergeOption)
    {
        var parameters = _typeMapper.GetParameters(edmFunction);
        var returnType = _typeMapper.GetReturnType(edmFunction);

        var paramList = String.Join(", ", parameters.Select(p => TypeMapper.FixNamespaces(p.FunctionParameterType) + " " + p.FunctionParameterName).ToArray());
        if (includeMergeOption)
        {
            paramList = _code.StringAfter(paramList, ", ") + "MergeOption mergeOption";
        }

        return string.Format(
            CultureInfo.InvariantCulture,
            "{0} {1} {2}({3})",
            AccessibilityAndVirtual(Accessibility.ForMethod(edmFunction)),
            returnType == null ? "int" : "ObjectResult<" + _typeMapper.GetTypeName(returnType, modelNamespace) + ">",
            _code.Escape(edmFunction),
            paramList);
    }
    
    public string ExecuteFunction(EdmFunction edmFunction, string modelNamespace, bool includeMergeOption)
    {
        var parameters = _typeMapper.GetParameters(edmFunction);
        var returnType = _typeMapper.GetReturnType(edmFunction);

        var callParams = _code.StringBefore(", ", String.Join(", ", parameters.Select(p => p.ExecuteParameterName).ToArray()));
        if (includeMergeOption)
        {
            callParams = ", mergeOption" + callParams;
        }
        
        return string.Format(
            CultureInfo.InvariantCulture,
            "return ((IObjectContextAdapter)this).ObjectContext.ExecuteFunction{0}(\"{1}\"{2});",
            returnType == null ? "" : "<" + _typeMapper.GetTypeName(returnType, modelNamespace) + ">",
            edmFunction.Name,
            callParams);
    }
    
    public string DbSet(EntitySet entitySet)
    {
        return string.Format(
            CultureInfo.InvariantCulture,
            "{0} virtual DbSet<{1}> {2} {{ get; set; }}",
            Accessibility.ForReadOnlyProperty(entitySet),
            _typeMapper.GetTypeName(entitySet.ElementType),
            _code.Escape(entitySet));
    }

    public string UsingDirectives(bool inHeader, bool includeCollections = true)
    {
        return inHeader == string.IsNullOrEmpty(_code.VsNamespaceSuggestion())
            ? string.Format(
                CultureInfo.InvariantCulture,
                "{0}using System;{1}" +
                "{2}",
                inHeader ? Environment.NewLine : "",
                includeCollections ? (Environment.NewLine + "using System.Collections.Generic;") : "",
                inHeader ? "" : Environment.NewLine)
            : "";
    }
}

public class TypeMapper
{
    private const string ExternalTypeNameAttributeName = @"http://schemas.microsoft.com/ado/2006/04/codegeneration:ExternalTypeName";

    private readonly System.Collections.IList _errors;
    private readonly CodeGenerationTools _code;
    private readonly MetadataTools _ef;

    public TypeMapper(CodeGenerationTools code, MetadataTools ef, System.Collections.IList errors)
    {
        ArgumentNotNull(code, "code");
        ArgumentNotNull(ef, "ef");
        ArgumentNotNull(errors, "errors");

        _code = code;
        _ef = ef;
        _errors = errors;
    }

    public static string FixNamespaces(string typeName)
    {
        return typeName.Replace("System.Data.Spatial.", "System.Data.Entity.Spatial.");
    }

    public string GetTypeName(TypeUsage typeUsage)
    {
        return typeUsage == null ? null : GetTypeName(typeUsage.EdmType, _ef.IsNullable(typeUsage), modelNamespace: null);
    }

    public string GetTypeName(EdmType edmType)
    {
        return GetTypeName(edmType, isNullable: null, modelNamespace: null);
    }

    public string GetTypeName(TypeUsage typeUsage, string modelNamespace)
    {
        return typeUsage == null ? null : GetTypeName(typeUsage.EdmType, _ef.IsNullable(typeUsage), modelNamespace);
    }

    public string GetTypeName(EdmType edmType, string modelNamespace)
    {
        return GetTypeName(edmType, isNullable: null, modelNamespace: modelNamespace);
    }

    public string GetTypeName(EdmType edmType, bool? isNullable, string modelNamespace)
    {
        if (edmType == null)
        {
            return null;
        }

        var collectionType = edmType as CollectionType;
        if (collectionType != null)
        {
            return String.Format(CultureInfo.InvariantCulture, "ICollection<{0}>", GetTypeName(collectionType.TypeUsage, modelNamespace));
        }

        var typeName = _code.Escape(edmType.MetadataProperties
                                .Where(p => p.Name == ExternalTypeNameAttributeName)
                                .Select(p => (string)p.Value)
                                .FirstOrDefault())
            ?? (modelNamespace != null && edmType.NamespaceName != modelNamespace ?
                _code.CreateFullName(_code.EscapeNamespace(edmType.NamespaceName), _code.Escape(edmType)) :
                _code.Escape(edmType));

        if (edmType is StructuralType)
        {
            return typeName;
        }

        if (edmType is SimpleType)
        {
            var clrType = UnderlyingClrType(edmType);
            if (!IsEnumType(edmType))
            {
                typeName = _code.Escape(clrType);
            }

            typeName = FixNamespaces(typeName);

            return clrType.IsValueType && isNullable == true ?
                String.Format(CultureInfo.InvariantCulture, "Nullable<{0}>", typeName) :
                typeName;
        }

        throw new ArgumentException("edmType");
    }
    
    public Type UnderlyingClrType(EdmType edmType)
    {
        ArgumentNotNull(edmType, "edmType");

        var primitiveType = edmType as PrimitiveType;
        if (primitiveType != null)
        {
            return primitiveType.ClrEquivalentType;
        }

        if (IsEnumType(edmType))
        {
            return GetEnumUnderlyingType(edmType).ClrEquivalentType;
        }

        return typeof(object);
    }
    
    public object GetEnumMemberValue(MetadataItem enumMember)
    {
        ArgumentNotNull(enumMember, "enumMember");
        
        var valueProperty = enumMember.GetType().GetProperty("Value");
        return valueProperty == null ? null : valueProperty.GetValue(enumMember, null);
    }
    
    public string GetEnumMemberName(MetadataItem enumMember)
    {
        ArgumentNotNull(enumMember, "enumMember");
        
        var nameProperty = enumMember.GetType().GetProperty("Name");
        return nameProperty == null ? null : (string)nameProperty.GetValue(enumMember, null);
    }

    public System.Collections.IEnumerable GetEnumMembers(EdmType enumType)
    {
        ArgumentNotNull(enumType, "enumType");

        var membersProperty = enumType.GetType().GetProperty("Members");
        return membersProperty != null 
            ? (System.Collections.IEnumerable)membersProperty.GetValue(enumType, null)
            : Enumerable.Empty<MetadataItem>();
    }
    
    public bool EnumIsFlags(EdmType enumType)
    {
        ArgumentNotNull(enumType, "enumType");
        
        var isFlagsProperty = enumType.GetType().GetProperty("IsFlags");
        return isFlagsProperty != null && (bool)isFlagsProperty.GetValue(enumType, null);
    }

    public bool IsEnumType(GlobalItem edmType)
    {
        ArgumentNotNull(edmType, "edmType");

        return edmType.GetType().Name == "EnumType";
    }

    public PrimitiveType GetEnumUnderlyingType(EdmType enumType)
    {
        ArgumentNotNull(enumType, "enumType");

        return (PrimitiveType)enumType.GetType().GetProperty("UnderlyingType").GetValue(enumType, null);
    }

    public string CreateLiteral(object value)
    {
        if (value == null || value.GetType() != typeof(TimeSpan))
        {
            return _code.CreateLiteral(value);
        }

        return string.Format(CultureInfo.InvariantCulture, "new TimeSpan({0})", ((TimeSpan)value).Ticks);
    }
    
    public bool VerifyCaseInsensitiveTypeUniqueness(IEnumerable<string> types, string sourceFile)
    {
        ArgumentNotNull(types, "types");
        ArgumentNotNull(sourceFile, "sourceFile");
        
        var hash = new HashSet<string>(StringComparer.InvariantCultureIgnoreCase);
        if (types.Any(item => !hash.Add(item)))
        {
            _errors.Add(
                new CompilerError(sourceFile, -1, -1, "6023",
                    String.Format(CultureInfo.CurrentCulture, CodeGenerationTools.GetResourceString("Template_CaseInsensitiveTypeConflict"))));
            return false;
        }
        return true;
    }
    
    public IEnumerable<SimpleType> GetEnumItemsToGenerate(IEnumerable<GlobalItem> itemCollection)
    {
        return GetItemsToGenerate<SimpleType>(itemCollection)
            .Where(e => IsEnumType(e));
    }
    
    public IEnumerable<T> GetItemsToGenerate<T>(IEnumerable<GlobalItem> itemCollection) where T: EdmType
    {
        return itemCollection
            .OfType<T>()
            .Where(i => !i.MetadataProperties.Any(p => p.Name == ExternalTypeNameAttributeName))
            .OrderBy(i => i.Name);
    }

    public IEnumerable<string> GetAllGlobalItems(IEnumerable<GlobalItem> itemCollection)
    {
        return itemCollection
            .Where(i => i is EntityType || i is ComplexType || i is EntityContainer || IsEnumType(i))
            .Select(g => GetGlobalItemName(g));
    }

    public string GetGlobalItemName(GlobalItem item)
    {
        if (item is EdmType)
        {
            return ((EdmType)item).Name;
        }
        else
        {
            return ((EntityContainer)item).Name;
        }
    }

    public IEnumerable<EdmProperty> GetSimpleProperties(EntityType type)
    {
        return type.Properties.Where(p => p.TypeUsage.EdmType is SimpleType && p.DeclaringType == type);
    }
    
    public IEnumerable<EdmProperty> GetSimpleProperties(ComplexType type)
    {
        return type.Properties.Where(p => p.TypeUsage.EdmType is SimpleType && p.DeclaringType == type);
    }
    
    public IEnumerable<EdmProperty> GetComplexProperties(EntityType type)
    {
        return type.Properties.Where(p => p.TypeUsage.EdmType is ComplexType && p.DeclaringType == type);
    }
    
    public IEnumerable<EdmProperty> GetComplexProperties(ComplexType type)
    {
        return type.Properties.Where(p => p.TypeUsage.EdmType is ComplexType && p.DeclaringType == type);
    }

    public IEnumerable<EdmProperty> GetPropertiesWithDefaultValues(EntityType type)
    {
        return type.Properties.Where(p => p.TypeUsage.EdmType is SimpleType && p.DeclaringType == type && p.DefaultValue != null);
    }
    
    public IEnumerable<EdmProperty> GetPropertiesWithDefaultValues(ComplexType type)
    {
        return type.Properties.Where(p => p.TypeUsage.EdmType is SimpleType && p.DeclaringType == type && p.DefaultValue != null);
    }

    public IEnumerable<NavigationProperty> GetNavigationProperties(EntityType type)
    {
        return type.NavigationProperties.Where(np => np.DeclaringType == type);
    }
    
    public IEnumerable<NavigationProperty> GetCollectionNavigationProperties(EntityType type)
    {
        return type.NavigationProperties.Where(np => np.DeclaringType == type && np.ToEndMember.RelationshipMultiplicity == RelationshipMultiplicity.Many);
    }
    
    public FunctionParameter GetReturnParameter(EdmFunction edmFunction)
    {
        ArgumentNotNull(edmFunction, "edmFunction");

        var returnParamsProperty = edmFunction.GetType().GetProperty("ReturnParameters");
        return returnParamsProperty == null
            ? edmFunction.ReturnParameter
            : ((IEnumerable<FunctionParameter>)returnParamsProperty.GetValue(edmFunction, null)).FirstOrDefault();
    }

    public bool IsComposable(EdmFunction edmFunction)
    {
        ArgumentNotNull(edmFunction, "edmFunction");

        var isComposableProperty = edmFunction.GetType().GetProperty("IsComposableAttribute");
        return isComposableProperty != null && (bool)isComposableProperty.GetValue(edmFunction, null);
    }

    public IEnumerable<FunctionImportParameter> GetParameters(EdmFunction edmFunction)
    {
        return FunctionImportParameter.Create(edmFunction.Parameters, _code, _ef);
    }

    public TypeUsage GetReturnType(EdmFunction edmFunction)
    {
        var returnParam = GetReturnParameter(edmFunction);
        return returnParam == null ? null : _ef.GetElementType(returnParam.TypeUsage);
    }
    
    public bool GenerateMergeOptionFunction(EdmFunction edmFunction, bool includeMergeOption)
    {
        var returnType = GetReturnType(edmFunction);
        return !includeMergeOption && returnType != null && returnType.EdmType.BuiltInTypeKind == BuiltInTypeKind.EntityType;
    }
}

public static void ArgumentNotNull<T>(T arg, string name) where T : class
{
    if (arg == null)
    {
        throw new ArgumentNullException(name);
    }
}
#>

 

 

 

 

 

 

 　　接下来BLL层，和DAL层类似，添加一个IObjeceBLL接口，添加运行时文本模板BLLTextTemplate.tt，代码如下，ctrl+s保存就会自动生成相应的代码了。

    public interface IObjeceBLL<TEntity>
    {
        /// <summary>
        /// 获取所有实体对象
        /// </summary>
        /// <returns></returns>
        List<TEntity> GetAll();

        /// <summary>
        /// 根据条件获取单个实体
        /// </summary>
        /// <returns></returns>
        TEntity GetObjectByConditionFrist(string whereCondition);

        /// <summary>
        /// 根据条件获取实体
        /// </summary>
        /// <returns></returns>
        List<TEntity> GetObjectByCondition(string whereCondition);

        /// <summary>
        /// 根据多条件获取单个实体
        /// </summary>
        /// <returns></returns>
        TEntity GetObjectByConditionFrist(object whereCondition);

        /// <summary>
        /// 根据多条件获取实体
        /// </summary>
        /// <param name="whereCondition"></param>
        /// <returns></returns>
        List<TEntity> GetObjectByCondition(object whereCondition);

        /// <summary>
        /// 更具ID判断是否存在
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        bool Exists(string id);

        /// <summary>
        /// 插入列表信息
        /// </summary>
        /// <param name="objectIQuery"></param>
        /// <returns></returns>
        List<TEntity> InsertObjectList(List<TEntity> objectList);

        /// <summary>
        /// 插入对象信息
        /// </summary>
        /// <param name="objectInfo"></param>
        /// <returns></returns>
        int? InsertObject(TEntity objectInfo);

        /// <summary>
        /// 更新对象信息
        /// </summary>
        /// <param name="objectInfo"></param>
        /// <returns></returns>
        bool UpdateObject(TEntity objectInfo);

        /// <summary>
        /// 删除对象信息
        /// </summary>
        /// <param name="objectInfo"></param>
        /// <returns></returns>
        bool DeleteObjectList(List<TEntity> objectInfoList);

        /// <summary>
        /// 删除选定的对象
        /// </summary>
        /// <param name="ObjectInfo"></param>
        /// <returns></returns>
        bool Delete(TEntity objectInfo);
    }

<#@ template debug="false" hostspecific="true" language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ include file="EF6.Utility.CS.ttinclude"#>
<#@ output extension=".cs" #>

<#
const string inputFile = @"..\SqlModel\Model.edmx";
var textTransform = DynamicTextTransformation.Create(this);
var code = new CodeGenerationTools(this);
var ef = new MetadataTools(this);
var typeMapper = new TypeMapper(code, ef, textTransform.Errors);
var    fileManager = EntityFrameworkTemplateFileManager.Create(this);
var itemCollection = new EdmMetadataLoader(textTransform.Host, textTransform.Errors).CreateEdmItemCollection(inputFile);
var codeStringGenerator = new CodeStringGenerator(code, typeMapper, ef);

if (!typeMapper.VerifyCaseInsensitiveTypeUniqueness(typeMapper.GetAllGlobalItems(itemCollection), inputFile))
{
    return string.Empty;
}

foreach (var entity in typeMapper.GetItemsToGenerate<EntityType>(itemCollection))
{
    fileManager.StartNewFile(entity.Name + "BLL.cs");

#>
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks; 
using SqlModel;
using DAL;
using Dapper;
using Common;
using System.Data.SqlClient;
using LogManager;
using DBHelp;
using System.Data;
namespace BLL
{
    [Table("<#=entity.Name#>")]
    public partial class <#=entity.Name#>BLL : IObjeceBLL<<#=entity.Name#>>
    {
        public <#=entity.Name#>DAL ObjectDAL { get; set; }
        public List<<#=entity.Name#>DAL> ObjectDALList { get; set; }

        public DbHelper DBHelper {set; get; }

        public <#=entity.Name#>BLL()
        {
            //获取连接字符串
            ConnectStringManager manager = new ConnectStringManager();
            string connectionString = manager.GetDefaultString();
            IDbConnection connection = DBConnectManager.CreatDBConnect(connectionString);

            //初始化数据库操作类
            DBHelper = new DbHelper(connection);
            ObjectDAL = new <#=entity.Name#>DAL(DBHelper);
        }

        public <#=entity.Name#>BLL(DbHelper dbhelper)
        {
            DBHelper = dbhelper;
            ObjectDAL = new <#=entity.Name#>DAL(DBHelper);
        }

        public <#=entity.Name#>BLL(string connectionStrings)
        {
            IDbConnection connection = DBConnectManager.CreatDBConnect(connectionStrings);

            //初始化数据库操作类
            DBHelper = new DbHelper(connection);
            ObjectDAL = new <#=entity.Name#>DAL(DBHelper);
        }

        public <#=entity.Name#>BLL(List<string> connectionStringsList)
        {
            foreach( string connectionstrings in connectionStringsList )
            {
                IDbConnection connection = DBConnectManager.CreatDBConnect(connectionstrings);

                DBHelper = new DbHelper(connection);
                <#=entity.Name#>DAL objectDAL = new <#=entity.Name#>DAL(DBHelper);
                ObjectDALList.Add(objectDAL);
            }
        }

        /// <summary>
        /// 获取所有实体对象
        /// </summary>
        /// <returns></returns>
        public List<<#=entity.Name#>> GetAll()
        {
            try
            {
                IDbConnection connection = DBHelper.GetConnection();
                if ( connection.State == ConnectionState.Broken || connection.State == ConnectionState.Closed )
                    connection.Open();

                List<<#=entity.Name#>> objectList = ObjectDAL.GetAll();
                connection.Close();
                return objectList;
            }
            catch (Exception ex)
            {
                LogEvent.LogInfo.Fatal(ex.ToString());
            }
            return null;
        }

        /// <summary>
        /// 根据条件获取实体
        /// </summary>
        /// <returns></returns>
        public List<<#=entity.Name#>> GetObjectByCondition(string whereCondition)
        {
            try
            {
                IDbConnection connection = DBHelper.GetConnection();
                if ( connection.State == ConnectionState.Broken || connection.State == ConnectionState.Closed )
                    connection.Open();

                List<<#=entity.Name#>> objectList = ObjectDAL.GetObjectByCondition( whereCondition );
                connection.Close();
                return objectList;
            }
            catch (Exception ex)
            {
                LogEvent.LogInfo.Fatal(ex.ToString());
            }
            return null;
        }


        /// <summary>
        /// 根据条件获取实体
        /// </summary>
        /// <returns></returns>
        public <#=entity.Name#> GetObjectByConditionFrist(string whereCondition)
        {
            <#=entity.Name#> ObjectInfo = null;
            try
            {
                IDbConnection connection = DBHelper.GetConnection();
                if ( connection.State == ConnectionState.Broken || connection.State == ConnectionState.Closed )
                    connection.Open();

                List<<#=entity.Name#>> ObjectList = ObjectDAL.GetObjectByCondition( whereCondition );
                connection.Close();

                if ( ObjectList == null || ObjectList.Count == 0 )
                {
                    return null;
                }
                
                ObjectInfo = ObjectList[0];
                
            }
            catch (Exception ex)
            {
                LogEvent.LogInfo.Fatal(ex.ToString());
            }
            return ObjectInfo;
        }

        /// <summary>
        /// 根据多条件获取实体
        /// </summary>
        /// <param name="whereCondition"></param>
        /// <returns></returns>
        public List<<#=entity.Name#>> GetObjectByCondition(object whereCondition)
        {
            try
            {
                IDbConnection connection = DBHelper.GetConnection();
                if ( connection.State == ConnectionState.Broken || connection.State == ConnectionState.Closed )
                    connection.Open();

                List<<#=entity.Name#>> objectList = ObjectDAL.GetObjectByCondition( whereCondition );
                connection.Close();
                return objectList;
            }
            catch (Exception ex)
            {
                LogEvent.LogInfo.Fatal(ex.ToString());
            }
            return null;
        }

        /// <summary>
        /// 根据多条件获取单个实体
        /// </summary>
        /// <returns></returns>
        public <#=entity.Name#> GetObjectByConditionFrist(object whereCondition)
        {
            <#=entity.Name#> ObjectInfo = null;
            try
            {    
                IDbConnection connection = DBHelper.GetConnection();
                if ( connection.State == ConnectionState.Broken || connection.State == ConnectionState.Closed )
                    connection.Open();

                List<<#=entity.Name#>> ObjectList = ObjectDAL.GetObjectByCondition( whereCondition );
                connection.Close();
                if ( ObjectList == null || ObjectList.Count == 0 )
                {
                    return null;
                }
                
                ObjectInfo = ObjectList[0];
            }
            catch (Exception ex)
            {
                LogEvent.LogInfo.Fatal(ex.ToString());
            }
            return ObjectInfo;
        }

        /// <summary>
        /// 更具ID判断是否存在
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public bool Exists(string id)
        {
            try
            {
                IDbConnection connection = DBHelper.GetConnection();
                if ( connection.State == ConnectionState.Broken || connection.State == ConnectionState.Closed )
                    connection.Open();

                bool result = ObjectDAL.Exists(id);
                connection.Close();
                return result;
            }
            catch (Exception ex)
            {
                LogEvent.LogInfo.Fatal(ex.ToString());
            }
            return false;
        }

        /// <summary>
        /// 插入列表信息
        /// </summary>
        /// <param name="objectIQuery"></param>
        /// <returns></returns>
        public List<<#=entity.Name#>> InsertObjectList(List<<#=entity.Name#>> objectList)
        {
            IDbTransaction transaction = null;
            List<<#=entity.Name#>> errorList = null;
            try
            {
                IDbConnection connection = DBHelper.GetConnection();
                if ( connection.State == ConnectionState.Broken || connection.State == ConnectionState.Closed )
                    connection.Open();
                transaction = connection.BeginTransaction();

                errorList = ObjectDAL.InsertObjectList(objectList, transaction);
                transaction.Commit();
                connection.Close();
            }
            catch (Exception ex)
            {
                if(transaction != null)
                    transaction.Rollback();
                LogEvent.LogInfo.Fatal(ex.ToString());
            }
            return errorList;
        }

        /// <summary>
        /// 插入对象信息
        /// </summary>
        /// <param name="objectInfo"></param>
        /// <returns></returns>
        public int? InsertObject(<#=entity.Name#> objectInfo)
        {
            try
            {
                IDbConnection connection = DBHelper.GetConnection();
                if ( connection.State == ConnectionState.Broken || connection.State == ConnectionState.Closed )
                    connection.Open();

                int? result = ObjectDAL.InsertObject(objectInfo);
                connection.Close();
                return result;
            }
            catch (Exception ex)
            {
                LogEvent.LogInfo.Fatal(ex.ToString());
            }
            return null;
        }

        /// <summary>
        /// 更新对象信息
        /// </summary>
        /// <param name="objectInfo"></param>
        /// <returns></returns>
        public bool UpdateObjectList(List<<#=entity.Name#>> objectInfoList)
        {
            IDbTransaction transaction = null;
            bool result = false;
            try
            {
                IDbConnection connection = DBHelper.GetConnection();
                if ( connection.State == ConnectionState.Broken || connection.State == ConnectionState.Closed )
                    connection.Open();
                transaction = connection.BeginTransaction();

                result = ObjectDAL.UpdateObjectList(objectInfoList, transaction);
                transaction.Commit();
                connection.Close();
            }
            catch (Exception ex)
            {
                if(transaction != null)
                    transaction.Rollback();
                LogEvent.LogInfo.Fatal(ex.ToString());
            }
            
            return result;
        }

        /// <summary>
        /// 更新对象信息
        /// </summary>
        /// <param name="objectInfo"></param>
        /// <returns></returns>
        public bool UpdateObject(<#=entity.Name#> objectInfo)
        {
            try
            {
                IDbConnection connection = DBHelper.GetConnection();

                if ( connection.State == ConnectionState.Broken || connection.State == ConnectionState.Closed )
                    connection.Open();

                bool result = ObjectDAL.UpdateObject(objectInfo);
                connection.Close();
                return result;
            }
            catch (Exception ex)
            {
                LogEvent.LogInfo.Fatal(ex.ToString());
            }
            return false;
        }

        /// <summary>
        /// 删除对象信息
        /// </summary>
        /// <param name="objectInfo"></param>
        /// <returns></returns>
        public bool DeleteObjectList(List<<#=entity.Name#>> objectInfoList)
        {
            IDbTransaction transaction = null;
            bool result = false;
            try
            {
                IDbConnection connection = DBHelper.GetConnection();
                if ( connection.State == ConnectionState.Broken || connection.State == ConnectionState.Closed )
                    connection.Open();
                transaction = connection.BeginTransaction();


                result = ObjectDAL.DeleteObjectList(objectInfoList, transaction);
                transaction.Commit();
                connection.Close();
            }
            catch (Exception ex)
            {
                if ( transaction != null )
                    transaction.Rollback();
                LogEvent.LogInfo.Fatal(ex.ToString());
            }
            
            return result;
        }

        /// <summary>
        /// 删除选定的对象
        /// </summary>
        /// <param name="ObjectInfo"></param>
        /// <returns></returns>
        public bool Delete(<#=entity.Name#> objectInfo)
        {
            try
            {
                IDbConnection connection = DBHelper.GetConnection();
                if ( connection.State == ConnectionState.Broken || connection.State == ConnectionState.Closed )
                    connection.Open();

                bool result = ObjectDAL.Delete(objectInfo);
                connection.Close();
                return result;
            }
            catch (Exception ex)
            {
                LogEvent.LogInfo.Fatal(ex.ToString());
            }
            return false;
        }
    }
}

<# 
    fileManager.EndBlock();
}
fileManager.Process();  
#>
    
<#+
public const string TemplateId = "CSharp_DbContext_Types_EF6";

public class CodeStringGenerator
{
    private readonly CodeGenerationTools _code;
    private readonly TypeMapper _typeMapper;
    private readonly MetadataTools _ef;

    public CodeStringGenerator(CodeGenerationTools code, TypeMapper typeMapper, MetadataTools ef)
    {
        ArgumentNotNull(code, "code");
        ArgumentNotNull(typeMapper, "typeMapper");
        ArgumentNotNull(ef, "ef");

        _code = code;
        _typeMapper = typeMapper;
        _ef = ef;
    }

    public string Property(EdmProperty edmProperty)
    {
        return string.Format(
            CultureInfo.InvariantCulture,
            "{0} {1} {2} {{ {3}get; {4}set; }}",
            Accessibility.ForProperty(edmProperty),
            _typeMapper.GetTypeName(edmProperty.TypeUsage),
            _code.Escape(edmProperty),
            _code.SpaceAfter(Accessibility.ForGetter(edmProperty)),
            _code.SpaceAfter(Accessibility.ForSetter(edmProperty)));
    } 

    public string NavigationProperty(NavigationProperty navProp)
    {
        var endType = _typeMapper.GetTypeName(navProp.ToEndMember.GetEntityType());
        return string.Format(
            CultureInfo.InvariantCulture,
            "{0} {1} {2} {{ {3}get; {4}set; }}",
            AccessibilityAndVirtual(Accessibility.ForNavigationProperty(navProp)),
            navProp.ToEndMember.RelationshipMultiplicity == RelationshipMultiplicity.Many ? ("ICollection<" + endType + ">") : endType,
            _code.Escape(navProp),
            _code.SpaceAfter(Accessibility.ForGetter(navProp)),
            _code.SpaceAfter(Accessibility.ForSetter(navProp)));
    }
    
    public string AccessibilityAndVirtual(string accessibility)
    {
        return accessibility + (accessibility != "private" ? " virtual" : "");
    }
    
    public string EntityClassOpening(EntityType entity)
    {
        return string.Format(
            CultureInfo.InvariantCulture,
            "{0} {1}partial class {2}{3}",
            Accessibility.ForType(entity),
            _code.SpaceAfter(_code.AbstractOption(entity)),
            _code.Escape(entity),
            _code.StringBefore(" : ", _typeMapper.GetTypeName(entity.BaseType)));
    }
    
    public string EnumOpening(SimpleType enumType)
    {
        return string.Format(
            CultureInfo.InvariantCulture,
            "{0} enum {1} : {2}",
            Accessibility.ForType(enumType),
            _code.Escape(enumType),
            _code.Escape(_typeMapper.UnderlyingClrType(enumType)));
        }
    
    public void WriteFunctionParameters(EdmFunction edmFunction, Action<string, string, string, string> writeParameter)
    {
        var parameters = FunctionImportParameter.Create(edmFunction.Parameters, _code, _ef);
        foreach (var parameter in parameters.Where(p => p.NeedsLocalVariable))
        {
            var isNotNull = parameter.IsNullableOfT ? parameter.FunctionParameterName + ".HasValue" : parameter.FunctionParameterName + " != null";
            var notNullInit = "new ObjectParameter(\"" + parameter.EsqlParameterName + "\", " + parameter.FunctionParameterName + ")";
            var nullInit = "new ObjectParameter(\"" + parameter.EsqlParameterName + "\", typeof(" + TypeMapper.FixNamespaces(parameter.RawClrTypeName) + "))";
            writeParameter(parameter.LocalVariableName, isNotNull, notNullInit, nullInit);
        }
    }
    
    public string ComposableFunctionMethod(EdmFunction edmFunction, string modelNamespace)
    {
        var parameters = _typeMapper.GetParameters(edmFunction);
        
        return string.Format(
            CultureInfo.InvariantCulture,
            "{0} IQueryable<{1}> {2}({3})",
            AccessibilityAndVirtual(Accessibility.ForMethod(edmFunction)),
            _typeMapper.GetTypeName(_typeMapper.GetReturnType(edmFunction), modelNamespace),
            _code.Escape(edmFunction),
            string.Join(", ", parameters.Select(p => TypeMapper.FixNamespaces(p.FunctionParameterType) + " " + p.FunctionParameterName).ToArray()));
    }
    
    public string ComposableCreateQuery(EdmFunction edmFunction, string modelNamespace)
    {
        var parameters = _typeMapper.GetParameters(edmFunction);
        
        return string.Format(
            CultureInfo.InvariantCulture,
            "return ((IObjectContextAdapter)this).ObjectContext.CreateQuery<{0}>(\"[{1}].[{2}]({3})\"{4});",
            _typeMapper.GetTypeName(_typeMapper.GetReturnType(edmFunction), modelNamespace),
            edmFunction.NamespaceName,
            edmFunction.Name,
            string.Join(", ", parameters.Select(p => "@" + p.EsqlParameterName).ToArray()),
            _code.StringBefore(", ", string.Join(", ", parameters.Select(p => p.ExecuteParameterName).ToArray())));
    }
    
    public string FunctionMethod(EdmFunction edmFunction, string modelNamespace, bool includeMergeOption)
    {
        var parameters = _typeMapper.GetParameters(edmFunction);
        var returnType = _typeMapper.GetReturnType(edmFunction);

        var paramList = String.Join(", ", parameters.Select(p => TypeMapper.FixNamespaces(p.FunctionParameterType) + " " + p.FunctionParameterName).ToArray());
        if (includeMergeOption)
        {
            paramList = _code.StringAfter(paramList, ", ") + "MergeOption mergeOption";
        }

        return string.Format(
            CultureInfo.InvariantCulture,
            "{0} {1} {2}({3})",
            AccessibilityAndVirtual(Accessibility.ForMethod(edmFunction)),
            returnType == null ? "int" : "ObjectResult<" + _typeMapper.GetTypeName(returnType, modelNamespace) + ">",
            _code.Escape(edmFunction),
            paramList);
    }
    
    public string ExecuteFunction(EdmFunction edmFunction, string modelNamespace, bool includeMergeOption)
    {
        var parameters = _typeMapper.GetParameters(edmFunction);
        var returnType = _typeMapper.GetReturnType(edmFunction);

        var callParams = _code.StringBefore(", ", String.Join(", ", parameters.Select(p => p.ExecuteParameterName).ToArray()));
        if (includeMergeOption)
        {
            callParams = ", mergeOption" + callParams;
        }
        
        return string.Format(
            CultureInfo.InvariantCulture,
            "return ((IObjectContextAdapter)this).ObjectContext.ExecuteFunction{0}(\"{1}\"{2});",
            returnType == null ? "" : "<" + _typeMapper.GetTypeName(returnType, modelNamespace) + ">",
            edmFunction.Name,
            callParams);
    }
    
    public string DbSet(EntitySet entitySet)
    {
        return string.Format(
            CultureInfo.InvariantCulture,
            "{0} virtual DbSet<{1}> {2} {{ get; set; }}",
            Accessibility.ForReadOnlyProperty(entitySet),
            _typeMapper.GetTypeName(entitySet.ElementType),
            _code.Escape(entitySet));
    }

    public string UsingDirectives(bool inHeader, bool includeCollections = true)
    {
        return inHeader == string.IsNullOrEmpty(_code.VsNamespaceSuggestion())
            ? string.Format(
                CultureInfo.InvariantCulture,
                "{0}using System;{1}" +
                "{2}",
                inHeader ? Environment.NewLine : "",
                includeCollections ? (Environment.NewLine + "using System.Collections.Generic;") : "",
                inHeader ? "" : Environment.NewLine)
            : "";
    }
}

public class TypeMapper
{
    private const string ExternalTypeNameAttributeName = @"http://schemas.microsoft.com/ado/2006/04/codegeneration:ExternalTypeName";

    private readonly System.Collections.IList _errors;
    private readonly CodeGenerationTools _code;
    private readonly MetadataTools _ef;

    public TypeMapper(CodeGenerationTools code, MetadataTools ef, System.Collections.IList errors)
    {
        ArgumentNotNull(code, "code");
        ArgumentNotNull(ef, "ef");
        ArgumentNotNull(errors, "errors");

        _code = code;
        _ef = ef;
        _errors = errors;
    }

    public static string FixNamespaces(string typeName)
    {
        return typeName.Replace("System.Data.Spatial.", "System.Data.Entity.Spatial.");
    }

    public string GetTypeName(TypeUsage typeUsage)
    {
        return typeUsage == null ? null : GetTypeName(typeUsage.EdmType, _ef.IsNullable(typeUsage), modelNamespace: null);
    }

    public string GetTypeName(EdmType edmType)
    {
        return GetTypeName(edmType, isNullable: null, modelNamespace: null);
    }

    public string GetTypeName(TypeUsage typeUsage, string modelNamespace)
    {
        return typeUsage == null ? null : GetTypeName(typeUsage.EdmType, _ef.IsNullable(typeUsage), modelNamespace);
    }

    public string GetTypeName(EdmType edmType, string modelNamespace)
    {
        return GetTypeName(edmType, isNullable: null, modelNamespace: modelNamespace);
    }

    public string GetTypeName(EdmType edmType, bool? isNullable, string modelNamespace)
    {
        if (edmType == null)
        {
            return null;
        }

        var collectionType = edmType as CollectionType;
        if (collectionType != null)
        {
            return String.Format(CultureInfo.InvariantCulture, "ICollection<{0}>", GetTypeName(collectionType.TypeUsage, modelNamespace));
        }

        var typeName = _code.Escape(edmType.MetadataProperties
                                .Where(p => p.Name == ExternalTypeNameAttributeName)
                                .Select(p => (string)p.Value)
                                .FirstOrDefault())
            ?? (modelNamespace != null && edmType.NamespaceName != modelNamespace ?
                _code.CreateFullName(_code.EscapeNamespace(edmType.NamespaceName), _code.Escape(edmType)) :
                _code.Escape(edmType));

        if (edmType is StructuralType)
        {
            return typeName;
        }

        if (edmType is SimpleType)
        {
            var clrType = UnderlyingClrType(edmType);
            if (!IsEnumType(edmType))
            {
                typeName = _code.Escape(clrType);
            }

            typeName = FixNamespaces(typeName);

            return clrType.IsValueType && isNullable == true ?
                String.Format(CultureInfo.InvariantCulture, "Nullable<{0}>", typeName) :
                typeName;
        }

        throw new ArgumentException("edmType");
    }
    
    public Type UnderlyingClrType(EdmType edmType)
    {
        ArgumentNotNull(edmType, "edmType");

        var primitiveType = edmType as PrimitiveType;
        if (primitiveType != null)
        {
            return primitiveType.ClrEquivalentType;
        }

        if (IsEnumType(edmType))
        {
            return GetEnumUnderlyingType(edmType).ClrEquivalentType;
        }

        return typeof(object);
    }
    
    public object GetEnumMemberValue(MetadataItem enumMember)
    {
        ArgumentNotNull(enumMember, "enumMember");
        
        var valueProperty = enumMember.GetType().GetProperty("Value");
        return valueProperty == null ? null : valueProperty.GetValue(enumMember, null);
    }
    
    public string GetEnumMemberName(MetadataItem enumMember)
    {
        ArgumentNotNull(enumMember, "enumMember");
        
        var nameProperty = enumMember.GetType().GetProperty("Name");
        return nameProperty == null ? null : (string)nameProperty.GetValue(enumMember, null);
    }

    public System.Collections.IEnumerable GetEnumMembers(EdmType enumType)
    {
        ArgumentNotNull(enumType, "enumType");

        var membersProperty = enumType.GetType().GetProperty("Members");
        return membersProperty != null 
            ? (System.Collections.IEnumerable)membersProperty.GetValue(enumType, null)
            : Enumerable.Empty<MetadataItem>();
    }
    
    public bool EnumIsFlags(EdmType enumType)
    {
        ArgumentNotNull(enumType, "enumType");
        
        var isFlagsProperty = enumType.GetType().GetProperty("IsFlags");
        return isFlagsProperty != null && (bool)isFlagsProperty.GetValue(enumType, null);
    }

    public bool IsEnumType(GlobalItem edmType)
    {
        ArgumentNotNull(edmType, "edmType");

        return edmType.GetType().Name == "EnumType";
    }

    public PrimitiveType GetEnumUnderlyingType(EdmType enumType)
    {
        ArgumentNotNull(enumType, "enumType");

        return (PrimitiveType)enumType.GetType().GetProperty("UnderlyingType").GetValue(enumType, null);
    }

    public string CreateLiteral(object value)
    {
        if (value == null || value.GetType() != typeof(TimeSpan))
        {
            return _code.CreateLiteral(value);
        }

        return string.Format(CultureInfo.InvariantCulture, "new TimeSpan({0})", ((TimeSpan)value).Ticks);
    }
    
    public bool VerifyCaseInsensitiveTypeUniqueness(IEnumerable<string> types, string sourceFile)
    {
        ArgumentNotNull(types, "types");
        ArgumentNotNull(sourceFile, "sourceFile");
        
        var hash = new HashSet<string>(StringComparer.InvariantCultureIgnoreCase);
        if (types.Any(item => !hash.Add(item)))
        {
            _errors.Add(
                new CompilerError(sourceFile, -1, -1, "6023",
                    String.Format(CultureInfo.CurrentCulture, CodeGenerationTools.GetResourceString("Template_CaseInsensitiveTypeConflict"))));
            return false;
        }
        return true;
    }
    
    public IEnumerable<SimpleType> GetEnumItemsToGenerate(IEnumerable<GlobalItem> itemCollection)
    {
        return GetItemsToGenerate<SimpleType>(itemCollection)
            .Where(e => IsEnumType(e));
    }
    
    public IEnumerable<T> GetItemsToGenerate<T>(IEnumerable<GlobalItem> itemCollection) where T: EdmType
    {
        return itemCollection
            .OfType<T>()
            .Where(i => !i.MetadataProperties.Any(p => p.Name == ExternalTypeNameAttributeName))
            .OrderBy(i => i.Name);
    }

    public IEnumerable<string> GetAllGlobalItems(IEnumerable<GlobalItem> itemCollection)
    {
        return itemCollection
            .Where(i => i is EntityType || i is ComplexType || i is EntityContainer || IsEnumType(i))
            .Select(g => GetGlobalItemName(g));
    }

    public string GetGlobalItemName(GlobalItem item)
    {
        if (item is EdmType)
        {
            return ((EdmType)item).Name;
        }
        else
        {
            return ((EntityContainer)item).Name;
        }
    }

    public IEnumerable<EdmProperty> GetSimpleProperties(EntityType type)
    {
        return type.Properties.Where(p => p.TypeUsage.EdmType is SimpleType && p.DeclaringType == type);
    }
    
    public IEnumerable<EdmProperty> GetSimpleProperties(ComplexType type)
    {
        return type.Properties.Where(p => p.TypeUsage.EdmType is SimpleType && p.DeclaringType == type);
    }
    
    public IEnumerable<EdmProperty> GetComplexProperties(EntityType type)
    {
        return type.Properties.Where(p => p.TypeUsage.EdmType is ComplexType && p.DeclaringType == type);
    }
    
    public IEnumerable<EdmProperty> GetComplexProperties(ComplexType type)
    {
        return type.Properties.Where(p => p.TypeUsage.EdmType is ComplexType && p.DeclaringType == type);
    }

    public IEnumerable<EdmProperty> GetPropertiesWithDefaultValues(EntityType type)
    {
        return type.Properties.Where(p => p.TypeUsage.EdmType is SimpleType && p.DeclaringType == type && p.DefaultValue != null);
    }
    
    public IEnumerable<EdmProperty> GetPropertiesWithDefaultValues(ComplexType type)
    {
        return type.Properties.Where(p => p.TypeUsage.EdmType is SimpleType && p.DeclaringType == type && p.DefaultValue != null);
    }

    public IEnumerable<NavigationProperty> GetNavigationProperties(EntityType type)
    {
        return type.NavigationProperties.Where(np => np.DeclaringType == type);
    }
    
    public IEnumerable<NavigationProperty> GetCollectionNavigationProperties(EntityType type)
    {
        return type.NavigationProperties.Where(np => np.DeclaringType == type && np.ToEndMember.RelationshipMultiplicity == RelationshipMultiplicity.Many);
    }
    
    public FunctionParameter GetReturnParameter(EdmFunction edmFunction)
    {
        ArgumentNotNull(edmFunction, "edmFunction");

        var returnParamsProperty = edmFunction.GetType().GetProperty("ReturnParameters");
        return returnParamsProperty == null
            ? edmFunction.ReturnParameter
            : ((IEnumerable<FunctionParameter>)returnParamsProperty.GetValue(edmFunction, null)).FirstOrDefault();
    }

    public bool IsComposable(EdmFunction edmFunction)
    {
        ArgumentNotNull(edmFunction, "edmFunction");

        var isComposableProperty = edmFunction.GetType().GetProperty("IsComposableAttribute");
        return isComposableProperty != null && (bool)isComposableProperty.GetValue(edmFunction, null);
    }

    public IEnumerable<FunctionImportParameter> GetParameters(EdmFunction edmFunction)
    {
        return FunctionImportParameter.Create(edmFunction.Parameters, _code, _ef);
    }

    public TypeUsage GetReturnType(EdmFunction edmFunction)
    {
        var returnParam = GetReturnParameter(edmFunction);
        return returnParam == null ? null : _ef.GetElementType(returnParam.TypeUsage);
    }
    
    public bool GenerateMergeOptionFunction(EdmFunction edmFunction, bool includeMergeOption)
    {
        var returnType = GetReturnType(edmFunction);
        return !includeMergeOption && returnType != null && returnType.EdmType.BuiltInTypeKind == BuiltInTypeKind.EntityType;
    }
}

public static void ArgumentNotNull<T>(T arg, string name) where T : class
{
    if (arg == null)
    {
        throw new ArgumentNullException(name);
    }
}
#>

 

　　三层结构至此生成完毕。接下里就是操作数据库了。  

  启动项目配置文件，appSettings中添加链接数据库的字符串，

    <!--MySQL-->
    <add key="ConnectionStrings" value="database=test1;server=127.0.0.1;port=3306;user id=root;password=123456;pooling=False;characterset=utf8" />
    <add key="SqlType" value="MySQL" />

 

 

 

 　　链接字符串ConnectStringManager.cs，其中用到了一个枚举，

    /// <summary>
    /// 连接类型
    /// </summary>
    public enum EnumGetConnectStringType { Config = 1, DataBase = 2, Default = 0 }

 

    public class ConnectStringManager
    {
        #region 属性

        /// <summary>
        /// 连接字符串
        /// </summary>
        private string ConnectString { set; get; }

        /// <summary>
        /// 批量操作使用的连接串LIST
        /// </summary>
        private List<string> ConnectStringList { set; get; }

        #endregion

        #region 构造

        /// <summary>
        /// 默认构造
        /// </summary>
        public ConnectStringManager()
        {
            ConnectString = ConfigurationManager.AppSettings["ConnectionStrings"].ToString();
        }

        /// <summary>
        /// 初始化连接方式
        /// </summary>
        /// <param name="type"></param>
        public ConnectStringManager(EnumGetConnectStringType type = EnumGetConnectStringType.Default)
        {
            switch (type)
            {
                case EnumGetConnectStringType.Default:
                    break;
                case EnumGetConnectStringType.DataBase:
                    break;
                case EnumGetConnectStringType.Config:
                    break;
                default:
                    break;
            }
        }

        #endregion

        #region 方法

        /// <summary>
        /// 获取操作连接字符串
        /// </summary>
        /// <returns></returns>
        public string GetDefaultString()
        {
            return ConnectString;
        }

        /// <summary>
        /// 获取批量连接字符串
        /// </summary>
        /// <returns></returns>
        public List<string> GetConnectionStringList()
        {
            return ConnectStringList;
        }

        #endregion

    }

 

　　数据库链接DBConnectManager.cs，这是获取数据库链接的操作，

    public class DBConnectManager
    {
        #region 属性 

        /// <summary>
        /// 数据库连接
        /// </summary>
        static private IDbConnection IConnection { get; set; }

        /// <summary>
        /// 数据库类型
        /// </summary>
        static private SimpleCRUD.Dialect EnumDBType { get; set; }

        #endregion

        #region 方法

        /// <summary>
        /// 创建数据库连接
        /// </summary>
        /// <param name="connectionString"></param>
        /// <returns></returns>
        static public IDbConnection CreatDBConnect(string connectionString)
        {
            EnumDBType = (SimpleCRUD.Dialect)Enum.Parse(typeof(SimpleCRUD.Dialect), ConfigurationManager.AppSettings["SqlType"].ToString());
            switch (EnumDBType)
            {
                case SimpleCRUD.Dialect.SQLServer:
                    IConnection = new SqlConnection(connectionString);
                    break;
                case SimpleCRUD.Dialect.PostgreSQL:
                    IConnection = new NpgsqlConnection(connectionString); ;
                    break;
                case SimpleCRUD.Dialect.MySQL:
                    IConnection = new MySqlConnection(connectionString);
                    break;
            }
            return IConnection;
        }

        /// <summary>
        /// 获取数据库类型
        /// </summary>
        /// <returns></returns>
        static public SimpleCRUD.Dialect GetDBType()
        {
            return EnumDBType;
        }

        #endregion

    }

 

　　数据操作帮助类DbHelper.cs，这主要是操作数据库，增删改查等，

    public class DbHelper
    {
        #region 属性

        /// <summary>
        /// 数据库链接
        /// </summary>
        IDbConnection Connection { set; get; }

        #endregion

        #region 构造

        /// <summary>
        /// 构造
        /// </summary>
        /// <param name="connection"></param>
        public DbHelper(IDbConnection connection)
        {
            Connection = connection;
            SimpleCRUD.SetDialect(DBConnectManager.GetDBType());
        }

        /// <summary>
        /// 获取链接
        /// </summary>
        /// <returns></returns>
        public IDbConnection GetConnection()
        {
            if (Connection.State == ConnectionState.Closed)
                Connection.Open();

            if (Connection.State == ConnectionState.Broken)
            {
                Connection.Close();
                Connection.Open();
            }

            return Connection;
        }

        #endregion

        #region 插入操作

        /// <summary>
        /// 同步插入单条数据
        /// </summary>
        /// <param name="entity">需要插入的数据</param>
        /// <returns>返回新插入的记录的主键</returns>
        public int? Insert(object entity, IDbTransaction transaction = null, int? commandTimeout = null)
        {
            try
            {
                return SimpleCRUD.Insert(Connection, entity, transaction, commandTimeout);
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        /// <summary>
        /// 同步插入单条数据
        /// </summary>
        /// <typeparam name="TEntity">返回新插入的记录的标识</typeparam>
        /// <param name="entity">需要插入的数据</param>
        /// <returns></returns>
        public int? Insert<TEntity>(TEntity entity, IDbTransaction transaction = null, int? commandTimeout = null)
        {
            try
            {
                return SimpleCRUD.Insert<TEntity>(Connection, entity, transaction, commandTimeout);
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        /// <summary>
        /// 异步插入单条数据
        /// </summary>
        /// <param name="entity">需要插入的数据</param>
        /// <returns>返回新插入的记录的主键</returns>
        public Task<int?> InsertAsync(object entity, IDbTransaction transaction = null, int? commandTimeout = null)
        {
            try
            {
                return SimpleCRUD.InsertAsync(Connection, entity, transaction, commandTimeout);
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        /// <summary>
        /// 异步插入单条数据
        /// </summary>
        /// <typeparam name="TEntity">数据类型</typeparam>
        /// <param name="entity">需要插入的数据</param>
        /// <returns></returns>
        public Task<int?> InsertAsync<TEntity>(TEntity entity, IDbTransaction transaction = null, int? commandTimeout = null)
        {
            try
            {
                return SimpleCRUD.InsertAsync(Connection, entity, transaction, commandTimeout);
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        #endregion

        #region 删除操作

        /// <summary>
        /// 通过标识删除数据库中的记录
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="id">标识</param>
        /// <returns>影响的记录数</returns>
        public int Deleted<T>(Object id, IDbTransaction transaction = null, int? commandTimeout = null)
        {
            try
            {
                return SimpleCRUD.Delete<T>(Connection, id, transaction, commandTimeout);
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        /// <summary>
        /// 在匹配对象的数据库中删除记录
        /// </summary>
        /// <typeparam name="T">对象类型</typeparam>
        /// <param name="entityToDelete">需要删除的对象</param>
        /// <returns>影响的记录数</returns>
        public int Deleted<T>(T entityToDelete, IDbTransaction transaction = null, int? commandTimeout = null)
        {
            try
            {
                return SimpleCRUD.Delete<T>(Connection, entityToDelete, transaction, commandTimeout);
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        /// <summary>
        /// 通过标识异步删除数据库中的记录
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="id">标识</param>
        /// <returns>影响的记录数</returns>
        public Task<int> DeletedAsync<T>(Object id, IDbTransaction transaction = null, int? commandTimeout = null)
        {
            try
            {
                return SimpleCRUD.DeleteAsync<T>(Connection, id, transaction, commandTimeout);
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        /// <summary>
        /// 在匹配对象的数据库中异步删除记录
        /// </summary>
        /// <typeparam name="T">对象类型</typeparam>
        /// <param name="entityToDelete">需要删除的对象</param>
        /// <returns>影响的记录数</returns>
        public Task<int> DeletedAsync<T>(T entityToDelete, IDbTransaction transaction = null, int? commandTimeout = null)
        {
            try
            {
                return SimpleCRUD.DeleteAsync<T>(Connection, entityToDelete, transaction, commandTimeout);
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        /// <summary>
        /// 根据条件删除数据库中的记录
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="conditions">条件</param>
        /// <returns>影响的行数</returns>
        public int DeletedList<T>(string conditions, IDbTransaction transaction = null, int? commandTimeout = null)
        {
            try
            {
                return SimpleCRUD.DeleteList<T>(Connection, conditions, transaction, commandTimeout);
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        /// <summary>
        /// 删除数据库中的记录列表 
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="whereConditions">有条件的类型</param>
        /// <returns>影响的条数</returns>
        public int DeletedList<T>(object whereConditions, IDbTransaction transaction = null, int? commandTimeout = null)
        {
            try
            {
                return SimpleCRUD.DeleteList<T>(Connection, whereConditions, transaction, commandTimeout);
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        /// <summary>
        /// 根据条件异步删除数据库中的记录
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="conditions">条件</param>
        /// <returns>影响的行数</returns>
        public Task<int> DeletedListAsync<T>(string conditions, IDbTransaction transaction = null, int? commandTimeout = null)
        {
            try
            {
                return SimpleCRUD.DeleteListAsync<T>(Connection, conditions, transaction, commandTimeout);
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        /// <summary>
        /// 删除数据库中的记录列表 
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="whereConditions">有条件的类型</param>
        /// <returns>影响的条数</returns>
        public Task<int> DeletedListAsync<T>(object whereConditions, IDbTransaction transaction = null, int? commandTimeout = null)
        {
            try
            {
                return SimpleCRUD.DeleteListAsync<T>(Connection, whereConditions, transaction, commandTimeout);
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        #endregion

        #region 修改操作

        /// <summary>
        /// 在数据库中更新记录
        /// </summary>
        /// <param name="entityToUpdate">需要更新的实体</param>
        /// <returns>影响记录的数量</returns>
        public int Update(Object entityToUpdate, IDbTransaction transaction = null, int? commandTimeout = null)
        {
            try
            {
                return SimpleCRUD.Update(Connection, entityToUpdate, transaction, commandTimeout);
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        /// <summary>
        /// 异步在数据库中更新记录
        /// </summary>
        /// <param name="entityToUpdate">需要更新的实体</param>
        /// <returns>影响记录的数量</returns>
        public Task<int> UpdateAsync(Object entityToUpdate, IDbTransaction transaction = null, int? commandTimeout = null)
        {
            try
            {
                return SimpleCRUD.UpdateAsync(Connection, entityToUpdate, transaction, commandTimeout);
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        #endregion

        #region 查询操作

        /// <summary>
        /// 获取表所有记录
        /// </summary>
        /// <typeparam name="T">返回类型</typeparam>
        /// <returns>表记录</returns>
        public IEnumerable<T> GetList<T>()
        {
            try
            {
                return SimpleCRUD.GetList<T>(Connection);
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        /// <summary>
        /// 异步获取表所有记录
        /// </summary>
        /// <typeparam name="T">返回类型</typeparam>
        /// <returns>表记录</returns>
        public Task<IEnumerable<T>> GetListAsync<T>()
        {
            try
            {
                return SimpleCRUD.GetListAsync<T>(Connection);
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        /// <summary>
        /// 获取数据库记录
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="conditions">条件</param>
        /// <returns>数据库记录</returns>
        public IEnumerable<T> GetList<T>(string conditions)
        {
            try
            {
                return SimpleCRUD.GetList<T>(Connection, conditions);
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        /// <summary>
        /// 异步获取数据库记录
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="conditions">条件</param>
        /// <returns>数据库记录</returns>
        public Task<IEnumerable<T>> GetListAsync<T>(string conditions)
        {
            try
            {
                return SimpleCRUD.GetListAsync<T>(Connection, conditions);
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        /// <summary>
        /// 查询表匹配的数据库记录
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="whereConditions">有条件的对象</param>
        /// <returns>数据库记录</returns>
        public IEnumerable<T> GetList<T>(object whereConditions)
        {
            try
            {
                return SimpleCRUD.GetList<T>(Connection, whereConditions);
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        /// <summary>
        /// 异步查询表匹配的数据库记录
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="whereConditions">有条件的对象</param>
        /// <returns>数据库记录</returns>
        public Task<IEnumerable<T>> GetListAsync<T>(object whereConditions)
        {
            try
            {
                return SimpleCRUD.GetListAsync<T>(Connection, whereConditions);
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        /// <summary>
        /// 通过ID获取数据库表记录
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="id">KEY</param>
        /// <returns>数据库表记录</returns>
        public T Get<T>(object id)
        {
            try
            {
                return SimpleCRUD.Get<T>(Connection, id);
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        /// <summary>
        /// 通过ID异步获取数据库表记录
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="id">KEY</param>
        /// <returns>数据库表记录</returns>
        public Task<T> GetAsync<T>(object id)
        {
            try
            {
                return SimpleCRUD.GetAsync<T>(Connection, id);
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        /// <summary>
        /// 获取分页记录信息
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="pageNumber">页数</param>
        /// <param name="rowsPerPage">记录数</param>
        /// <param name="conditions">查询条件</param>
        /// <param name="orderby">排序条件</param>
        /// <returns>分页记录</returns>
        public IEnumerable<T> GetListPaged<T>(int pageNumber, int rowsPerPage, string conditions, string orderby)
        {
            try
            {
                return SimpleCRUD.GetListPaged<T>(Connection, pageNumber, rowsPerPage, conditions, orderby);
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        /// <summary>
        /// 异步获取分页记录信息
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="pageNumber">页数</param>
        /// <param name="rowsPerPage">记录数</param>
        /// <param name="conditions">查询条件</param>
        /// <param name="orderby">排序条件</param>
        /// <returns>分页记录</returns>
        public Task<IEnumerable<T>> GetListPagedAsync<T>(int pageNumber, int rowsPerPage, string conditions, string orderby)
        {
            try
            {
                return SimpleCRUD.GetListPagedAsync<T>(Connection, pageNumber, rowsPerPage, conditions, orderby);
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        #endregion

        #region 获取Count

        /// <summary>
        /// 获取记录的数量
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="conditions">条件</param>
        /// <returns>记录的数量</returns>
        public int RecordCount<T>(string conditions = "")
        {
            try
            {
                return SimpleCRUD.RecordCount<T>(Connection, conditions);
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        /// <summary>
        /// 异步获取记录的数量
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="conditions">条件</param>
        /// <returns>记录的数量</returns>
        public Task<int> RecordCountAsync<T>(string conditions = "")
        {
            try
            {
                return SimpleCRUD.RecordCountAsync<T>(Connection, conditions);
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        #endregion

        #region 执行SQL

        /// <summary>
        /// 执行SQL语句并返回结果
        /// </summary>
        /// <param name="sql"></param>
        /// <returns></returns>
        public IEnumerable<T> Query<T>(string sql, object whereCondition = null, IDbTransaction transaction = null)
        {
            try
            {
                return Connection.Query<T>(sql, whereCondition, transaction);
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        /// <summary>
        /// 异步执行SQL语句并返回结果
        /// </summary>
        /// <param name="sql"></param>
        /// <returns></returns>
        public Task<IEnumerable<dynamic>> QueryAsync(string sql, object whereCondition = null, IDbTransaction transaction = null)
        {
            try
            {
                return Connection.QueryAsync(sql, whereCondition, transaction);
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        /// <summary>
        /// 执行sql 影响的行数
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="whereCondition"></param>
        /// <param name="transaction"></param>
        /// <returns></returns>
        public int ExecSql(string sql, object whereCondition = null, IDbTransaction transaction = null)
        {
            try
            {
                return Connection.Execute(sql, whereCondition, transaction);
            }
            catch (Exception ex)
            {
                throw (ex);
            }
        }

        #endregion
    }

　　接下来表现层操作数据库表，查看当前表中无数据，

　　执行代码，

            profit_rule_profitrulemainBLL bll = new profit_rule_profitrulemainBLL();

            Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss fff"));
            List<profit_rule_profitrulemain> rules = bll.GetAll();

            Console.WriteLine("rules.count = {0}", rules.Count);
            Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss fff"));

            List<profit_rule_profitrulemain> ruleList = new List<profit_rule_profitrulemain>();

            for(int i = 0; i < 100; i++)
            {
                profit_rule_profitrulemain ruleMain = new profit_rule_profitrulemain
                {
                    ruleid = Guid.NewGuid().ToString(),
                    stationid = Guid.NewGuid().ToString(),
                    statistictype = i,
                    statisticname = i.ToString(),
                    sectionid = i,
                    sectionname = i.ToString(),
                    expression = Guid.NewGuid().ToString()
                };

                ruleList.Add(ruleMain);

                bll.InsertObject(ruleMain);
            }
            Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss fff"));

            bll.InsertObjectList(ruleList);
            Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss fff"));

 

　　再次查看表中数据，表中数据200行，这是因为执行了单个对象插入和多行插入，

　　查询、删除，

            string sql = string.Format("where id > 29");
            List<profit_rule_profitrulemain> ruleList = bll.GetObjectByCondition(sql);

            bll.DeleteObjectList(ruleList);

 

 　　获取单条信息，

　　　　　　List<profit_rule_profitrulemain> mainList = bll.GetObjectByCondition(new { id = 29 });

 

　　更新，

　　　　　　　profit_rule_profitrulemain main = bll.GetObjectByConditionFrist(new { id = 29 });
            main.stationid = "2222";
            bll.UpdateObject(main);