ReportExecutionService.Render Metodo

Riferimento

Definizione

Spazio dei nomi:: ReportExecution2005

Assembly:: ReportExecution2005.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Elabora un report specifico e ne esegue il rendering nel formato specificato.

public:
 cli::array <System::Byte> ^ Render(System::String ^ Format, System::String ^ DeviceInfo, [Runtime::InteropServices::Out] System::String ^ % Extension, [Runtime::InteropServices::Out] System::String ^ % MimeType, [Runtime::InteropServices::Out] System::String ^ % Encoding, [Runtime::InteropServices::Out] cli::array <ReportExecution2005::Warning ^> ^ % Warnings, [Runtime::InteropServices::Out] cli::array <System::String ^> ^ % StreamIds);

public byte[] Render (string Format, string DeviceInfo, out string Extension, out string MimeType, out string Encoding, out ReportExecution2005.Warning[] Warnings, out string[] StreamIds);

member this.Render : string * string * string * string * string * Warning[] * String[] -> byte[]

Public Function Render (Format As String, DeviceInfo As String, ByRef Extension As String, ByRef MimeType As String, ByRef Encoding As String, ByRef Warnings As Warning(), ByRef StreamIds As String()) As Byte()

Parametri

Format: String

Formato da utilizzare per il rendering del report. Questo argomento esegue il mapping a un'estensione per il rendering. Le estensioni supportate includono XML, NULL, CSV, IMAGE, PDF, HTML4.0, HTML3.2, MHTML, EXCEL e Word. È possibile ottenere un elenco di estensioni supportate chiamando il metodo ListRenderingExtensions().

DeviceInfo: String

Stringa XML che contiene il contenuto specifico del dispositivo richiesto dall'estensione per il rendering specificata nel Format parametro . È necessario passare le impostazioni DeviceInfo come elementi interni di un elemento XML DeviceInfo. Per altre informazioni sulle impostazioni delle informazioni sul dispositivo per formati di output specifici, vedere Passaggio delle impostazioni delle informazioni sul dispositivo alle estensioni per il rendering.

Extension: String

[out] Estensione file corrispondente al flusso di output.

MimeType: String

[out] Tipo MIME del report visualizzabile.

Encoding: String

[out] Codifica utilizzata quando il server di report esegue il rendering del contenuto del report.

Warnings: Warning[]

[out] Matrice di oggetti Warning che descrive gli avvisi generati durante l'elaborazione del report.

StreamIds: String[]

[out] Identificatori di flusso. Tali ID vengono passati al metodo RenderStream(String, String, String, String, String). È possibile utilizzarli per eseguire il rendering delle risorse esterne, ad esempio le immagini, associate a un determinato report.

Se viene usata l'estensione per il rendering IMAGE, il metodo restituisce una matrice vuota in StreamIds.

Restituisce

Byte[]

Matrice Byte[] del report nel formato specificato.

Esempio

Per compilare l'esempio di codice seguente, è necessario fare riferimento alla Reporting Services WSDL e importare determinati spazi dei nomi. Per altre informazioni, vedere Compilazione ed esecuzione di esempi di codice. L'esempio di codice seguente esegue il rendering di un report in MHTML e lo salva come file con estensione mht su disco.

Imports System  
Imports System.IO  
Imports System.Web.Services.Protocols  
Imports myNamespace.MyReferenceName  

Class Sample  
    Public Shared Sub Main()  
        Dim rs As New ReportExecutionService()  
        rs.Credentials = System.Net.CredentialCache.DefaultCredentials  
        rs.Url = "http://myserver/reportserver/ReportExecution2005.asmx"  

        ' Render arguments  
        Dim result As Byte() = Nothing  
        Dim reportPath As String = "/AdventureWorks Sample Reports/Employee Sales Summary "  
        Dim format As String = "MHTML"  
        Dim historyID As String = Nothing  
        Dim devInfo As String = "<DeviceInfo><Toolbar>False</Toolbar></DeviceInfo>"  

        ' Prepare report parameter.  
        Dim parameters(2) As ParameterValue  

        parameters(0) = New ParameterValue()  
        parameters(0).Name = "EmpID"  
        parameters(0).Value = "288"  
        parameters(1) = New ParameterValue()  
        parameters(1).Name = "ReportMonth"  
        parameters(1).Value = "6" ' June  
        parameters(2) = New ParameterValue()  
        parameters(2).Name = "ReportYear"  
        parameters(2).Value = "2004"  

        Dim credentials As DataSourceCredentials() = Nothing  
        Dim showHideToggle As String = Nothing  
        Dim encoding As String = ""  
        Dim mimeType As String = ""  
        Dim warnings As Warning() = Nothing  
        Dim reportHistoryParameters As ParameterValue() = Nothing  
        Dim streamIDs As String() = Nothing  

        Dim execInfo As New ExecutionInfo  
        Dim execHeader As New ExecutionHeader()  
        Dim SessionId As String  
        Dim extension As String = ""  

        rs.ExecutionHeaderValue = execHeader  

        execInfo = rs.LoadReport(reportPath, historyID)  

        rs.SetExecutionParameters(parameters, "en-us")  

        SessionId = rs.ExecutionHeaderValue.ExecutionID  
        Console.WriteLine("SessionID: {0}", rs.ExecutionHeaderValue.ExecutionID)  

        Try  
            result = rs.Render(format, devInfo, extension, _  
               encoding, mimeType, warnings, streamIDs)  

            execInfo = rs.GetExecutionInfo()  

            Console.WriteLine("Execution date and time: {0}", execInfo.ExecutionDateTime)  

        Catch e As SoapException  
            Console.WriteLine(e.Detail.OuterXml)  
        End Try  

        ' Write the contents of the report to an MHTML file.  
        Try  
            Dim stream As FileStream = File.Create("report.mht", result.Length)  
            Console.WriteLine("File created.")  
            stream.Write(result, 0, result.Length)  
            Console.WriteLine("Result written to the file.")  
            stream.Close()  
        Catch e As Exception  
            Console.WriteLine(e.Message)  
        End Try  
    End Sub 'Main  
