Although every comparison depends on the point of customer’s perspective, usually at least the choice of solutions to be compared is simple. Not this time. While confronting Microsoft with SAP, even this choice isn’t so obvious. According to that, Microsoft Reporting Services should be compared twice, from a two-dimensional perspective.

As shown in the diagram below, Microsoft Reporting Services might function in a twofold way. Firstly, as a standalone reporting server, therefore working as an independent solution, and, secondly, as a tool to integrate reporting into a parallel .Net application.
The thing of this comparison is to answer, whether one, common solution – Microsoft Reporting Services – is enough to replace two separate concretely-aimed solutions. Both – offered by SAP – Crystal Reports 2008 and Crystal Reports Server XI have been designed for different types of customers.

Reporting Services and Crystal Reports

Microsoft SQL Server Reporting Services, unlikely Crystal Reports, is quite a new tool, released in 2004. Announced to be distributed for free (bundled with the MS SQL Server), Reporting Services has had to grab the attention of Visual Studio .NET users.
Very loudly introduced to the market, SQL Server Reporting Services has immediately become the most significant Crystal Reports’ rival. Suddenly people started comparing two extremely different (in an experience perspective) tools – “new-born” SSRS, and more than ten-years-old Crystal Reports (11 version). Years of incessant improvements were stood across brand-new product. No one could have been sure of results of the clash. What were the both sides’ arguments?

To begin with – that time – already existing solution, Crystal Reports. The first thing repeated as often as possible, were the years of experience that haven’t gone to waste. With every new product release, producer provided numerous fixes, increasing also the system’s performance. While introducing 11 version to a market, SAP emphasized that current release is completely different from “not-the-best” Crystal 8.5 version.

On the other hand, Microsoft praised SQL Server Reporting Services for its freshness, and – disposing SAP’s experience boasts – demonstrated SSRS readiness to immediate use. While preparing this product, Microsoft had a chance do rate every offered then solution, and, therefore, had a chance to base on best parts of each, still having enough time to ensure not multiplying the weaknesses. Thereupon, even the newest product might have competed with those already released.

Let’s have a look, how does it work in a practice.

Integrating reporting into a .Net application

The first strength of Reporting Services is Microsoft brand followed by world fame and generally-known trustworthiness. Almost everyone has heard about the Redmond Giant, therefore people might feel a bit more familiar with Microsoft than SAP. Along that, comes a loyalty. Regardless of thousands of accusation presented everyday by Microsoft’s opponents, worldwide recognition result in better start position while thinking about choosing a solution. Back to Reporting Services, it’s a solution known for its features – provided set is richly enough for majority of basic uses.

Problems begin when it comes to a bit more advanced tasks, for example combining web data with local data. Reporting Services cannot ensure such cooperation, rather Crystal Reports 2008 would be better. The same problems come out while trying to do both financial and non-financial reports with only one reporting tool. Unlikely Crystal Reports 2008 and its improved crosstabs, Microsoft Reporting Services isn’t designed well-enough to fulfill these needs.

While talking about Microsoft world-famous name, an interesting aspect should also be mentioned. It’s not as widely-known fact, that Business Objects cooperates with Microsoft, becoming its “Gold Partner”. The partnership lasts for quite a lot of time as Crystal Reports supplies Microsoft platform. What’s worth noticing, Crystal Reports has been also included in Visual Basic and Visual Studio environments. This kind solution has been offered since the version 2 Visual Basic development environment and does not seem to be retired soon, as it continues with Visual Studio 2008.

SSRS and Crystal Reports strengths and weaknesses

SQL Server Reporting Services is praised especially for its independence, but its generality has also a few bad sides.

