Exportation programmée de rapports à partir de SQL 2012 Reporting Services

Question

J'ai une application console qui doit se connecter à SQL Reporting Services sur SQL Server Express 2012. Toute la logique d'exportation doit être implémentée dans une dll séparée, et les chemins d'accès doivent être dynamiques (je dois parcourir en boucle divers paramètres pour divers serveurs/rapports et les exporter vers Excel un par un).

J'ai essayé de suivre ces tutoriels :

http://www.aspose.com/docs/display/wordsreportingservices/Rendering+Rapports+Programmation

http://blogs.msdn.com/b/selvar/archive/2010/12/13/accessing-the-reportexecutionservice-render-method-when-reporting-service-2008-r2-is-in-forms-based-authentication.aspx

En gros, j'ai ajouté des références web :

http://localhost:80/ReportServer_SQLEXPRESS12/ReportExecution2005.asmx

y

http://localhost:80/ReportServer_SQLEXPRESS12/ReportService2010.asmx

à mon dll. Tout va bien jusqu'à présent, sauf ces méchants paramètres app.config (je devrai les ajuster dynamiquement plus tard).

J'ai ensuite essayé de faire comme dans l'exemple :

// Create Web service proxies.
ReportingService2010.ReportingService2010 rs = new ReportingService2010.ReportingService2010();
ReportExecutionService.ReportExecutionService rsExec = new ReportExecutionService.ReportExecutionService();

et a eu quelques problèmes :

Error   76  The type or namespace name 'ReportExecutionService' does not exist in the namespace 'MyDllNamespace.ReportExecutionService' (are you missing an assembly reference?)    

Error   74  The type or namespace name 'ReportingService2010' does not exist in the namespace 'MyDllNamespace.ReportingService2010' (are you missing an assembly reference?)

Comment puis-je utiliser l'API de Reporting Services si je ne peux même pas créer un objet proxy ? Ou devrais-je plutôt utiliser la classe ServerReport du ReportViewer de Winforms au lieu de ces références Web ?

Même l'un des exemples de Microsoft consiste à utiliser ReportViewer dans une application console, mais il semble un peu délicat d'importer des Winforms dans une application console.

Answer 1

J'espère que ce qui suit vous aidera (extrait des parties pertinentes du code)

            using (ZUtilities.SSRS.Report report = new ZUtilities.SSRS.Report {
                ReportServerPath = VParameter.GetValue("SSRS_WebServiceUrl", _repo.Parameters).ToString(),
                Format = rformat,
                ReportPath = "some_path_on_ssrs_server"
            }) {
                report.Params.Add("Id", id.ToString());
                report.Credentials = nwc;
                MemoryStream ms = new MemoryStream();
                report.Render().CopyTo(ms);
                FileContentResult fsr = new FileContentResult(ms.ToArray(), rctype);
                fsr.FileDownloadName = String.Format("EPV-{0}-{1:yyyyMMdd}.{2}", epv.ExternalReference, DateTime.Now, fext);
                ms.Close();
                return fsr;
            }

avec les éléments suivants (attention à la gestion des flux)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net;
using System.IO;

namespace ZUtilities.SSRS {
    public enum ReportFormats {
        Html = 1,
        MHtml,
        Pdf,
        Xlsx,
        Docx
    }

    public class ReportFormat {
        static ReportFormat() {
            Html = new ReportFormat { Code = ReportFormats.Html, Instruction = "HTML4.0" };
            MHtml = new ReportFormat { Code = ReportFormats.MHtml, Instruction = "MHTML" };
            Pdf = new ReportFormat { Code = ReportFormats.Pdf, Instruction = "PDF" };
            Xlsx = new ReportFormat { Code = ReportFormats.Xlsx, Instruction = "EXCELOPENXML" };
            Docx = new ReportFormat { Code = ReportFormats.Docx, Instruction = "WORDOPENXML" };
        }

        private ReportFormat() {
        }

        public ReportFormats Code { get; set; }
        public String Instruction { get; set; }

        public static ReportFormat Html { get; private set; }
        public static ReportFormat MHtml { get; private set; }
        public static ReportFormat Pdf { get; private set; }
        public static ReportFormat Xlsx { get; private set; }
        public static ReportFormat Docx { get; private set; }

        public static ReportFormat ByCode(ReportFormats code) {
            switch (code) {
                case ReportFormats.Html: return Html;
                case ReportFormats.MHtml: return Html; //<<======================
                case ReportFormats.Pdf: return Pdf;
                case ReportFormats.Xlsx: return Xlsx;
                case ReportFormats.Docx: return Docx;
                default : return null;
            }
        }
    }

    public class Report : IDisposable {
        private HttpWebRequest _httpWReq;
        private WebResponse _httpWResp;

        public Report() {
            _httpWReq = null;
            _httpWResp = null;
            Format = ReportFormats.Html;
            Params = new Dictionary<String, String>();
        }

        public Dictionary<String, String> Params { get; set; }

        public String ReportServerPath { get; set; }
        public String ReportPath { get; set; }
        public ReportFormats Format { get; set; }
        public NetworkCredential Credentials { get; set; }

        //public String PostData { get { return String.Format("rs:Command=Render&rs:Format={0}", ReportFormat.ByCode(Format).Instruction); } }
        public String PostData { get {
            StringBuilder sb = new StringBuilder(1024);
            sb.AppendFormat("rs:Command=Render&rs:Format={0}", ReportFormat.ByCode(Format).Instruction);
            if (Format == ReportFormats.Html) {
                sb.Append("&rc:Toolbar=false");
            }
            foreach (var kv in Params) {
                sb.AppendFormat("&{0}={1}", kv.Key, kv.Value);
            }

            return sb.ToString();
        } }

        public String ReportFullPath { get { return ReportServerPath + "?/" +  ReportPath; } }

        public Stream Render() {
            _httpWReq = (HttpWebRequest)HttpWebRequest.Create(ReportFullPath);
            _httpWReq.Method = "POST";
            if (Credentials != null)
                _httpWReq.Credentials = Credentials;

            byte[] byteArray = Encoding.UTF8.GetBytes(PostData);
            _httpWReq.ContentType = "application/x-www-form-urlencoded";
            _httpWReq.ContentLength = byteArray.Length;
            Stream dataStream = _httpWReq.GetRequestStream();
            dataStream.Write(byteArray, 0, byteArray.Length);
            dataStream.Close();

            if (_httpWResp != null )
                _httpWResp.Close();
                            _httpWResp = _httpWReq.GetResponse();               

            return _httpWResp.GetResponseStream();
        }

        public void RenderTo(String fileName) {            
            Stream receiveStream = Render();
            Stream ds = File.Open(fileName, FileMode.Create);
            receiveStream.CopyTo(ds);
            ds.Close();
            receiveStream.Close();            
        }

        public void Dispose() {
            if (_httpWResp != null) {
                _httpWResp.Close();
                _httpWResp = null;
            }

            if (_httpWReq != null) {
                _httpWReq = null;
            }
        }
    }
}