C#的REPORTVIEW通用框架

 内容摘要：最近花了很多工夫研究了C# 2005的RDLC报表，个人感觉功能是很强大，但是编码却很费力，并且这方面的示例也实在是太少了。以下是我整理的一报表控件，在此与大家分享。一、改进后的ReportViewer1 using System; 2 using System.Collections.Generic; 3 using System.Text; 4 using Microsoft.Repor。

 

最近花了很多工夫研究了C# 2005的RDLC报表，个人感觉功能是很强大，但是编码却很费力，并且这方面的示例也实在是太少了。以下是我整理的一报表控件，在此与大家分享。

一、改进后的ReportViewer

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Reporting.WinForms;
using System.ComponentModel;
using System.IO;

namespace FBS.GDTVMember.Report
{
    public class ReportViewer : Microsoft.Reporting.WinForms.ReportViewer
    {
        private string _rcfile;
        private ReportConfig _rpc;
        private object _datasource;
        private MemoryStream m_rdl;
 
        public ReportViewer() :base()
        {
 
        }
 
        /// <summary>
        /// 配置文件
       /// </summary>
        [DefaultValue("")]
        public string Filename
        {
            get { return _rcfile; }
            set
            {
                _rcfile = value;
                _rpc = new ReportConfig(_rcfile);
            }
        }
 
        /// <summary>
        /// 报表配置
        /// </summary>
        public ReportConfig ReportConfig
        {
            get { return _rpc; }
        }
 
        /// <summary>
        /// 数据源
        /// </summary>
        public object DataSource
        {
            get { return _datasource; }
            set { _datasource = value; }
        }
 
        /// <summary>
        /// 显示报表
        /// </summary>
        public void ShowReport()
        {
            if (m_rdl != null)
                m_rdl.Dispose();
            m_rdl = GenerateRdl();
 
            Reset();
            LocalReport.LoadReportDefinition(m_rdl);
            LocalReport.DataSources.Add(new ReportDataSource("FaibLists", _datasource));
            RefreshReport();
        }
 
        /// <summary>
        /// 生成Rdl流
        /// </summary>
        /// <returns></returns>
        private MemoryStream GenerateRdl()
        {
            MemoryStream ms = new MemoryStream();
            RdlGenerator gen = new RdlGenerator();
            gen.ReportConfig = _rpc;
            gen.WriteXml(ms);
            ms.Position = 0;
            return ms;
        }
 
    }
 }




二、Rdl生成类


using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Xml.Serialization;
 
namespace FBS.GDTVMember.Report
{
    public class RdlGenerator
    {
        private ReportConfig _rpc;
 
        /// <summary>
        /// 报表配置
        /// </summary>
        public ReportConfig ReportConfig
        {
            get { return _rpc; }
            set { _rpc = value; }
        }
 
        /// <summary>
        /// 创建报表
        /// </summary>
        /// <returns></returns>
        private Rdl.Report CreateReport()
        {
            Rdl.Report report = new Rdl.Report();
            string w = "", h = "", lm = "", tm = "", rm = "", bm = "";
            //设置报表页面
            if(!string.IsNullOrEmpty(_rpc.Unit))
            {
                w = _rpc.Width + _rpc.Unit;
                h = _rpc.Height + _rpc.Unit;
                lm = _rpc.LeftMargin + _rpc.Unit;
                tm = _rpc.TopMargin + _rpc.Unit;
                rm = _rpc.RightMargin + _rpc.Unit;
                bm = _rpc.BottomMargin + _rpc.Unit;
            }
            else
            {
                w = (_rpc.PageSettings.PaperSize.Width / 96.0) + "in";
                h = (_rpc.PageSettings.PaperSize.Height / 96.0) + "in";
                lm = (_rpc.LeftMargin / 96.0) + "in";
                tm = (_rpc.TopMargin / 96.0) + "in";
                rm = (_rpc.RightMargin / 96.0) + "in";
                bm = (_rpc.BottomMargin / 96.0) + "in";
            }
            report.Items = new object[] 
                {
                    CreateDataSources(),
                    CreateHeader(),
                    CreateBody(),
                    CreateFooter(),
                    CreateDataSets(),
                    w,
                    h,
                    lm,
                    tm,
                    rm,
                    bm,
                };
            report.ItemsElementName = new Rdl.ItemsChoiceType37[]
                { 
                    Rdl.ItemsChoiceType37.DataSources, 
                    Rdl.ItemsChoiceType37.PageHeader,
                    Rdl.ItemsChoiceType37.Body,
                    Rdl.ItemsChoiceType37.PageFooter,
                    Rdl.ItemsChoiceType37.DataSets,
                    Rdl.ItemsChoiceType37.Width,
                    Rdl.ItemsChoiceType37.PageHeight,
                    Rdl.ItemsChoiceType37.LeftMargin,
                    Rdl.ItemsChoiceType37.TopMargin,
                    Rdl.ItemsChoiceType37.RightMargin,
                    Rdl.ItemsChoiceType37.BottomMargin,
                };
            return report;
        }
 
