ReportExecutionService.Render Méthode

Référence

Définition

Espace de noms:: ReportExecution2005

Assembly:: ReportExecution2005.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Traite un rapport spécifique et effectue le rendu du rapport au format spécifié.

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

Paramètres

Format: String

Format de rendu du rapport. Cet argument correspond à une extension de rendu Les extensions de rendu prises en charge sont XML, NULL, CSV, IMAGE, PDF, HTML4.0, HTML3.2, MHTML, EXCEL et Word. Une liste des extensions prises en charge peut être obtenue en appelant la méthode ListRenderingExtensions().

DeviceInfo: String

Chaîne XML qui contient le contenu spécifique à l’appareil requis par l’extension de rendu spécifiée dans le Format paramètre . Les paramètres DeviceInfo doivent être passés en tant qu'éléments internes d'un élément XML DeviceInfo. Pour plus d’informations sur les paramètres d’informations sur l’appareil pour des formats de sortie spécifiques, consultez Transmission de paramètres d’informations d’appareil aux extensions de rendu.

Extension: String

[out] Extension de fichier correspondant au flux de sortie.

MimeType: String

[out] Type MIME du rapport rendu.

Encoding: String

[out] Encodage utilisé lorsque le serveur de rapports restitue le contenu du rapport.

Warnings: Warning[]

[out] Tableau d'objets Warning qui décrit les avertissements qui ont été rencontrés pendant le traitement du rapport.

StreamIds: String[]

[out] Identificateurs de flux. Ces ID sont passés à la méthode RenderStream(String, String, String, String, String). Vous pouvez les utiliser pour restituer les ressources externes (images, etc.) qui sont associées à un rapport donné.

Si l’extension de rendu IMAGE est utilisée, la méthode génère un tableau vide dans StreamIds.

Retours

Byte[]

Tableau Byte[] du rapport au format spécifié.

Exemples

Pour compiler l’exemple de code suivant, vous devez référencer le Reporting Services WSDL et importer certains espaces de noms. Pour plus d’informations, consultez Compilation et exécution d’exemples de code. L’exemple de code suivant restitue un rapport en MHTML et l’enregistre en tant que fichier .mht sur le disque.

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);  
        }  

    }  
}

Remarques

Le tableau suivant présente les informations relatives aux en-têtes et aux autorisations sur cette opération.


Utilisation de l’en-tête SOAP	(In) TrustedUserHeaderValue (In) ExecutionHeaderValue (Out) ServerInfoHeaderValue
Autorisations requises en mode natif	Sur le main rapport et tous les sous-rapports : ReadProperties ANDExecuteAndView
Autorisations requises en mode SharePoint	Sur le main rapport et tous les sous-rapports :<xref:Microsoft.SharePoint.SPBasePermissions.ViewListItems>

Render restitue un rapport traité associé à l’exécution du rapport identifié dans l’en-tête ExecutionInfo . S’il n’existe aucune instantané temporaire pour le rapport traité dans l’état d’exécution, cette méthode exécute le rapport (si toutes les exigences en matière d’informations d’identification et de paramètre sont remplies), ce qui entraîne la création d’un instantané temporaire pour l’état d’exécution. Si le rapport est retraité en raison d’une modification des valeurs de paramètre non-requête, une nouvelle instantané temporaire est créée. Pour plus d’informations sur l’état d’exécution, consultez Identification de l’état d’exécution.

Si les options d’exécution sont définies sur la mise en cache ou l’exécution instantané, l’appel à Render peut utiliser une instantané existante.

Si le rapport est mis en cache et que les valeurs de paramètre et les informations d’identification fournies correspondent, la copie mise en cache du instantané peut être chargée au lieu de traiter réellement le rapport.

Si les exigences en matière d’informations d’identification et de paramètres ne sont pas remplies, cette méthode retourne une erreur.

Les appels suivants à Render peuvent être utilisés pour extraire des pages supplémentaires du rapport si l’extension de rendu prend en charge la spécification de plusieurs pages.

Une limitation de la méthode Render est que la sortie ne peut pas être diffusée en continu, de sorte que le fichier entier doit être en mémoire.

Consultez Identification de l’état d’exécution pour une présentation du cycle de vie de l’exécution, qui inclut une description des étapes nécessaires pour charger et afficher un rapport.

S’applique à

Partager via