faib的技术专栏

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

一、改进后的ReportViewer

Code
 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 {
10     public class ReportViewer : Microsoft.Reporting.WinForms.ReportViewer
11     {
12         private string _rcfile;
13         private ReportConfig _rpc;
14         private object _datasource;
15         private MemoryStream m_rdl;
16 
17         public ReportViewer() :base()
18         {
19 
20         }
21 
22         /// <summary>
23         /// 配置文件
24         /// </summary>
25         [DefaultValue("")]
26         public string Filename
27         {
28             get { return _rcfile; }
29             set
30             {
31                 _rcfile = value;
32                 _rpc = new ReportConfig(_rcfile);
33             }
34         }
35 
36         /// <summary>
37         /// 报表配置
38         /// </summary>
39         public ReportConfig ReportConfig
40         {
41             get { return _rpc; }
42         }
43 
44         /// <summary>
45         /// 数据源
46         /// </summary>
47         public object DataSource
48         {
49             get { return _datasource; }
50             set { _datasource = value; }
51         }
52 
53         /// <summary>
54         /// 显示报表
55         /// </summary>
56         public void ShowReport()
57         {
58             if (m_rdl != null)
59                 m_rdl.Dispose();
60             m_rdl = GenerateRdl();
61 
62             Reset();
63             LocalReport.LoadReportDefinition(m_rdl);
64             LocalReport.DataSources.Add(new ReportDataSource("FaibLists", _datasource));
65             RefreshReport();
66         }
67 
68         /// <summary>
69         /// 生成Rdl流
70         /// </summary>
71         /// <returns></returns>
72         private MemoryStream GenerateRdl()
73         {
74             MemoryStream ms = new MemoryStream();
75             RdlGenerator gen = new RdlGenerator();
76             gen.ReportConfig = _rpc;
77             gen.WriteXml(ms);
78             ms.Position = 0;
79             return ms;
80         }
81 
82     }
83 }
84 

 

二、Rdl生成类

Code
  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 