        #region 数据源
        /// <summary>
        /// 数据源
        /// </summary>
        /// <returns></returns>
        private Rdl.DataSourcesType CreateDataSources()
        {
            Rdl.DataSourcesType dataSources = new Rdl.DataSourcesType();
            dataSources.DataSource = new Rdl.DataSourceType[] { CreateDataSource() };
            return dataSources;
        }
 
        private Rdl.DataSourceType CreateDataSource()
        {
            Rdl.DataSourceType dataSource = new Rdl.DataSourceType();
            dataSource.Name = "FaibLists";
            dataSource.Items = new object[] { CreateConnectionProperties() };
            return dataSource;
        }
 
        private Rdl.ConnectionPropertiesType CreateConnectionProperties()
        {
            Rdl.ConnectionPropertiesType connectionProperties = new Rdl.ConnectionPropertiesType();
            connectionProperties.Items = new object[]
                {
                    "",
                    "SQL",
                };
            connectionProperties.ItemsElementName = new Rdl.ItemsChoiceType[]
                {
                    Rdl.ItemsChoiceType.ConnectString,
                    Rdl.ItemsChoiceType.DataProvider,
                };
            return connectionProperties;
        }
        #endregion
 
        #region 主体
        /// <summary>
        /// 报表主体
        /// </summary>
        /// <returns></returns>
        private Rdl.BodyType CreateBody()
        {
            Rdl.BodyType body = new Rdl.BodyType();
            body.Items = new object[]
                {
                    CreateReportItems(),
                    "1in",
                };
            body.ItemsElementName = new Rdl.ItemsChoiceType30[]
                {
                    Rdl.ItemsChoiceType30.ReportItems,
                    Rdl.ItemsChoiceType30.Height,
                };
            return body;
        }
 
        private Rdl.ReportItemsType CreateReportItems()
        {
            Rdl.ReportItemsType reportItems = new Rdl.ReportItemsType();
            TableRdlGenerator tableGen = new TableRdlGenerator();
            tableGen.Fields = _rpc.DataItem;
            reportItems.Items = new object[] { tableGen.CreateTable() };
            return reportItems;
        }
        #endregion
 
        #region 页头页尾
        private Rdl.PageHeaderFooterType CreateHeader()
        {
            Rdl.PageHeaderFooterType header = new FBS.GDTVMember.Report.Rdl.PageHeaderFooterType();
            HeaderFooterRdlGenerator headerGen = new HeaderFooterRdlGenerator();
            headerGen.Fields = _rpc.Header;
 
            header.Items = new object[]
                {
                    (_rpc.HeadHeight / 96.0) + "in",
                    true,
                    true,
                    headerGen.CreateItems(),
                };
            header.ItemsElementName = new Rdl.ItemsChoiceType34[]
                {
                    Rdl.ItemsChoiceType34.Height,
                    Rdl.ItemsChoiceType34.PrintOnFirstPage,
                    Rdl.ItemsChoiceType34.PrintOnLastPage,
                    Rdl.ItemsChoiceType34.ReportItems
                };
            return header;
        }
 
        private Rdl.PageHeaderFooterType CreateFooter()
        {
            Rdl.PageHeaderFooterType footer = new FBS.GDTVMember.Report.Rdl.PageHeaderFooterType();
            HeaderFooterRdlGenerator footerGen = new HeaderFooterRdlGenerator();
            footerGen.Fields = _rpc.Footer;
 
            footer.Items = new object[]
                {
                    (_rpc.FootHeight / 96.0) + "in",
                    true,
                    true,
                    footerGen.CreateItems(),
                };
            footer.ItemsElementName = new Rdl.ItemsChoiceType34[]
                {
                    Rdl.ItemsChoiceType34.Height,
                    Rdl.ItemsChoiceType34.PrintOnFirstPage,
                    Rdl.ItemsChoiceType34.PrintOnLastPage,
                    Rdl.ItemsChoiceType34.ReportItems
                };
            return footer;
        }
        #endregion
 
        #region 数据集
        private Rdl.DataSetsType CreateDataSets()
        {
            Rdl.DataSetsType dataSets = new Rdl.DataSetsType();
            dataSets.DataSet = new Rdl.DataSetType[] { CreateDataSet() };
            return dataSets;
        }
 
        private Rdl.DataSetType CreateDataSet()
        {
            Rdl.DataSetType dataSet = new Rdl.DataSetType();
            dataSet.Name = "FaibLists";
            dataSet.Items = new object[] { CreateQuery(), CreateFields() };
            return dataSet;
        }
 
