使用ReportXml的帮助类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml.Linq;
using System.Text.RegularExpressions;
using System.Data.SqlClient;
using System.Data;
using System.Configuration;
using System.Xml;

namespace Components
{
    public static class ReportHelper
    {
        #region 获取分页数据
        /// <summary>
        /// 获取分页数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="reportName"></param>
        /// <param name="p_Params"></param>
        /// <param name="p_ReportXmlName"></param>
        /// <param name="totalCount"></param>
        /// <returns></returns>
        public static List<T> GetPageData<T>(string reportName, ReportParams p_Params, string p_ReportXmlName, out int totalCount)
        {
            List<T> m_List = new List<T>();
            DataSet m_result = getReportDataByPage(reportName, p_Params, p_ReportXmlName, out totalCount);
            if (!m_result.IsEmpty())
            {
                m_List = m_result.Tables[0].ToList<T>();
            }
            return m_List;
        }

        /// <summary>
        /// 获取分页数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="reportName"></param>
        /// <param name="p_Params"></param>
        /// <param name="p_ReportXmlName"></param>
        /// <param name="totalCount"></param>
        /// <returns>返回DataTable</returns>
        public static DataTable GetDataTablePageData(string reportName, ReportParams p_Params, string p_ReportXmlName, out int totalCount)
        {
            DataSet m_result = getReportDataByPage(reportName, p_Params, p_ReportXmlName, out totalCount);
            if (!m_result.IsEmpty())
            {
                return m_result.Tables[0];
            }
            return null;
        }
        /// <summary>
        /// 获取不分页数据
        /// </summary>
        /// <param name="reportName"></param>
        /// <param name="p_Params"></param>
        /// <param name="p_ReportXmlName"></param>
        /// <param name="totalCount"></param>
        /// <returns></returns>
        public static DataTable GetDataTableData(string reportName, ReportParams p_Params, string p_ReportXmlName)
        {
            return getData(reportName, p_Params, p_ReportXmlName);
        }
        /// <summary>
        /// 获取不分页数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="reportName"></param>
        /// <param name="p_Params"></param>
        /// <param name="p_ReportXmlName"></param>
        /// <returns></returns>
        public static List<T> GetDataListData<T>(string reportName, ReportParams p_Params, string p_ReportXmlName)
        {
            List<T> m_List = new List<T>();
            DataTable m_result = getData(reportName, p_Params, p_ReportXmlName);
            if (!m_result.IsEmpty())
            {
                m_List = m_result.ToList<T>();
            }
            return m_List;
        }
        #endregion

        #region 导出报表
        /// <summary>
        /// 获取分页数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="reportName"></param>
        /// <param name="p_Params"></param>
        /// <param name="p_ReportXmlName"></param>
        /// <returns></returns>
        public static List<T> GetExportData<T>(string reportName, string p_ReportXmlName, ReportParams p_Params, out int totalCount)
        {
            totalCount = 0;
            List<T> m_List = new List<T>();
            DataTable m_result = getData(reportName, p_Params, p_ReportXmlName);
            //DataSet m_result = getReportExportData(reportName, p_ReportXmlName, p_Params.Where);
            if (!m_result.IsEmpty())
            {
                m_List = m_result.ToList<T>();
            }
            return m_List;
        }

        #endregion

