发布一个水晶报表的通用类:CrystalHelper,适用环境如下:

.Net Framework 2.0 ,ASP.NET2.0中直接实例化就可以用了,封装了常用的操作,特别是权限验证部分,很方便,可以避免在ASP.NET 中使用CrystalReports时遇到的很多问题!部分代码如下:

usingSystem;
usingSystem.Text;
usingSystem.Data;
usingSystem.Drawing;
usingSystem.Globalization;
usingSystem.Threading;
usingSystem.Windows.Forms;
usingSystem.Web;
usingSystem.Diagnostics.CodeAnalysis;
usingSystem.Collections.Generic;

//Crystalreports required assembliesusingCrystalDecisions.CrystalReports.Engine;
usingCrystalDecisions.Shared;
usingCrystalDecisions.Windows.Forms;

namespaceCrystalLibrary
{
/**////<summary>///Supported export formats for Crystal reports.
///</summary>
publicenumCrystalExportFormat
{
/**////<summary>///Export to Microsoft Word (*.doc)
///</summary>
Word,

/**////<summary>///Export to Microsoft Excel (*.xls)
///</summary>
Excel,

/**////<summary>///Export to Rich Text format (*.rtf)
///</summary>
RichText,

/**////<summary>///Export to Adobe Portable Doc format (*.pdf)
///</summary>
PortableDocFormat
    }
/**////<summary>///<p>The CrystalHelper class handles a number of actions that are usually
///required to use Crystal Reports for Visual Studio .Net. 
///</p>///<p>This class can be used for all reports based on typed datasets and reports that
///have embedded queries.</p>///<p>Please note that you need to register Crystal Reports when you want to use 
///it in Visual Studio. Registration of Crystal Reports for VS.Net is free!</p>///</summary>///<example>///The following example shows how CrystalHelper can be used to print a report
///where the information is supplied by a DataSet:
///<code>///void PrintReport(SqlConnection conn)
///{
///using (DataSet ds = new TestData())
///{
///SqlHelper.FillDataset(conn, 
///CommandType.Text, "SELECT * FROM Customers", 
///ds, new string [] {"Customers"});
//////using (CrystalHelper helper = new CrystalHelper(new CrystalReport1()))
///{
///helper.DataSource = ds;
///helper.Open();
///helper.Print();
///helper.Close();
///}
///}
///}
///</code>//////</example>
publicclassCrystalHelper : IDisposable
{
Local Variables#regionLocal Variables
privatestring_datebaseName;
privatestring_serverName;
privatestring_userId;
privatestring_password;
privatebool_integratedSecurity;

privateReportDocument    _reportDocument;
privateDataSet            _reportData;
privatestring_reportFile;
privatebool_reportIsOpen;
privateSortedList<string,object>_parameters;

#endregion
Private methods#regionPrivate methods
/**////<summary>///Get the Crystal Export format using the CrystalExportFormat export format definitions
///</summary>///<param name="exportFormat"><see cref="CrystalExportFormat"/>export type</param>///<returns>Crystal Reports<see cref="ExportFormatType"/>type</returns>
privatestaticExportFormatType GetExportType(CrystalExportFormat exportFormat)
{
            ExportFormatType result=ExportFormatType.RichText;

switch(exportFormat)
{
caseCrystalExportFormat.Word        : 
                    result=ExportFormatType.WordForWindows;    
break;
caseCrystalExportFormat.Excel        : 
                    result=ExportFormatType.Excel;            
break;
caseCrystalExportFormat.RichText    : 
                    result=ExportFormatType.RichText;
break;
caseCrystalExportFormat.PortableDocFormat    : 
                    result=ExportFormatType.PortableDocFormat;
break;
default:
thrownewCrystalHelperException(string.Format(CultureInfo.CurrentUICulture,"Unsupported export format '{0}'.", exportFormat.ToString()));
            }returnresult;
        }
/**////<summary>///Get the CrystalExportFormat export format definitions using the file name extension
///</summary>///<param name="fileName">Name of the export file</param>///<returns><see cref="CrystalExportFormat"/>export type</returns>
[SuppressMessage("Microsoft.Performance","CA1807:AvoidUnnecessaryStringCreation", MessageId="stack0")]
privatestaticCrystalExportFormat GetExportFormat(stringfileName)
{
            CrystalExportFormat result=CrystalExportFormat.RichText;

stringextension=Helpers.FileExtension(fileName).ToUpper(CultureInfo.CurrentCulture);

switch(extension)
{
case"DOC": 
                    result=CrystalExportFormat.Word;    
break;
case"XLS": 
                    result=CrystalExportFormat.Excel;            
break;
case"RTF": 
                    result=CrystalExportFormat.RichText;
break;
case"PDF": 
                    result=CrystalExportFormat.PortableDocFormat;
break;
default:
thrownewCrystalHelperException(string.Format(CultureInfo.CurrentUICulture,"Unsupported export format for file '{0}'.", fileName));
            }returnresult;
        }
/**////<summary>///Assign a<see cref="ConnectionInfo"/>to a<see cref="CrystalDecisions.CrystalReports.Engine.Table"/>object
///</summary>///<param name="table">Table to which the connection is to be assigned</param>///<param name="connection">Connection to the database.</param>
privatestaticvoidAssignTableConnection(CrystalDecisions.CrystalReports.Engine.Table table, ConnectionInfo connection)
{
//Cache the logon info blockTableLogOnInfo logOnInfo=table.LogOnInfo;

//Set the connectionlogOnInfo.ConnectionInfo=connection;

//Apply the connection to the table!table.ApplyLogOnInfo(logOnInfo);
        }
/**////<summary>///Assign the database connection to the table in all the report sections.
///</summary>
privatevoidAssignConnection()
{
            ConnectionInfo connection=newConnectionInfo();

            connection.DatabaseName=_datebaseName;
            connection.ServerName=_serverName;
if(_integratedSecurity)
{
                connection.IntegratedSecurity=_integratedSecurity;
            }else{
                connection.UserID=_userId;
                connection.Password=_password;
            }
//First we assign the connection to all tables in the main report
//
foreach(CrystalDecisions.CrystalReports.Engine.Table tablein_reportDocument.Database.Tables)
{
                AssignTableConnection(table, connection);
            }
//Now loop through all the sections and its objects to do the same for the subreports
//
foreach(CrystalDecisions.CrystalReports.Engine.Section sectionin_reportDocument.ReportDefinition.Sections)
{
//In each section we need to loop through all the reporting objectsforeach(CrystalDecisions.CrystalReports.Engine.ReportObject reportObjectinsection.ReportObjects)
{
if(reportObject.Kind==ReportObjectKind.SubreportObject)
{
                        SubreportObject subReport=(SubreportObject)reportObject;
                        ReportDocument  subDocument=subReport.OpenSubreport(subReport.SubreportName);

foreach(CrystalDecisions.CrystalReports.Engine.Table tableinsubDocument.Database.Tables)
{
                            AssignTableConnection(table, connection);
                        }                    }                }            }        }
/**////<summary>///Assign the DataSet to the report.
///</summary>
privatevoidAssignDataSet()
{
            DataSet reportData=_reportData.Copy();

//Remove primary key info. CR9 does not appreciate this information!!!foreach(DataTable dataTableinreportData.Tables)
{
foreach(DataColumn dataColumnindataTable.PrimaryKey)
{
                    dataColumn.AutoIncrement=false;
                }                dataTable.PrimaryKey=null;
            }
//Now assign the dataset to all tables in the main report
//
_reportDocument.SetDataSource(reportData);

//Now loop through all the sections and its objects to do the same for the subreports
//
foreach(CrystalDecisions.CrystalReports.Engine.Section sectionin_reportDocument.ReportDefinition.Sections)
{
//In each section we need to loop through all the reporting objectsforeach(CrystalDecisions.CrystalReports.Engine.ReportObject reportObjectinsection.ReportObjects)
{
if(reportObject.Kind==ReportObjectKind.SubreportObject)
{
                        SubreportObject subReport=(SubreportObject)reportObject;
                        ReportDocument  subDocument=subReport.OpenSubreport(subReport.SubreportName);

                        subDocument.SetDataSource(reportData);
                    }                }            }        }
/**////<summary>///Create a ReportDocument object using a report file and store
///the name of the file.
///</summary>///<param name="reportFile">Name of the CrystalReports file (*.rpt).</param>///<returns>A valid ReportDocument object.</returns>
privateReportDocument CreateReportDocument(stringreportFile)
{
            ReportDocument newDocument=newReportDocument();

            _reportFile=reportFile;
            newDocument.Load(reportFile);

returnnewDocument;
        }
/**////<summary>///Sets the parameters that have been added using the SetParameter method
///</summary>
privatevoidSetParameters()
{
foreach(ParameterFieldDefinition parameterin_reportDocument.DataDefinition.ParameterFields)
{
try{
//Now get the current value for the parameterCrystalDecisions.Shared.ParameterValues currentValues=parameter.CurrentValues;
                    currentValues.Clear();

//Create a value object for Crystal reports and assign the specified value.CrystalDecisions.Shared.ParameterDiscreteValue newValue=newCrystalDecisions.Shared.ParameterDiscreteValue();

if(_parameters.ContainsKey(parameter.Name))
{
                        newValue.Value=_parameters[parameter.Name];
                    }
//Now add the new value to the values collection and apply the 
//collection to the report.currentValues.Add(newValue);
                    parameter.ApplyCurrentValues(currentValues);
                }catch{
//Ignore any errors}            }        }
#endregion
Constructors#regionConstructors
/**////<summary>///Initializes a new instance of the<see cref="T:CrystalHelper"/>class.
///</summary>
publicCrystalHelper()
{
            _parameters=newSortedList<string,object>();
        }
/**////<summary>///Initializes a new instance of the<see cref="T:CrystalHelper"/>class.
///</summary>///<param name="report">The<see cref="T:ReportDocument"/>object for an embedded report.</param>
publicCrystalHelper(ReportDocument report) :this()
{
            _reportDocument=report;
        }
/**////<summary>///Initializes a new instance of the<see cref="T:CrystalHelper"/>class.
///</summary>///<param name="reportFile">Name and path for a CrystalReports (*.rpt) file.</param>
publicCrystalHelper(stringreportFile)
            :this()
{
            _reportDocument=CreateReportDocument(reportFile);
        }
/**////<summary>///Initializes a new instance of the<see cref="T:CrystalHelper"/>class.
///</summary>///<param name="report">The<see cref="T:ReportDocument"/>object for an embedded report.</param>///<param name="serverName">Name of the database server.</param>///<param name="databaseName">Name of the database.</param>///<param name="userId">The user id required for logon.</param>///<param name="userPassword">The password for the specified user.</param>
publicCrystalHelper(ReportDocument report,stringserverName,stringdatabaseName,stringuserId,stringuserPassword)
            :this()
{
            _reportDocument=report;

//Setup the connection information_serverName=serverName;        
            _datebaseName=databaseName;
            _userId=userId;
            _password=userPassword;
        }
/**////<summary>///Initializes a new instance of the<see cref="T:CrystalHelper"/>class.
///</summary>///<param name="report">The<see cref="T:ReportDocument"/>object for an embedded report.</param>///<param name="serverName">Name of the database server.</param>///<param name="databaseName">Name of the database.</param>///<param name="integratedSecurity">if set to<c>true</c>integrated security is used to connect to the database; false if otherwise.</param>
publicCrystalHelper(ReportDocument report,stringserverName,stringdatabaseName,boolintegratedSecurity)
            :this()
{
            _reportDocument=report;

//Setup the connection information_serverName=serverName;
            _datebaseName=databaseName;
            _integratedSecurity=integratedSecurity;
        }
/**////<summary>///Initializes a new instance of the<see cref="T:CrystalHelper"/>class.
///</summary>///<param name="reportFile">Name and path for a CrystalReports (*.rpt) file.</param>///<param name="serverName">Name of the database server.</param>///<param name="databaseName">Name of the database.</param>///<param name="userId">The user id required for logon.</param>///<param name="userPassword">The password for the specified user.</param>
publicCrystalHelper(stringreportFile,stringserverName,stringdatabaseName,stringuserId,stringuserPassword)
            :this()
{
            _reportDocument=CreateReportDocument(reportFile);

//Setup the connection information_serverName=serverName;        
            _datebaseName=databaseName;
            _userId=userId;
            _password=userPassword;
        }
/**////<summary>///Initializes a new instance of the<see cref="T:CrystalHelper"/>class.
///</summary>///<param name="reportFile">Name and path for a CrystalReports (*.rpt) file.</param>///<param name="serverName">Name of the database server.</param>///<param name="databaseName">Name of the database.</param>///<param name="integratedSecurity">if set to<c>true</c>integrated security is used to connect to the database; false if otherwise.</param>
publicCrystalHelper(stringreportFile,stringserverName,stringdatabaseName,boolintegratedSecurity)
            :this()
{
            _reportDocument=CreateReportDocument(reportFile);

//Setup the connection information_serverName=serverName;
            _datebaseName=databaseName;
            _integratedSecurity=integratedSecurity;
        }        
#endregion
Public properties#regionPublic properties
/**////<summary>///Gets or sets the report source.
///</summary>///<value>The report source.</value>///<remarks>///Use this property when you want to show the report in the 
///CrystalReportsViewer control.</remarks>
publicReportDocument ReportSource
{
get{ 
return_reportDocument; 
            }set{
if(_reportDocument!=null)
{
                    _reportDocument.Dispose();
                }                _reportDocument=value;
if(value==null)
{
                    _reportFile=null;
                }            }        }
/**////<summary>///Gets or sets the report file.
///</summary>///<value>The report file.</value>
publicstringReportFile
{
get{ 
return_reportFile; 
            }set{
if(_reportDocument!=null)
{
                    _reportDocument.Dispose();
                }if(value!=null&&value.Trim().Length>0)
{
                    _reportDocument=CreateReportDocument(value);
                }else{
                    _reportFile=value;
                    _reportDocument=null;
                }            }        }
/**////<summary>///Gets or sets the data source.
///</summary>///<value>The data source.</value>
publicDataSet DataSource
{
get{ 
return_reportData; 
            }set{ 
if(_reportData!=null)
{
                    _reportData.Dispose();
                }                _reportData=value; 
            }        }
/**////<summary>///Gets or sets the name of the server.
///</summary>///<value>The name of the server.</value>
publicstringServerName
{
get{ 
return_serverName; 
            }set{ 
                _serverName=value; 
            }        }
/**////<summary>///Gets or sets the name of the database.
///</summary>///<value>The name of the database.</value>
publicstringDatabaseName
{
get{
return_datebaseName; 
            }set{ 
                _datebaseName=value; 
            }        }
/**////<summary>///Gets or sets the user id.
///</summary>///<value>The user id.</value>
publicstringUserId
{
get{ 
return_userId; 
            }set{ 
                _userId=value; 
            }        }
/**////<summary>///Gets or sets the password.
///</summary>///<value>The password.</value>
publicstringPassword
{
get{ 
return_password; 
            }set{ 
                _password=value; 
            }        }
/**////<summary>///Gets or sets a value indicating whether [integrated security].
///</summary>///<value><c>true</c>if integrated security is used to connect to the database; false if otherwise.</value>
publicboolIntegratedSecurity
{
get{
return_integratedSecurity;
            }set{
                _integratedSecurity=value;
            }        }
#endregion
Public static properties#regionPublic static properties
/**////<summary>///Gets the export filter for a<see cref="T:SaveFileDialog"/>///</summary>///<value>The export filter.</value>
publicstaticstringExportFilter
{
get{
                StringBuilder filter=newStringBuilder();

//TODO: Translations???filter.Append("Rich text (*.rtf)|*.rtf|");
                filter.Append("Excel (*.xls)|*.xls|");
                filter.Append("Word (*.doc)|*.doc|");
                filter.Append("Portable Document Format (*.pdf)|*.pdf");

returnfilter.ToString();
            }        }
#endregion
Public methods#regionPublic methods
/**////<summary>///Set value for report parameters
///</summary>///<param name="name">Parameter name.</param>///<param name="value">Value to be set for the specified parameter.</param>
publicvoidSetParameter(stringname,objectvalue)
{
if(_parameters.ContainsKey(name))
{
                _parameters[name]=value;
            }else{
                _parameters.Add(name, value);
            }        }
/**////<summary>///Close the report.
///</summary>///<remarks>///This method will throw an exception when the Open() method is not yet called on this object.
///</remarks>
publicvoidClose()
{
if(!_reportIsOpen)thrownewInvalidOperationException("The report is already closed.");

            _reportDocument.Close();
            _reportIsOpen=false;
        }
/**////<summary>///Open the report.
///</summary>///<remarks>///<p>This method will first attempt to assign the DataSource if that was specified. When no DataSource has been
///assigned, a check will be made to see if database connection information has been specified. When this is the case
///this information will be assigned to the report.
///</p>///<P>This method will throw an exception when:
///<list type="bullet">///<item><description>The report (rpt) has not been assigned yet.</description></item>///<item><description>The Open() method has already been called on this object.</description></item>///<item><description>A table being used in the report does not exist in the dataset which has been assigned to this report. (only when a dataset has been assigned to the DataSource property)</description></item>///<item><description>The ServerName, DatabaseName or UserId property has not been set. (only when the DataSource property has not been set)</description></item>///<item><description>When no database connection or datset could be assignd.</description></item>///</list>///</P></remarks>
publicvoidOpen()
{
if(_reportDocument==null)thrownewCrystalHelperException("First assign a report document.");
if(_reportIsOpen)thrownewInvalidOperationException("The report is already open.");

            SetParameters();
            
//Check if the connection object exists. If so assign that
//to the report.if(_reportData!=null)
{
//Assign the dataset to the report.AssignDataSet();
            }else{
if(_serverName.Length==0||(!_integratedSecurity&&_userId.Length==0)||_datebaseName.Length==0)
{
thrownewCrystalHelperException("Connection information is incomplete. Report could not be opened.");
                }                AssignConnection();
            }            _reportIsOpen=true;
        }
/**////<summary>///Force a refresh of the data in the report. 
///</summary>///<remarks>///When the report is based on a DataSource, the report will be refreshed using 
///data in that DataSource. In case the report has it's own database connection 
///and uses SQL queries, the report will be refreshed using that information. 
///<br/>///<p>///This method will throw an exception when the Open() method is not yet called on this object.
///</p>///</remarks>
publicvoidRefresh()
{
if(!_reportIsOpen)thrownewInvalidOperationException("The report is not open.");

            _reportDocument.Refresh();
        }
/**////<summary>///Print the report to the specified printer. 
///</summary>///<param name="printerName">Name of the printer to print the information to.</param>///<param name="nrCopies">The number of copies required.</param>///<param name="collatePages">Indicates whether to collate the pages.</param>///<param name="firstPage">First page to be printed. When less than 1, printing starts at the first page.</param>///<param name="lastPage">Last page to be printed. When less than 1, or more than 9999, the last page will be printed as last page.</param>///<remarks>///This method will throw an exception when the Open() method is not yet called on this object.
///</remarks>
publicvoidPrint(stringprinterName,intnrCopies,boolcollatePages,intfirstPage,intlastPage)
{
boolopenedHere=false;

if(!_reportIsOpen)
{
this.Open();
                openedHere=true;
            }
            _reportDocument.PrintOptions.PrinterName=printerName;

if(firstPage<1) firstPage=0;
if((lastPage<1)||(lastPage>9999)) lastPage=0;

            _reportDocument.PrintToPrinter(nrCopies, collatePages, firstPage, lastPage);
if(openedHere)
{
this.Close();
            }        }
/**////<summary>///Prints one copy of the entire report to the default printer.
///</summary>///<remarks>///This method will throw an exception when the Open() method is not yet called on this object.
///</remarks>
publicvoidPrint()
{
this.Print(string.Empty,1,false,0,0);
        }
/**////<summary>///Export the report to a file. 
///</summary>///<param name="fileName">Name of the export file.</param>///<remarks>///The type of document is specified by the extension for the file 
///name When no extension is specified, the export format will default to Rich text.
///The following document types are supported:
///<list type="bullet">///<item><description>Word (*.doc).</description></item>///<item><description>Excel (*.xls).</description></item>///<item><description>Rich text (*.rtf).</description></item>///<item><description>Portable Doc Format (*.pdf)</description></item>///</list><br/>///<p>///This method will throw an exception when the Open() method is not yet called on this object.
///</p>///</remarks>
publicvoidExport(stringfileName)
{
this.Export(fileName, GetExportFormat(fileName));
        }
/**////<summary>///Export the report to a file using the specified format. 
///</summary>///<param name="fileName">Name of the export file.</param>///<param name="exportFormat">CrystalExportFormat.</param>///<remarks>///The following document types are supported:
///<list type="bullet">///<item><description>Word (*.doc).</description></item>///<item><description>Excel (*.xls).</description></item>///<item><description>Rich text (*.rtf).</description></item>///<item><description>Portable Doc Format (*.pdf)</description></item>///</list><br/>///<p>///This method will throw an exception when the Open() method is not yet called on this object.
///</p>///</remarks>
publicvoidExport(stringfileName, CrystalExportFormat exportFormat)
{
boolopenedHere=false;

if(!_reportIsOpen) 
{
this.Open();
                openedHere=true;
            }
            _reportDocument.ExportToDisk(GetExportType(exportFormat), fileName);

if(openedHere)
{
this.Close();
            }        }
/**////<summary>///Exports the report to the specified HttpResponse.
///</summary>///<param name="response">The response object to export the report to.</param>///<param name="exportFormat">The export format.</param>
publicvoidExport(HttpResponse response, CrystalExportFormat exportFormat)
{
this.Export(response, exportFormat,false,"");
        }
/**////<summary>///Exports the report to the specified HttpResponse and prompts the user for a file name. The default 
///name is the specified file name, 
///</summary>///<param name="response">The response object to export the report to.</param>///<param name="exportFormat">The export format.</param>///<param name="asAttachment">If the asAttachment Boolean variable is set to True, a File Download dialog box appears. If the asAttachment Boolean variable is set to False, the exported report opens in the browser window.</param>///<param name="attachmentName">When you choose to save the file, the file name is set to the attachmentName string variable. If you do not specify the attachmentName variable, then the default file name is "Untitled," with the specified file extension. The file name can be changed in the Save As dialog box.</param>
publicvoidExport(HttpResponse response, CrystalExportFormat exportFormat,boolasAttachment,stringattachmentName)
{
if(response==null)thrownewArgumentNullException("response");
if(attachmentName==null)thrownewArgumentNullException("asAttachment");

boolopenedHere=false;

try{
if(!_reportIsOpen)
{
this.Open();
                    openedHere=true;
                }
                _reportDocument.ExportToHttpResponse(GetExportType(exportFormat), response, asAttachment, attachmentName);
            }finally{
if(openedHere)
{
this.Close();
                }            }        }
#endregion
Public static methods#regionPublic static methods
/**////<summary>///Show or hide the status bar on the crystalreports viewer.
///</summary>///<param name="viewer">Current viewer.</param>///<param name="visible">Set if the status bar is visible or not.</param>///<remarks>///This method will throw an exception when the viewer object is not specified.
///</remarks>///<example>///This example shows how the status bar can be removed:
///<code>///CrystalHelper.ViewerStatusBar(myViewer, false);
///</code>///</example>
[SuppressMessage("Microsoft.Design","CA1011:ConsiderPassingBaseTypesAsParameters")]
publicstaticvoidViewerStatusBar(CrystalReportViewer viewer,boolvisible)
{
if(viewer==null)thrownewArgumentNullException("viewer");

foreach(Control controlinviewer.Controls)
{
if(string.Compare(control.GetType().Name,"StatusBar",true, CultureInfo.InvariantCulture)==0)
{
                    control.Visible=visible;
                }            }        }
/**////<summary>///Show or hide the tabs on the crystalreports viewer.
///</summary>///<param name="viewer">Current viewer</param>///<param name="visible">Set if the status bar is visible or not.</param>///<remarks>///This method will throw an exception when the viewer object is not specified.
///</remarks>///<example>///This example shows how the tabs can be removed:
///<code>///CrystalHelper.ViewerTabs(myViewer, false);
///</code>///</example>
[SuppressMessage("Microsoft.Design","CA1011:ConsiderPassingBaseTypesAsParameters")]
publicstaticvoidViewerTabs(CrystalReportViewer viewer,boolvisible)
{
if(viewer==null)thrownewArgumentNullException("viewer");

foreach(Control controlinviewer.Controls)
{
if(string.Compare(control.GetType().Name,"PageView",true, CultureInfo.InvariantCulture)==0)
{
                    TabControl tab=(TabControl)((PageView)control).Controls[0];

if(!visible)
{
                        tab.ItemSize=newSize(0,1);
                        tab.SizeMode=TabSizeMode.Fixed;
                        tab.Appearance=TabAppearance.Buttons;
                    }else{
                        tab.ItemSize=newSize(67,18);
                        tab.SizeMode=TabSizeMode.Normal;
                        tab.Appearance=TabAppearance.Normal;
                    }                }            }        }
/**////<summary>///Replace the current name of a tab with a new name.
///</summary>///<param name="viewer">Current viewer.</param>///<param name="oldName">The name to be replaced.</param>///<param name="newName">The new name.</param>///<remarks>///This method will throw an exception when:
///<list type="bullet">///<item><description>The viewer object is not specified.</description></item>///<item><description>The Open() method is not yet called on this object.</description></item>///</list>///</remarks>///<example>///This example shows how the default tab description MainReport can be replaced.
///<code>///CrystalHelper.ViewerStatusBar(myViewer, "MainReport", "And now for something completely different");
///</code>///</example>
[SuppressMessage("Microsoft.Design","CA1011:ConsiderPassingBaseTypesAsParameters")]
publicstaticvoidReplaceReportName(CrystalReportViewer viewer,stringoldName,stringnewName)
{
if(viewer==null)thrownewArgumentNullException("viewer");
if(oldName==null||oldName.Length==0)thrownewArgumentException("May not be empty.","oldName");

foreach(Control controlinviewer.Controls)
{
if(string.Compare(control.GetType().Name,"PageView",true, CultureInfo.InvariantCulture)==0)
{
foreach(Control controlInPageincontrol.Controls)
{
if(string.Compare(controlInPage.GetType().Name,"TabControl",true, CultureInfo.InvariantCulture)==0)
{
                            TabControl tabs=(TabControl)controlInPage;

foreach(TabPage tabPageintabs.TabPages)
{
if(string.Compare(tabPage.Text, oldName,false, CultureInfo.InvariantCulture)==0)
{
                                    tabPage.Text=newName;
return;
                                }                            }                        }                    }                }            }        }
#endregion
IDisposable Members#regionIDisposable Members
/**////<summary>///Dispose of this object's resources.
///</summary>
publicvoidDispose()
{
            Dispose(true);
            GC.SuppressFinalize(true);//as a service to those who might inherit from us}
/**////<summary>///Free the instance variables of this object.
///</summary>///<param name="disposing">if set to<c>true</c>[disposing].</param>
protectedvirtualvoidDispose(booldisposing)
{
if(disposing)
{
if(_reportIsOpen)
{
                    _reportDocument.Close();
                }if(_reportDocument!=null)
{
                    _reportDocument.Dispose();
                    _reportDocument=null;
                }
if(_reportData!=null)
{
                    _reportData.Dispose();
                    _reportData=null;
                }            }        }
#endregion    }}