        private Rdl.QueryType CreateQuery()
        {
            Rdl.QueryType query = new Rdl.QueryType();
            query.Items = new object[] 
                {
                    "FaibLists",
                    "",
                };
            query.ItemsElementName = new Rdl.ItemsChoiceType2[]
                {
                    Rdl.ItemsChoiceType2.DataSourceName,
                    Rdl.ItemsChoiceType2.CommandText,
                };
            return query;
        }
 
        private Rdl.FieldsType CreateFields()
        {
            Rdl.FieldsType fields = new Rdl.FieldsType();
            Dictionary<string, TextItem> m_fields = _rpc.DataItem;
            fields.Field = new Rdl.FieldType[m_fields.Count];
            int i = 0;
            foreach (string key in m_fields.Keys)
            {
                fields.Field[i++] = CreateField(m_fields[key]);
            }
 
            return fields;
        }
 
        private Rdl.FieldType CreateField(TextItem item)
        {
            Rdl.FieldType field = new Rdl.FieldType();
            field.Name = item.DataMember;
            field.Items = new object[] { item.DataMember };
            field.ItemsElementName = new Rdl.ItemsChoiceType1[] { Rdl.ItemsChoiceType1.DataField };
            return field;
        }
        #endregion
 
        public void WriteXml(Stream stream)
        {
            XmlSerializer serializer = new XmlSerializer(typeof(Rdl.Report));
            serializer.Serialize(stream, CreateReport());
        }
    }
 }




