澳门美高梅手机网站轻量级O奥迪Q7M

 

4.5 合理技术手段作扶助

      
有前方政策手段做基础,实施消息化系统就有了方针面包车型地铁靠山;上边也涉及施工公司音讯化要有正统的软件服务商协助,例如能够软件服务商要做一些如图2的多少总计,让他们协调比较,自个儿知耻而后进。有督促有相比,有策略的支持,那本人还缺什么呢,当然我们还缺软件系统在平时工作应用时的便利性,让软件服务商开发一些帐务复合检查、跟踪,以防一条数据错,不能查证,影响全局,那就失去了对系统的亲信。单一的多少录入情势是不能满意当下施工业公司业新闻化实施须要的,选用合理的开发情势,合理的跟踪对帐手段也是第三,有关跟踪对帐的软件开头方式请参见随想《施工业集团业综合项目管理种类多层开发框架结构》。合理的跟踪对帐相对应的图示为图3。当然那一个技术手段的声援还有众多,这个招数也会随着软件技术的前行而频频转变,再回来这句古语选择合适音信化的搭档软件上是何其的最紧要。那里的贴切首若是行行业内部的,还要是能长时间服务的,能抗得住金融暴风,并不是解决问题过于急躁的。

图2
音讯实行数据录入总计图

图3
音信进行跟踪对帐图

怎么行使:

4.4 合理的新闻化学工业作小组的组装

世家都了然信息化学工业程正是一把手工程。这对于六当中标的消息化实施小组组建的主要意义就同理可得了,那它的多少个根本要素正是:① 、有分量的首席营业官;二 、能源办公室事的政工骨干。只有那样才能单位合营、齐抓共同管理、协调拉动。那里我们日常会波及雷蛇集团老董Carly
Florina,他在谈到改进的时候总说:在革命前边要么积极投入,要么表明退出;决不允许坐在一旁评头论足,指手画脚。所以说消息化学工业作是公民的事体。提出音信化小组的组成如下:

图1
音信化小组关系图

讲述如下:

组 
长:公司总工程师(或总经济师、副总首席营业官等公司级首席营业官)

  副高级管:公司各管理部

      音信基本官员

  成 
员:集团各部骨干

            各子分公司副CEO

            音讯中央成员

using System;
using System.Collections.Generic;
using System.Linq;

namespace Models
{
    /// <summary>
    /// 
    /// </summary>
    [Serializable]
    public partial class BS_Template
    {
        /// <summary>
        /// 
        /// </summary>
        [IsId]
        [IsDBField]
        public string id { get; set; }
        /// <summary>
        /// 
        /// </summary>
        [IsDBField]
        public string typeCode { get; set; }
        /// <summary>
        /// 
        /// </summary>
        [IsDBField]
        public string type { get; set; }
        /// <summary>
        /// 
        /// </summary>
        [IsDBField]
        public string code { get; set; }
        /// <summary>
        /// 
        /// </summary>
        [IsDBField]
        public string name { get; set; }
        /// <summary>
        /// 
        /// </summary>
        [IsDBField]
        public string path { get; set; }
        /// <summary>
        /// 
        /// </summary>
        [IsDBField]
        public string folder { get; set; }
        /// <summary>
        /// 
        /// </summary>
        [IsDBField]
        public string remarks { get; set; }
    }
}

4.2加重普通管理制度

音信化的实施无法大跃进,不过也不是可作可不作。我们应当统一筹划规划、分步实施,抓宗旨,稳步深远的有助于。登录信息连串是大家每一天需求做的,将登记电子数码纳入平日正规内部。实用综合项目管理新闻类别正是大家的工作,所以制度化是行得通执行音信化的方针手段。中国建工业总会集团二局三集团使用的《集团综合项目管理种类推进工作义务状》值得我们参考。他们将分店COO和各职能部门COO作为第三法人,对一切种类的递进工作通盘承担。

    添加:

4.1消息化实施雷区

第贰施工业企业业的首席执行官管理方式来说以往一般分为两种:① 、项目自己经营情势;二 、总承包方式。对于这两种管理情势音讯化实施的首要条件也正是雷区,是无法靠消息系统实施的计量结果来故意照旧无意的开始展览利益的再分配,新闻化系统的主要职分是显示当下的生产力水平,那在宣扬上和在制度确立上都要遵从。项目收入的再分配是管理制度改进,不能够靠新闻种类来做主打。

View Code

5 截至语及展望

当然,一切的策略支撑与技术援助假使背离了新闻化学工业作“一把手”原则,都将化为泡影。在居室与城市和乡村城乡村建设设环保部各级领导者的中度器重与出席下,我们院加入的音信化项指标各种工作正在按我们完全的有助于思路举办。大家有理由相信,在社会各界职员的共同努力下,选用可行的心计,建筑施浙商银行业音讯化学工业作一定会迎来2个簇新的范围!

参考文献

