ReportExecutionService.Render Método

Referência

Definição

Namespace:: ReportExecution2005

Assembly:: ReportExecution2005.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Processa um relatório específico e o renderiza no formato especificado.

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()

Parâmetros

Format: String

O formato no qual um relatório deve ser renderizado. Esse argumento é mapeado para uma extensão de renderização. As extensões com suporte incluem XML, NULL, CSV, IMAGE, PDF, HTML 4.0, HTML3.2, MHTML, EXCEL e Word. Uma lista de extensões com suporte pode ser obtida chamando o método ListRenderingExtensions().

DeviceInfo: String

Uma cadeia de caracteres XML que contém o conteúdo específico do dispositivo exigido pela extensão de renderização especificada no Format parâmetro . As configurações de DeviceInfo devem ser transmitidas como elementos internos de um elemento XML DeviceInfo. Para obter mais informações sobre as configurações de informações do dispositivo para formatos de saída específicos, consulte Passando configurações de informações do dispositivo para extensões de renderização.

Extension: String

[out] A extensão de arquivo que corresponde ao fluxo de saída.

MimeType: String

[out] O tipo MIME do relatório renderizado.

Encoding: String

[out] A codificação usada quando o servidor de relatório renderiza o conteúdo do relatório.

Warnings: Warning[]

[out] Uma matriz de objetos Warning que descreve todos os avisos ocorridos durante o processamento do relatório.

StreamIds: String[]

[out] Os identificadores de fluxo. Essas IDs são transmitidas para o método RenderStream(String, String, String, String, String). É possível usá-las para renderizar os recursos externos (imagens, etc.) associados a um determinado relatório.

Se a extensão de renderização IMAGE for usada, o método gerará uma matriz vazia em StreamIds.

Retornos

Byte[]

Uma matriz Byte[] do relatório no formato especificado.

Exemplos

Para compilar o exemplo de código a seguir, você deve referenciar o Reporting Services WSDL e importar determinados namespaces. Para obter mais informações, consulte Compilando e executando exemplos de código. O exemplo de código a seguir renderiza um relatório em MHTML e o salva como um arquivo .mht no 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);  
        }  

    }  
}

Comentários

A tabela a seguir mostra o cabeçalho e as informações de permissão sobre esta operação.


Uso do cabeçalho SOAP	(In) TrustedUserHeaderValue (In) ExecutionHeaderValue (Out) ServerInfoHeaderValue
Permissões necessárias do modo nativo	No relatório main e todos os sub-relatórios: ReadProperties ANDExecuteAndView
Permissões necessárias do modo do SharePoint	No relatório main e todos os sub-relatórios:<xref:Microsoft.SharePoint.SPBasePermissions.ViewListItems>

Render renderiza um relatório processado associado à execução do relatório identificada no ExecutionInfo cabeçalho . Se não houver instantâneo temporária para o relatório processado no estado de execução, esse método executará o relatório (se todos os requisitos de credenciais e parâmetros forem atendidos), resultando em um instantâneo temporário sendo criado para o estado de execução. Se o relatório for reprocessado porque os valores de parâmetro não consulta foram alterados, um novo instantâneo temporário será criado. Para obter mais informações sobre o estado de execução, consulte Identificando o estado de execução.

Se as opções de execução estiverem definidas como cache ou instantâneo de execução, a chamada para Render poderá usar um instantâneo existente.

Se o relatório estiver definido como cache e os valores de parâmetro e as credenciais fornecidos corresponderem, a cópia armazenada em cache do instantâneo poderá ser carregada em vez de realmente processar o relatório.

Se os requisitos de credenciais e parâmetros não forem atendidos, esse método retornará um erro.

Chamadas subsequentes para Render poderão ser usadas para buscar páginas adicionais do relatório se a extensão de renderização der suporte à especificação de várias páginas.

Uma limitação do método Render é que a saída não pode ser transmitida, portanto, todo o arquivo deve estar na memória.

Consulte Identificando o estado de execução para uma discussão sobre o ciclo de vida de execução, que inclui uma descrição das etapas necessárias para carregar e renderizar um relatório.

Aplica-se a