I have designed a class as given below:---


using System;
using Medlytics.Objects;
using Medlytics.DataObjects.General;
using CrystalDecisions.CrystalReports;
using CrystalDecisions.CrystalReports.Engine;
using CrystalDecisions.Shared;
using System.Data.SqlClient;
using System.Data;
using System.IO;
using System.Text;
using System.Web;


namespace Medlytics.Objects.Reports
{
    /// <summary>
    /// Summary description for Report.
    /// </summary>
    public class MedlyticsReportDocument
    {
        string sqlString=null;
        string RPTFileName=null;
        string DocumentFileName=null;
        ReportDocument ReportDoc = null;
        DataSet _dataSet=null;
        HttpResponse Response=HttpContext.Current.Response;

        public MedlyticsReportDocument()
        {

        }

        public void SetHttpResponse(HttpResponse Response)
        {
          this.Response =Response;
        }

        public string GetDocumentFileName()
        {
          return this.DocumentFileName;
        }

        public void SetDocumentFileName(string DocumentFileName)
        {
            this.DocumentFileName=DocumentFileName;
        }

        public DataSet GetDataSet()
        {
           return this._dataSet;
        }

        public void SetDataSet(DataSet _dataSet)
        {
           this._dataSet =_dataSet;
        }

        public void SetDataSource(DataSet _dataSet)
        {
            this._dataSet =_dataSet;
            this.GetReportDocument ().SetDataSource(_dataSet);
        }

        public void SetReportDocument(ReportDocument ReportDoc)
        {
            this.ReportDoc = ReportDoc;
        }

        public ReportDocument GetReportDocument()
        {
            return this.ReportDoc;
        }

        public void SetRPTFile(string RPTFileName)
        {
          this.RPTFileName = RPTFileName;
        }

        public string GetRPTFile()
        {
          return RPTFileName;
        }

        public bool ExportReport(ReportDocument crReportDocument,
            string ExpType,string ExportPath, string filename)
        {

            filename = filename + "." + ExpType;

            //creating storage directory if not exists
            if (!Directory.Exists(ExportPath))
                Directory.CreateDirectory(ExportPath);
            else
            {
                Directory.Delete (ExportPath,true);
                Directory.CreateDirectory(ExportPath);
            }
            //creating new instance representing disk file destination
            //options such as filename, export type etc.
            DiskFileDestinationOptions crDiskFileDestinationOptions =
                new DiskFileDestinationOptions();
            ExportOptions crExportOptions = crReportDocument.ExportOptions;


            switch(ExpType)
            {
                case "rtf":
                {
                    //setting disk file name
                    crDiskFileDestinationOptions.DiskFileName =
                        ExportPath + filename;
                    //setting destination type in our case disk file
                    crExportOptions.ExportDestinationType =
                        ExportDestinationType.DiskFile;
                    //setuing export format type
                    crExportOptions.ExportFormatType = ExportFormatType.RichText;
                    //setting previously defined destination
                    //opions to our input report document
                    crExportOptions.DestinationOptions = crDiskFileDestinationOptions;
                    break;
                }

                case "pdf":
                {
                    crDiskFileDestinationOptions.DiskFileName =
                        ExportPath + filename;
                    crExportOptions.DestinationOptions =
                        crDiskFileDestinationOptions;
                    crExportOptions.ExportDestinationType =
                        ExportDestinationType.DiskFile;
                    crExportOptions.ExportFormatType =
                        ExportFormatType.PortableDocFormat;
                    break;
                }
                case "doc":
                {
                    crDiskFileDestinationOptions.DiskFileName = ExportPath + filename;
                    crExportOptions.ExportDestinationType =
                        ExportDestinationType.DiskFile;
                    crExportOptions.ExportFormatType = ExportFormatType.WordForWindows;
                    crExportOptions.DestinationOptions = crDiskFileDestinationOptions;
                    break;
                }
                case "xls":
                {
                    crDiskFileDestinationOptions.DiskFileName = ExportPath + filename;
                    crExportOptions.ExportDestinationType =
                        ExportDestinationType.DiskFile;
                    crExportOptions.ExportFormatType = ExportFormatType.Excel;
                    crExportOptions.DestinationOptions = crDiskFileDestinationOptions;
                    break;
                }
                case "rpt":
                {
                    crDiskFileDestinationOptions.DiskFileName = ExportPath + filename;
                    crExportOptions.ExportDestinationType =
                        ExportDestinationType.DiskFile;
                    crExportOptions.ExportFormatType = ExportFormatType.CrystalReport;
                    crExportOptions.DestinationOptions = crDiskFileDestinationOptions;
                    break;
                }
                case "htm":
                {
                    HTMLFormatOptions HTML40Formatopts = new HTMLFormatOptions();
                    crExportOptions.ExportDestinationType =
                        ExportDestinationType.DiskFile;
                    crExportOptions.ExportFormatType = ExportFormatType.HTML40;
                    HTML40Formatopts.HTMLBaseFolderName = ExportPath + filename;
                    HTML40Formatopts.HTMLFileName = "HTML40.html";
                    HTML40Formatopts.HTMLEnableSeparatedPages = true;
                    HTML40Formatopts.HTMLHasPageNavigator = true;
                    HTML40Formatopts.FirstPageNumber = 1;
                    HTML40Formatopts.LastPageNumber = 3;
                    crExportOptions.FormatOptions = HTML40Formatopts;
                    break;
                }

            }
            try
            {
                this.SetDocumentFileName(ExportPath + filename);
                crReportDocument.Export();
                Response.ClearContent();
                Response.ClearHeaders();
                Response.Buffer =true;
                Response.ContentType="application/"+ExpType;
                Response.AppendHeader ("Content-Disposition","inline;filename="+ExportPath + filename);
                //Response.BinaryWrite (MedlyticsReportDocument.ExportReportToStream(crRe portDocument,crExportOptions.ExportFormatType));
                Response.WriteFile (ExportPath + filename);
                Response.Flush();
                Response.Close();
                return true;
            }
            catch (Exception err)
            {
                Response.Write(err.ToString ());
                return false;
            }
        }