三、报表主体生成类TableRdlGenerator


 using System;
 using System.Collections.Generic;
 using System.Text;
 using System.Drawing;
 
 namespace FBS.GDTVMember.Report
 {
    public class TableRdlGenerator
    {
        private Dictionary<string, TextItem> m_fields;
 
        public Dictionary<string, TextItem> Fields
        {
            get { return m_fields; }
            set { m_fields = value; }
        }
 
        public Rdl.TableType CreateTable()
        {
            //定义表格
            Rdl.TableType table = new Rdl.TableType();
            table.Name = "Table1";
            table.Items = new object[]
                {
                    CreateTableColumns(),
                    CreateHeader(),
                    CreateDetails(),
                };
            table.ItemsElementName = new Rdl.ItemsChoiceType21[]
                {
                    Rdl.ItemsChoiceType21.TableColumns,
                    Rdl.ItemsChoiceType21.Header,
                    Rdl.ItemsChoiceType21.Details,
                };
            return table;
        }
 
        private Rdl.HeaderType CreateHeader()
        {
            Rdl.HeaderType header = new Rdl.HeaderType();
            header.Items = new object[]
                {
                    CreateHeaderTableRows(),
                    true,
                };
            header.ItemsElementName = new Rdl.ItemsChoiceType20[]
                {
                    Rdl.ItemsChoiceType20.TableRows,
                    Rdl.ItemsChoiceType20.RepeatOnNewPage,
                };
            return header;
        }
 
        private Rdl.TableRowsType CreateHeaderTableRows()
        {
            Rdl.TableRowsType headerTableRows = new Rdl.TableRowsType();
            headerTableRows.TableRow = new Rdl.TableRowType[] { CreateHeaderTableRow() };
            return headerTableRows;
        }
 
        private Rdl.TableRowType CreateHeaderTableRow()
        {
            Rdl.TableRowType headerTableRow = new Rdl.TableRowType();
            headerTableRow.Items = new object[] { CreateHeaderTableCells(), "0.25in" };
            return headerTableRow;
        }
 
        private Rdl.TableCellsType CreateHeaderTableCells()
        {
            Rdl.TableCellsType headerTableCells = new Rdl.TableCellsType();
            headerTableCells.TableCell = new Rdl.TableCellType[m_fields.Count];
            int i = 0;
            foreach (string key in m_fields.Keys)
            {
                headerTableCells.TableCell[i++] = CreateHeaderTableCell(m_fields[key]);
            }
            return headerTableCells;
        }
 
        private Rdl.TableCellType CreateHeaderTableCell(TextItem item)
        {
            Rdl.TableCellType headerTableCell = new Rdl.TableCellType();
            headerTableCell.Items = new object[] { CreateHeaderTableCellReportItems(item) };
            return headerTableCell;
        }
 
        private Rdl.ReportItemsType CreateHeaderTableCellReportItems(TextItem item)
        {
            Rdl.ReportItemsType headerTableCellReportItems = new Rdl.ReportItemsType();
            headerTableCellReportItems.Items = new object[] { CreateHeaderTableCellTextbox(item) };
            return headerTableCellReportItems;
        }
 
        private Rdl.TextboxType CreateHeaderTableCellTextbox(TextItem item)
        {
            Rdl.TextboxType headerTableCellTextbox = new Rdl.TextboxType();
            headerTableCellTextbox.Name = item.Text + "_Header";
            headerTableCellTextbox.Items = new object[] 
                {
                    item.Text,
                    CreateHeaderTableCellTextboxStyle(item),
                    true,
                };
            headerTableCellTextbox.ItemsElementName = new Rdl.ItemsChoiceType14[] 
                {
                    Rdl.ItemsChoiceType14.Value,
                    Rdl.ItemsChoiceType14.Style,
                    Rdl.ItemsChoiceType14.CanGrow,
                };
            return headerTableCellTextbox;
        }
 
        private Rdl.StyleType CreateHeaderTableCellTextboxStyle(TextItem item)
        {
            Rdl.StyleType headerTableCellTextboxStyle = new Rdl.StyleType();
            headerTableCellTextboxStyle.Items = new object[]
                {
                    item.HeaderFont.Name,
                    item.HeaderFont.Size + "pt",
                    item.HeaderFont.Bold ? "700" : "100",
                    "Center",
                    "Middle",
                    CreateBorderStyle(),
                };
            headerTableCellTextboxStyle.ItemsElementName = new Rdl.ItemsChoiceType5[]
                {
                    Rdl.ItemsChoiceType5.FontFamily,
                    Rdl.ItemsChoiceType5.FontSize,
                    Rdl.ItemsChoiceType5.FontWeight,
                    Rdl.ItemsChoiceType5.TextAlign,
                    Rdl.ItemsChoiceType5.VerticalAlign,
                    Rdl.ItemsChoiceType5.BorderStyle,
                };
            return headerTableCellTextboxStyle;
        }
 
        private Rdl.DetailsType CreateDetails()
        {
            Rdl.DetailsType details = new Rdl.DetailsType();
            details.Items = new object[] { CreateTableRows() };
            return details;
        }
 
        private Rdl.TableRowsType CreateTableRows()
        {
            Rdl.TableRowsType tableRows = new Rdl.TableRowsType();
            tableRows.TableRow = new Rdl.TableRowType[] { CreateTableRow() };
            return tableRows;
        }
 
        private Rdl.TableRowType CreateTableRow()
        {
            Rdl.TableRowType tableRow = new Rdl.TableRowType();
            tableRow.Items = new object[] { CreateTableCells(), "0.25in" };
            return tableRow;
        }
 
        private Rdl.TableCellsType CreateTableCells()
        {
            Rdl.TableCellsType tableCells = new Rdl.TableCellsType();
            tableCells.TableCell = new Rdl.TableCellType[m_fields.Count];
            int i = 0;
            foreach(string key in m_fields.Keys)
            {
                tableCells.TableCell[i++] = CreateTableCell(m_fields[key]);
            }
            return tableCells;
        }
 
        private Rdl.TableCellType CreateTableCell(TextItem item)
        {
            Rdl.TableCellType tableCell = new Rdl.TableCellType();
            tableCell.Items = new object[] { CreateTableCellReportItems(item) };
            return tableCell;
        }
 
        private Rdl.ReportItemsType CreateTableCellReportItems(TextItem item)
        {
            Rdl.ReportItemsType reportItems = new Rdl.ReportItemsType();
            reportItems.Items = new object[] { CreateTableCellTextbox(item) };
            return reportItems;
        }
 
        private Rdl.TextboxType CreateTableCellTextbox(TextItem item)
        {
            Rdl.TextboxType textbox = new Rdl.TextboxType();
            textbox.Name = item.Key;
            textbox.Items = new object[] 
                {
                    "=Fields!" + item.DataMember + ".Value",
                    CreateTableCellTextboxStyle(item),
                    true,
                };
            textbox.ItemsElementName = new Rdl.ItemsChoiceType14[] 
                {
                    Rdl.ItemsChoiceType14.Value,
                    Rdl.ItemsChoiceType14.Style,
                    Rdl.ItemsChoiceType14.CanGrow,
                };
            return textbox;
        }
 
        private Rdl.StyleType CreateTableCellTextboxStyle(TextItem item)
        {
            Rdl.StyleType style = new Rdl.StyleType();
            style.Items = new object[]
                {
                    item.Font.Name,
                    item.Font.Size + "pt",
                    item.Font.Bold ? "400" : "100",
                    GetAlign(item.Align.Alignment),
                    "Middle",
                    CreateBorderStyle(),
                    "1pt",
                    "1pt",
                    "1pt",
                    "1pt",
                };
            style.ItemsElementName = new Rdl.ItemsChoiceType5[]
                {
                    Rdl.ItemsChoiceType5.FontFamily,
                    Rdl.ItemsChoiceType5.FontSize,
                    Rdl.ItemsChoiceType5.FontWeight,
                    Rdl.ItemsChoiceType5.TextAlign,
                    Rdl.ItemsChoiceType5.VerticalAlign,
                    Rdl.ItemsChoiceType5.BorderStyle,
                    Rdl.ItemsChoiceType5.PaddingLeft,
                    Rdl.ItemsChoiceType5.PaddingTop,
                    Rdl.ItemsChoiceType5.PaddingRight,
                    Rdl.ItemsChoiceType5.PaddingBottom,
                };
            return style;
        }
 
        private Rdl.TableColumnsType CreateTableColumns()
        {
            Rdl.TableColumnsType tableColumns = new Rdl.TableColumnsType();
            tableColumns.TableColumn = new Rdl.TableColumnType[m_fields.Count];
            int i = 0;
            foreach (string key in m_fields.Keys)
            {
                tableColumns.TableColumn[i++] = CreateTableColumn(m_fields[key]);
            }
            return tableColumns;
        }
 
        private Rdl.TableColumnType CreateTableColumn(TextItem item)
        {
            Rdl.TableColumnType tableColumn = new Rdl.TableColumnType();
            tableColumn.Items = new object[] { (item.Rect.Width / 96.0) + "in" };
            return tableColumn;
        }
 
        private Rdl.BorderColorStyleWidthType CreateBorderStyle()
        {
            Rdl.BorderColorStyleWidthType bstyle = new Rdl.BorderColorStyleWidthType();
            bstyle.Items = new object[]
                {
                    "Solid",
                };
            bstyle.ItemsElementName = new Rdl.ItemsChoiceType3[]
                {
                    Rdl.ItemsChoiceType3.Default,
                };
            return bstyle;
        }
 
        private string GetVAlign(StringAlignment sformat)
        {
            switch (sformat)
            {
                case StringAlignment.Center: return "Middle";
                case StringAlignment.Far: return "Bottom";
                default: return "Top";
            }
        }
 
        private string GetAlign(StringAlignment sformat)
        {
            switch (sformat)
            {
                case StringAlignment.Center: return "Center";
                case StringAlignment.Far: return "Right";
                default: return "Left";
            }
        }
    }
 }

 