        #region 前台需要点击排序的时候调用
        /// <summary>
        /// 要获取数据的XML配置报表名称
        /// </summary>
        /// <param name="reportName">要获取数据的XML配置报表名称</param>
        /// <param name="p_Params">报表参数</param>
        /// <param name="p_ReportXmlName">报表XML文件名称</param>
        /// <param name="totalCount">数据总数</param>
        /// <returns></returns>
        private static DataSet getReportDataByPage(string reportName, ReportParams p_Params, string p_ReportXmlName, out int totalCount)
        {
            List<KeyValue> where = p_Params.Where;
            int pageSize = p_Params.PageSize;
            int pageIndex = p_Params.PageIndex;
            string order = p_Params.Order;
            string sort = p_Params.Sort;
            totalCount = 0;
            if (pageIndex < 1)  //不能出现索引页小于1的情况，否则查询语句报错
                return null;
            if (where == null)
                where = new List<KeyValue>();

            string reportPath = GetReportPath(p_ReportXmlName); //报表路径

            if (string.IsNullOrEmpty(reportPath))
                return null;

            string sql = GetSql(reportPath, reportName, where).Trim(); //获取要查询的SQL语句 及其 参数
            if (string.IsNullOrEmpty(sql))
                return null;

            string conString = GetConnection(); //获取SQL连接串
           
            if (string.IsNullOrEmpty(conString))
                return null;
            string rowOrder = "";
            if (!string.IsNullOrEmpty(order))
            {
                rowOrder = "order by "+sort+" " + order+ " ";
            }
            else
            {
                rowOrder = "order by t.Id desc";
            }
            int start = pageSize * (pageIndex - 1) + 1;
            int end = pageSize * pageIndex;


            var match = Regex.Match(sql, @"s+orders+", RegexOptions.IgnoreCase); //检查语句中是否含有order by
            string strCount = sql;
            if (match.Success) //有order by 则舍去order by 
            {
                strCount = sql.Substring(0, match.Index);
                if (string.IsNullOrEmpty(order))
                {
                    rowOrder = sql.Substring(match.Index);
                }

                sql = ForSql(strCount, rowOrder, start, end); //把order by 加入到rownumber
            }
            else
            {
                strCount = sql;
                sql = @" SELECT * FROM ( SELECT Row_Number() OVER ({0}) row, * from ( select * FROM (" + sql + " )  tt) t ) item "
                       + " WHERE item.row BETWEEN " + start + " AND " + end + " ";

                sql = string.Format(sql, rowOrder);
            }
            strCount = "select count(0) from (" + strCount + ") item ";

            sql = sql + ";" + strCount;
            SqlConnection conn = new SqlConnection(conString);
            SqlCommand cmd = new SqlCommand(sql, conn);
            //where 替换
            foreach (var data in where)
            {
                cmd.Parameters.Add(new SqlParameter("@" + data.Key, data.Value));
            }
            DataSet ds = new DataSet();
            SqlDataAdapter adp = new SqlDataAdapter(cmd);
            adp.Fill(ds);
            conn.Close();
            totalCount = Convert.ToInt32(ds.Tables[1].Rows[0][0]);
            return ds;
        }
        #endregion

        #region 获取数据，不分页
        /// <summary>
        /// 获取数据，不分页
        /// </summary>
        /// <param name="reportName"></param>
        /// <param name="where"></param>
        /// <param name="order"></param>
        /// <param name="reportType"></param>
        /// <param name="totalCount"></param>
        /// <returns></returns>
        private static DataTable getData(string reportName, ReportParams p_Params, string p_ReportXmlName)
        {

            var order = p_Params.Order;
            List<KeyValue> where = p_Params.Where;
            if (where == null)
                where = new List<KeyValue>();

            string reportPath = GetReportPath(p_ReportXmlName); //报表路径

            if (string.IsNullOrEmpty(reportPath))
                return null;
            string sql = GetSql(reportPath, reportName, where).Trim(); //获取要查询的SQL语句 及其 参数
            if (string.IsNullOrEmpty(sql))
                return null;
            string conString = GetConnection(); //获取SQL连接串

            if (string.IsNullOrEmpty(conString))
                return null;
            string rowOrder = "";
            if (!string.IsNullOrEmpty(order))
            {
                rowOrder = "order by " + order + "";
            }
            else
            {
                rowOrder = "order by t.Id desc";
            }

            var match = Regex.Match(sql, @"s+orders+", RegexOptions.IgnoreCase); //检查语句中是否含有order by
            string strCount = sql;
            if (match.Success) //有order by 则舍去order by 
            {
                strCount = sql.Substring(0, match.Index);
                if (string.IsNullOrEmpty(order))
                {
                    rowOrder = sql.Substring(match.Index);
                }

                //sql = ForSql(strCount, rowOrder); //把order by 加入到rownumber
            }
            else
            {
                //strCount = sql;
                sql = @"select * FROM (" + sql + " )";

                sql = string.Format(sql, rowOrder);
            }

            //strCount = "select count(0) from (" + strCount + ") item ";

            // sql = sql+";" + strCount;
            SqlConnection conn = new SqlConnection(conString);

            SqlCommand cmd = new SqlCommand(sql, conn);
            //where 替换
            foreach (var data in where)
            {
                cmd.Parameters.Add(new SqlParameter("@" + data.Key, data.Value));
            }
            DataSet ds = new DataSet();

            SqlDataAdapter adp = new SqlDataAdapter(cmd);

            adp.Fill(ds);
            conn.Close();
            //totalCount = Convert.ToInt32(ds.Tables[1].Rows[0][0]);
            return ds.Tables[0];
        }

