Implementing and embedding Crystal Reports in the .Net environment is extremely easy to do. Once the tools are downloaded from the businessobject website creating and editing reports from Visual Studio is a breeze. We are going to be covering the caching functionality that the Crystal Report framework provides through the ICachedReport interface.

What you will learn

  • What is the ICachedReport interface.
  • System generated classes and when to modify them.
  • Adding extensions to support ConnectionInfo binding.
  • Putting it all together.

ICachedReport Interface

The ICachedReport interface will work like a flag to signal the Crystal Report framework that the report should be cache. It works by creating a layer ontop of the Asp.net Cache object to accommodate the needs of the report. The interface is found in the CrystalDecisions.ReportSource namespace.

System Generated Classes (Benefits of embedding)

Using Visual Studio to add a report as a new item will generate a report wrapper class with the name of the report. The second class will be the management class named Cached[ReportName]. Visual Studio will generate both classes in the same file (ReportName.cs). Below you will see an example of a generated class for a report called SalesDirectory. For the most part this class will expose everything needed to work with the report without any changes. In some cases when using the Cached class properties will need to be added to support parameters.

namespace Optimized.Reports {

using System;
 using System.ComponentModel;
 using CrystalDecisions.Shared;

using CrystalDecisions.ReportSource;
 using CrystalDecisions.CrystalReports.Engine;

public class SalesDirectory : ReportClass {…}

[System.Drawing.ToolboxBitmapAttribute(typeof(CrystalDecisions.Shared.ExportOptions),

"report.bmp")]

public class CachedSalesDirectory : Component, IcachedReport {…}

}

Extension Methods for Report

What you will often find is that if the report is not properly authenticated, it will prompt the user everytime the report is loaded. What we will do here is leverage the ConnectionInfo object and create an extension method for the Tables inside the report.

using CrystalDecisions.CrystalReports.Engine;

using CrystalDecisions.Shared;

namespace Core.Util

{

public static class Extensions

{

/// <summary>

/// Set Crystal Report ConnectionInfo.

/// </summary>

/// <param name="tables">CrystalDecisions.CrystalReports.Engine.Tables</param>

public static void SetLocation(this Tables tables)

{

ConnectionInfo connectionInfo = new ConnectionInfo();

connectionInfo.ServerName =

ConfigurationManager.AppSettings["CrystalServerName"].ToString();

connectionInfo.DatabaseName =

ConfigurationManager.AppSettings["CrystalDatabaseName"].ToString();

connectionInfo.UserID =

ConfigurationManager.AppSettings["CrystalUserID"].ToString();

connectionInfo.Password =

ConfigurationManager.AppSettings["CrystalPassword"].ToString();

connectionInfo.IntegratedSecurity =

Convert.ToBoolean(

ConfigurationManager.AppSettings["CrystalIntegratedSecurity"]);

foreach (CrystalDecisions.CrystalReports.Engine.Table table in tables)

{

TableLogOnInfo tableLogOnInfo = table.LogOnInfo;

tableLogOnInfo.ConnectionInfo = connectionInfo;

table.ApplyLogOnInfo(tableLogOnInfo);

}

}

}

}

In the example the values are kept in the WebConfig, but it is not a requirement. If the namespace for the Extension class and the pages that have the controls are not the same-it must be added in order for the method to show.

Putting It Together

Now that we have our SalesDirectory report with the wrapper and utility class, we are going to create a page to hold a report viewer. Below is the code listing for adding the directive to the page and immediately after the declaration for the control.

<%@ Register assembly="CrystalDecisions.Web, Version=13.0.2000.0, Culture=neutral, PublicKeyToken=692fbea5521e1304" namespace="CrystalDecisions.Web" tagprefix="CR" %>

<CR:CrystalReportViewer ID="CrystalReportViewer"

runat="server"

AutoDataBind="true" Visible="true" />



With the report viewer in place the last thing we need to do is create and bind the report to the viewer. We need to cover the difference in how you would setup both approaches so that we can compare performance and also because leveraging the caching management class requires an extra step.

// Without Caching - To be able to compare performance differences.

private void DisplayDirectoryReport()

{

SalesDirectory directoryReport = new SalesDirectory();

directoryReport.Database.Tables.SetLocation(); // Set Connection

// Set the location for any subreport

foreach (CrystalDecisions.CrystalReports.Engine.ReportDocument rDocument in

directoryReport.Subreports)

rDocument.Database.Tables.SetLocation();

CrystalReportViewer.ReportSource = directoryReport;

CrystalReportViewer.DataBind();

}


// Implementing the caching management class.

private void DisplayDirectoryReport()

{

Reports.CachedSalesDirectory cachedSalesDirectory = new

Reports.CachedSalesDirectory();

// Extra step (part of the interface and for the most part will have all the code

// needed.

cachedSalesDirectory.CreateReport();

CrystalReportViewer.ReportSource = cachedSalesDirectory;

CrystalReportViewer.DataBind();

}

// Inside CachedSalesDirectory code in red is the code that needs to be added.

public virtual CrystalDecisions.CrystalReports.Engine.ReportDocument CreateReport() {

SalesDirectory rpt = new SalesDirectory();

rpt.Site = this.Site;

rpt.Database.Tables.SetLocation();

foreach (CrystalDecisions.CrystalReports.Engine.ReportDocument rDocument in

rpt.Subreports)

rDocument.Database.Tables.SetLocation();

return rpt;

}

The code listing above covers most cases, but what if the report contains parameters. The last listing is going to show how parameters could be streamlined into the Cached[ReportName] class generated for you. Following the example of the SalesDirectory report, we are going to add two properties to the CachedSalesDirectory class.

[System.Drawing.ToolboxBitmapAttribute(typeof(CrystalDecisions.Shared.ExportOptions), "report.bmp")]

public class CachedSalesDirectory : Component, ICachedReport {

public string Counties { get; set; }

public int StateID { get; set; }

…}

Next step is to set the new properties before calling create.

// Implementing the caching management class.

private void DisplayDirectoryReport(string counties, int StateID)

{

Reports.CachedSalesDirectory cachedSalesDirectory = new

Reports.CachedSalesDirectory();

cachedSalesDirectory.Counties = counties;

cachedSalesDirectory.StateID = StateID;

cachedSalesDirectory.CreateReport();

CrystalReportViewer.ReportSource = cachedSalesDirectory;

CrystalReportViewer.DataBind();

}

Finally we will change the CreateReport function to account for the parameters.

// Inside CachedSalesDirectory code in red is the code that needs to be added.

public virtual CrystalDecisions.CrystalReports.Engine.ReportDocument CreateReport() {

SalesDirectory rpt = new SalesDirectory();

rpt.Site = this.Site;

rpt.SetParameterValue("@Counties", Counties);

rpt.SetParameterValue("@StateID", StateID);

foreach (CrystalDecisions.CrystalReports.Engine.ReportDocument rDocument in

rpt.Subreports)

rDocument.Database.Tables.SetLocation();

return rpt;

}

In conclusion, we have covered a feature of the Crystal Report and .Net framework that allows for faster loading, paging, and grouping of Crystal Report.

Implementing both solutions will prove the efficiency of leveraging the caching functionality.

Ref: http://msdn.microsoft.com/en-us/library/ms225452(v=vs.80).aspx