四、页头页尾生成类HeaderFooterRdlGenerator


 using System;
 using System.Collections.Generic;
 using System.Text;
 using System.Drawing;
 
 namespace FBS.GDTVMember.Report
 {
    public class HeaderFooterRdlGenerator
    {
        private Dictionary<string, TextItem> m_fields;
        private int m_height;
 
        public Dictionary<string, TextItem> Fields
        {
            get { return m_fields; }
            set { m_fields = value; }
        }
 
        public int Height
        {
            get { return m_height; }
            set { m_height = value; }
        }
 
        public Rdl.ReportItemsType CreateItems()
        {
            Rdl.ReportItemsType items = new Rdl.ReportItemsType();
            items.Items = new Rdl.TextboxType[m_fields.Count];
            int i = 0;
            foreach (string key in m_fields.Keys)
            {
                items.Items[i++] = CreateTextBox(m_fields[key]);
            }
            return items;
        }
 
        private Rdl.TextboxType CreateTextBox(TextItem item)
        {
            Rdl.TextboxType textbox = new Rdl.TextboxType();
            textbox.Name = item.Key;
            textbox.Items = new object[] 
                {
                    item.Text,
                    CreateTextboxStyle(item),
                    true,
                    (item.Rect.Left / 96.0) + "in",
                    (item.Rect.Top / 96.0) + "in",
                    (item.Rect.Width / 96.0) + "in",
                    (item.Rect.Height / 96.0) + "in",
                };
            textbox.ItemsElementName = new Rdl.ItemsChoiceType14[] 
                {
                    Rdl.ItemsChoiceType14.Value,
                    Rdl.ItemsChoiceType14.Style,
                    Rdl.ItemsChoiceType14.CanGrow,
                    Rdl.ItemsChoiceType14.Left,
                    Rdl.ItemsChoiceType14.Top,
                    Rdl.ItemsChoiceType14.Width,
                    Rdl.ItemsChoiceType14.Height,
                };
            return textbox;
        }
 
        private Rdl.StyleType CreateTextboxStyle(TextItem item)
        {
            Rdl.StyleType style = new Rdl.StyleType();
            style.Items = new object[]
                {
                    GetAlign(item.Align.Alignment),
                    GetVAlign(item.Align.LineAlignment),
                    item.Font.Name,
                    item.Font.Size + "pt",
                    item.Font.Bold ? "700" : "100",
                };
            style.ItemsElementName = new Rdl.ItemsChoiceType5[]
                {
                    Rdl.ItemsChoiceType5.TextAlign,
                    Rdl.ItemsChoiceType5.VerticalAlign,
                    Rdl.ItemsChoiceType5.FontFamily,
                    Rdl.ItemsChoiceType5.FontSize,
                    Rdl.ItemsChoiceType5.FontWeight,
                };
            return style;
        }
 
        private string GetVAlign(StringAlignment sformat)
        {
            switch(sformat)
            {
                case StringAlignment.Center: return "Middle";
                case StringAlignment.Far: return "Bottom";
                default: return "Top";
            }
        }
 
        private string GetAlign(StringAlignment sformat)
        {
            switch (sformat)
            {
                case StringAlignment.Center: return "Center";
                case StringAlignment.Far: return "Right";
                default: return "Left";
            }
        }
    }
 }