        #endregion

        #region 导出报表
        /// <summary>
        /// 导出报表
        /// </summary>
        /// <param name="reportName">报表名称</param>
        /// <param name="p_ReportXmlName">Xml文件名称</param>
        /// <param name="where">条件</param>
        /// <returns></returns>
        private static DataSet getReportExportData(string reportName, string p_ReportXmlName, List<KeyValue> where)
        {
            if (where == null)
                where = new List<KeyValue>();

            string reportPath = GetReportPath(p_ReportXmlName); //报表路径
            if (string.IsNullOrEmpty(reportPath))
                return null;
            string reportSql = GetSql(reportPath, reportName, where); //获取要查询的SQL语句 及其 参数

            if (string.IsNullOrEmpty(reportSql))
                return null;

            string conString = GetConnection(); //获取SQL连接串

            if (string.IsNullOrEmpty(conString))
                return null;
            string sql = reportSql;
            SqlConnection conn = new SqlConnection(conString);
            SqlCommand cmd = new SqlCommand(sql, conn);
            //where 替换
            foreach (var data in where)
            {
                cmd.Parameters.Add(new SqlParameter("@" + data.Key, data.Value));
            }
            SqlDataAdapter adapter = new SqlDataAdapter(cmd);
            DataSet ds = new DataSet();
            adapter.Fill(ds);
            conn.Close();
            return ds;
        }
        #endregion