End Class

using System;  
using System.IO;  
using System.Web.Services.Protocols;  
using myNamespace.MyReferenceName;  

class Sample  
{  
    static void Main(string[] args)  
    {  
        ReportExecutionService rs = new ReportExecutionService();  
        rs.Credentials = System.Net.CredentialCache.DefaultCredentials;  
        rs.Url = "http://myserver/reportserver/ReportExecution2005.asmx";  

        // Render arguments  
        byte[] result = null;  
        string reportPath = "/AdventureWorks Sample Reports/Employee Sales Summary";  
        string format = "MHTML";  
        string historyID = null;  
        string devInfo = @"<DeviceInfo><Toolbar>False</Toolbar></DeviceInfo>";  

        // Prepare report parameter.  
        ParameterValue[] parameters = new ParameterValue[3];  
        parameters[0] = new ParameterValue();  
        parameters[0].Name = "EmpID";  
        parameters[0].Value = "288";  
        parameters[1] = new ParameterValue();  
        parameters[1].Name = "ReportMonth";  
        parameters[1].Value = "6"; // June  
        parameters[2] = new ParameterValue();  
        parameters[2].Name = "ReportYear";  
        parameters[2].Value = "2004";  

        DataSourceCredentials[] credentials = null;  
        string showHideToggle = null;  
        string encoding;  
        string mimeType;  
        string extension;  
        Warning[] warnings = null;  
        ParameterValue[] reportHistoryParameters = null;  
        string[] streamIDs = null;  

        ExecutionInfo execInfo = new ExecutionInfo();  
        ExecutionHeader execHeader = new ExecutionHeader();  

        rs.ExecutionHeaderValue = execHeader;  

        execInfo = rs.LoadReport(reportPath, historyID);  

        rs.SetExecutionParameters(parameters, "en-us");   
        String SessionId = rs.ExecutionHeaderValue.ExecutionID;  

        Console.WriteLine("SessionID: {0}", rs.ExecutionHeaderValue.ExecutionID);  

        try  
        {  
            result = rs.Render(format, devInfo, out extension, out encoding, out mimeType, out warnings, out streamIDs);  

            execInfo = rs.GetExecutionInfo();  

            Console.WriteLine("Execution date and time: {0}", execInfo.ExecutionDateTime);  

        }  
        catch (SoapException e)  
        {  
            Console.WriteLine(e.Detail.OuterXml);  
        }  
        // Write the contents of the report to an MHTML file.  
        try  
        {  
            FileStream stream = File.Create("report.mht", result.Length);  
            Console.WriteLine("File created.");  
            stream.Write(result, 0, result.Length);  
            Console.WriteLine("Result written to the file.");  
            stream.Close();  
        }  
        catch (Exception e)  
        {  
            Console.WriteLine(e.Message);  
        }  

    }  
}

Commenti

Nella tabella seguente vengono mostrate le informazioni sull'intestazione e sulle autorizzazioni relative a questa operazione.


Utilizzo intestazione SOAP	(In) TrustedUserHeaderValue (In) ExecutionHeaderValue (Out) ServerInfoHeaderValue
Autorizzazioni necessarie per la modalità nativa	Nel report principale e in tutti i sottoreport: ReadProperties AND ExecuteAndView
Autorizzazioni necessarie per la modalità SharePoint	Nel report principale e in tutti i sottoreport: <xref:Microsoft.SharePoint.SPBasePermissions.ViewListItems>

Render esegue il rendering di un report elaborato associato all'esecuzione del report identificata nell'intestazione ExecutionInfo . Se non esiste alcun snapshot temporaneo per il report elaborato nello stato di esecuzione, questo metodo eseguirà il report (se vengono soddisfatti tutti i requisiti di credenziali e parametri), con conseguente creazione di uno snapshot temporaneo per lo stato di esecuzione. Se il report viene rielaborato perché i valori dei parametri non di query sono stati modificati, viene creato un nuovo snapshot temporaneo. Per altre informazioni sullo stato di esecuzione, vedere Identificazione dello stato di esecuzione.

Se le opzioni di esecuzione sono impostate sulla cache o sullo snapshot di esecuzione, la chiamata a Render può usare uno snapshot esistente.

Se il report è impostato sulla cache e i valori e le credenziali dei parametri specificati corrispondono, è possibile caricare la copia memorizzata nella cache dello snapshot anziché elaborare effettivamente il report.

Se i requisiti delle credenziali e dei parametri non sono soddisfatti, questo metodo restituirà un errore.

Le chiamate successive a Render possono essere utilizzate per recuperare pagine aggiuntive del report se l'estensione per il rendering supporta la specifica di più pagine.

Una limitazione del metodo Render è che l'output non può essere trasmesso, quindi l'intero file deve essere in memoria.

Vedere Identificazione dello stato di esecuzione per una descrizione del ciclo di vita dell'esecuzione, che include una descrizione dei passaggi necessari per caricare ed eseguire il rendering di un report.

Si applica a

Condividi tramite