The first thing that might have been prepared much better is report design environment. The one included in Reporting Services lacks in options. Moreover, editing reports with data is almost impossible – that demands a separate preview cycle, what results in lengthening report design process. Also, the formula of editing might be a bit more advanced. And finally, accessing data demands SQL knowledge. Solutions provided by Crystal Reports 2008 seem more user-friendly. What’s most significant, Crystal Reports allows changing report design even while it’s been already fulfilled with the data. Then, adding conditional logic to reports is simplified, due to a broadened formula workshop included in Crystal Reports 2008. Also, knowing SQL isn’t required – with graphical Database Expert, data access is possible simply as drag and drop.

Microsoft SQL Server Reporting Services doesn’t support Flash and Flex, impossible is forwarding data from report into Flash.

Crystal Reports 2008 cooperates well with Adobe Flash and Flex. Well-prepared integration enables creating powerful visualizations with only standard tools. With simplified Adobe Flex embedding, integrating reports with different web services is easier than ever before. With a help of Xcelsius, designing what-if scenarios is also possible.

Reporting Services isn’t also designed straight for financial reporting. This kind uses generally demand implementing a second tool – Microsoft FRX/Performance Point server. In opposite to Crystal Reports 2008 that is provided with crosstab features which creating financial reports is much easier with. Crystal Reports is completely self-sufficient – a customer doesn’t need to use any other reporting tool for financial reports.

Furthermore, Reporting Services doesn’t enable web deployments without the SQL server database – applications based on SSRS need to operate on SQL Server. The thing looks extremely different in Crystal Reports – it has its own reporting engine, therefore no other support is required. What’s more, deploying runtime engine to server isn’t problematic with only 24MB EXE, .MSI or MSM file – all self-extracting.

Finally, Reporting Services has never been a goal itself. It’s main role is to increase SQL Server sale, and – for that – run both database and report processing on one server. Crystal Reports functions a bit differently with over fifteen-year experience in reporting that led to separating database from report processing. During these years efficient partnerships have been worked out, thereupon currently cooperating with Flash or other formats is rather trouble-free.

Even though Crystal Reports has a lot of strengths, there are some widely known weaknesses that have been improved in newest releases. Former versions of Crystal Reports were accused of too complex licensing, too big footprint, and, finally, being too static.

Fortunately, things have got significantly improved with Crystal 2008. Current licensing enables user to free deploy all kinds of applications across the enterprise, as well as royalty-free access to .Net Report Creation interfaces. Also, Crystal Reports implementing isn’t as problematic as before with only about 24MB runtime engine and 300MB report design tool. Changes have applied not only to prevent the weaknesses, but also increasing strengths with a higher level of interactivity – Crystal Reports 2008 customers are supported with new parameter panels and controls.

Reporting Services as a standalone reporting server

Functioning as a standalone reporting server, Microsoft Reporting Services has almost the same set of strengths, which are also followed by a low price. Microsoft’s product seems to be significantly cheaper than its equivalents. The thing isn’t so obvious, though. Reporting Services might be really implemented for free, but only while not separating report from database processing. Trying to use Reporting Services on an independent server, buying another SQL Server license is required.

Not only strengths are similar. While using Microsoft Reporting Services as a standalone reporting server, some weaknesses repeat as well. The same as earlier, design environment isn’t enough for anything more than extremely basic uses. Also the accusations of Reporting Services dependence are well-founded. Unfortunately, the list of weaknesses isn’t over yet.

Another troubles come out while trying to use a semantic layer for accessing a relational data – it’s impossible. For this place, Crystal Reports Server XI – SAP’s equivalent for standalone reporting server – offers Business Views semantic layer, which power is mixed with highest levels security in.

Microsoft Reporting Services significantly lacks for advanced exporting capabilities. By standard offered are only static exports to Excel spreadsheets and PDF files. How is it solved in Crystal Reports? By the Live Office service that enables live integrating modifiable reports into Microsoft Word documents, PowerPoint presentations, and other Office documents.

Microsoft Reporting Services is designed rather for online work, therefore viewing reports while being offline demands converting files. SAP provides Crystal Reports Viewer XI – it’s a free tool, which viewing reports – even being disconnected – is possible in.