        public static byte[] ExportReportToStream(ReportDocument
            crReportDocument,ExportFormatType exptype)
        {
            Stream st;
            st = crReportDocument.ExportToStream(exptype);

            byte[] arr = new byte[st.Length];
            st.Read(arr,0,(int) st.Length);

            return arr;

        }


        public static string ExportReportToString(
            ReportDocument crReportDocument)
        {
            Stream st;
            st = crReportDocument.ExportToStream(
                ExportFormatType.PortableDocFormat);

            byte[] arr = new byte[st.Length];
            st.Read(arr,0,(int) st.Length);

            string rep = new UnicodeEncoding().GetString(arr);

            return rep;
        }

        public void SetParamValue (string paramName, string paramValue)
        {
            for(int i=0;i<ReportDoc.DataDefinition.FormulaFields.Count ; i++)
                if(ReportDoc.DataDefinition.FormulaFields[i].FormulaName=="{" + paramName + "}")
                    ReportDoc.DataDefinition.FormulaFields[i].Text = "\"" +paramValue +"\"";

        }

        public string GetParamValue (string paramName)
        {
            string tmpValue="";
            for(int i=0;i<ReportDoc.DataDefinition.FormulaFields.Count ; i++)
            {
                if(ReportDoc.DataDefinition.FormulaFields[i].FormulaName=="{" + paramName + "}")
                    tmpValue= ReportDoc.DataDefinition.FormulaFields[i].Text ;
            }
            return tmpValue;
        }
        public DataSet FillReportData(string sqlString,DBManager dbManager)
        {
            SQLDataAdapter sqlDataAdapter=new SQLDataAdapter(sqlString,dbManager);
            sqlDataAdapter.FillDataSet();
            this._dataSet= sqlDataAdapter.GetDataSet();
            this.ReportDoc.SetDataSource(sqlDataAdapter.GetDat aSet());
            return this.GetDataSet ();
        }

        public void LoadReport(string fileName)
        {
            this.SetRPTFile (fileName);
            ReportDoc.Load(fileName);
        }

        public void LoadReport()
        {
            ReportDoc.Load(this.GetRPTFile());
        }

    }
}




I am then using this class to pass parameters to a .rpt file. The code is as follows:---


using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;
using Medlytics.DataObjects.RTF;
using Medlytics.Objects.Util;
using Medlytics.DataObjects.General;
using System.Text;
using System.Data.SqlClient;
using CrystalDecisions.Shared;
using CrystalDecisions.CrystalReports.Engine;
using Medlytics.Objects.Reports;
using Medlytics.CrystalReport;

namespace Medlytics.Reports.Department
{
    /// <summary>
    /// Summary description for WebForm1.
    /// </summary>
    public class WebForm1 : System.Web.UI.Page
    {
        protected System.Web.UI.WebControls.Button Button1;



        private void Page_Load(object sender, System.EventArgs e)
        {
            // Put user code to initialize the page here
        }

        #region Web Form Designer generated code
        override protected void OnInit(EventArgs e)
        {
            //
            // CODEGEN: This call is required by the ASP.NET Web Form Designer.
            //
            InitializeComponent();
            base.OnInit(e);
        }

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            this.Button1.Click += new System.EventHandler(this.Button1_Click);
            this.Load += new System.EventHandler(this.Page_Load);

        }
        #endregion

        private void Button1_Click(object sender, System.EventArgs e)
        {


            //CompanyParticulars c=new CompanyParticulars ();

            ReportDocument crReportDocument=new ReportDocument();
            MedlyticsReportDocument reportDocument=new MedlyticsReportDocument ();
            string sqlString = "select name from department";
            DBManager dbManager=new DBManager();
            dbManager.Open("medlytics");
            reportDocument.SetReportDocument(crReportDocument) ;
            reportDocument.LoadReport (Server.MapPath("/")+"/CrystalReport/CrystalReportTesting.rpt");
            reportDocument.FillReportData (sqlString,dbManager);
            DataRow _dataRow=reportDocument.GetDataSet().Tables [0].Rows[0];
            //reportDocument.GetReportDocument ().SetParameterValue ("DeptName",_dataRow[0].ToString ());



            ParameterDiscreteValue parameterDiscreteValue=new ParameterDiscreteValue();
            ParameterValues parameterValues= new ParameterValues();

            ParameterFieldDefinition parameterFieldDefinition = reportDocument.GetReportDocument ().DataDefinition.ParameterFields["DeptName"];

            parameterDiscreteValue.Value = "Test";
            parameterValues.Add(parameterDiscreteValue);

            parameterFieldDefinition.ApplyCurrentValues(parame terValues);

            reportDocument.GetReportDocument ().DataDefinition.ParameterFields["DeptName"].ApplyCurrentValues(parameterValues);

            reportDocument.ExportReport(reportDocument.GetRepo rtDocument() , "pdf", "c:/Reports/", Session.SessionID.ToString());

            dbManager.Close ();

        }

    }
}


I am facing problem with an exception related to Current Value of the parameter. Pls help.

Joydip.

E-Mail: [email protected]