五、报表配置类ReportConfig


 using System;
 using System.Collections.Generic;
 using System.Drawing;
 using System.Drawing.Printing;
 using System.Text;
 using System.Reflection;
 using System.Xml;
 
 namespace FBS.GDTVMember.Report
 {
    /// <summary>
    /// 报表配置
    /// </summary>
    public class ReportConfig
    {
        private string _filename;
        private bool _autosize;
        private PageSettings _pset = new PageSettings();
        private Dictionary<string, TextItem> _header;
        private Dictionary<string, TextItem> _dataitem;
        private Dictionary<string, TextItem> _footer;
        private Dictionary<string, object> _cusmdata;
        private float _headheight;
        private float _footheight;
        private float _width, _height, _lm, _tm, _rm, _bm;
        private string _unit;
 
        public ReportConfig()
        {
        }
 
        public ReportConfig(string frpFile)
        {
            _filename = frpFile;
            XmlDocument xdoc = new XmlDocument();
            xdoc.Load(frpFile);
            XmlNode pnode = xdoc.SelectSingleNode("//configuration/pageset");
            ReportConfig.GetAttribute(pnode, "unit", ref _unit);
            if(string.IsNullOrEmpty(_unit)) //没有单位
            {
                //页面大小
                int w = 0, h = 0;
                ReportConfig.GetAttribute(pnode, "width", ref w);
                ReportConfig.GetAttribute(pnode, "height", ref h);
                _autosize = h == 0;
                _pset.PaperSize = new PaperSize(frpFile, w, h);
                //页边距
                int m_left = 0, m_top = 0, m_right = 0, m_bottom = 0;
                ReportConfig.GetAttribute(pnode, "margin-left", ref m_left);
                ReportConfig.GetAttribute(pnode, "margin-top", ref m_top);
                ReportConfig.GetAttribute(pnode, "margin-right", ref m_right);
                ReportConfig.GetAttribute(pnode, "margin-bottom", ref m_bottom);
                _pset.Margins = new Margins(m_left, m_right, m_top, m_bottom);
            }
            else
            {
                ReportConfig.GetAttribute(pnode, "width", ref _width);
                ReportConfig.GetAttribute(pnode, "height", ref _height);
                ReportConfig.GetAttribute(pnode, "margin-left", ref _lm);
                ReportConfig.GetAttribute(pnode, "margin-top", ref _tm);
                ReportConfig.GetAttribute(pnode, "margin-right", ref _rm);
                ReportConfig.GetAttribute(pnode, "margin-bottom", ref _bm);
            }
            //头
            pnode = xdoc.SelectSingleNode("//configuration/header");
            ReportConfig.GetAttribute(pnode, "height", ref _headheight);
            //字段
            foreach (XmlNode node in xdoc.SelectNodes("//configuration/header/textitem"))
            {
                TextItem item = new TextItem(node);
                if (_header == null)
                {
                    _header = new Dictionary<string, TextItem>();
                }
                _header.Add(item.Key, item);
            }
            //尾
            pnode = xdoc.SelectSingleNode("//configuration/footer");
            ReportConfig.GetAttribute(pnode, "height", ref _footheight);
            //字段
            foreach (XmlNode node in xdoc.SelectNodes("//configuration/footer/textitem"))
            {
                TextItem item = new TextItem(node);
                if (_footer == null)
                {
                    _footer = new Dictionary<string, TextItem>();
                }
                _footer.Add(item.Key, item);
            }
            //数据字段
            foreach (XmlNode node in xdoc.SelectNodes("//configuration/dataitem/textitem"))
            {
                TextItem item = new TextItem(node);
                if(_dataitem == null)
                {
                    _dataitem = new Dictionary<string, TextItem>();
                }
                _dataitem.Add(item.Key, item);
            }
        }
 
        public Dictionary<string, object> CustomData
        {
            get {
                if (_cusmdata == null)
                    _cusmdata = new Dictionary<string, object>();
                return _cusmdata; 
            }
        }
 
        public Dictionary<string, TextItem> Header
        {
            get { return _header; }
        }
 
        public Dictionary<string, TextItem> DataItem
        {
            get { return _dataitem; }
        }
 
        public Dictionary<string, TextItem> Footer
        {
            get { return _footer; }
        }
 
        public PageSettings PageSettings
        {
            get { return _pset; }
        }
 
        public float HeadHeight
        {
            get { return _headheight; }
        }
 
        public float FootHeight
        {
            get { return _footheight; }
        }
 
        public float Width
        {
            get { return _width; }
        }
 
        public float Height
        {
            get { return _height; }
        }
 
        public float LeftMargin
        {
            get { return _lm; }
        }
 
        public float TopMargin
        {
            get { return _tm; }
        }
 
        public float RightMargin
        {
            get { return _rm; }
        }
 
        public float BottomMargin
        {
            get { return _bm; }
        }
 
        public bool AutoSize
        {
            get { return _autosize; }
            set { _autosize = value; }
        }
 
        public string Unit
        {
            get { return _unit; }
            set { _unit = value; }
        }
 
        /// <summary>
        /// 从一个类获取数据
        /// </summary>
        /// <param name="data"></param>
        public void DataFromDataItem(object data)
        {
            Type type = data.GetType();
            foreach (PropertyInfo pinfo in type.GetProperties(BindingFlags.Instance | BindingFlags.IgnoreCase | BindingFlags.NonPublic | BindingFlags.Public))
            {
                if (CustomData.ContainsKey(pinfo.Name))
                    continue;
                object value = type.InvokeMember(pinfo.Name, BindingFlags.Instance | BindingFlags.GetProperty | BindingFlags.Public | BindingFlags.NonPublic, null, data, null);
                if(value != null)
                {
                    CustomData.Add(pinfo.Name, value);
                }
            }
        }
 
        internal static void GetAttribute(XmlNode node, string key, ref string value)
        {
            if (node.Attributes[key] != null)
            {
                value = node.Attributes[key].Value;
            }
        }
 
        internal static void GetAttribute(XmlNode node, string key, ref int value)
        {
            if (node.Attributes[key] != null)
            {
                value = int.Parse(node.Attributes[key].Value);
            }
        }
 
        internal static void GetAttribute(XmlNode node, string key, ref float value)
        {
            if (node.Attributes[key] != null)
            {
                value = float.Parse(node.Attributes[key].Value);
            }
        }
    }
 }