Finally, Crystal Reports offer an online service www.crystalreports.com/share – it’s a nice facilitation allowing customers to host and share online their reports. That reduces a necessary IT involvement. Microsoft doesn’t have anything like that.

Comparison summary

As it’s been mentioned many times before (at the beginning of this article, as well), the choice of every reporting tool, or maybe more generally: of every product, depends on customer’s needs. Specifying them is a first step that must be done before even trying to choose anything. Unfortunately, not all the customers remembered about that and – as soon as they heard about new product – moved leaving all the rest behind. Not everyone was happy with that change.

It’s impossible to unambiguously state which one, SSRS or Crystal Reports, is better. Depends on the requirements. Despite all of the strengths and weaknesses, no product is perfect since its beginning. And – as well – no one can guarantee that the final version of product will be perfect. Customers must be prepared for advantages and disadvantages, therefore they should care especially to choose a product, which producer ensures not to leave a client alone with his problems.

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>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.

The Tweaks:

Windows allows you to create your own paper size for that matter, let it be known, the tweaks is that you can create a custom paper size by means of a “Printer’s Form” and it will automatically create the PaperID that the Crystal report use in its initial printer configuration before printing a document. To Create new form follow the procedure below:

1. Go to Printer and Faxes. (Start->Settings->Printer and Faxes).
2. Select your Printer.
3. On File Menu Select File->Server Properties.
4. Tick the “Create new Form” Check box.
5. On the Form name Field, enter your desired Paper size Name, like for instance “CEPCRP”.
6. On the Form Description (measurements).
7. Enter the desired paper size, example: Width: 8.5 and Height: 6.5
8. Enter the print area margins as well.
9. and then click Save Form to create the form.

After you add the new paper size, this paper size will be available in windows paper size list.

The Code:

If you just configured your crystal report at design time and have successfully print it from the CR Designer, during run time this will not work for the reason that, CR does not save the paper size name but rather the equivalent paperid of that custom paper size we have created earlier, in order that the correct paperid corresponding to that we have created we need to create a routine  to iterate through system.drawing.printing.printdocument namespace to extract the paperid given only the paper size name and the printer name, this to insure that the paper size name is available on that specific printer in which we are about to print or else the default setting will be use that is not compatible with our crystal report settings. Below is the routine I created to iterate through the available paper size list.

