RDLC自定义报表

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

 

一、改进后的ReportViewer

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Text;
 4 using Microsoft.Reporting.WinForms;
 5 using System.ComponentModel;
 6 using System.IO;
 7 
 8 namespace FBS.GDTVMember.Report
 9 {
     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生成类

  1 using System;
  2 using System.Collections.Generic;
  3 using System.Text;
  4 using System.IO;
  5 using System.Xml.Serialization;
  6 
  7 namespace FBS.GDTVMember.Report
  8 {
  9     public class RdlGenerator
 10     {
 11         private ReportConfig _rpc;
 12 
 13         /// <summary>
 14         /// 报表配置
 15         /// </summary>
 16         public ReportConfig ReportConfig
 17         {
 18             get { return _rpc; }
 19             set { _rpc = value; }
 20         }
 21 
 22         /// <summary>
 23         /// 创建报表
 24         /// </summary>
 25         /// <returns></returns>
 26         private Rdl.Report CreateReport()
 27         {
 28             Rdl.Report report = new Rdl.Report();
 29             string w = "", h = "", lm = "", tm = "", rm = "", bm = "";
 30             //设置报表页面
 31             if(!string.IsNullOrEmpty(_rpc.Unit))
 32             {
 33                 w = _rpc.Width + _rpc.Unit;
 34                 h = _rpc.Height + _rpc.Unit;
 35                 lm = _rpc.LeftMargin + _rpc.Unit;
 36                 tm = _rpc.TopMargin + _rpc.Unit;
 37                 rm = _rpc.RightMargin + _rpc.Unit;
 38                 bm = _rpc.BottomMargin + _rpc.Unit;
 39             }
 40             else
 41             {
 42                 w = (_rpc.PageSettings.PaperSize.Width / 96.0) + "in";
 43                 h = (_rpc.PageSettings.PaperSize.Height / 96.0) + "in";
 44                 lm = (_rpc.LeftMargin / 96.0) + "in";
 45                 tm = (_rpc.TopMargin / 96.0) + "in";
 46                 rm = (_rpc.RightMargin / 96.0) + "in";
 47                 bm = (_rpc.BottomMargin / 96.0) + "in";
 48             }
 49             report.Items = new object[] 
 50                 {
 51                     CreateDataSources(),
 52                     CreateHeader(),
 53                     CreateBody(),
 54                     CreateFooter(),
 55                     CreateDataSets(),
 56                     w,
 57                     h,
 58                     lm,
 59                     tm,
 60                     rm,
 61                     bm,
 62                 };
 63             report.ItemsElementName = new Rdl.ItemsChoiceType37[]
 64                 { 
 65                     Rdl.ItemsChoiceType37.DataSources, 
 66                     Rdl.ItemsChoiceType37.PageHeader,
 67                     Rdl.ItemsChoiceType37.Body,
 68                     Rdl.ItemsChoiceType37.PageFooter,
 69                     Rdl.ItemsChoiceType37.DataSets,
 70                     Rdl.ItemsChoiceType37.Width,
 71                     Rdl.ItemsChoiceType37.PageHeight,
 72                     Rdl.ItemsChoiceType37.LeftMargin,
 73                     Rdl.ItemsChoiceType37.TopMargin,
 74                     Rdl.ItemsChoiceType37.RightMargin,
 75                     Rdl.ItemsChoiceType37.BottomMargin,
 76                 };
 77             return report;
 78         }
 79 
 80         #region 数据源
 81         /// <summary>
 82         /// 数据源
 83         /// </summary>
 84         /// <returns></returns>
 85         private Rdl.DataSourcesType CreateDataSources()
 86         {
 87             Rdl.DataSourcesType dataSources = new Rdl.DataSourcesType();
 88             dataSources.DataSource = new Rdl.DataSourceType[] { CreateDataSource() };
 89             return dataSources;
 90         }
 91 
 92         private Rdl.DataSourceType CreateDataSource()
 93         {
 94             Rdl.DataSourceType dataSource = new Rdl.DataSourceType();
 95             dataSource.Name = "FaibLists";
 96             dataSource.Items = new object[] { CreateConnectionProperties() };
 97             return dataSource;
 98         }
 99 
         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

  1 using System;
  2 using System.Collections.Generic;
  3 using System.Text;
  4 using System.Drawing;
  5 
  6 namespace FBS.GDTVMember.Report
  7 {
  8     public class TableRdlGenerator
  9     {
 10         private Dictionary<string, TextItem> m_fields;
 11 
 12         public Dictionary<string, TextItem> Fields
 13         {
 14             get { return m_fields; }
 15             set { m_fields = value; }
 16         }
 17 
 18         public Rdl.TableType CreateTable()
 19         {
 20             //定义表格
 21             Rdl.TableType table = new Rdl.TableType();
 22             table.Name = "Table1";
 23             table.Items = new object[]
 24                 {
 25                     CreateTableColumns(),
 26                     CreateHeader(),
 27                     CreateDetails(),
 28                 };
 29             table.ItemsElementName = new Rdl.ItemsChoiceType21[]
 30                 {
 31                     Rdl.ItemsChoiceType21.TableColumns,
 32                     Rdl.ItemsChoiceType21.Header,
 33                     Rdl.ItemsChoiceType21.Details,
 34                 };
 35             return table;
 36         }
 37 
 38         private Rdl.HeaderType CreateHeader()
 39         {
 40             Rdl.HeaderType header = new Rdl.HeaderType();
 41             header.Items = new object[]
 42                 {
 43                     CreateHeaderTableRows(),
 44                     true,
 45                 };
 46             header.ItemsElementName = new Rdl.ItemsChoiceType20[]
 47                 {
 48                     Rdl.ItemsChoiceType20.TableRows,
 49                     Rdl.ItemsChoiceType20.RepeatOnNewPage,
 50                 };
 51             return header;
 52         }
 53 
 54         private Rdl.TableRowsType CreateHeaderTableRows()
 55         {
 56             Rdl.TableRowsType headerTableRows = new Rdl.TableRowsType();
 57             headerTableRows.TableRow = new Rdl.TableRowType[] { CreateHeaderTableRow() };
 58             return headerTableRows;
 59         }
 60 
 61         private Rdl.TableRowType CreateHeaderTableRow()
 62         {
 63             Rdl.TableRowType headerTableRow = new Rdl.TableRowType();
 64             headerTableRow.Items = new object[] { CreateHeaderTableCells(), "0.25in" };
 65             return headerTableRow;
 66         }
 67 
 68         private Rdl.TableCellsType CreateHeaderTableCells()
 69         {
 70             Rdl.TableCellsType headerTableCells = new Rdl.TableCellsType();
 71             headerTableCells.TableCell = new Rdl.TableCellType[m_fields.Count];
 72             int i = 0;
 73             foreach (string key in m_fields.Keys)
 74             {
 75                 headerTableCells.TableCell[i++] = CreateHeaderTableCell(m_fields[key]);
 76             }
 77             return headerTableCells;
 78         }
 79 
 80         private Rdl.TableCellType CreateHeaderTableCell(TextItem item)
 81         {
 82             Rdl.TableCellType headerTableCell = new Rdl.TableCellType();
 83             headerTableCell.Items = new object[] { CreateHeaderTableCellReportItems(item) };
 84             return headerTableCell;
 85         }
 86 
 87         private Rdl.ReportItemsType CreateHeaderTableCellReportItems(TextItem item)
 88         {
 89             Rdl.ReportItemsType headerTableCellReportItems = new Rdl.ReportItemsType();
 90             headerTableCellReportItems.Items = new object[] { CreateHeaderTableCellTextbox(item) };
 91             return headerTableCellReportItems;
 92         }
 93 
 94         private Rdl.TextboxType CreateHeaderTableCellTextbox(TextItem item)
 95         {
 96             Rdl.TextboxType headerTableCellTextbox = new Rdl.TextboxType();
 97             headerTableCellTextbox.Name = item.Text + "_Header";
 98             headerTableCellTextbox.Items = new object[] 
 99                 {
                     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

  1 using System;
  2 using System.Collections.Generic;
  3 using System.Text;
  4 using System.Drawing;
  5 
  6 namespace FBS.GDTVMember.Report
  7 {
  8     public class HeaderFooterRdlGenerator
  9     {
 10         private Dictionary<string, TextItem> m_fields;
 11         private int m_height;
 12 
 13         public Dictionary<string, TextItem> Fields
 14         {
 15             get { return m_fields; }
 16             set { m_fields = value; }
 17         }
 18 
 19         public int Height
 20         {
 21             get { return m_height; }
 22             set { m_height = value; }
 23         }
 24 
 25         public Rdl.ReportItemsType CreateItems()
 26         {
 27             Rdl.ReportItemsType items = new Rdl.ReportItemsType();
 28             items.Items = new Rdl.TextboxType[m_fields.Count];
 29             int i = 0;
 30             foreach (string key in m_fields.Keys)
 31             {
 32                 items.Items[i++] = CreateTextBox(m_fields[key]);
 33             }
 34             return items;
 35         }
 36 
 37         private Rdl.TextboxType CreateTextBox(TextItem item)
 38         {
 39             Rdl.TextboxType textbox = new Rdl.TextboxType();
 40             textbox.Name = item.Key;
 41             textbox.Items = new object[] 
 42                 {
 43                     item.Text,
 44                     CreateTextboxStyle(item),
 45                     true,
 46                     (item.Rect.Left / 96.0) + "in",
 47                     (item.Rect.Top / 96.0) + "in",
 48                     (item.Rect.Width / 96.0) + "in",
 49                     (item.Rect.Height / 96.0) + "in",
 50                 };
 51             textbox.ItemsElementName = new Rdl.ItemsChoiceType14[] 
 52                 {
 53                     Rdl.ItemsChoiceType14.Value,
 54                     Rdl.ItemsChoiceType14.Style,
 55                     Rdl.ItemsChoiceType14.CanGrow,
 56                     Rdl.ItemsChoiceType14.Left,
 57                     Rdl.ItemsChoiceType14.Top,
 58                     Rdl.ItemsChoiceType14.Width,
 59                     Rdl.ItemsChoiceType14.Height,
 60                 };
 61             return textbox;
 62         }
 63 
 64         private Rdl.StyleType CreateTextboxStyle(TextItem item)
 65         {
 66             Rdl.StyleType style = new Rdl.StyleType();
 67             style.Items = new object[]
 68                 {
 69                     GetAlign(item.Align.Alignment),
 70                     GetVAlign(item.Align.LineAlignment),
 71                     item.Font.Name,
 72                     item.Font.Size + "pt",
 73                     item.Font.Bold ? "700" : "100",
 74                 };
 75             style.ItemsElementName = new Rdl.ItemsChoiceType5[]
 76                 {
 77                     Rdl.ItemsChoiceType5.TextAlign,
 78                     Rdl.ItemsChoiceType5.VerticalAlign,
 79                     Rdl.ItemsChoiceType5.FontFamily,
 80                     Rdl.ItemsChoiceType5.FontSize,
 81                     Rdl.ItemsChoiceType5.FontWeight,
 82                 };
 83             return style;
 84         }
 85 
 86         private string GetVAlign(StringAlignment sformat)
 87         {
 88             switch(sformat)
 89             {
 90                 case StringAlignment.Center: return "Middle";
 91                 case StringAlignment.Far: return "Bottom";
 92                 default: return "Top";
 93             }
 94         }
 95 
 96         private string GetAlign(StringAlignment sformat)
 97         {
 98             switch (sformat)
 99             {
                 case StringAlignment.Center: return "Center";
                 case StringAlignment.Far: return "Right";
                 default: return "Left";
             }
         }
     }
 }
 

 

五、报表配置类ReportConfig

  1 using System;
  2 using System.Collections.Generic;
  3 using System.Drawing;
  4 using System.Drawing.Printing;
  5 using System.Text;
  6 using System.Reflection;
  7 using System.Xml;
  8 
  9 namespace FBS.GDTVMember.Report
 10 {
 11     /// <summary>
 12     /// 报表配置
 13     /// </summary>
 14     public class ReportConfig
 15     {
 16         private string _filename;
 17         private bool _autosize;
 18         private PageSettings _pset = new PageSettings();
 19         private Dictionary<string, TextItem> _header;
 20         private Dictionary<string, TextItem> _dataitem;
 21         private Dictionary<string, TextItem> _footer;
 22         private Dictionary<string, object> _cusmdata;
 23         private float _headheight;
 24         private float _footheight;
 25         private float _width, _height, _lm, _tm, _rm, _bm;
 26         private string _unit;
 27 
 28         public ReportConfig()
 29         {
 30         }
 31 
 32         public ReportConfig(string frpFile)
 33         {
 34             _filename = frpFile;
 35             XmlDocument xdoc = new XmlDocument();
 36             xdoc.Load(frpFile);
 37             XmlNode pnode = xdoc.SelectSingleNode("//configuration/pageset");
 38             ReportConfig.GetAttribute(pnode, "unit", ref _unit);
 39             if(string.IsNullOrEmpty(_unit)) //没有单位
 40             {
 41                 //页面大小
 42                 int w = 0, h = 0;
 43                 ReportConfig.GetAttribute(pnode, "width", ref w);
 44                 ReportConfig.GetAttribute(pnode, "height", ref h);
 45                 _autosize = h == 0;
 46                 _pset.PaperSize = new PaperSize(frpFile, w, h);
 47                 //页边距
 48                 int m_left = 0, m_top = 0, m_right = 0, m_bottom = 0;
 49                 ReportConfig.GetAttribute(pnode, "margin-left", ref m_left);
 50                 ReportConfig.GetAttribute(pnode, "margin-top", ref m_top);
 51                 ReportConfig.GetAttribute(pnode, "margin-right", ref m_right);
 52                 ReportConfig.GetAttribute(pnode, "margin-bottom", ref m_bottom);
 53                 _pset.Margins = new Margins(m_left, m_right, m_top, m_bottom);
 54             }
 55             else
 56             {
 57                 ReportConfig.GetAttribute(pnode, "width", ref _width);
 58                 ReportConfig.GetAttribute(pnode, "height", ref _height);
 59                 ReportConfig.GetAttribute(pnode, "margin-left", ref _lm);
 60                 ReportConfig.GetAttribute(pnode, "margin-top", ref _tm);
 61                 ReportConfig.GetAttribute(pnode, "margin-right", ref _rm);
 62                 ReportConfig.GetAttribute(pnode, "margin-bottom", ref _bm);
 63             }
 64             //头
 65             pnode = xdoc.SelectSingleNode("//configuration/header");
 66             ReportConfig.GetAttribute(pnode, "height", ref _headheight);
 67             //字段
 68             foreach (XmlNode node in xdoc.SelectNodes("//configuration/header/textitem"))
 69             {
 70                 TextItem item = new TextItem(node);
 71                 if (_header == null)
 72                 {
 73                     _header = new Dictionary<string, TextItem>();
 74                 }
 75                 _header.Add(item.Key, item);
 76             }
 77             //尾
 78             pnode = xdoc.SelectSingleNode("//configuration/footer");
 79             ReportConfig.GetAttribute(pnode, "height", ref _footheight);
 80             //字段
 81             foreach (XmlNode node in xdoc.SelectNodes("//configuration/footer/textitem"))
 82             {
 83                 TextItem item = new TextItem(node);
 84                 if (_footer == null)
 85                 {
 86                     _footer = new Dictionary<string, TextItem>();
 87                 }
 88                 _footer.Add(item.Key, item);
 89             }
 90             //数据字段
 91             foreach (XmlNode node in xdoc.SelectNodes("//configuration/dataitem/textitem"))
 92             {
 93                 TextItem item = new TextItem(node);
 94                 if(_dataitem == null)
 95                 {
 96                     _dataitem = new Dictionary<string, TextItem>();
 97                 }
 98                 _dataitem.Add(item.Key, item);
 99             }
         }
 
         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

  1 using System;
  2 using System.Drawing;
  3 using System.Drawing.Printing;
  4 using System.Text;
  5 using System.Xml;
  6 
  7 namespace FBS.GDTVMember.Report
  8 {
  9     [Serializable]
 10     public class TextItem
 11     {
 12         private string _text;
 13         private string _key;
 14         private string _datamember;
 15         private Rectangle _rect;
 16         private StringFormat _align;
 17         private bool _count;
 18         private string _format;
 19         internal decimal _sum;
 20         private Font _font = System.Windows.Forms.Control.DefaultFont;
 21         private Font _headerfont = System.Windows.Forms.Control.DefaultFont;
 22 
 23         public TextItem(XmlNode node)
 24         {
 25             _key = node.Attributes["key"].Value;
 26             if(!string.IsNullOrEmpty(node.InnerText))
 27             {
 28                 _text = node.InnerText;
 29             }
 30             else
 31             {
 32                 ReportConfig.GetAttribute(node, "text", ref _text);
 33             }
 34             ReportConfig.GetAttribute(node, "data", ref _datamember);
 35             ReportConfig.GetAttribute(node, "format", ref _format);
 36             string font_name = _font.Name;
 37             string font_bold = "";
 38             string font_italic = "";
 39             string font_underline = "";
 40             float font_size = Font.Size;
 41             FontStyle fsty = FontStyle.Regular;
 42             ReportConfig.GetAttribute(node, "font-name", ref font_name);
 43             ReportConfig.GetAttribute(node, "font-size", ref font_size);
 44             ReportConfig.GetAttribute(node, "font-bold", ref font_bold);
 45             ReportConfig.GetAttribute(node, "font-italic", ref font_italic);
 46             ReportConfig.GetAttribute(node, "font-underline", ref font_underline);
 47             if (font_bold.Equals("1"))
 48             {
 49                 fsty |= FontStyle.Bold;
 50             }
 51             if (font_italic.Equals("1"))
 52             {
 53                 fsty |= FontStyle.Italic;
 54             }
 55             if (font_underline.Equals("1"))
 56             {
 57                 fsty |= FontStyle.Underline;
 58             }
 59             _font = new Font(font_name, font_size, fsty);
 60 
 61             font_name = _font.Name;
 62             font_bold = "";
 63             font_italic = "";
 64             font_underline = "";
 65             font_size = Font.Size;
 66             fsty = FontStyle.Regular;
 67             ReportConfig.GetAttribute(node, "header-font-name", ref font_name);
 68             ReportConfig.GetAttribute(node, "header-font-size", ref font_size);
 69             ReportConfig.GetAttribute(node, "header-font-bold", ref font_bold);
 70             ReportConfig.GetAttribute(node, "header-font-italic", ref font_italic);
 71             ReportConfig.GetAttribute(node, "header-font-underline", ref font_underline);
 72             if (font_bold.Equals("1"))
 73             {
 74                 fsty |= FontStyle.Bold;
 75             }
 76             if (font_italic.Equals("1"))
 77             {
 78                 fsty |= FontStyle.Italic;
 79             }
 80             if (font_underline.Equals("1"))
 81             {
 82                 fsty |= FontStyle.Underline;
 83             }
 84             _headerfont = new Font(font_name, font_size, fsty);
 85 
 86             int left = 0, top = 0, width = 0, height = 0;
 87             ReportConfig.GetAttribute(node, "left", ref left);
 88             ReportConfig.GetAttribute(node, "top", ref top);
 89             ReportConfig.GetAttribute(node, "width", ref width);
 90             ReportConfig.GetAttribute(node, "height", ref height);
 91             _rect = new Rectangle(left, top, width, height);
 92 
 93             string align = "left";
 94             ReportConfig.GetAttribute(node, "align", ref align);
 95             string valign = "top";
 96             ReportConfig.GetAttribute(node, "valign", ref valign);
 97             _align = new StringFormat();
 98             if (align.Equals("right", StringComparison.OrdinalIgnoreCase))
 99             {
                 _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; }
         }
     }
 }
 

 

七、报表配置示例

 1 <?xml version="1.0" encoding="gb2312"?>
 2 <configuration>
 3   <pageset width="29.7" height="21" unit="cm" margin-left="1" margin-top="1" margin-right="1" margin-bottom="1" />
 4   <header height="90">
 5     <textitem key="ShopName" left="5" top="6" width="960" height="20" align="center" font-name="宋体" font-size="16" font-bold="1" text="" />
 6     <textitem key="Title" left="5" top="30" width="960" height="20" align="center" font-name="宋体" font-size="16" font-bold="1" text="消费明细报表" />
 7     <textitem key="Admin" left="0" top="60" width="300" height="24" text="" />
 8     <textitem key="Date" align="right" left="0" top="60" width="960" height="24" text="" />
 9   </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">="第" &amp; Globals!PageNumber &amp; "页 共" &amp; Globals!TotalPages &amp; "页"</textitem>
   </footer>
 </configuration>