100         private Rdl.ConnectionPropertiesType CreateConnectionProperties()
101         {
102             Rdl.ConnectionPropertiesType connectionProperties = new Rdl.ConnectionPropertiesType();
103             connectionProperties.Items = new object[]
104                 {
105                     "",
106                     "SQL",
107                 };
108             connectionProperties.ItemsElementName = new Rdl.ItemsChoiceType[]
109                 {
110                     Rdl.ItemsChoiceType.ConnectString,
111                     Rdl.ItemsChoiceType.DataProvider,
112                 };
113             return connectionProperties;
114         }
115         #endregion
116 
117         #region 主体
118         /// <summary>
119         /// 报表主体
120         /// </summary>
121         /// <returns></returns>
122         private Rdl.BodyType CreateBody()
123         {
124             Rdl.BodyType body = new Rdl.BodyType();
125             body.Items = new object[]
126                 {
127                     CreateReportItems(),
128                     "1in",
129                 };
130             body.ItemsElementName = new Rdl.ItemsChoiceType30[]
131                 {
132                     Rdl.ItemsChoiceType30.ReportItems,
133                     Rdl.ItemsChoiceType30.Height,
134                 };
135             return body;
136         }
137 
138         private Rdl.ReportItemsType CreateReportItems()
139         {
140             Rdl.ReportItemsType reportItems = new Rdl.ReportItemsType();
141             TableRdlGenerator tableGen = new TableRdlGenerator();
142             tableGen.Fields = _rpc.DataItem;
143             reportItems.Items = new object[] { tableGen.CreateTable() };
144             return reportItems;
145         }
146         #endregion
147 
148         #region 页头页尾
149         private Rdl.PageHeaderFooterType CreateHeader()
150         {
151             Rdl.PageHeaderFooterType header = new FBS.GDTVMember.Report.Rdl.PageHeaderFooterType();
152             HeaderFooterRdlGenerator headerGen = new HeaderFooterRdlGenerator();
153             headerGen.Fields = _rpc.Header;
154 
155             header.Items = new object[]
156                 {
157                     (_rpc.HeadHeight / 96.0) + "in",
158                     true,
159                     true,
160                     headerGen.CreateItems(),
161                 };
162             header.ItemsElementName = new Rdl.ItemsChoiceType34[]
163                 {
164                     Rdl.ItemsChoiceType34.Height,
165                     Rdl.ItemsChoiceType34.PrintOnFirstPage,
166                     Rdl.ItemsChoiceType34.PrintOnLastPage,
167                     Rdl.ItemsChoiceType34.ReportItems
168                 };
169             return header;
170         }
171 
172         private Rdl.PageHeaderFooterType CreateFooter()
173         {
174             Rdl.PageHeaderFooterType footer = new FBS.GDTVMember.Report.Rdl.PageHeaderFooterType();
175             HeaderFooterRdlGenerator footerGen = new HeaderFooterRdlGenerator();
176             footerGen.Fields = _rpc.Footer;
177 
178             footer.Items = new object[]
179                 {
180                     (_rpc.FootHeight / 96.0) + "in",
181                     true,
182                     true,
183                     footerGen.CreateItems(),
184                 };
185             footer.ItemsElementName = new Rdl.ItemsChoiceType34[]
186                 {
187                     Rdl.ItemsChoiceType34.Height,
188                     Rdl.ItemsChoiceType34.PrintOnFirstPage,
189                     Rdl.ItemsChoiceType34.PrintOnLastPage,
190                     Rdl.ItemsChoiceType34.ReportItems
191                 };
192             return footer;
193         }
194         #endregion
195 
196         #region 数据集
197         private Rdl.DataSetsType CreateDataSets()
198         {
199             Rdl.DataSetsType dataSets = new Rdl.DataSetsType();
200             dataSets.DataSet = new Rdl.DataSetType[] { CreateDataSet() };
201             return dataSets;
202         }
203 
204         private Rdl.DataSetType CreateDataSet()
205         {
206             Rdl.DataSetType dataSet = new Rdl.DataSetType();
207             dataSet.Name = "FaibLists";
208             dataSet.Items = new object[] { CreateQuery(), CreateFields() };
209             return dataSet;
210         }
211 
212         private Rdl.QueryType CreateQuery()
213         {
214             Rdl.QueryType query = new Rdl.QueryType();
215             query.Items = new object[] 
216                 {
217                     "FaibLists",
218                     "",
219                 };
220             query.ItemsElementName = new Rdl.ItemsChoiceType2[]
221                 {
222                     Rdl.ItemsChoiceType2.DataSourceName,
223                     Rdl.ItemsChoiceType2.CommandText,
224                 };
225             return query;
226         }
227 
228         private Rdl.FieldsType CreateFields()
229         {
230             Rdl.FieldsType fields = new Rdl.FieldsType();
231             Dictionary<string, TextItem> m_fields = _rpc.DataItem;
232             fields.Field = new Rdl.FieldType[m_fields.Count];
233             int i = 0;
234             foreach (string key in m_fields.Keys)
235             {
236                 fields.Field[i++] = CreateField(m_fields[key]);
237             }
238 
239             return fields;
240         }
241 
242         private Rdl.FieldType CreateField(TextItem item)
243         {
244             Rdl.FieldType field = new Rdl.FieldType();
245             field.Name = item.DataMember;
246             field.Items = new object[] { item.DataMember };
247             field.ItemsElementName = new Rdl.ItemsChoiceType1[] { Rdl.ItemsChoiceType1.DataField };
248             return field;
249         }
250         #endregion
251 
252         public void WriteXml(Stream stream)
253         {
254             XmlSerializer serializer = new XmlSerializer(typeof(Rdl.Report));
255             serializer.Serialize(stream, CreateReport());
256         }
257     }
258 }
259 

三、报表主体生成类TableRdlGenerator

Code
  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                 {
100                     item.Text,
101                     CreateHeaderTableCellTextboxStyle(item),
102                     true,
103                 };
104             headerTableCellTextbox.ItemsElementName = new Rdl.ItemsChoiceType14[] 
105                 {
106                     Rdl.ItemsChoiceType14.Value,
107                     Rdl.ItemsChoiceType14.Style,
108                     Rdl.ItemsChoiceType14.CanGrow,
109                 };
110             return headerTableCellTextbox;
111         }
112 
113         private Rdl.StyleType CreateHeaderTableCellTextboxStyle(TextItem item)
114         {
115             Rdl.StyleType headerTableCellTextboxStyle = new Rdl.StyleType();
116             headerTableCellTextboxStyle.Items = new object[]
117                 {
118                     item.HeaderFont.Name,
119                     item.HeaderFont.Size + "pt",
120                     item.HeaderFont.Bold ? "700" : "100",
121                     "Center",
122                     "Middle",
123                     CreateBorderStyle(),
124                 };
125             headerTableCellTextboxStyle.ItemsElementName = new Rdl.ItemsChoiceType5[]
126                 {
127                     Rdl.ItemsChoiceType5.FontFamily,
128                     Rdl.ItemsChoiceType5.FontSize,
129                     Rdl.ItemsChoiceType5.FontWeight,
130                     Rdl.ItemsChoiceType5.TextAlign,
131                     Rdl.ItemsChoiceType5.VerticalAlign,
132                     Rdl.ItemsChoiceType5.BorderStyle,
133                };
134             return headerTableCellTextboxStyle;
135         }
136 
137         private Rdl.DetailsType CreateDetails()
138         {
139             Rdl.DetailsType details = new Rdl.DetailsType();
140             details.Items = new