Visual Basic.net Fragment Code:

 ''' <summary>
 ''' Gets the PaperSizeID from the Given PapersizeName.
 ''' </summary>
 ''' <returns></returns>
 ''' <remarks></remarks>
 Public Function GetPapersizeID(ByVal PrinterName As String, ByVal PaperSizeName As String) As Integer
     Dim doctoprint As New System.Drawing.Printing.PrintDocument()
     Dim PaperSizeID As Integer = 0
     Dim ppname As String = ""
     Dim s As String = ""
     doctoprint.PrinterSettings.PrinterName = PrinterName  '(ex. "Epson SQ-1170 ESC/P 2")
     For i As Integer = 0 To doctoprint.PrinterSettings.PaperSizes.Count - 1
         Dim rawKind As Integer
         ppname = PaperSizeName
         If doctoprint.PrinterSettings.PaperSizes(i).PaperName = ppname Then
            rawKind = CInt(doctoprint.PrinterSettings.PaperSizes(i).GetType().GetField("kind",             �
Reflection.BindingFlags.Instance Or Reflection.BindingFlags.NonPublic).GetValue(doctoprint.PrinterSettings.PaperSizes(i)))
                PaperSizeID = rawKind
                Exit For
         End If
     Next
         Return PaperSizeID
End Function

And then you can this function before printing the document:

Dim repOptions As CrystalDecisions.CrystalReports.Engine.PrintOptions
With ReportDocument
    repOptions = .PrintOptions  �
.Load(ReportPath, CrystalDecisions.Shared.OpenReportMethod.OpenReportByDefault)
    .SetDataSource(ds.Tables(0))
    With repOptions
          .PaperOrientation = CrystalDecision.Shared.PaperOrientation.Portrait
          .PaperSize = GetPapersizeID("EPSON LX-300+II", "CEPCRP")
          .PrinterName = "EPSON LX-300+II"              �
    End With
          .Refresh()
          .PrintToPrinter(NumberOFCopies, Collated, StartPage, EndPage)
End With

These are just fragment of my codes to print a custom paper size with 8.5×6.5 inches dimension in a portrait orientation.

Please also note that if all the steps are performed correctly the total time to produce a report dependent on the parameters is only 2 MINUTES

I am using the Northwind database. The category names from the “Categories” table are displayed in the DropDownList. Once, the category is selected the corresponding products are displayed as a report on the webform. The first thing that you must do is to add a Crystal Report in the project. Once, the report is added you can select the tables. Since, we are dealing with Categories and Products you need to select both the tables. When you select tables it will show you the join between them which will be on CategoryID. Now, you must add the ParameterField to the report. The ParameterField have to be “CategoryID” since your result is based on the selection of Category. You can simply open the report and select ( View -> Other Windows -> Document OutLine ) this will display the additional features you can add with the report. Then select the PropertyField and type the name of the field as “CategoryID” and make it a “Number” datatype.

After this you need to configure the “Select Expert”. Simply, select “Crytal Reports” from the top menu then select “Report” -> “Select Report”. Here you can adjust the parameter to “is equal to” and then select the “CategoryID” from the parameter list.

At this point you are set from the Crystal Reports side now you need to do some configuration on the ASP.NET side. First you need to fill the DropDownList with the category name and categoryID as DataTextField and DataValueField respectively.

After this you need to implement the button click event which will take the categoryID from the DropDownList and publish the report based on the categoryID.

Here is the complete code for the page:

Code behind:

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Data.SqlClient;
using CrystalDecisions.CrystalReports.Engine;
using CrystalDecisions.Shared;
public partial class _Default : System.Web.UI.Page
{
private ReportDocument report = new ReportDocument();  

protected void Page_Load(object sender, EventArgs e)
{
report.Load(Server.MapPath("CrystalReport.rpt"));
report.FileName = Server.MapPath("CrystalReport.rpt"); 

if (!Page.IsPostBack)
{
BindData();
}
}
protected override void OnUnload(EventArgs e)
{
base.OnUnload(e);
this.Unload+=new EventHandler(Page_Unload);
}
public void Page_Unload(object sender, EventArgs e)
{
// clean up the resources
report.Clone();
report.Dispose();
}
private void BindData()
{
string connectionString = @"Server=localhost;Database=Northwind;Trusted_Connection=true";
SqlConnection myConnection = new SqlConnection(connectionString);
SqlDataAdapter ad = new SqlDataAdapter("SELECT CategoryName,CategoryID FROM Categories", myConnection);
DataSet ds = new DataSet();
ad.Fill(ds);
ddlCategory.DataSource = ds;
ddlCategory.DataTextField = "CategoryName";
ddlCategory.DataValueField = "CategoryID";
ddlCategory.DataBind();
}
// This will display the report
protected void Btn_DisplayReport(object sender, EventArgs e)
{
// get the selected CategoryID
int categoryID = Convert.ToInt32(ddlCategory.SelectedValue);
report.SetParameterValue("CategoryID", categoryID);
CrystalReportViewer1.ReportSource = report;
}
}

And here is the HTML part of the code:

<div>
Select a category: <asp:DropDownList ID="ddlCategory" runat="server" >
</asp:DropDownList>
<asp:Button ID="Btn_Display" runat="server" Text="Display Report"
OnClick="Btn_DisplayReport" />
<CR:CrystalReportViewer ID="CrystalReportViewer1" runat="server"
AutoDataBind="true" />
</div>