[1]
洪鲜明。中夏族民共和国斥资类型管理消息化的背景、现状、难题与机关[Z]。(http://www.mypm.net),2004年

[2]
丁士昭。建设工程音信化导论[M],中中原人民共和国建筑工业出版社,二〇〇六年三月

[3]
周朝阳,韩传峰。建工项目管理新闻化PM-ASP形式[J]。建管现代化。2007(03):5-8

 

2.2援救公司公司各项管理层次

本条层次也正是大家常说的“施工企管消息类别平台”,一般包蕴办公自动化OA系统、财务管理系统、人力财富管理种类、综合项目管理种类等汇总采纳、全体成员参与的四大管理新闻化系统。这一个层次的施用由单纯的私家单机应用接入到多个人搭档网络选用,由目标性很强的工具软件到商行的汇总管理。当然未来部分商户也在小编方面包车型大巴品尝,普及比较广、做的相比好的第1是办公自动化OA系统,其次由于操作规模较为窄的财务系统、人力财富系统,由于涉及到的部门和人口相相比较例较少,所以在公司层次也收获了较好的进行。而对此涉嫌范围相比较深,能深深企管链条的花色管理体系往往都以浮于表面,要不正是与实际施工管理进程不贴合,要不正是涉嫌到全部施工过程的主导利益,往往都以不能够一语破的的贯彻到项目一般管理中。可是那里面不乏部分实力较强、利润较高的正规施工业公司业也在开始深切推行“综合项目管理种类”。很当然的说尖锐实施综合项目管理消息连串是大家常见施工业公司业最近要么未来一块追求的对象,那也是建筑施工业公司业新闻化的主导所在。

从以上五个层次不难看出,实际上他们是3个递增关系。近期多数商行都落得了第二层次。而对此第贰层次一大半动工业公司业也都在或多或少的摸索中。就算未来网络技术、通信手段都曾经很强盛,就算现行反革命无数进出口创造业的音讯化程度都早就获得了比较大的突破,国内创制业的ELacrosseP都获得了比较好的使用,然而对于建筑施工公司那种产值高、利润低、职员多、管理难度大的功成名就案例却照旧凤毛麟角。能够很自信的讲国内的动工软件商店已经有丰富的能力研制出适合作者国现状的总结项目管理软件。建筑行业是一古板行业,工艺规范、管理体制完善,大家的管理人士经验丰盛,国家的正经万分,不过由于施工项目标不可复制性,同样对于施工业公司业音讯化这一个“项目”也一致不可复制。

上面已经涉嫌的“不可复制”,那对于大家软件开发商、管理商讨机关、公司自己等专业职员辛费劲苦研制出来的可比贴合自个儿的“综合项目管心绪系统”,为何无法有效地促成下去,不能够行之有效地为我们全部企管服务吗(钢材暴跌的时候,为何还大量买入钢筋;为啥还要间段内的标价有个别类别4200元/吨,你的入库价格是5300元/吨)?那当中就遇到了软件服务进程的三个很要紧的环节“实施”,纵观国际软件发展,由单独的软件研究开发到明日的软件全经过服务,大家施工业集团业的软件服务也不能够例外。

澳门美高梅手机网站 1澳门美高梅手机网站 2

4.3 管理方式的更动

涉及管理格局,并不是指项目利益分配方面包车型大巴管理控制,而是指项目职员配备情势的更动。要想将精细化花费管理控制做到益处,那必须有定位的裨益分配方式,更要有公司公司直管项指标运行方式。而对此总承包的营业方式就符合集团监督、教导,但并不要过多少深度入出席具体事务。此外一种关键的情势改变就是使用系统记帐,渐渐撤销手工业帐,那种电子表格、电子邮件的传递情势就要稳步淡出视野。

澳门美高梅手机网站 3澳门美高梅手机网站 4

3 集团消息化实施面临的崛起难点

      
利用综述项目管理种类来改造守旧的建筑施工业公司业,差别历史背景的公司会选择两样的方法,当然分化的法子自然会发生差异的作用,可是这一执行进度却绝非易事,那里面暴漏出来的标题肯定是成都百货上千的,计算一下我们中中原人民共和国构筑科研院在那10年来实施的长河中相见的题材,首要有以下几下面:

一 、    基础知识管理的软弱

固然现代施工项目管理的盘算根源我们明天施工恐怕即将施工的花色,可是就现状来看,非常一些的建筑施工集团的根底工作都以不成就的,例如项指标材质员是空缺的,他们只通晓拿着带有签字的床单去财务办理并了结款,却连材质部的素材帐务簿都没有,更不用提统一的资料编码、统一的供应商目录。那一个突起显现是“量化”管理水平普遍不高,集团的根基管理工科作离标准化、规范化、制度化还有或多或少的差别,急需升高。

贰 、    新闻人才紧缺

音讯化学工业作的拓展必要一支高素质复合型并且相对稳定的音信化队容,那一个人口不仅是项目管理的行业内部骨干,同时还要具有扎实的音信化管理文化。最重庆大学的能以大局的历史观来看题目,能对音信化进度中的种种方案作很好的宏图并付诸实施。从此时此刻行行业内部的从事来源来看,此类人才应该是要么尤其缺的。

③ 、    制度的倒退

今昔众多破土集团都在尝试举行消息化系统,然后一套系统的、与商户管理整合紧凑、且可操作性强的音信管理制度与运营规律却卓殊广泛不够,可上可不上,最后致使消息化系统的推行贫乏需要的制度支持而展开迟缓,那或多或少是今日新闻化实施不成功的重中之重原因。

四 、    专项资金的空缺

可见将消息化专项资金列集团年度财务预算的很少,直接后果正是整整公司开始展览音信化学工业作安插与运维凌乱,无章法可言。

五 、    软件同盟商的非专业性

能做软件的协作商比比皆是,不过能做建筑行业的软件服务商确是九牛一毛,找3个相符本人公司提升的建筑行业软件服务器更是举步维艰。由于外行业职员不能在短时间内熟识建筑施工业集团业的军管细节,加上很多同盟商过分追求项目进程、追求目前市面利润,综上可得,肯定会促成众多音讯化项目“供给调查研商不到底,开发的软件系统实用性差,一再反复调查切磋,数次反复实践”现象大量产出,那之中的频率和成效同理可得。但那还不是最关键的,“每一回的退步都会使下三回的成功难度作了三遍平方”。

陆 、    地区正式的距离

对于大、中型建筑施工业公司业而言,施工项目遍布的范围广,而国情是例本省市都有例外的建筑专业(比如技术交底,品质安全验收规范等等),结果也使得开发体系时能纳入这一个专业改成第2大难题,合理的规划消息种类的适用范围,那无论是给系统的调查研究、开发乃至成功执行都埋下了伏笔。

/// <summary>
/// 删除
/// </summary>
public void Delete(string conditions)
{
    dbHelper.Delete<BS_Template>(conditions);
}

4 新闻化实施工作的思路与对策

对于消息化实施以来“存在即为合理”,任何难点的发生都有它一定的起因。音讯化实施也尚无无从出手,关键依然在于领导本人不俗心态,通过经历分析,结合大家施工业集团业自个儿的实际上,肯定能找到消除难题的切入点的。

澳门美高梅手机网站 5澳门美高梅手机网站 6

1前言

次贷风险自二零零六年11月上马席卷美利坚联邦合众国、欧洲结盟和日本等世界重庆大学金融市镇,由而对华夏实业经济发生严重影响。中中原人民共和国政坛经过选用了多轮的激励、打压固定资金财产投资,而对此我们施工公司确实都以愈演愈烈的市镇竞争,那个竞争让我们深入体会到了适者生存这一市经的早晚规律。作为古板产业链中的建筑施工业公司业,准备以一种怎么着的情态来敷衍现在的市镇竞争,那应该说已经成为我们普遍建筑施工业集团业协同探讨的课题。当然对于一个人曾在美利坚同盟国读完MBA的高层官员而言,最终提议的精雕细刻手法及应对手段也是过多的,然则大家都会有2个中央的共同的认识正是——中华夏族民共和国的施工业集团业与海外总承包商相比较,落后的不是施工工艺,而是大家的管理方式。为此众多建筑施工集团也在中中原人民共和国住房和城市和乡村城乡建设环保部的领路下,从增强公司自身管理初始,不断学习和借鉴国外总承包商先进的管住理念及措施,并在平日的田管进度中付诸实践。那里面极度醒指标一项课题正是借助现代音信技术来帮助、改造现阶段商行中间的保管难点,在中中原人民共和国住房和城市和乡村城乡村建设设环保部积极引导下一定多的大、中型建筑施工业集团业公司现已或许正在展开那方面包车型客车品尝,本文也将就此难点进行部分实施方面包车型地铁研讨,同时也总结一下中华人民共和国建造科研院在松开施工公司消息化进度中的一些做法和遇到的标题。

View Code

2 国内建筑施工业公司业集团软件系统选拔现状

从建筑施工业公司业总括机软件应用的进化进度来分析,能够将近期全方位公司音信化程度分为七个层次:① 、专项工作软件普及层次;二 、协理公司公司各项管理层次。**

澳门美高梅手机网站,    查询列表:

统筹规划,分步实施——音讯化实施商量

于明国
殷晓冬 周耀明

中华夏族民共和国大兴土木科研院

 

【摘要】施工业集团业新闻化的施行是信赖政策范围的辅助,软件服务商技术手段的支撑,百折不挠部门通力同盟、齐抓共管、协调带动,并百折不回一切和多渠道作育、吸引、提金秋家消息化人才,逐年加大投入,接纳统一筹划规划、分步实施、安分守纪,并末了走向成功。它不能够逾越雷区,无法复制,只好各有特色各有奥秘。

【关键词】项目管理、消息化、实施

澳门美高梅手机网站 7澳门美高梅手机网站 8

2.1专项工作软件普及层次

乘机计算机等电子装置日益进入公司和家园,其应用层次也水涨船高,计算机支持处理的范围也不断增加。工程施工人士对此利用软件来增派完成工作的须求也逐年增强,同时所有行业的工具软件开发和选择都拿走了比较大的开始展览,所以应该说未来的国情为行业工具软件的应用提供了大好的环境,比如PKPM结构软件、PKPM三合一清单软件、PKPM施工安全总括软件等的施用,使得大家工程职员的工效获得了非常的大抓牢,日常工作与电脑软件结合的紧凑性也更为强。那也是大家大多数施工业集团业的软件应用现状。

    根据ID删除:

   
获取最大ID(当然,ID一般选择自增,对于并发量极少的种类,或单机系统,为了便利,能够这么做):

澳门美高梅手机网站 9澳门美高梅手机网站 10

View Code

View Code

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using DBUtil;
using Models;

namespace DAL
{
    /// <summary>
    /// 模板
    /// </summary>
    public class TemplateDal
    {
        #region 变量
        private DBHelper dbHelper = new DBHelper();
        #endregion

        #region 分页获取模板集合
        /// <summary>
        /// 分页获取模板集合
        /// </summary>
        public List<BS_Template> GetList(ref PagerModel pager, string noticeType, string coreType, string name, Enums.TemplateType templateType)
        {
            StringBuilder sql = new StringBuilder(string.Format(@"
                select *
                from BS_Template t
                where 1=1 "));

            if (!string.IsNullOrWhiteSpace(noticeType))
            {
                sql.AppendFormat(" and nt.name like '%{0}%'", noticeType);
            }

            if (!string.IsNullOrWhiteSpace(coreType))
            {
                sql.AppendFormat(" and ct.name like '%{0}%'", coreType);
            }

            if (!string.IsNullOrWhiteSpace(name))
            {
                sql.AppendFormat(" and t.name like '%{0}%'", name);
            }

            sql.AppendFormat(" and t.type = '{0}'", (int)templateType);

            string orderby = "order by cast(id as int)";
            pager = dbHelper.FindPageBySql<BS_Template>(sql.ToString(), orderby, pager.rows, pager.page);
            return pager.result as List<BS_Template>;
        }
        #endregion

        #region 获取字段关联模板集合
        /// <summary>
        /// 获取字段关联模板集合
        /// </summary>
        public List<BS_Template> GetList(string fieldId)
        {
            StringBuilder sql = new StringBuilder(string.Format(@"
                select *
                from BS_Template t
                left join BS_TplFieldRelation r on r.templateId=t.id
                left join BS_TplField f on f.id=r.fieldId  
                where f.id='{0}'", fieldId));
            return dbHelper.FindListBySql<BS_Template>(sql.ToString());
        }
        #endregion

        #region 获取
        public BS_Template Get(string typeCode, Enums.TemplateType templateType)
        {
            StringBuilder sql = new StringBuilder(string.Format(@"
                select *
                from BS_Template 
                where typeCode='{0}' 
                and type='{1}'", typeCode, (int)templateType));
            return dbHelper.FindBySql<BS_Template>(sql.ToString());
        }
        public BS_Template Get2(string templateId, Enums.TemplateType templateType)
        {
            StringBuilder sql = new StringBuilder(string.Format(@"
                select *
                from BS_Template 
                where id='{0}' 
                and type='{1}'", templateId, (int)templateType));
            return dbHelper.FindBySql<BS_Template>(sql.ToString());
        }
        #endregion

        #region GetMaxId
        /// <summary>
        /// GetMaxId
        /// </summary>
        public int GetMaxId()
        {
            return dbHelper.GetMaxID<BS_Template>("id");
        }
        #endregion

        #region 添加
        /// <summary>
        /// 添加
        /// </summary>
        public void Insert(object obj)
        {
            dbHelper.Insert(obj);
        }
        #endregion

        #region 修改
        /// <summary>
        /// 修改
        /// </summary>
        public void Update(object obj)
        {
            dbHelper.Update(obj);
        }
        #endregion

        #region 删除
        /// <summary>
        /// 删除
        /// </summary>
        public void Del(int id)
        {
            dbHelper.Delete<BS_Template>(id);
        }
        /// <summary>
        /// 删除
        /// </summary>
        public void BatchDelete(string ids)
        {
            dbHelper.BatchDelete<BS_Template>(ids);
        }
        /// <summary>
        /// 删除
        /// </summary>
        public void Delete(string conditions)
        {
            dbHelper.Delete<BS_Template>(conditions);
        }
        #endregion

    }
}

澳门美高梅手机网站 11澳门美高梅手机网站 12

    完整DAL:

/// <summary>
/// 查询列表
/// </summary>
public List<BS_Test> GetList(string name)
{
    StringBuilder sql = new StringBuilder(string.Format(@"
        select *
        from BS_Test t
        where 1=1 "));

    if (!string.IsNullOrWhiteSpace(name))
    {
        sql.AppendFormat(" and t.name like '%{0}%'", name);
    }

    return dbHelper.FindListBySql<BS_Test>(sql.ToString());
}

澳门美高梅手机网站 13澳门美高梅手机网站 14

View Code

/// <summary>
/// 分页获取模板集合
/// </summary>
public List<BS_Template> GetList(ref PagerModel pager, string noticeType, string coreType, string name, Enums.TemplateType templateType)
{
    StringBuilder sql = new StringBuilder(string.Format(@"
        select *
        from BS_Template t
        where 1=1 "));

    if (!string.IsNullOrWhiteSpace(noticeType))
    {
        sql.AppendFormat(" and nt.name like '%{0}%'", noticeType);
    }

    if (!string.IsNullOrWhiteSpace(coreType))
    {
        sql.AppendFormat(" and ct.name like '%{0}%'", coreType);
    }

    if (!string.IsNullOrWhiteSpace(name))
    {
        sql.AppendFormat(" and t.name like '%{0}%'", name);
    }

    sql.AppendFormat(" and t.type = '{0}'", (int)templateType);

    string orderby = "order by cast(id as int)";
    pager = dbHelper.FindPageBySql<BS_Template>(sql.ToString(), orderby, pager.rows, pager.page);
    return pager.result as List<BS_Template>;
}
try
{
    DBHelper.BeginTransaction();

    BS_Template model = new BS_Template();
    model.id = m_TemplateDal.GetMaxId().ToString();
    model.code = k.ToString("0000");
    model.name = "测试" + k.ToString();
    model.remarks = "测试" + k.ToString();
    model.type = ((int)Enums.TemplateType.Notice).ToString();
    m_TemplateDal.Insert(model);
    //throw new Exception("a");

    BS_Test test = new BS_Test();
    test.id = m_TestDal.GetMaxId().ToString();
    test.code = "测试" + k.ToString();
    test.name = "测试" + k.ToString();
    test.remarks = "测试" + k.ToString();
    m_TestDal.Insert(test);

    DBHelper.CommitTransaction();
    MessageBox.Show("成功");
}
catch (Exception ex)
{
    DBHelper.RollbackTransaction();
    MessageBox.Show(ex.Message);
}

    依照规则查询实体:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Configuration;
using System.Data;
using System.Data.Common;
using System.Data.Objects.DataClasses;
using System.Data.OracleClient;
using System.Data.SqlClient;
using System.Data.SQLite;
using System.Reflection;
using System.Text;
using Models;
using MySql.Data.MySqlClient;

namespace DBUtil
{
    /// <summary>
    /// 数据库操作类
    /// 2016年09月09日
    /// </summary>
    public class DBHelper
    {
        #region 变量
        /// <summary>
        /// 数据库类型
        /// </summary>
        private static string m_DBType = ConfigurationManager.AppSettings["DBType"];
        /// <summary>
        /// 数据库类型
        /// </summary>
        private static bool m_AutoIncrement = ConfigurationManager.AppSettings["AutoIncrement"].ToLower() == "true" ? true : false;
        /// <summary>
        /// 数据库连接字符串
        /// </summary>
        private static string m_ConnectionString = ConfigurationManager.ConnectionStrings["DefaultConnection"].ToString();
        /// <summary>
        /// 事务
        /// </summary>
        [ThreadStatic]
        private static DbTransaction m_Tran;
        /// <summary>
        /// 带参数的SQL插入和修改语句中,参数前面的符号
        /// </summary>
        private static string m_ParameterMark = GetParameterMark();
        #endregion

        #region 构造函数
        /// <summary>
        /// 数据库操作类
        /// </summary>
        public DBHelper()
        {
        }
        #endregion

        #region 生成变量
        #region 生成 IDbCommand
        /// <summary>
        /// 生成 IDbCommand
        /// </summary>
        private DbCommand GetCommand()
        {
            DbCommand command = null;

            switch (m_DBType)
            {
                case "oracle":
                    command = new OracleCommand();
                    break;
                case "mssql":
                    command = new SqlCommand();
                    break;
                case "mysql":
                    command = new MySqlCommand();
                    break;
                case "sqlite":
                    command = new SQLiteCommand();
                    break;
            }

            return command;
        }
        /// <summary>
        /// 生成 IDbCommand
        /// </summary>
        private DbCommand GetCommand(string sql, DbConnection conn)
        {
            DbCommand command = null;

            switch (m_DBType)
            {
                case "oracle":
                    command = new OracleCommand(sql);
                    command.Connection = conn;
                    break;
                case "mssql":
                    command = new SqlCommand(sql);
                    command.Connection = conn;
                    break;
                case "mysql":
                    command = new MySqlCommand(sql);
                    command.Connection = conn;
                    break;
                case "sqlite":
                    command = new SQLiteCommand(sql);
                    command.Connection = conn;
                    break;
            }

            return command;
        }
        #endregion

        #region 生成 IDbConnection
        /// <summary>
        /// 生成 IDbConnection
        /// </summary>
        private static DbConnection GetConnection()
        {
            DbConnection conn = null;

            switch (m_DBType)
            {
                case "oracle":
                    conn = new OracleConnection(m_ConnectionString);
                    break;
                case "mssql":
                    conn = new SqlConnection(m_ConnectionString);
                    break;
                case "mysql":
                    conn = new MySqlConnection(m_ConnectionString);
                    break;
                case "sqlite":
                    conn = new SQLiteConnection(m_ConnectionString);
                    break;
            }

            return conn;
        }
        #endregion

        #region 生成 IDbDataAdapter
        /// <summary>
        /// 生成 IDbDataAdapter
        /// </summary>
        private DbDataAdapter GetDataAdapter(DbCommand cmd)
        {
            DbDataAdapter dataAdapter = null;

            switch (m_DBType)
            {
                case "oracle":
                    dataAdapter = new OracleDataAdapter();
                    dataAdapter.SelectCommand = cmd;
                    break;
                case "mssql":
                    dataAdapter = new SqlDataAdapter();
                    dataAdapter.SelectCommand = cmd;
                    break;
                case "mysql":
                    dataAdapter = new MySqlDataAdapter();
                    dataAdapter.SelectCommand = cmd;
                    break;
                case "sqlite":
                    dataAdapter = new SQLiteDataAdapter();
                    dataAdapter.SelectCommand = cmd;
                    break;
            }

            return dataAdapter;
        }
        #endregion

        #region 生成 m_ParameterMark
        /// <summary>
        /// 生成 m_ParameterMark
        /// </summary>
        private static string GetParameterMark()
        {
            switch (m_DBType)
            {
                case "oracle":
                    return ":";
                case "mssql":
                    return "@";
                case "mysql":
                    return "@";
                case "sqlite":
                    return ":";
            }
            return ":";
        }
        #endregion

        #region 生成 DbParameter
        /// <summary>
        /// 生成 DbParameter
        /// </summary>
        private DbParameter GetDbParameter(string name, object value)
        {
            DbParameter dbParameter = null;

            switch (m_DBType)
            {
                case "oracle":
                    dbParameter = new OracleParameter(name, value);
                    break;
                case "mssql":
                    dbParameter = new SqlParameter(name, value);
                    break;
                case "mysql":
                    dbParameter = new MySqlParameter(name, value);
                    break;
                case "sqlite":
                    dbParameter = new SQLiteParameter(name, value);
                    break;
            }

            return dbParameter;
        }
        #endregion
        #endregion

        #region 基础方法
        #region  执行简单SQL语句
        #region Exists
        public bool Exists(string sqlString)
        {
            using (DbConnection conn = GetConnection())
            {
                using (DbCommand cmd = GetCommand(sqlString, conn))
                {
                    try
                    {
                        conn.Open();
                        object obj = cmd.ExecuteScalar();
                        if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
                        {
                            return false;
                        }
                        else
                        {
                            return true;
                        }
                    }
                    catch (Exception ex)
                    {
                        throw ex;
                    }
                    finally
                    {
                        cmd.Dispose();
                        conn.Close();
                    }
                }
            }
        }
        #endregion

        #region 执行SQL语句,返回影响的记录数
        /// <summary>
        /// 执行SQL语句,返回影响的记录数
        /// </summary>
        /// <param name="sqlString">SQL语句</param>
        /// <returns>影响的记录数</returns>
        public int ExecuteSql(string sqlString)
        {
            DbConnection conn = m_Tran == null ? GetConnection() : m_Tran.Connection;
            using (DbCommand cmd = GetCommand(sqlString, conn))
            {
                try
                {
                    if (conn.State != ConnectionState.Open) conn.Open();
                    if (m_Tran != null) cmd.Transaction = m_Tran;
                    int rows = cmd.ExecuteNonQuery();
                    return rows;
                }
                catch (Exception ex)
                {
                    throw new Exception(ex.Message);
                }
                finally
                {
                    cmd.Dispose();
                    if (m_Tran == null) conn.Close();
                }
            }
        }
        #endregion

        #region 执行一条计算查询结果语句,返回查询结果
        /// <summary>
        /// 执行一条计算查询结果语句,返回查询结果(object)
        /// </summary>
        /// <param name="sqlString">计算查询结果语句</param>
        /// <returns>查询结果(object)</returns>
        public object GetSingle(string sqlString)
        {
            using (DbConnection conn = GetConnection())
            {
                using (DbCommand cmd = GetCommand(sqlString, conn))
                {
                    try
                    {
                        if (conn.State != ConnectionState.Open) conn.Open();
                        object obj = cmd.ExecuteScalar();
                        if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
                        {
                            return null;
                        }
                        else
                        {
                            return obj;
                        }
                    }
                    catch (Exception ex)
                    {
                        throw ex;
                    }
                    finally
                    {
                        cmd.Dispose();
                    }
                }
            }
        }
        #endregion

        #region 执行查询语句,返回IDataReader
        /// <summary>
        /// 执行查询语句,返回IDataReader ( 注意:调用该方法后,一定要对IDataReader进行Close )
        /// </summary>
        /// <param name="sqlString">查询语句</param>
        /// <returns>IDataReader</returns>
        public DbDataReader ExecuteReader(string sqlString)
        {
            DbConnection conn = GetConnection();
            DbCommand cmd = GetCommand(sqlString, conn);
            try
            {
                if (conn.State != ConnectionState.Open) conn.Open();
                DbDataReader myReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
                return myReader;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        #endregion

        #region 执行查询语句,返回DataSet
        /// <summary>
        /// 执行查询语句,返回DataSet
        /// </summary>
        /// <param name="sqlString">查询语句</param>
        /// <returns>DataSet</returns>
        public DataSet Query(string sqlString)
        {
            using (DbConnection conn = GetConnection())
            {
                DataSet ds = new DataSet();
                try
                {
                    conn.Open();
                    using (DbCommand cmd = GetCommand(sqlString, conn))
                    {
                        DbDataAdapter adapter = GetDataAdapter(cmd);
                        adapter.Fill(ds, "ds");
                    }
                }
                catch (Exception ex)
                {
                    throw ex;
                }
                finally
                {
                    conn.Close();
                }
                return ds;
            }
        }
        #endregion
        #endregion

        #region 执行带参数的SQL语句
        #region 执行SQL语句,返回影响的记录数
        /// <summary>
        /// 执行SQL语句,返回影响的记录数
        /// </summary>
        /// <param name="SQLString">SQL语句</param>
        /// <returns>影响的记录数</returns>
        public int ExecuteSql(string SQLString, params DbParameter[] cmdParms)
        {
            DbConnection conn = m_Tran == null ? GetConnection() : m_Tran.Connection;
            using (DbCommand cmd = GetCommand())
            {
                try
                {
                    PrepareCommand(cmd, conn, m_Tran, SQLString, cmdParms);
                    int rows = cmd.ExecuteNonQuery();
                    cmd.Parameters.Clear();
                    return rows;
                }
                catch (Exception ex)
                {
                    throw ex;
                }
                finally
                {
                    cmd.Dispose();
                    if (m_Tran == null) conn.Close();
                }
            }
        }
        #endregion

        #region 执行查询语句,返回IDataReader
        /// <summary>
        /// 执行查询语句,返回IDataReader ( 注意:调用该方法后,一定要对IDataReader进行Close )
        /// </summary>
        /// <param name="strSQL">查询语句</param>
        /// <returns>IDataReader</returns>
        public DbDataReader ExecuteReader(string sqlString, params DbParameter[] cmdParms)
        {
            DbConnection conn = GetConnection();
            DbCommand cmd = GetCommand();
            try
            {
                PrepareCommand(cmd, conn, null, sqlString, cmdParms);
                DbDataReader myReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
                cmd.Parameters.Clear();
                return myReader;
            }
            catch (Exception ex)
            {
                throw ex;
            }

        }
        #endregion

        #region 执行查询语句,返回DataSet
        /// <summary>
        /// 执行查询语句,返回DataSet
        /// </summary>
        /// <param name="sqlString">查询语句</param>
        /// <returns>DataSet</returns>
        public DataSet Query(string sqlString, params DbParameter[] cmdParms)
        {
            DbConnection conn = GetConnection();
            DbCommand cmd = GetCommand();
            PrepareCommand(cmd, conn, null, sqlString, cmdParms);
            using (DbDataAdapter da = GetDataAdapter(cmd))
            {
                DataSet ds = new DataSet();
                try
                {
                    da.Fill(ds, "ds");
                    cmd.Parameters.Clear();
                }
                catch (Exception ex)
                {
                    throw ex;
                }
                finally
                {
                    cmd.Dispose();
                    conn.Close();
                }
                return ds;
            }
        }
        #endregion

        #region PrepareCommand
        private void PrepareCommand(DbCommand cmd, DbConnection conn, DbTransaction trans, string cmdText, DbParameter[] cmdParms)
        {
            if (conn.State != ConnectionState.Open) conn.Open();
            cmd.Connection = conn;
            cmd.CommandText = cmdText;
            if (trans != null) cmd.Transaction = trans;
            cmd.CommandType = CommandType.Text;
            if (cmdParms != null)
            {
                foreach (DbParameter parm in cmdParms)
                {
                    cmd.Parameters.Add(parm);
                }
            }
        }
        #endregion
        #endregion
        #endregion

        #region 增删改查
        #region 获取最大编号
        /// <summary>
        /// 获取最大编号
        /// </summary>
        /// <typeparam name="T">实体Model</typeparam>
        /// <param name="key">主键</param>
        public int GetMaxID<T>(string key)
        {
            Type type = typeof(T);

            string sql = null;
            switch (m_DBType)
            {
                case "oracle":
                    sql = string.Format("SELECT Max({0}) FROM {1}", key, type.Name);
                    break;
                case "mssql":
                    sql = string.Format("SELECT Max({0}) FROM {1}", key, type.Name);
                    break;
                case "mysql":
                    sql = string.Format("SELECT Max({0}) FROM {1}", key, type.Name);
                    break;
                case "sqlite":
                    sql = string.Format("SELECT Max(cast({0} as int)) FROM {1}", key, type.Name);
                    break;
            }

            using (DbConnection conn = GetConnection())
            {
                using (IDbCommand cmd = GetCommand(sql, conn))
                {
                    try
                    {
                        conn.Open();
                        object obj = cmd.ExecuteScalar();
                        if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
                        {
                            return 1;
                        }
                        else
                        {
                            return int.Parse(obj.ToString()) + 1;
                        }
                    }
                    catch (Exception ex)
                    {
                        throw ex;
                    }
                    finally
                    {
                        cmd.Dispose();
                        conn.Close();
                    }
                }
            }
        }
        #endregion

        #region 添加
        /// <summary>
        /// 添加
        /// </summary>
        public void Insert(object obj)
        {
            Insert(obj, m_AutoIncrement);
        }
        /// <summary>
        /// 添加
        /// </summary>
        public void Insert(object obj, bool autoIncrement)
        {
            StringBuilder strSql = new StringBuilder();
            Type type = obj.GetType();
            strSql.Append(string.Format("insert into {0}(", type.Name));

            PropertyInfo[] propertyInfoList = GetEntityProperties(type);
            List<string> propertyNameList = new List<string>();
            int savedCount = 0;
            foreach (PropertyInfo propertyInfo in propertyInfoList)
            {
                if (propertyInfo.GetCustomAttributes(typeof(IsIdAttribute), false).Length > 0 && autoIncrement) return;
                if (propertyInfo.GetCustomAttributes(typeof(IsDBFieldAttribute), false).Length > 0)
                {
                    propertyNameList.Add(propertyInfo.Name);
                    savedCount++;
                }
            }

            strSql.Append(string.Format("{0})", string.Join(",", propertyNameList.ToArray())));
            strSql.Append(string.Format(" values ({0})", string.Join(",", propertyNameList.ConvertAll<string>(a => m_ParameterMark + a).ToArray())));
            DbParameter[] parameters = new DbParameter[savedCount];
            int k = 0;
            for (int i = 0; i < propertyInfoList.Length && savedCount > 0; i++)
            {
                PropertyInfo propertyInfo = propertyInfoList[i];
                if (propertyInfo.GetCustomAttributes(typeof(IsIdAttribute), false).Length > 0 && autoIncrement) return;
                if (propertyInfo.GetCustomAttributes(typeof(IsDBFieldAttribute), false).Length > 0)
                {
                    object val = propertyInfo.GetValue(obj, null);
                    DbParameter param = GetDbParameter(m_ParameterMark + propertyInfo.Name, val == null ? DBNull.Value : val);
                    parameters[k++] = param;
                }
            }

            ExecuteSql(strSql.ToString(), parameters);
        }
        #endregion

        #region 修改
        /// <summary>
        /// 修改
        /// </summary>
        public void Update(object obj)
        {
            object oldObj = Find(obj, false);
            if (oldObj == null) throw new Exception("无法获取到旧数据");

            StringBuilder strSql = new StringBuilder();
            Type type = obj.GetType();
            strSql.Append(string.Format("update {0} ", type.Name));

            PropertyInfo[] propertyInfoList = GetEntityProperties(type);
            List<string> propertyNameList = new List<string>();
            int savedCount = 0;
            foreach (PropertyInfo propertyInfo in propertyInfoList)
            {
                if (propertyInfo.GetCustomAttributes(typeof(IsDBFieldAttribute), false).Length > 0)
                {
                    object oldVal = propertyInfo.GetValue(oldObj, null);
                    object val = propertyInfo.GetValue(obj, null);
                    if (!object.Equals(oldVal, val))
                    {
                        propertyNameList.Add(propertyInfo.Name);
                        savedCount++;
                    }
                }
            }

            strSql.Append(string.Format(" set "));
            DbParameter[] parameters = new DbParameter[savedCount];
            StringBuilder sbPros = new StringBuilder();
            int k = 0;
            for (int i = 0; i < propertyInfoList.Length && savedCount > 0; i++)
            {
                PropertyInfo propertyInfo = propertyInfoList[i];
                if (propertyInfo.GetCustomAttributes(typeof(IsDBFieldAttribute), false).Length > 0)
                {
                    object oldVal = propertyInfo.GetValue(oldObj, null);
                    object val = propertyInfo.GetValue(obj, null);
                    if (!object.Equals(oldVal, val))
                    {
                        sbPros.Append(string.Format(" {0}={1}{0},", propertyInfo.Name, m_ParameterMark));
                        DbParameter param = GetDbParameter(m_ParameterMark + propertyInfo.Name, val == null ? DBNull.Value : val);
                        parameters[k++] = param;
                    }
                }
            }
            if (sbPros.Length > 0)
            {
                strSql.Append(sbPros.ToString(0, sbPros.Length - 1));
            }
            strSql.Append(string.Format(" where {0}='{1}'", GetIdName(obj.GetType()), GetIdVal(obj).ToString()));

            if (savedCount > 0)
            {
                ExecuteSql(strSql.ToString(), parameters);
            }
        }
        #endregion

        #region 删除
        /// <summary>
        /// 根据Id删除
        /// </summary>
        public void Delete<T>(int id)
        {
            Type type = typeof(T);
            StringBuilder sbSql = new StringBuilder();
            sbSql.Append(string.Format("delete from {0} where {2}='{1}'", type.Name, id, GetIdName(type)));

            ExecuteSql(sbSql.ToString());
        }
        /// <summary>
        /// 根据Id集合删除
        /// </summary>
        public void BatchDelete<T>(string ids)
        {
            if (string.IsNullOrWhiteSpace(ids)) return;

            Type type = typeof(T);
            StringBuilder sbSql = new StringBuilder();
            sbSql.Append(string.Format("delete from {0} where {2} in ({1})", type.Name, ids, GetIdName(type)));

            ExecuteSql(sbSql.ToString());
        }
        /// <summary>
        /// 根据条件删除
        /// </summary>
        public void Delete<T>(string conditions)
        {
            if (string.IsNullOrWhiteSpace(conditions)) return;

            Type type = typeof(T);
            StringBuilder sbSql = new StringBuilder();
            sbSql.Append(string.Format("delete from {0} where {1}", type.Name, conditions));

            ExecuteSql(sbSql.ToString());
        }
        #endregion

        #region 获取实体
        #region 根据实体获取实体
        /// <summary>
        /// 根据实体获取实体
        /// </summary>
        private object Find(object obj, bool readCache = true)
        {
            Type type = obj.GetType();

            object result = Activator.CreateInstance(type);
            bool hasValue = false;
            IDataReader rd = null;

            string sql = string.Format("select * from {0} where {2}='{1}'", type.Name, GetIdVal(obj), GetIdName(obj.GetType()));

            try
            {
                rd = ExecuteReader(sql);

                PropertyInfo[] propertyInfoList = GetEntityProperties(type);

                int fcnt = rd.FieldCount;
                List<string> fileds = new List<string>();
                for (int i = 0; i < fcnt; i++)
                {
                    fileds.Add(rd.GetName(i).ToUpper());
                }

                while (rd.Read())
                {
                    hasValue = true;
                    IDataRecord record = rd;

                    foreach (PropertyInfo pro in propertyInfoList)
                    {
                        if (!fileds.Contains(pro.Name.ToUpper()) || record[pro.Name] == DBNull.Value)
                        {
                            continue;
                        }

                        pro.SetValue(result, record[pro.Name] == DBNull.Value ? null : getReaderValue(record[pro.Name], pro.PropertyType), null);
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (rd != null && !rd.IsClosed)
                {
                    rd.Close();
                    rd.Dispose();
                }
            }

            if (hasValue)
            {
                return result;
            }
            else
            {
                return null;
            }
        }
        #endregion

        #region 根据Id获取实体
        /// <summary>
        /// 根据Id获取实体
        /// </summary>
        private object FindById(Type type, int id)
        {
            object result = Activator.CreateInstance(type);
            IDataReader rd = null;
            bool hasValue = false;

            string sql = string.Format("select * from {0} where {2}='{1}'", type.Name, id, GetIdName(type));

            try
            {
                rd = ExecuteReader(sql);

                PropertyInfo[] propertyInfoList = GetEntityProperties(type);

                int fcnt = rd.FieldCount;
                List<string> fileds = new List<string>();
                for (int i = 0; i < fcnt; i++)
                {
                    fileds.Add(rd.GetName(i).ToUpper());
                }

                while (rd.Read())
                {
                    hasValue = true;
                    IDataRecord record = rd;

                    foreach (PropertyInfo pro in propertyInfoList)
                    {
                        if (!fileds.Contains(pro.Name.ToUpper()) || record[pro.Name] == DBNull.Value)
                        {
                            continue;
                        }

                        pro.SetValue(result, record[pro.Name] == DBNull.Value ? null : getReaderValue(record[pro.Name], pro.PropertyType), null);
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (rd != null && !rd.IsClosed)
                {
                    rd.Close();
                    rd.Dispose();
                }
            }

            if (hasValue)
            {
                return result;
            }
            else
            {
                return null;
            }
        }
        #endregion

        #region 根据Id获取实体
        /// <summary>
        /// 根据Id获取实体
        /// </summary>
        public T FindById<T>(string id) where T : new()
        {
            Type type = typeof(T);
            T result = (T)Activator.CreateInstance(type);
            IDataReader rd = null;
            bool hasValue = false;

            string sql = string.Format("select * from {0} where {2}='{1}'", type.Name, id, GetIdName(type));

            try
            {
                rd = ExecuteReader(sql);

                PropertyInfo[] propertyInfoList = GetEntityProperties(type);

                int fcnt = rd.FieldCount;
                List<string> fileds = new List<string>();
                for (int i = 0; i < fcnt; i++)
                {
                    fileds.Add(rd.GetName(i).ToUpper());
                }

                while (rd.Read())
                {
                    hasValue = true;
                    IDataRecord record = rd;

                    foreach (PropertyInfo pro in propertyInfoList)
                    {
                        if (!fileds.Contains(pro.Name.ToUpper()) || record[pro.Name] == DBNull.Value)
                        {
                            continue;
                        }

                        pro.SetValue(result, record[pro.Name] == DBNull.Value ? null : getReaderValue(record[pro.Name], pro.PropertyType), null);
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (rd != null && !rd.IsClosed)
                {
                    rd.Close();
                    rd.Dispose();
                }
            }

            if (hasValue)
            {
                return result;
            }
            else
            {
                return default(T);
            }
        }
        #endregion

        #region 根据sql获取实体
        /// <summary>
        /// 根据sql获取实体
        /// </summary>
        public T FindBySql<T>(string sql) where T : new()
        {
            Type type = typeof(T);
            T result = (T)Activator.CreateInstance(type);
            IDataReader rd = null;
            bool hasValue = false;

            try
            {
                rd = ExecuteReader(sql);

                PropertyInfo[] propertyInfoList = GetEntityProperties(type);

                int fcnt = rd.FieldCount;
                List<string> fileds = new List<string>();
                for (int i = 0; i < fcnt; i++)
                {
                    fileds.Add(rd.GetName(i).ToUpper());
                }

                while (rd.Read())
                {
                    hasValue = true;
                    IDataRecord record = rd;

                    foreach (PropertyInfo pro in propertyInfoList)
                    {
                        if (!fileds.Contains(pro.Name.ToUpper()) || record[pro.Name] == DBNull.Value)
                        {
                            continue;
                        }

                        pro.SetValue(result, record[pro.Name] == DBNull.Value ? null : getReaderValue(record[pro.Name], pro.PropertyType), null);
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (rd != null && !rd.IsClosed)
                {
                    rd.Close();
                    rd.Dispose();
                }
            }

            if (hasValue)
            {
                return result;
            }
            else
            {
                return default(T);
            }
        }
        #endregion
        #endregion

        #region 获取列表
        /// <summary>
        /// 获取列表
        /// </summary>
        public List<T> FindListBySql<T>(string sql) where T : new()
        {
            List<T> list = new List<T>();
            object obj;
            IDataReader rd = null;

            try
            {
                rd = ExecuteReader(sql);

                if (typeof(T) == typeof(int))
                {
                    while (rd.Read())
                    {
                        list.Add((T)rd[0]);
                    }
                }
                else if (typeof(T) == typeof(string))
                {
                    while (rd.Read())
                    {
                        list.Add((T)rd[0]);
                    }
                }
                else
                {
                    PropertyInfo[] propertyInfoList = (typeof(T)).GetProperties();

                    int fcnt = rd.FieldCount;
                    List<string> fileds = new List<string>();
                    for (int i = 0; i < fcnt; i++)
                    {
                        fileds.Add(rd.GetName(i).ToUpper());
                    }

                    while (rd.Read())
                    {
                        IDataRecord record = rd;
                        obj = new T();


                        foreach (PropertyInfo pro in propertyInfoList)
                        {
                            if (!fileds.Contains(pro.Name.ToUpper()) || record[pro.Name] == DBNull.Value)
                            {
                                continue;
                            }

                            pro.SetValue(obj, record[pro.Name] == DBNull.Value ? null : getReaderValue(record[pro.Name], pro.PropertyType), null);
                        }
                        list.Add((T)obj);
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (rd != null && !rd.IsClosed)
                {
                    rd.Close();
                    rd.Dispose();
                }
            }

            return list;
        }
        #endregion

        #region 获取列表
        /// <summary>
        /// 获取列表
        /// </summary>
        public List<T> FindListBySql<T>(string sql, params DbParameter[] cmdParms) where T : new()
        {
            List<T> list = new List<T>();
            object obj;
            IDataReader rd = null;

            try
            {
                rd = ExecuteReader(sql, cmdParms);

                if (typeof(T) == typeof(int))
                {
                    while (rd.Read())
                    {
                        list.Add((T)rd[0]);
                    }
                }
                else if (typeof(T) == typeof(string))
                {
                    while (rd.Read())
                    {
                        list.Add((T)rd[0]);
                    }
                }
                else
                {
                    PropertyInfo[] propertyInfoList = (typeof(T)).GetProperties();

                    int fcnt = rd.FieldCount;
                    List<string> fileds = new List<string>();
                    for (int i = 0; i < fcnt; i++)
                    {
                        fileds.Add(rd.GetName(i).ToUpper());
                    }

                    while (rd.Read())
                    {
                        IDataRecord record = rd;
                        obj = new T();


                        foreach (PropertyInfo pro in propertyInfoList)
                        {
                            if (!fileds.Contains(pro.Name.ToUpper()) || record[pro.Name] == DBNull.Value)
                            {
                                continue;
                            }

                            pro.SetValue(obj, record[pro.Name] == DBNull.Value ? null : getReaderValue(record[pro.Name], pro.PropertyType), null);
                        }
                        list.Add((T)obj);
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (rd != null && !rd.IsClosed)
                {
                    rd.Close();
                    rd.Dispose();
                }
            }

            return list;
        }
        #endregion

        #region 分页获取列表
        /// <summary>
        /// 分页(任意entity,尽量少的字段)
        /// </summary>
        public PagerModel FindPageBySql<T>(string sql, string orderby, int pageSize, int currentPage) where T : new()
        {
            PagerModel pagerModel = new PagerModel(currentPage, pageSize);

            using (DbConnection connection = GetConnection())
            {
                connection.Open();
                IDbCommand cmd = null;
                StringBuilder sb = new StringBuilder();
                string commandText = null;
                int startRow = 0;
                int endRow = 0;
                switch (m_DBType)
                {
                    case "oracle":
                        #region 分页查询语句
                        commandText = string.Format("select count(*) from ({0}) T", sql);
                        cmd = GetCommand(commandText, connection);
                        pagerModel.totalRows = int.Parse(cmd.ExecuteScalar().ToString());

                        startRow = pageSize * (currentPage - 1);
                        endRow = startRow + pageSize;

                        sb.Append("select * from ( select row_limit.*, rownum rownum_ from (");
                        sb.Append(sql);
                        if (!string.IsNullOrWhiteSpace(orderby))
                        {
                            sb.Append(" ");
                            sb.Append(orderby);
                        }
                        sb.Append(" ) row_limit where rownum <= ");
                        sb.Append(endRow);
                        sb.Append(" ) where rownum_ >");
                        sb.Append(startRow);
                        #endregion
                        break;
                    case "mssql":
                        #region 分页查询语句
                        commandText = string.Format("select count(*) from ({0}) T", sql);
                        cmd = GetCommand(commandText, connection);
                        pagerModel.totalRows = int.Parse(cmd.ExecuteScalar().ToString());

                        startRow = pageSize * (currentPage - 1) + 1;
                        endRow = startRow + pageSize - 1;

                        sb.Append(string.Format(@"
                            select * from 
                            (select ROW_NUMBER() over({1}) as rowNumber, t.* from ({0}) t) tempTable
                            where rowNumber between {2} and {3} ", sql, orderby, startRow, endRow));
                        #endregion
                        break;
                    case "mysql":
                        #region 分页查询语句
                        commandText = string.Format("select count(*) from ({0}) T", sql);
                        cmd = GetCommand(commandText, connection);
                        pagerModel.totalRows = int.Parse(cmd.ExecuteScalar().ToString());

                        startRow = pageSize * (currentPage - 1);

                        sb.Append("select * from (");
                        sb.Append(sql);
                        if (!string.IsNullOrWhiteSpace(orderby))
                        {
                            sb.Append(" ");
                            sb.Append(orderby);
                        }
                        sb.AppendFormat(" ) row_limit limit {0},{1}", startRow, pageSize);
                        #endregion
                        break;
                    case "sqlite":
                        #region 分页查询语句
                        commandText = string.Format("select count(*) from ({0}) T", sql);
                        cmd = GetCommand(commandText, connection);
                        pagerModel.totalRows = int.Parse(cmd.ExecuteScalar().ToString());

                        startRow = pageSize * (currentPage - 1);

                        sb.Append(sql);
                        if (!string.IsNullOrWhiteSpace(orderby))
                        {
                            sb.Append(" ");
                            sb.Append(orderby);
                        }
                        sb.AppendFormat(" limit {0} offset {1}", pageSize, startRow);
                        #endregion
                        break;
                }

                List<T> list = FindListBySql<T>(sb.ToString());
                pagerModel.result = list;
            }

            return pagerModel;
        }
        #endregion

        #region 分页获取列表
        /// <summary>
        /// 分页(任意entity,尽量少的字段)
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="sql"></param>
        /// <returns></returns>
        public PagerModel FindPageBySql<T>(string sql, string orderby, int pageSize, int currentPage, params DbParameter[] cmdParms) where T : new()
        {
            PagerModel pagerModel = new PagerModel(currentPage, pageSize);

            using (DbConnection connection = GetConnection())
            {
                connection.Open();
                IDbCommand cmd = null;
                StringBuilder sb = new StringBuilder();
                string commandText = null;
                int startRow = 0;
                int endRow = 0;
                switch (m_DBType)
                {
                    case "oracle":
                        #region 分页查询语句
                        commandText = string.Format("select count(*) from ({0}) T", sql);
                        cmd = GetCommand(commandText, connection);
                        pagerModel.totalRows = int.Parse(cmd.ExecuteScalar().ToString());

                        startRow = pageSize * (currentPage - 1);
                        endRow = startRow + pageSize;

                        sb.Append("select * from ( select row_limit.*, rownum rownum_ from (");
                        sb.Append(sql);
                        if (!string.IsNullOrWhiteSpace(orderby))
                        {
                            sb.Append(" ");
                            sb.Append(orderby);
                        }
                        sb.Append(" ) row_limit where rownum <= ");
                        sb.Append(endRow);
                        sb.Append(" ) where rownum_ >");
                        sb.Append(startRow);
                        #endregion
                        break;
                    case "mssql":
                        #region 分页查询语句
                        commandText = string.Format("select count(*) from ({0}) T", sql);
                        cmd = GetCommand(commandText, connection);
                        pagerModel.totalRows = int.Parse(cmd.ExecuteScalar().ToString());

                        startRow = pageSize * (currentPage - 1) + 1;
                        endRow = startRow + pageSize - 1;

                        sb.Append(string.Format(@"
                            select * from 
                            (select ROW_NUMBER() over({1}) as rowNumber, t.* from ({0}) t) tempTable
                            where rowNumber between {2} and {3} ", sql, orderby, startRow, endRow));
                        #endregion
                        break;
                    case "mysql":
                        #region 分页查询语句
                        commandText = string.Format("select count(*) from ({0}) T", sql);
                        cmd = GetCommand(commandText, connection);
                        pagerModel.totalRows = int.Parse(cmd.ExecuteScalar().ToString());

                        startRow = pageSize * (currentPage - 1);

                        sb.Append("select * from (");
                        sb.Append(sql);
                        if (!string.IsNullOrWhiteSpace(orderby))
                        {
                            sb.Append(" ");
                            sb.Append(orderby);
                        }
                        sb.AppendFormat(" ) row_limit limit {0},{1}", startRow, pageSize);
                        #endregion
                        break;
                    case "sqlite":
                        #region 分页查询语句
                        commandText = string.Format("select count(*) from ({0}) T", sql);
                        cmd = GetCommand(commandText, connection);
                        pagerModel.totalRows = int.Parse(cmd.ExecuteScalar().ToString());

                        startRow = pageSize * (currentPage - 1);

                        sb.Append(sql);
                        if (!string.IsNullOrWhiteSpace(orderby))
                        {
                            sb.Append(" ");
                            sb.Append(orderby);
                        }
                        sb.AppendFormat(" limit {0} offset {1}", pageSize, startRow);
                        #endregion
                        break;
                }

                List<T> list = FindListBySql<T>(sb.ToString(), cmdParms);
                pagerModel.result = list;
            }

            return pagerModel;
        }


        #endregion

        #region 分页获取列表
        /// <summary>
        /// 分页(任意entity,尽量少的字段)
        /// </summary>
        public DataSet FindPageBySql(string sql, string orderby, int pageSize, int currentPage, out int totalCount, params DbParameter[] cmdParms)
        {
            DataSet ds = null;

            using (DbConnection connection = GetConnection())
            {
                connection.Open();
                IDbCommand cmd = null;
                StringBuilder sb = new StringBuilder();
                string commandText = null;
                int startRow = 0;
                int endRow = 0;
                totalCount = 0;
                switch (m_DBType)
                {
                    case "oracle":
                        #region 分页查询语句
                        commandText = string.Format("select count(*) from ({0}) T", sql);
                        cmd = GetCommand(commandText, connection);
                        totalCount = int.Parse(cmd.ExecuteScalar().ToString());

                        startRow = pageSize * (currentPage - 1);
                        endRow = startRow + pageSize;

                        sb.Append("select * from ( select row_limit.*, rownum rownum_ from (");
                        sb.Append(sql);
                        if (!string.IsNullOrWhiteSpace(orderby))
                        {
                            sb.Append(" ");
                            sb.Append(orderby);
                        }
                        sb.Append(" ) row_limit where rownum <= ");
                        sb.Append(endRow);
                        sb.Append(" ) where rownum_ >");
                        sb.Append(startRow);
                        #endregion
                        break;
                    case "mssql":
                        #region 分页查询语句
                        commandText = string.Format("select count(*) from ({0}) T", sql);
                        cmd = GetCommand(commandText, connection);
                        totalCount = int.Parse(cmd.ExecuteScalar().ToString());

                        startRow = pageSize * (currentPage - 1) + 1;
                        endRow = startRow + pageSize - 1;

                        sb.Append(string.Format(@"
                            select * from 
                            (select ROW_NUMBER() over({1}) as rowNumber, t.* from ({0}) t) tempTable
                            where rowNumber between {2} and {3} ", sql, orderby, startRow, endRow));
                        #endregion
                        break;
                    case "mysql":
                        #region 分页查询语句
                        commandText = string.Format("select count(*) from ({0}) T", sql);
                        cmd = GetCommand(commandText, connection);
                        totalCount = int.Parse(cmd.ExecuteScalar().ToString());

                        startRow = pageSize * (currentPage - 1);

                        sb.Append("select * from (");
                        sb.Append(sql);
                        if (!string.IsNullOrWhiteSpace(orderby))
                        {
                            sb.Append(" ");
                            sb.Append(orderby);
                        }
                        sb.AppendFormat(" ) row_limit limit {0},{1}", startRow, pageSize);
                        #endregion
                        break;
                    case "sqlite":
                        #region 分页查询语句
                        commandText = string.Format("select count(*) from ({0}) T", sql);
                        cmd = GetCommand(commandText, connection);
                        totalCount = int.Parse(cmd.ExecuteScalar().ToString());

                        startRow = pageSize * (currentPage - 1);

                        sb.Append(sql);
                        if (!string.IsNullOrWhiteSpace(orderby))
                        {
                            sb.Append(" ");
                            sb.Append(orderby);
                        }
                        sb.AppendFormat(" limit {0} offset {1}", pageSize, startRow);
                        #endregion
                        break;
                }

                ds = Query(sql, cmdParms);
            }
            return ds;
        }
        #endregion

        #region getReaderValue 转换数据
        /// <summary>
        /// 转换数据
        /// </summary>
        private Object getReaderValue(Object rdValue, Type ptype)
        {
            if (ptype == typeof(double))
                return Convert.ToDouble(rdValue);

            if (ptype == typeof(decimal))
                return Convert.ToDecimal(rdValue);

            if (ptype == typeof(int))
                return Convert.ToInt32(rdValue);

            if (ptype == typeof(long))
                return Convert.ToInt64(rdValue);

            if (ptype == typeof(DateTime))
                return Convert.ToDateTime(rdValue);

            if (ptype == typeof(Nullable<double>))
                return Convert.ToDouble(rdValue);

            if (ptype == typeof(Nullable<decimal>))
                return Convert.ToDecimal(rdValue);

            if (ptype == typeof(Nullable<int>))
                return Convert.ToInt32(rdValue);

            if (ptype == typeof(Nullable<long>))
                return Convert.ToInt64(rdValue);

            if (ptype == typeof(Nullable<DateTime>))
                return Convert.ToDateTime(rdValue);

            return rdValue;
        }
        #endregion

        #region 获取主键名称
        /// <summary>
        /// 获取主键名称
        /// </summary>
        public string GetIdName(Type type)
        {
            PropertyInfo[] propertyInfoList = GetEntityProperties(type);
            foreach (PropertyInfo propertyInfo in propertyInfoList)
            {
                if (propertyInfo.GetCustomAttributes(typeof(IsIdAttribute), false).Length > 0)
                {
                    return propertyInfo.Name;
                }
            }
            return "Id";
        }
        #endregion

        #region 获取主键值
        /// <summary>
        /// 获取主键名称
        /// </summary>
        public object GetIdVal(object val)
        {
            string idName = GetIdName(val.GetType());
            if (!string.IsNullOrWhiteSpace(idName))
            {
                return val.GetType().GetProperty(idName).GetValue(val, null);
            }
            return 0;
        }
        #endregion

        #region 获取实体类属性
        /// <summary>
        /// 获取实体类属性
        /// </summary>
        private PropertyInfo[] GetEntityProperties(Type type)
        {
            List<PropertyInfo> result = new List<PropertyInfo>();
            PropertyInfo[] propertyInfoList = type.GetProperties();
            foreach (PropertyInfo propertyInfo in propertyInfoList)
            {
                if (propertyInfo.GetCustomAttributes(typeof(EdmRelationshipNavigationPropertyAttribute), false).Length == 0
                    && propertyInfo.GetCustomAttributes(typeof(BrowsableAttribute), false).Length == 0)
                {
                    result.Add(propertyInfo);
                }
            }
            return result.ToArray();
        }
        #endregion

        #region 获取基类
        /// <summary>
        /// 获取基类
        /// </summary>
        public Type GetBaseType(Type type)
        {
            while (type.BaseType != null && type.BaseType.Name != typeof(Object).Name)
            {
                type = type.BaseType;
            }
            return type;
        }
        #endregion
        #endregion

        #region 事务
        #region 开始事务
        /// <summary>
        /// 开始事务
        /// </summary>
        public static void BeginTransaction()
        {
            DbConnection conn = GetConnection();
            if (conn.State != ConnectionState.Open) conn.Open();
            m_Tran = conn.BeginTransaction();
        }
        #endregion

        #region 提交事务
        /// <summary>
        /// 提交事务
        /// </summary>
        public static void CommitTransaction()
        {
            DbConnection conn = m_Tran.Connection;
            try
            {
                m_Tran.Commit();
            }
            catch (Exception ex)
            {
                m_Tran.Rollback();
            }
            finally
            {
                if (conn.State == ConnectionState.Open) conn.Close();
                m_Tran.Dispose();
                m_Tran = null;
            }
        }
        #endregion

        #region 回滚事务(出错时调用该方法回滚)
        /// <summary>
        /// 回滚事务(出错时调用该方法回滚)
        /// </summary>
        public static void RollbackTransaction()
        {
            DbConnection conn = m_Tran.Connection;
            m_Tran.Rollback();
            if (conn.State == ConnectionState.Open) conn.Close();
        }
        #endregion
        #endregion
    }
}

ExtModel:

    依据标准删除:

    select换行,from换行,join换行,where换行,and换行。

澳门美高梅手机网站 15澳门美高梅手机网站 16

   
不知底或然称的上是O奥迪Q3M,其实便是一个DBHelper。看到网上海人民广播电视台湾大学人写本身的ORubiconM,但自小编觉得都不太好。

/// <summary>
/// 修改
/// </summary>
public void Update(object obj)
{
    dbHelper.Update(obj);
}

    

View Code

View Code

Model:

View Code

View Code

/// <summary>
/// 删除
/// </summary>
public void BatchDelete(string ids)
{
    dbHelper.BatchDelete<BS_Template>(ids);
}

Model层的设计:

澳门美高梅手机网站 17澳门美高梅手机网站 18

    依据ID批量删除:

   
笔者那些OENCOREM,学习开销很低,常用的法门仅有多少个,在运用的历程中,你不须要有太多要专注的地方,也不会有“作者哪些完毕连表查询”的疑问。反射就义局地质量,可是降低了贯彻和使用的复杂度。

    SQL不能够写的非常倒霉,该换行换行,该对齐对齐,例:

View Code

澳门美高梅手机网站 19澳门美高梅手机网站 20

 

澳门美高梅手机网站 21澳门美高梅手机网站 22

View Code

    查询sql书写规范:

澳门美高梅手机网站 23

/// <summary>
/// 删除
/// </summary>
public void Del(int id)
{
    dbHelper.Delete<BS_Template>(id);
}
/// <summary>
/// GetMaxId
/// </summary>
public int GetMaxId()
{
    return dbHelper.GetMaxID<BS_Template>("id");
}

    分页查询列表:

    帮衬Oracle、MSSQL、MySQL、SQLite种种数据库,并配有Model生成器。

澳门美高梅手机网站 24澳门美高梅手机网站 25

View Code

澳门美高梅手机网站 26澳门美高梅手机网站 27

public BS_Test Get(string id)
{
    return dbHelper.FindById<BS_Test>(id);
}

    代码下载:http://files.cnblogs.com/files/s0611163/DBHelperDemo.zip

View Code

   
例(由于是SQLite数据库,所以生成的Model没有注释,此外二种数据库有注释):

View Code

public BS_Template Get(string typeCode, Enums.TemplateType templateType)
{
    StringBuilder sql = new StringBuilder(string.Format(@"
        select *
        from BS_Template 
        where typeCode='{0}' 
        and type='{1}'", typeCode, (int)templateType));
    return dbHelper.FindBySql<BS_Template>(sql.ToString());
}
public BS_Template Get2(string templateId, Enums.TemplateType templateType)
{
    StringBuilder sql = new StringBuilder(string.Format(@"
        select *
        from BS_Template 
        where id='{0}' 
        and type='{1}'", templateId, (int)templateType));
    return dbHelper.FindBySql<BS_Template>(sql.ToString());
}

    依据ID查询实体:

DBHelper代码:

    数据库事务:

澳门美高梅手机网站 28澳门美高梅手机网站 29

 

View Code

using System;
using System.Collections.Generic;
using System.Linq;

namespace Models
{
    /// <summary>
    /// 
    /// </summary>
    public partial class BS_Template
    {
        //暂没有扩展字段
    }
}
/// <summary>
/// 添加
/// </summary>
public void Insert(object obj)
{
    dbHelper.Insert(obj);
}

View Code

澳门美高梅手机网站 30澳门美高梅手机网站 31

   
Model生成器下载:http://files.cnblogs.com/files/s0611163/Model%E7%94%9F%E6%88%90%E5%99%A8.zip

   
Models目录中的类及其性质和数据库中的表和字段是完全对应的,Models全体由生成器生成,并且不允许手动修改。ExtModels目录中的类是增添类,首要用来查询与体现,比如表中存的是code,但您要求关联查询另一张表中的name,就能够在那么些扩张类中扩展三个用来显示的name字段。Models和ExtModels目录的中类都以partial修饰。

/// <summary>
/// 分页获取模板集合
/// </summary>
public List<BS_Template> GetList(ref PagerModel pager, string noticeType, string coreType, string name, Enums.TemplateType templateType)
{
    StringBuilder sql = new StringBuilder(string.Format(@"
        select *
        from BS_Template t
        where 1=1 "));

    if (!string.IsNullOrWhiteSpace(noticeType))
    {
        sql.AppendFormat(" and nt.name like '%{0}%'", noticeType);
    }

    if (!string.IsNullOrWhiteSpace(coreType))
    {
        sql.AppendFormat(" and ct.name like '%{0}%'", coreType);
    }

    if (!string.IsNullOrWhiteSpace(name))
    {
        sql.AppendFormat(" and t.name like '%{0}%'", name);
    }

    sql.AppendFormat(" and t.type = '{0}'", (int)templateType);

    string orderby = "order by cast(id as int)";
    pager = dbHelper.FindPageBySql<BS_Template>(sql.ToString(), orderby, pager.rows, pager.page);
    return pager.result as List<BS_Template>;
}

    修改:

澳门美高梅手机网站 32澳门美高梅手机网站 33

发表评论

电子邮件地址不会被公开。 必填项已用*标注