六、文本项类TextItem


 using System;
 using System.Drawing;
 using System.Drawing.Printing;
 using System.Text;
 using System.Xml;
 
 namespace FBS.GDTVMember.Report
 {
   [Serializable]
    public class TextItem
    {
        private string _text;
        private string _key;
        private string _datamember;
        private Rectangle _rect;
        private StringFormat _align;
        private bool _count;
        private string _format;
        internal decimal _sum;
        private Font _font = System.Windows.Forms.Control.DefaultFont;
        private Font _headerfont = System.Windows.Forms.Control.DefaultFont;
 
        public TextItem(XmlNode node)
        {
            _key = node.Attributes["key"].Value;
            if(!string.IsNullOrEmpty(node.InnerText))
            {
                _text = node.InnerText;
            }
            else
            {
                ReportConfig.GetAttribute(node, "text", ref _text);
            }
            ReportConfig.GetAttribute(node, "data", ref _datamember);
            ReportConfig.GetAttribute(node, "format", ref _format);
            string font_name = _font.Name;
            string font_bold = "";
            string font_italic = "";
            string font_underline = "";
            float font_size = Font.Size;
            FontStyle fsty = FontStyle.Regular;
            ReportConfig.GetAttribute(node, "font-name", ref font_name);
            ReportConfig.GetAttribute(node, "font-size", ref font_size);
            ReportConfig.GetAttribute(node, "font-bold", ref font_bold);
            ReportConfig.GetAttribute(node, "font-italic", ref font_italic);
            ReportConfig.GetAttribute(node, "font-underline", ref font_underline);
            if (font_bold.Equals("1"))
            {
                fsty |= FontStyle.Bold;
            }
            if (font_italic.Equals("1"))
            {
                fsty |= FontStyle.Italic;
            }
            if (font_underline.Equals("1"))
            {
                fsty |= FontStyle.Underline;
            }
            _font = new Font(font_name, font_size, fsty);
 
            font_name = _font.Name;
            font_bold = "";
            font_italic = "";
            font_underline = "";
            font_size = Font.Size;
            fsty = FontStyle.Regular;
            ReportConfig.GetAttribute(node, "header-font-name", ref font_name);
            ReportConfig.GetAttribute(node, "header-font-size", ref font_size);
            ReportConfig.GetAttribute(node, "header-font-bold", ref font_bold);
            ReportConfig.GetAttribute(node, "header-font-italic", ref font_italic);
            ReportConfig.GetAttribute(node, "header-font-underline", ref font_underline);
            if (font_bold.Equals("1"))
            {
                fsty |= FontStyle.Bold;
            }
            if (font_italic.Equals("1"))
            {
                fsty |= FontStyle.Italic;
            }
            if (font_underline.Equals("1"))
            {
                fsty |= FontStyle.Underline;
            }
            _headerfont = new Font(font_name, font_size, fsty);
 
            int left = 0, top = 0, width = 0, height = 0;
            ReportConfig.GetAttribute(node, "left", ref left);
            ReportConfig.GetAttribute(node, "top", ref top);
            ReportConfig.GetAttribute(node, "width", ref width);
            ReportConfig.GetAttribute(node, "height", ref height);
            _rect = new Rectangle(left, top, width, height);
 
            string align = "left";
            ReportConfig.GetAttribute(node, "align", ref align);
            string valign = "top";
            ReportConfig.GetAttribute(node, "valign", ref valign);
            _align = new StringFormat();
            if (align.Equals("right", StringComparison.OrdinalIgnoreCase))
            {
                _align.Alignment = StringAlignment.Far;
            }
            else if (align.Equals("center", StringComparison.OrdinalIgnoreCase))
            {
                _align.Alignment = StringAlignment.Center;
            }
            if (valign.Equals("bottom", StringComparison.OrdinalIgnoreCase))
            {
                _align.LineAlignment = StringAlignment.Far;
            }
            else if (valign.Equals("middle", StringComparison.OrdinalIgnoreCase))
            {
                _align.LineAlignment = StringAlignment.Center;
            }
 
            string count = "";
            ReportConfig.GetAttribute(node, "count", ref count);
            if(count.Equals("1"))
            {
                _count = true;
            }
        }
 
        public string Key
        {
            get { return _key; }
        }
 
        public string Text
        {
            get { return _text; }
            set { _text = value; }
        }
 
        public string DataMember
        {
            get { return _datamember; }
        }
 
        public string DataFormat
        {
            get { return _format; }
        }
 
        public StringFormat Align
        {
            get { return _align; }
        }
 
        public Rectangle Rect
        {
            get { return _rect; }
            set { _rect = value; }
        }
 
        public bool Count
        {
            get { return _count; }
        }
 
        public Font Font
        {
            get { return _font; }
        }
 
        public Font HeaderFont
        {
            get { return _headerfont; }
        }
    }
 }