        /// <summary>
        /// 
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="order"></param>
        /// <param name="start"></param>
        /// <param name="end"></param>
        /// <returns></returns>
        private static string ForSql(string sql, string order, int start, int end)
        {
            var match = Regex.Match(sql, @"[s+]?SELECTs+");
            if (match.Success)
            {
                sql = sql.Insert(match.Length, string.Format("Row_Number() OVER ({0}) rowNumber,", order));
                // sql = string.Format("select Row_Number() OVER ({0}) rowNumber,* from ({1}) t", order, sql);
                sql = @" SELECT * FROM  (" + sql + " ) item "
                       + " WHERE item.rowNumber BETWEEN " + start + " AND " + end + " ";

            }
            return sql;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="order"></param>
        /// <returns></returns>
        private static string ForSql(string sql, string order)
        {
            var match = Regex.Match(sql, @"[s+]?SELECTs+");
            if (match.Success)
            {
                sql = sql.Insert(match.Length, string.Format("Row_Number() OVER ({0}) rowNumber,", order));
                // sql = string.Format("select Row_Number() OVER ({0}) rowNumber,* from ({1}) t", order, sql);
                /*sql = @" SELECT * FROM  (" + sql + " ) item "
                       + " WHERE item.rowNumber BETWEEN " + start + " AND " + end + " ";*/
            }
            return sql;
        }

        #region 获取连接串
        /// <summary>
        /// 获取连接串
        /// </summary>
        /// <returns></returns>
        internal static string GetConnection()
        {
            return ConfigurationManager.ConnectionStrings["ConnectionString"].ConnectionString;
        }
        #endregion

        #region 获取报表路径
        /// <summary>
        /// 获取报表路径
        /// </summary>
        /// <param name="p_ReportXmlName"></param>
        /// <returns></returns>
        internal static string GetReportPath(string p_ReportXmlName)
        {
            string m_BasePath = AppDomain.CurrentDomain.BaseDirectory + "/bin/Resource/ReportXml/";
            return m_BasePath + p_ReportXmlName + ".xml";
        }
        #endregion

        #region 获取Sql语句
        /// <summary>
        /// 获取Sql语句
        /// </summary>
        /// <param name="reportPath"></param>
        /// <param name="reportName"></param>
        /// <param name="where"></param>
        /// <returns></returns>
        internal static string GetSql(string reportPath, string reportName, List<KeyValue> where)
        {
            var xDoc = XDocument.Load(reportPath);  //加载XML报表参数

            //读取XML获取参数字段信息
            var queryXml = (from q in xDoc.Descendants("report")
                            where q.Attribute("id").Value.Trim().ToLower() == reportName.Trim().ToLower()
                            select q).AsQueryable();

            var querySql = queryXml.Elements("sql").FirstOrDefault();  //查出SQL语句
            //var m_SqlType = string.Empty;
            //var querySqlObj = queryXml.Elements("type").FirstOrDefault();
            //if (m_SqlType != null)
            //{
            //    m_SqlType = querySqlObj.Value;
            //}

            #region 语句最后的查询条件
            if (querySql == null)  //如果没配置则返回NULL
                return null;

            string uperSql = querySql.Value;

            #region 子查询的查询条件
            var childAttr = queryXml.Elements("childDynamic");

            foreach (var _child in childAttr)
            {
                int cIndex = 1;
                var child = _child.Elements("isNotEmpty");
                if (child == null)
                    continue;
                var childEle = _child.Elements("isNotEmpty").ToList();

                //StringBuilder para = new StringBuilder();
                string c_Param = HandleParam(childEle, where, cIndex);
                string childEnd = _child.Element("childEnd") == null ? "" : _child.Element("childEnd").Value;
                if (c_Param.Length == 0)
                {
                    uperSql = uperSql.Replace(_child.Attribute("property").Value.ToLower(), childEnd);
                    continue;
                }
                uperSql = uperSql.Replace(_child.Attribute("property").Value.ToLower(), c_Param.Insert(0, _child.Attribute("prepend").Value + " ") + childEnd);
            }

            #endregion

            StringBuilder sql = new StringBuilder();
            var attr = queryXml.Elements("dynamic");    //得到设置类型的查询参数  (获取查询条件)
            if (attr == null || attr.Elements("isNotEmpty").Count() == 0)
                return uperSql;
            sql.Append(uperSql);

            var paraEle = attr.Elements("isNotEmpty").ToList();
            int index = 1;

            string strPara = HandleParam(paraEle, where, index); //where 参数

            #endregion
            if (!string.IsNullOrEmpty(strPara))
            {
                sql.Append(strPara.Insert(0, attr.Attributes("prepend").Select(q => q.Value).FirstOrDefault() + " "));
            }
            var endSql = queryXml.Elements("endSql");
            if (endSql.FirstOrDefault() != null)
            {
                sql.Append(endSql.Select(q => q.Value).FirstOrDefault() + " ");
            }

            return sql.ToString();  //得到查询的SQL语句,去掉XML里面的多余空格 

        }
        #endregion

        #region 处理所有参数以及Where的值
        /// <summary>
        /// 处理所有参数以及Where的值
        /// </summary>
        /// <param name="childEle"></param>
        /// <param name="where"></param>
        /// <param name="index"></param>
        /// <returns></returns>
        private static string HandleParam(List<XElement> childEle, List<KeyValue> where, int index)
        {
            StringBuilder para = new StringBuilder();
            foreach (var ele in childEle)
            {
                if (ele.Attribute("value") != null && ele.Attribute("value").Value.ToLower() == "fixed")
                {
                    para.Append(" " + GetStr(index, ele.Value, ele.Attribute("prepend").Value));
                    index++;
                    continue;
                }
                var ctn = where.Where(q => q.Key.ToString().ToLower() == ele.Attribute("property").Value.ToLower()).FirstOrDefault(); //判断查询条件是否存在
                if (ctn == null)
                    continue;

                object objType = ele.Attribute("type");
                string type = string.Empty;
                if (null != objType)
                {
                    type = ele.Attribute("type").Value.ToLower();
                }

                //in条件特殊处理
                if (type == "in")
                {
                    string[] inValue = ctn.Value.ToString().Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Select(n => n).ToArray();
                    string strValue = string.Join(",", inValue);

                    List<string> p = new List<string>();
                    for (int i = 0; i < inValue.Count(); i++)
                    {
                        where.Add(new KeyValue { Key = ctn.Key.ToString() + i, Value = inValue[i] });
                        p.Add("@" + ctn.Key + i);
                    }

                    if (index == 1)
                    {
                        para.Append(" " + ele.Value.ToLower().Replace("@" + ctn.Key.ToString().ToLower(), string.Join(",", p)));
                    }
                    else
                    {
                        para.Append(" " + ele.Attribute("prepend").Value);
                        para.Append(" " + ele.Value.ToLower().Replace("@" + ctn.Key.ToString().ToLower(), string.Join(",", p)));
                    }
                    where.Remove(ctn);
                    index++;
                    continue;
                }

                if (type == "like" && (ctn.Value.ToString().Contains("%") || ctn.Value.ToString().Contains("_")))
                {
                    ctn.Value = ctn.Value.ToString().Replace("%", "[%]").Replace("_", "[_]");
                    para.Append(" " + GetStr(index, ele.Value, ele.Attribute("prepend").Value));

                    index++;
                    continue;
                }

                para.Append(" " + GetStr(index, ele.Value, ele.Attribute("prepend").Value));
                index++;
            }
            return para.ToString();
        }
        #endregion

        #region type sql的查询条件，index，where 当1的时候紧跟where后面 strIn in的时候值带入SQL语句,XML中的语句,prepend 语句中的关键字（and ,or ）
        /// <summary>
        /// type sql的查询条件，index，where 当1的时候紧跟where后面 strIn in的时候值带入SQL语句,XML中的语句,prepend 语句中的关键字（and ,or ）
        /// </summary>
        /// <param name="index"></param>
        /// <param name="eleStr"></param>
        /// <param name="prepend"></param>
        /// <returns></returns>
        private static string GetStr(int index, string eleStr, string prepend)
        {
            string para = string.Empty;
            if (index == 1)
            {
                return eleStr;
            }
            else
            {
                return prepend + " " + eleStr;
            }
        }
        #endregion


    }

    #region 报表参数
    /// <summary>
    /// 报表参数
    /// </summary>
    public class ReportParams
    {
        /// <summary>
        /// 过滤条件
        /// </summary>
        public List<KeyValue> Where { get; set; }
        /// <summary>
        /// 页面大小
        /// </summary>
        public int PageSize { get; set; }
        /// <summary>
        /// 页面索引
        /// </summary>
        public int PageIndex { get; set; }
        /// <summary>
        /// 排序方式
        /// </summary>
        public string Order { get; set; }
        /// <summary>
        /// 排序字段
        /// </summary>
        public string Sort { get; set; }
    }

    public class KeyValue
    {
        public object Key { get; set; }

        public object Value { get; set; }
    }
    #endregion
}