七、报表配置示例


 <?xml version="1.0" encoding="gb2312"?>
 <configuration>
  <pageset width="29.7" height="21" unit="cm" margin-left="1" margin-top="1" margin-right="1" margin-bottom="1" />
  <header height="90">
    <textitem key="ShopName" left="5" top="6" width="960" height="20" align="center" font-name="宋体" font-size="16" font-bold="1" text="" />
    <textitem key="Title" left="5" top="30" width="960" height="20" align="center" font-name="宋体" font-size="16" font-bold="1" text="消费明细报表" />
    <textitem key="Admin" left="0" top="60" width="300" height="24" text="" />
    <textitem key="Date" align="right" left="0" top="60" width="960" height="24" text="" />
  </header>
  <dataitem>
    <textitem key="Code" text="单号" data="Code" width="90" />
    <textitem key="Card" text="卡号" data="Card" width="100" />
    <textitem key="MemberName" text="姓名" data="MemberName" width="60" />
    <textitem key="ProductName" text="消费项目" data="ProductName" width="220" />
    <textitem key="Price" text="单价" data="Price" width="60" align="right" />
    <textitem key="Discount" text="折扣" data="Discount" width="60" align="right" />
    <textitem key="Quantity" text="数量" data="Quantity" width="60" align="right" />
    <textitem key="TCount" text="金额合计" data="TCount" width="60" align="right" />
    <textitem key="Score" text="商铺积分" data="Score" width="60" align="right" />
    <textitem key="MasterScore" text="平台积分" data="MasterScore" width="60" align="right" />
    <textitem key="AddTime" text="消费日期" data="AddTime" width="124" />
  </dataitem>
  <footer height="40">
    <textitem key="Count" left="5" top="10" width="400" height="24" text="" />
    <textitem key="Page" align="right" left="800" top="10" width="160" height="24">="第" & Globals!PageNumber & "页 共" & Globals!TotalPages & "页"</textitem>
  </footer>
 </configuration>

文章出处：http://www.cnblogs.com/faib/archive/2008/08/03/1259161.html