SAP Crystal Report pour le Guide du développeur

Transcription

SAP Crystal Reports, version développeur pour Microsoft Visual Studio
Version du document : Support Package 10 - 2014-06-23
SAP Crystal Report pour le Guide du
développeur de SAP SDK Visual
Studio .NET
Table des matières
1
Guide du développeur du SAP SDK Crystal Reports .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.1
Démarrage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.1.1
Présentation de SAP Crystal Reports, version développeur pour Microsoft Visual Studio
............................................................................4
1.1.2
1.2
1.3
Migration de l'application SAP Crystal Reports .Net. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Configuration de l'environnement de développement. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.2.1
Configuration du système. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .10
1.2.2
Configuration d'un projet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Principes fondamentaux du SDK. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
1.3.1
Architecture. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
1.3.2
Contrôle CrystalReportViewer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
1.3.3
Quelle méthode de persistance utiliser avec SAP Crystal Reports ?. . . . . . . . . . . . . . . . . . . . 53
1.3.4
Evolutivité de l'application. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
1.3.5
Utilisation de SAP Crystal Reports dans une batterie de serveurs Web ou un jardin Web
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
1.4
1.5
1.6
1.7
2
1.3.6
Utilisation de Crystal Reports en tant que service Web. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
1.3.7
Considérations de sécurité. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .111
Utilisation du SDK. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .113
1.4.1
Impression d'un rapport. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
1.4.2
Exportation d'un rapport. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .123
1.4.3
Filtrage de données avec des paramètres ou des formules. . . . . . . . . . . . . . . . . . . . . . . . . .136
1.4.4
Définition de la source de données. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
1.4.5
Visualisation d'un rapport. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
1.4.6
Personnalisation du contrôle CrystalReportViewer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
1.4.7
Utilisation des rapports SAP Crystal Reports Read-Only (RPTR). . . . . . . . . . . . . . . . . . . . . 243
Tutoriels. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243
1.5.1
Tutoriels du modèle d'objet CrystalReportViewer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243
1.5.2
Tutoriels du modèle d'objet ReportDocument. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 340
1.5.3
Tutoriels de programmation allégée dans Visual Studio. . . . . . . . . . . . . . . . . . . . . . . . . . . 508
1.5.4
Tutoriels sur la connectivité des données. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .549
1.5.5
Tutoriels supplémentaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 589
Déploiement. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 618
1.6.1
Composants de déploiement. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .618
1.6.2
Déploiement pour Visual Studio. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 629
Création des rapports. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 646
1.7.1
Utilisation du SAP Crystal Reports Designer incorporé. . . . . . . . . . . . . . . . . . . . . . . . . . . . 647
1.7.2
Formules - Référence. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 786
1.7.3
Interface utilisateur - Référence. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 856
© 2014 SAP AG ou société affiliée SAP. Tous droits réservés.
SAP Crystal Report pour le Guide du développeur de SAP SDK Visual Studio .NET
Table des matières
1.8
Glossaire. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .1009
Table des matières
3
1
Guide du développeur du SAP SDK
Crystal Reports .NET
1.1
Démarrage
Cette aide en ligne est conçue pour vous aider à développer vos propres applications Web ou Windows à l'aide du
SDK SAP Crystal Reports .NET. Elle comprend des tutoriels et des références de programmation qui vous
aideront à implémenter le SDK SAP Crystal Reports .NET.
1.1.1
Présentation de SAP Crystal Reports, version
développeur pour Microsoft Visual Studio
SAP Crystal Reports, version développeur pour Microsoft Visual Studio permet de créer des rapports complexes
de qualité professionnelle dans un programme basé sur une interface utilisateur graphique. Vous pouvez alors
connecter votre rapport à pratiquement n'importe quelle source de base de données ou à des données proxy,
comme un ensemble de résultats (par exemple, un objet DataSet ADO.NET). A l'aide des assistants du
concepteur d'interface utilisateur, vous pouvez définir la mise en forme, le regroupement, les diagrammes et
d'autres critères.
Vous pouvez héberger votre rapport dans une application Web ou Windows avec l'un des contrôles visualiseur de
rapports de SAP Crystal Reports. La présentation des rapports dans les clients Windows et HTML 4.0 est
hautement interactive et offre des fonctionnalités telles que l'exploration de diagrammes, la navigation dans les
rapports et la recherche de texte.
SAP Crystal Reports, version développeur pour Microsoft Visual Studio est fourni avec un SDK complet. Ce SDK
vous permet d'interagir avec le rapport par programmation au moment de l'exécution, grâce à l'emploi de l'un des
quatre modèles d'objet suivants :
●
CrystalReportViewer, le modèle d'objet le plus simple.
●
ReportDocument, le modèle d'objet le plus complet.
●
ReportClientDocument, le modèle d'objet le plus complet. Ce modèle d'objet est disponible avec un serveur
RAS.
●
InfoObject, un modèle d'objet puissant conçu pour la planification et la configuration de rapports dans la
structure SAP Crystal Reports Server ou de la plateforme SAP BusinessObjects Business Intelligence.
Remarque
Les modèles d'objet CrystalReportViewer et ReportDocument sont disponibles avec toutes les versions
de SAP Crystal Reports, version développeur pour Microsoft Visual Studio. Les modèles d'objet
ReportClientDocument et InfoObject nécessitent une licence mise à niveau. Voir Solutions de reporting de
SAP BusinessObjects Business Intelligence [page 65].
Vous pouvez associer des rapports à un projet Visual Studio de nombreuses façons :
●
Incorporez les rapports directement dans le projet.
●
Accédez aux rapports à partir d'un répertoire de fichiers.
4
Guide du développeur du SAP SDK Crystal Reports .NET
●
Accédez aux rapports en tant que service Web de rapports à partir d'un serveur distant.
●
Connectez vos rapports en tant que services Crystal.
●
Avec une mise à niveau vers SAP Crystal Reports Server, accédez aux rapports via le serveur RAS.
●
Avec une mise à niveau vers la plateforme SAP BusinessObjects Business Intelligence, accédez aux rapports
via le Page Server ou le serveur RAS présent dans la structure de la plateforme SAP BusinessObjects
Business Intelligence.
1.1.1.1
Fonctionnalités disponibles dans
SAP Crystal Report Designer
SAP Crystal Reports Designer propose plusieurs fonctionnalités qui ne sont pas disponibles avec
SAP Crystal Reports, version développeur pour Microsoft Visual Studio :
Fonction
Description
Membres calculés dans des diagrammes de tableau croisé
Vous pouvez ajouter des lignes ou des colonnes à un
diagramme de Tableau croisé en insérant un membre
calculé. Ces lignes ou colonnes peuvent contenir des calculs
personnalisés (par exemple, la différence de ventes entre
deux régions) ou peuvent être entièrement utilisées à des fins
de mise en forme (par exemple, en insérant une ligne vide
toutes les trois lignes pour améliorer la clarté). Vous disposez
d'une entière souplesse dans la conception de vos propres
formules de calcul et pouvez choisir si elles apparaissent
seulement une fois ou se répètent régulièrement dans le
Tableau croisé.
Objets Flash incorporés
Vous pouvez incorporer un objet Flash ou créer un lien vers
un objet Flash dans une section quelconque de rapport
SAP Crystal Reports.
Résumés incorporés dans des tableaux croisés
Vous pouvez ajouter un calcul supplémentaire à votre
diagramme de Tableau croisé en insérant un résumé
incorporé. Les résumés incorporés n'ajoutent pas de lignes
ou de colonnes à votre Tableau croisé. Ils entraînent plutôt
l'apparition de calculs supplémentaires dans chacune des
cellules du Tableau croisé. Par exemple, dans un rapport
affichant les ventes régionales, vous pouvez insérer un calcul
pour chaque région, qui affiche le pourcentage des ventes
totales du pays.
Aperçu modifiable
Avec SAP Crystal Reports Designer, vous pouvez visualiser
un rapport dans l'onglet de conception ou l'onglet d'aperçu.
Vous disposez des mêmes possibilités de mise en forme
dans l'onglet Aperçu que dans l'onglet Conception.
Néanmoins, dans l'onglet Aperçu, vous travaillez avec les
5
Fonction
Description
données réelles. Au lieu d'un cadre de champ de données
représentant plusieurs valeurs de champ de données, les
valeurs réelles apparaissent dans le rapport.
Code-barres mis en forme
SAP Crystal Reports Designer comprend les formules et
polices nécessaires à la prise en charge des code-barres
Code39. Vous pouvez utiliser l'option Mettre en forme le
champ pour modifier l'apparence d'un code-barres.
Il existe de nombreuses raisons pour modifier l'apparence
d'un code-barres, dont les suivantes :
●
Pour changer la taille de sorte que le code-barres ne soit
ni trop grand ni trop petit pour être lu par un scanneur.
●
Champs de tri interactifs
Pour afficher le code-barres dans une autre couleur.
Vous pouvez concevoir votre rapport de sorte que les
utilisateurs puissent modifier un champ de tri ou un sens de
tri sans actualiser les informations de la base de données.
Pour ce faire, ajoutez un Contrôle de tri à votre rapport.
Un Contrôle de tri est particulièrement utile pour plusieurs
raisons :
●
Il permet aux utilisateurs de trier les données du rapport
pour une analyse plus approfondie sans quitter la zone
de dessin du rapport.
●
Il élimine la demande de traitement sur la base de
données.
●
Il réduit le temps d'attente des utilisateurs pendant le tri
des données.
●
Il permet aux utilisateurs de trier les champs du rapport,
même s'ils ne disposent pas d'une connexion ou des
droits d'accès à la base de données au moment de
l'affichage.
Workbench
Sur le Workbench, vous pouvez créer des projets contenant
un ou plusieurs rapports. Les options de la barre d'outils vous
permettent d'ajouter, supprimer ou renommer les dossiers,
rapports et packages d'objets. Vous pouvez réorganiser les
fichiers dans un dossier ou des dossiers en les faisant glisser
et en les déposant où vous souhaitez qu'ils apparaissent.
Vous pouvez également faire glisser des fichiers de rapport
de l'Explorateur Windows et les déposer dans le dossier de
votre choix sur le Workbench.
6
1.1.2
Migration de l'application SAP Crystal Reports .Net
Cette section contient des informations sur la migration de l'application SAP Crystal Reports .Net vers
SAP Crystal Reports, version développeur pour Microsoft Visual Studio.
Remarque
SAP Crystal Reports, version développeur pour Microsoft Visual Studio est doté d'un ensemble complet de
fonctionnalités et est disponible en téléchargement gratuit s'intégrant à Visual Studio 2010 ou version
ultérieure. SAP Crystal Reports, version développeur pour Microsoft Visual Studio n'est pas fourni avec
l'application SAP Crystal Reports Designer.
7
Options de migration dans les différentes versions de SAP Crystal Reports
Ce diagramme représente les différents chemins de migration entre les versions de SAP Crystal Reports.
8
Migration vers SAP Crystal Reports, version développeur pour Microsoft
Visual Studio
SAP Crystal Reports, version développeur pour Microsoft Visual Studio met automatiquement à niveau vos
anciens projets vers la version actuelle. Si un projet contient des références à d'anciens composants, l'utilisateur
est invité à effectuer une mise à niveau.
Si vous cliquez sur le bouton Oui, les projets et les fichiers associés sont mis à niveau vers la version actuelle de
SAP Crystal Reports. Si vous cliquez sur le bouton Non, le projet est adapté de manière à utiliser les références
d'origine. Certaines fonctionnalités récentes sont désactivées si elles ne sont pas prises en charge par les
composants plus anciens.
Remarque
Si le fichier de projet (tout fichier ASPX possédant des composants SAP Crystal Reports ou le fichier
web.config) est verrouillé, la mise à niveau ou l'adaptation échoue.
Informations associées
Solutions de reporting de SAP BusinessObjects Business Intelligence [page 65]
1.1.2.1
Problèmes de migration
Un rapport basé sur une source de données ADO.NET ne fonctionnera pas si le
projet vise .NET 4.x Framework
Les rapports basés sur une source de données ADO.NET ne fonctionneront pas si le projet vise .NET 4.x
Framework. L'erreur suivante se produit : "Additional information: Mixed mode assembly is built against version
'v2.0.50727' of the runtime and cannot be loaded in the 4.x runtime without additional configuration information
(Informations complémentaires : la liaison d'assembly en mode mixte a été créée avec la version v2.0.50727 du
programme d'exécution et ne peut pas être chargée dans le programme d'exécution 4.0 sans informations de
configuration supplémentaires)".
Pour résoudre ce problème, vous pouvez mettre à jour le fichier .config de votre projet. Ajoutez les lignes de
code suivantes dans la section <configuration></configuration> du fichier :
<startup useLegacyV2RuntimeActivationPolicy="true">
<supportedRuntime version="v4.x"/>
</startup>
9
1.1.2.2
Limites en 64 bits
L'architecture 64 bits est prise en charge dans SAP Crystal Reports, version développeur pour Microsoft
Visual Studio x 64 (AMD64). Toutefois, l'architecture IA64 (Itanium) n'est pas prise en charge à ce jour.
Fonctionnalités actuellement non prises en charge dans les scénarios 64 bits :
●
Exportation de rapports au format HTML.
●
Composants de création de cartes géographiques.
●
Composants de police de codes à barres Azalea.
1.2
Configuration de l'environnement de développement
Cette section fournit des instructions détaillées sur l'installation et la configuration de votre environnement de
développement, ainsi que sur la création d'un site Web ou d'un projet Windows dans SAP Crystal Reports, version
développeur pour Microsoft Visual Studio.
1.2.1
Configuration du système
Cette section indique comment configurer votre environnement de développement pour tester et développer des
applications Windows ou des sites Web utilisant le SDK de SAP Crystal Reports .NET.
1.2.1.1
Eléments à installer
Vous devez installer SAP Crystal Reports, version développeur pour Microsoft Visual Studio avant de pouvoir
créer des applications Web ou Windows utilisant SAP Crystal Reports.
1.2.1.1.1
Versions de Visual Studio prises en charge
Si vous envisagez d'utiliser SAP Crystal Reports, version développeur pour Microsoft Visual Studio, vérifiez que la
version de Visual Studio que vous avez installée prend en charge SAP Crystal Reports.
Les éditions Visual Studio Ultimate, Premium et Professional sont prises en charge pour Visual Studio 2010 et
ultérieure. Les éditions Visual Studio Express ne sont pas prises en charge par SAP Crystal Reports.
Solutions de reporting de SAP BusinessObjects Business Intelligence [page 65]
10
1.2.1.1.2
Versions SAP Crystal Reports
Plusieurs versions de SAP Crystal Reports sont disponibles. De nombreuses procédures décrites dans ce
document s'appliquent à une version spécifique. Pour utiliser au mieux ce document, déterminez d'abord quelle
version de SAP Crystal Reports est installée sur votre système.
1.2.1.1.2.1
Pour déterminer la version de
SAP Crystal Reports que vous utilisez
Procédure
1.
Accédez au cache GAC (Global Assembly Cache) à l'emplacement C:\WINNT\Assembly ou C:\Windows
\Assembly.
2.
Recherchez le fichier CrystalDecisions.CrystalReports.Engine.
Remarque
Si vous avez installé différentes versions de SAP Crystal Reports, plusieurs versions de ces fichiers se
trouvent dans le Global Assembly Cache. Le fichier CrystalDecisions.CrystalReports.Engine est sélectionné
car il est inclus dans chaque version de SAP Crystal Reports.
3.
Recherchez la colonne Version affichée dans la fenêtre.
Il s'agit de la "version de l'assembly".
4.
Recherchez le numéro d'assembly le plus élevé.
5.
Comparez la version de l'assembly avec le numéro de version indiqué dans le tableau des versions de
1.2.1.1.2.2
Produit
Version de l'assembly
SAP Crystal Reports, version développeur pour Microsoft
Visual Studio (.NET 4.0 Framework)
13.0.2000.0
SAP Crystal Reports 2008 (.NET 2.0 Framework)
12.0.2000.0
SAP Crystal Reports 2008 (.NET 1.1 Framework)
12.0.1100.0
SAP Crystal Reports XI Release 2
11.5.3300.0
SAP Crystal Reports XI Release 1
11.0.3300.0
SAP Crystal Reports Basic pour Visual Studio 2008
10.5.3600.0
SAP Crystal Reports pour Visual Studio 2005
10.2.3600.0
11
Produit
Version de l'assembly
SAP Crystal Reports 10
10.0.3300.0
SAP Crystal Reports 9
9.2.3300
SAP Crystal Reports pour Visual Studio 2003
9.1.5000
SAP Crystal Reports 2008 et SAP Crystal Reports 2008 SP1 utilisent le même numéro de version d'assembly. Si
SAP Crystal Reports 2008 SP1 est installé, la version du fichier doit commencer par 12.1 et non par 12.0.
1.2.1.1.3
Installation du service de mise à jour de
SAP Crystal Reports
Contexte
SAP Crystal Reports, version développeur pour Microsoft Visual Studio fournit désormais en option un service de
mise à jour de SAP Crystal Reports qui recherche les mises à jour et les correctifs de SAP Crystal Reports.
Le service de mise à jour de SAP Crystal Reports, version développeur pour Microsoft Visual Studio n'est pas
fourni en tant que composant du programme d'installation. Vous devez le télécharger et l'installer séparément.
Procédure
1.
Après avoir installé SAP Crystal Reports, version développeur pour Microsoft Visual Studio, démarrez
Visual Studio et créez un site Web ou un projet Windows.
2.
Dans l'Explorateur de solutions, cliquez avec le bouton droit de la souris sur le nom de projet affiché en gras,
puis cliquez sur
Ajouter
Nouvel élément .
3.
Dans la boîte de dialogue Ajouter un nouvel élément, sélectionnez Rapport Crystal.
4.
Dans le champ Nom, saisissez Test.rpt, puis cliquez sur Ajouter.
Remarque
Si vous utilisez le SAP Crystal Report Designer incorporé pour la première fois, un message vous invite à
accepter les termes du Contrat de licence utilisateur. Ensuite, la boîte de dialogue Service de mise à jour
s'ouvre. Si vous avez déjà utilisé le SAP Crystal Report Designer incorporé auparavant, vous devrez ouvrir
la boîte de dialogue Service de mise à jour manuellement.
Le SAP Crystal Reports Designer incorporé s'ouvre et affiche le nouveau rapport.
5.
Si la boîte de dialogue Service de mise à jour n'apparaît pas, cliquez sur Rechercher les mises à jour dans le
menu Crystal Reports.
Si le service de mise à jour de SAP Crystal Reports n'est pas installé, un message vous invite à le faire.
6.
Dans la boîte de dialogue Service de mise à jour, cliquez sur Oui.
Le site Web du service de mise à jour de SAP Crystal Reports s'affiche avec un lien permettant de télécharger
ce service.
12
7.
Téléchargez et installez le service de mise à jour de SAP Crystal Reports.
8.
Démarrez à nouveau Visual Studio.
9.
Ouvrez Test.rpt.
Le SAP Crystal Report Designer incorporé démarre et affiche le rapport.
10. Dans le menu Crystal Reports, cliquez sur Rechercher les mises à jour.
Le service de mise à jour démarre et recherche les mises à jour. Vous pouvez accepter ou refuser toutes les
mises à jour disponibles.
1.2.1.1.4
Code clé de produit SAP Crystal Reports
Le code clé consiste en une chaîne alphanumérique comportant 19 chiffres ou caractères. Dans
SAP Crystal Reports, version développeur pour Microsoft Visual Studio, lorsque vous créez des projets de
déploiement utilisant le programme Windows Installer, il peut être nécessaire d'indiquer un code clé de produit
pour valider les informations de licence des applications Web ou Windows.
1.2.1.2
Eléments à vérifier
Pour développer un site Web ou une application Windows qui utilise le SDK de SAP Crystal Reports .NET, vous
devez vérifier que les composants de Crystal Reports Developer ont été correctement installés et intégrés à
Visual Studio. Pour développer un site Web, vous devez également vérifier que le répertoire virtuel des
visualiseurs a été correctement installé sur les serveurs Web de développement et de déploiement.
Cette section détaille les paramètres à vérifier avant la création d'une application SAP Crystal Reports .NET.
Versions de Visual Studio prises en charge [page 10]
1.2.1.2.1
Vérification de l'installation de SAP Crystal Reports
Contexte
Pour vérifier que le composant SAP Crystal Reports de Visual Studio est installé, assurez-vous que son nom est
affiché dans la boîte de dialogue Ajouter un nouvel élément de l'application Visual Studio.
13
Procédure
1.
Lancez Visual Studio.
2.
Créez un projet Web ou Windows (dans le langage de votre choix), ou ouvrez un projet Web ou Windows
existant.
3.
Dans le menu Projet, cliquez sur Ajouter un nouvel élément.
Remarque
Les nouveaux fichiers de rapport doivent être ajoutés directement à un projet. Vous ne pouvez pas créer un
rapport Crystal dans Visual Studio via le menu Fichier.
4.
Dans la boîte de dialogue Ajouter un nouvel élément, faites défiler la liste des éléments disponibles pour
vérifier que Crystal Reports y figure bien.
1.2.1.2.2
Répertoire des visualiseurs
SAP Crystal Reports utilise un répertoire virtuel pour accéder aux visualiseurs à afficher. Le nom du répertoire
virtuel et le chemin d'accès aux fichiers associés diffèrent dans chaque version de SAP Crystal Reports. Cela évite
les risques de conflit si vous installez plusieurs versions de SAP Crystal Reports sur le même ordinateur.
1.2.1.2.2.1
Emplacement par défaut du répertoire virtuel des
visualiseurs
Si vous avez installé SAP Crystal Reports avec les paramètres et chemins d'accès par défaut, les visualiseurs se
trouvent dans le répertoire virtuel indiqué ci-dessous.
Version
Structure
SAP Crystal Reports, 4.x Framework
version développeur
pour Microsoft Vi
sual Studio
Chemin d'accès
Chemin d'accès au fichier lors de l'utilisation du serveur de déve
loppement ASP.NET :
\Windows\Microsoft.NET\Framework
\v4.0.30319\ASP.NETClientFiles
\crystalreportviewers13
Chemin d'accès au fichier lors de l'utilisation d'IIS :
\inetpub\wwwroot\aspnet_client\system_web
\4_0_30319\crystalreportviewers13
SAP Crystal Reports, 2.0 Framework
version développeur
pour Microsoft Vi
sual Studio
14
Chemin d'accès au fichier lors de l'utilisation du serveur de déve
loppement ASP.NET :
Version
Structure
Chemin d'accès
\Windows\Microsoft.NET\Framework
\v2.0.50727\ASP.NETClientFiles
\crystalreportviewers13
Chemin d'accès au fichier lors de l'utilisation d'IIS :
\inetpub\wwwroot\aspnet_client\system_web
\2_0_50727\crystalreportviewers13
1.2.1.2.2.2
Pour rechercher le répertoire des visualiseurs
Procédure
1.
Dans le Panneau de configuration, cliquez deux fois sur Outils d'administration, puis sur Internet Information
Services.
2.
Dans la boîte de dialogue Internet Information Services, développez le nœud Site Web, puis le nœud Site Web
par défaut.
3.
Localisez tous les dossiers contenant un dossier crystalreportsviewers13.
4.
Cliquez avec le bouton droit de la souris sur chaque dossier crystalreportsviewers13, puis sélectionnez
Propriétés.
5.
Dans la boîte de dialogue Propriétés, vérifiez que le chemin d'accès local est correctement configuré pour
votre version de SAP Crystal Reports ou de Visual Studio.
1.2.1.2.3
Répertoire d'exemples de rapports
Certains exemples de fonctionnalités, scénarios de liaison de rapports et tutoriels reposent sur des exemples de
rapports fournis avec SAP Crystal Reports.
Vous pouvez télécharger les exemples de rapports à partir de l'adresse suivante : http://
www.sdn.sap.com/irj/boc/downloads
1.2.2
Configuration d'un projet
Cette section présente des informations essentielles pour les développeurs ayant un niveau avancé ou
intermédiaire. Elle indique les meilleures pratiques à suivre pour créer et configurer un projet Windows ou un
projet/site Web à l'aide de SAP Crystal Reports, version développeur pour Microsoft Visual Studio.
En outre, le projet que vous allez créer sera utilisé dans les tutoriels présentés dans cette aide en ligne.
15
1.2.2.1
Configuration d'un site Web dans Visual Studio
Cette section décrit la configuration d'un site Web dans Visual Studio. Le site Web que vous allez ainsi créer
servira de prérequis aux tutoriels de programmation classique fournis dans cette aide en ligne.
1.2.2.1.1
Création d'un site Web dans Visual Studio
Procédure
1.
2.
Dans le menu Fichier, sélectionnez Nouveau Site Web.
3.
Dans la boîte de dialogue Nouveau site Web, cliquez sur Site Web ASP.NET.
4.
Dans la liste déroulante Emplacement, sélectionnez Système de fichiers.
5.
Dans la liste déroulante Langage, sélectionnez le langage de programmation que vous souhaitez utiliser.
6.
Dans le champ de texte Emplacement, saisissez le chemin d'accès du répertoire C:\WebSites\, suivi du nom
de votre projet.
C:\WebSites\NomMonProjet
7.
Cliquez sur OK.
1.2.2.1.2
1.2.2.1.2.1
Préparation du Web Form
Pour créer le Web Form
Contexte
Dans cette section, vous allez configurer la classe code-behind pour le Web Form.
Remarque
Les termes "Web Form", "page ASPX" et "Default.aspx" sont utilisés de manière interchangeable.
Procédure
1.
Dans l'Explorateur de solutions, cliquez deux fois sur le fichier Default.aspx pour ouvrir le Web Form.
2.
Dans le menu Affichage, cliquez sur Code.
16
La classe code-behind s'ouvre. Cette classe s'appelle classe _Default. Le fichier de classe s'appelle
Default.aspx.cs ou Default.aspx.vb.
Remarque
Si votre page Default.aspx a été créée avec un code incorporé, son code n'a pas été placé dans un fichier
séparé. Dans ce cas, supprimez la page ASPX et recréez-la. Lorsque vous créez la page ASPX, activez la
case à cocher "Placer le code dans un fichier distinct".
3.
Si vous écrivez cette classe en langage Visual Basic, tapez "Option Strict On" au début de la classe.
Remarque
Il est recommandé de définir Option Strict sur On au début de chaque classe Visual Basic de votre site
Web. Ainsi, vous serez tenu de respecter les conventions d'écriture du code, à savoir l'emploi de
déclarations de variables fortement typées et la définition d'un cast valide, deux conventions qui sont
vérifiées au moment de la compilation du code. Cette précaution aide à réduire les exceptions générées à
l'exécution du code.
1.2.2.1.2.2
Pour ajouter des instructions Imports et Using
aux espaces de noms de référence
Procédure
1.
Ouvrez la page Default.aspx.
2.
La classe code-behind du Web Form s'affiche.
3.
Au-dessus de la signature de classe, ajoutez une déclaration "Imports" [Visual Basic] ou "using" [C#] au
début de la classe contenant les espaces de noms SAP Crystal Reports suivants.
Imports CrystalDecisions.CrystalReports.Engine
Imports CrystalDecisions.Shared
using CrystalDecisions.CrystalReports.Engine;
using CrystalDecisions.Shared;
Remarque
Les classes de ces deux assemblies sont couramment utilisées dans tous les tutoriels. En ce qui concerne
les assemblies supplémentaires dont vous pourriez avoir besoin dans des tutoriels spécifiques, vous
trouverez des instructions pour les ajouter tout au long de ce tutoriel.
17
1.2.2.1.2.3
Pour ajouter une méthode d'assistance privée
pour le code de configuration de SAP Crystal Reports
Procédure
Dans la classe, ajoutez une nouvelle méthode d'assistance privée nommée ConfigureCrystalReports(),
sans valeur renvoyée.
Private Sub ConfigureCrystalReports()
End Sub
private void ConfigureCrystalReports()
{
}
La méthode ConfigureCrystalReports() permet aux utilisateurs d'interagir avec le rapport au moment
de l'exécution. De plus, elle contrôle l'interaction par programme avec le rapport.
Étapes suivantes
Ensuite, vous allez ajouter un gestionnaire d'événements Page_Init à partir duquel appeler la méthode
ConfigureCrystalReports(). Le fait d'appeler la méthode ConfigureCrystalReports() à partir de ce
gestionnaire d'événements garantit que le code de configuration du rapport Crystal s'exécutera durant
l'événement d'initialisation de la page.
1.2.2.1.2.4
Pour ajouter un gestionnaire d'événements
Page_Init à la classe code-behind
Contexte
Généralement, le gestionnaire d'événements Page_Load permet de saisir le code de configuration du Web Form
dans une application Web ASP.NET de manière à ce que ce programme soit appelé pendant l'événement
Page.Load. Mais le code de configuration du rapport Crystal doit être appelé plus tôt, pendant l'événement
Page.Init.
Procédure
1.
Ajoutez l'événement Page_Init à votre code.
18
○
Si vous codez dans Visual Basic, sélectionnez Page Events dans la liste déroulante supérieure gauche et
l'événement Init dans la liste déroulante supérieure droite. Le gestionnaire d'événements Page_Init
sera ajouté à votre classe code-behind.
Private Sub Page_Init(ByVal sender As Object, ByVal e As System.EventArgs)
Handles Me.Init
End Sub
○
Si vous codez en C#, saisissez le gestionnaire d'événements Page_Init à l'aide de la syntaxe exacte
indiquée.
private void Page_Init(object sender, EventArgs e)
{
}
Remarque
Dans un Web Form C# de Visual Studio 2005 ou version suivante, les gestionnaires d'événements
Page_Init, Page_Load ou Page_PreRender de la classe code-behind sont connectés
automatiquement à l'événement Init, Load ou PreRender. La signature de gestionnaire d'événements
doit correspondre exactement pour pouvoir être appelée.
Cette fonctionnalité est disponible lorsque le paramètre AutoEventWireup de la directive Page, qui se
trouve au début de la page ASPX en mode HTML, est défini sur True.
Les versions précédentes de Visual Studio .NET définissaient toujours la directive Page
AutoEventWireup sur False, mais dans les Web Form C# de Visual Studio 2005 ou version suivante,
la directive Page AutoEventWireup est définie sur True par défaut.
2.
dans le gestionnaire d'événements Page_Init de Visual Basic ou C#, ajoutez un appel à la méthode
d'assistance ConfigureCrystalReports().
ConfigureCrystalReports()
ConfigureCrystalReports();
3.
Dans le menu Fichier, cliquez sur Enregistrer tout.
1.2.2.1.3
site Web
Pour ajouter un contrôle CrystalReportViewer à un
Procédure
1.
2.
Cliquez sur le bouton Design au bas du formulaire.
19
3.
Dans la Boîte à outils, ouvrez le nœud Reporting afin de localiser le contrôle CrystalReportViewer.
Remarque
Dans les versions précédentes de SAP Crystal Reports, version développeur pour Microsoft Visual Studio,
le contrôle CrystalReportViewer apparaissait dans le nœud Crystal Reports.
4.
Faites glisser le contrôle CrystalReportViewer sur le Web Form.
5.
Résultats
Si vous ajoutez un contrôle CrystalReportViewer à votre application, les références aux assemblies
SAP Crystal Reports seront automatiquement ajoutées à votre rapport.
1.2.2.1.4
Configuration du fichier Web.Config
Un fichier Web.Config dans une application Web ASP.NET stocke les paramètres globaux, tels que les
informations de connexion à la base de données, les références d'assembly et la gestion des erreurs. Ce fichier est
écrit en langage XML et son élément racine doit toujours être <configuration>. Il s'agit d'une configuration
avancée qui est facultative.
Les éléments suivants sont spécifiques à SAP Crystal Reports et peuvent être ajoutés à votre fichier Web.Config.
Remarque
Les numéros de version peuvent changer en fonction du produit dont vous disposez.
Remarque
Dans .NET 2.0 et versions ultérieures, la balise section du fichier Web.Config doit utiliser la syntaxe suivante :
<configSections>
<sectionGroup name="businessObjects">
<sectionGroup name="crystalReports">
<section name="printControl"
type="System.Configuration.NameValueSectionHandler" />
</sectionGroup>
</sectionGroup>
</configSections>
CrystalImageCleaner
Le processus CrystalImageCleaner supprime automatiquement les images générées dynamiquement
rendues par le contrôle CrystalReportViewer. Ce paramètre vous permet de définir l'intervalle entre les analyses
20
du répertoire d'images et l'âge minimal des fichiers avant suppression. Cet élément est automatiquement ajouté
au fichier Web.Config lorsque vous ajoutez le contrôle CrystalReportViewer à votre site Web. Il correspond à la
classe CrystalImageCleaner.
●
CrystalImageCleaner-Sleep initialise la durée en millisecondes pendant laquelle le nettoyeur d'image
reste en veille avant d'analyser et de nettoyer les fichiers image dans le répertoire des images dynamiques.
●
CrystalImageCleaner-Age initialise l'âge minimal d'un fichier, en millisecondes, avant sa suppression.
●
CrystalImageCleaner-AutoStart contrôle le processus CrystalImageCleaner. Le nettoyeur d'image
nettoie les images temporaires qui sont créées lors de la visualisation d'un rapport.
Remarque
Un seul nettoyeur d'image peut être démarré dans un processus de traitement ASP.NET unique.
<appSettings>
<add key="CrystalImageCleaner-AutoStart" value="true" />
<add key="CrystalImageCleaner-Sleep" value="60000" />
<add key="CrystalImageCleaner-Age" value="120000" />
</appSettings>
CrystalImageHandler
L'élément CrystalImageHandler affiche toutes les images dynamiques dans le contrôle CrystalReportViewer.
Ce paramètre configure le processus de traitement ASP.NET pour rediriger les requêtes adressées à
CrystalImageHandler.aspx vers une classe de traitement d'image interne uniquement. Si le paramètre
CrystalImageHandler ne figure pas dans votre fichier Web.Config, les images de votre site Web ne
s'afficheront pas. Cet élément est automatiquement ajouté au fichier Web.Config lorsque vous ajoutez le contrôle
CrystalReportViewer à votre site Web.
<system.web>
<httpHandlers>
<add verb="GET" path="CrystalImageHandler.aspx"
type="CrystalDecisions.Web.CrystalImageHandler, CrystalDecisions.Web,
Version=13.0.2000.0, Culture=neutral, PublicKeyToken=692fbea5521e1304"/>
</httpHandlers>
</system.web>
documentView
L'élément documentView contrôle l'apparence du rapport dans la trame du rapport. Deux paramètres sont
fournis :
●
Si la valeur est définie sur printlayout, une bordure grise s'affiche autour du rapport et une ombre portée
s'affiche dans la trame. Il s'agit de la valeur par défaut.
21
●
Si la valeur est définie sur weblayout le rapport remplit la trame.
<configSections>
<section name="crystalReportViewer"
</sectionGroup>
</sectionGroup>
</configSections>
<businessObjects>
<crystalReports>
<crystalReportViewer>
<add key="documentView" value="weblayout"/>
</crystalReportViewer>
</crystalReports>
</businessObjects>
EnableTextClipping
L'élément EnableTextClipping contrôle si le texte du champ est tronqué. Une fois défini sur true, le texte
contenu dans un champ ne chevauchera pas le texte dans le champ situé en regard..
<configSections>
</sectionGroup>
</sectionGroup>
</configSections>
<businessObjects>
<crystalReports>
<add key="EnableTextClipping" value="true"/>
</crystalReports>
</businessObjects>
globalResourcePath
L'élément globalResourcePath est la référence au chemin du répertoire de fichiers pour les ressources
globales. Ce répertoire de fichiers contient vos ressources de langue personnalisées dans un emplacement
central et peut être partagé par plusieurs applications Web. Ce paramètre vous permet d'accéder aux ressources
globales d'un site Web spécifique. Dans SAP CrystalReports.NET, les fichiers de ressources par défaut ne sont
pas fournis lors de l'installation du produit, mais peuvent être téléchargés à partir du site Web de support
technique de SAP BusinessObjects : http://help.sap.com. Cet élément doit être manuellement ajouté au fichier
Web.Config de votre site Web.
<appSettings>
22
<add key="globalResourcePath" value="c:\CrystalReportViewer_resource_files\"/>
</appSettings>
maxNumberListOfValues
L'élément maxNumberListOfValues contrôle le nombre d'éléments LOV qui seront envoyés au client. Contrôle
le nombre de valeurs affichées dans le panneau des paramètres. Si cette valeur est définie, seules les n premières
valeurs apparaissent dans la liste de valeurs. La boîte de dialogue Paramètres avancés permet de paginer
plusieurs ensembles de valeurs en fonction de la taille de la liste et de la valeur de l'élément
maxNumberListOfValues. Si vous disposez, par exemple, de 180 valeurs et que vous définissez l'élément
maxNumberListOfValues sur 50, vous pourrez afficher les 50 premières valeurs du panneau des paramètres.
Vous pourrez paginer les 180 valeurs dans la boîte de dialogue Paramètres avancés et afficher ainsi trois groupes
de 50 valeurs et un groupe de 30 valeurs.
Il est recommandé de définir systématiquement une valeur supérieure à 0. La valeur par défaut est 200.
<configSections>
</sectionGroup>
</sectionGroup>
</configSections>
<businessObjects>
<crystalReports>
<add key="maxNumberListOfValues" value="50"/>
</crystalReports>
</businessObjects>
printControl
L'élément printControl vous permet d'imprimer le rapport directement sur votre imprimante locale. Le
répertoire d'installation par défaut est C:\Program Files (x86)\SAP BusinessObjects\Crystal
Reports for .NET Framework 4.0\Common\Crystal Reports 2011\crystalreportviewers.
Ce paramètre rend le fichier .cab visible par votre site Web .NET SAP Crystal Reports. Cet élément doit être
manuellement ajouté au fichier Web.Config de votre site Web.
<configSections>
</sectionGroup>
</sectionGroup>
</configSections>
23
<businessObjects>
<crystalReports>
<printControl>
<add key="url" value="http://localhost/PrintControl.cab" />
</printControl>
</crystalReports>
</businessObjects>
processingIndicatorDelay
L'élément processingIndicatorDelay contrôle le délai préalable à l'apparition de l'indicateur de traitement de
rapport. La valeur est spécifiée en millisecondes. Le fait de définir cette valeur sur 0 désactive l'indicateur de
traitement de rapport. La valeur par défaut est de 200 ms.
<configSections>
</sectionGroup>
</sectionGroup>
</configSections>
<businessObjects>
<crystalReports>
<add key="processingIndicatorDelay" value="20"/>
</crystalReports>
</businessObjects>
processingIndicatorText
L'élément processingIndicatorText contrôle le texte affiché dans l'indicateur de traitement de rapport. Le
texte par défaut est : Veuillez patienter pendant le traitement du document.
<configSections>
</sectionGroup>
</sectionGroup>
</configSections>
<businessObjects>
<crystalReports>
<add key="processingIndicatorText" value="Thank you for waiting."/>
</crystalReports>
</businessObjects>
24
reportMappings
L'élément reportMappings met à jour les sites Web créés dans Visual Studio 2003 qui utilisent des rapports
incorporés et les convertit en sites Web non incorporés lorsqu'ils sont ouverts dans Visual Studio 2005 ou version
suivante. Ce paramètre convertit le fichier .dll créé dans Visual Studio 2003 en fichier disque. Visual Studio 2005
et 2008 ne prennent pas en charge les sites Web incorporés et vous devez donc modifier votre fichier Web.Config
pour vous assurer que votre rapport sera toujours fonctionnel avec la nouvelle version de Visual Studio. Cet
élément doit être manuellement ajouté au fichier Web.Config de votre site Web. Le paramètre reportMappings
nécessite un chemin absolu.
Remarque
Cet élément est valide pour Visual Studio 2005 et Visual Studio 2008 uniquement.
<configSections>
<section name="reportMappings"
type="CrystalDecisions.Shared.ReportMappingHandler" />
</sectionGroup>
</sectionGroup>
</configSections>
<businessObjects>
<crystalReports>
<reportMappings>
<add reportName="World Sales Report.rpt" path="C:\Report\World Sales
Report.rpt" />
</reportMappings>
</crystalReports>
</businessObjects>
resourceURI
L'élément resourceURI définit l'emplacement du répertoire crystalreportviewers dans l'application Web.
Le répertoire crystalreportviewers contient tous les fichiers requis par le visualiseur.
<configSections>
</sectionGroup>
</sectionGroup>
</configSections>
<businessObjects>
<crystalReports>
<add key="resourceURI" value="~/crystalreportviewers12" />
</crystalReports>
</businessObjects>
25
serverFileReportManager
L'élément serverFileReportManager est un service Web qui énumère les fichiers serveur situés sur le serveur.
Ce paramètre vous permet d'obtenir une liste d'objets (dossiers et rapports) depuis un ordinateur distant. Il a
pour valeur la racine du répertoire de fichiers du serveur. Dans cet exemple, la racine définie est c:\inetpub
\wwroot. Cet élément doit être manuellement ajouté au fichier Web.Config de votre site Web.
Remarque
Il correspond à la classe serverFileReportManager.
<configSections>
<sectionGroup name="crystalDecisions">
<section name="serverFileReportManager"
</sectionGroup>
</configSections>
<crystalDecisions>
<serverFileReportManager>
<add key="rootDirectory" value="c:\inetpub\wwwroot" />
</serverFileReportManager>
</crystalDecisions>
UseAsynchronousRequests
Les requêtes asynchrones sont autorisées par défaut dans le visualiseur DHTML. Pour activer le bouton Retour
dans le navigateur afin d'utiliser le visualiseur DHTML, vous devez désactiver les requêtes asynchrones en
définissant ce paramètre sur false.
Remarque
Il est recommandé de ne pas définir l'élément UseAsynchronousRequests sur false. Cette action désactive
en effet la boîte de dialogue Paramètres avancés dans le panneau des paramètres ainsi que certaines
améliorations au niveau de la performance du visualiseur et certaines fonctionnalités qui permettent
d'améliorer l'apparence.
<context-param>
<param-name>crystal_use_asynchronous_requests</param-name>
<param-value>false</param-value>
</context-param>
UseBrowserLocale
L'élément UseBrowserLocale extrait les paramètres de langue de votre navigateur pour le contrôle
CrystalReportViewer. Lorsqu'il est défini sur true, ce paramètre configure le contrôle CrystalReportViewer pour
observer les paramètres régionaux du navigateur. Lorsqu'il est défini sur false, il limite les paramètres régionaux
26
qui sont affichés page par page. Cet élément doit être manuellement ajouté au fichier Web.Config de votre site
Web.
<configSections>
</sectionGroup>
</sectionGroup>
</configSections>
<businessObjects>
<crystalReports>
<add key="UseBrowserLocale" value="true" />
</crystalReports>
</businessObjects>
Exemple
Exemple de fichier Web.Config
<?xml version="1.0"?>
<configuration>
<appSettings>
<add key="CrystalImageCleaner-AutoStart" value="true"/>
<add key="CrystalImageCleaner-Sleep" value="60000"/>
<add key="CrystalImageCleaner-Age" value="120000"/>
</appSettings>
<connectionStrings/>
<system.web>
<compilation debug="true">
<assemblies>
<add assembly="CrystalDecisions.Web, Version=13.0.2000,
Culture=neutral, PublicKeyToken=692FBEA5521E1304"/>
<add assembly="CrystalDecisions.Shared, Version=13.0.2000,
<add assembly="CrystalDecisions.ReportSource, Version=13.0.2000,
<add assembly="CrystalDecisions.CrystalReports.Engine,
Version=13.0.2000, Culture=neutral, PublicKeyToken=692FBEA5521E1304"/>
</assemblies>
</compilation>
<authentication mode="Windows"/>
<httpHandlers>
</httpHandlers>
</system.web>
</configuration>
Impression
27
Web : configuration de la localisation basée sur le navigateur
Web : configuration des ressources personnalisées globales ou locales
Comment ajouter ou supprimer des références dans Visual Studio
1.2.2.2
Configuration d'un projet Windows dans
Visual Studio
Cette section présente des informations essentielles pour les développeurs ayant un niveau avancé ou
intermédiaire. Elle indique les méthodes à suivre pour créer et configurer un projet Windows à l'aide de
La configuration d'un projet Windows présentée dans cette section fait appel à un modèle de programmation
classique. Au cours de cette procédure, vous serez amené à accéder à la classe Form1 et à entrer du code. Ce
projet Windows que vous allez ainsi créer servira de condition prérequise aux tutoriels de programmation
classique fournis dans cette aide en ligne.
1.2.2.2.1
Création d'un projet Windows dans Visual Studio
Procédure
1.
2.
Dans le menu Fichier, sélectionnez Nouveau, puis cliquez sur Projet.
3.
Dans la boîte de dialogue Nouveau projet, dans la liste Types de projets, sélectionnez un dossier de langage
pour C# ou Visual Basic.
4.
Dans la liste Modèles, cliquez sur Application Windows Forms.
5.
Dans le champ Nom, remplacez le nom de projet par défaut par le nom de votre projet.
Respectez la convention d'affectation de noms Pascal selon laquelle la première lettre du nom du projet doit
être une majuscule car le nom du projet sera également utilisé comme nom de l'espace de noms de
l'assembly généré à partir du projet.
6.
28
Cliquez sur OK.
1.2.2.2.2
Application des paramètres de projet Visual Basic
standard (facultatif)
Contexte
Pour configurer un projet Visual Basic de manière à pouvoir l'utiliser avec les tutoriels fournis dans cette
documentation, vous devez apporter une modification mineure à ses paramètres.
Procédure
1.
Dans l'Explorateur de solutions, cliquez avec le bouton droit de la souris sur le nom du projet en gras affiché
sous le nom de la solution, puis sélectionnez Propriétés.
2.
Dans la vue Propriétés, cliquez sur l'onglet Compiler.
3.
Dans la liste Option Strict, cliquez sur On.
4.
Fermez la vue Propriétés.
5.
Remarque
Il est recommandé d'activer OptionStrict dès le début de la création d'un projet Visual Basic. Ainsi, vous
serez tenu de respecter les conventions d'écriture du code, à savoir l'emploi de déclarations de variables
fortement typées et la définition d'un cast valide, deux conventions qui sont vérifiées au moment de la
compilation du code. Cette précaution aide à réduire les exceptions générées à l'exécution du code.
1.2.2.2.3
1.2.2.2.3.1
Préparation du Windows Form dans Visual
Pour créer le Windows Form
Contexte
Dans les applications Visual Basic 6 pour Windows, un formulaire par défaut est généralement toujours défini par
le nom Form1. Sur ce modèle, vous créez un projet Windows en lui attribuant le même nom de formulaire par
défaut, Form1, et l'extension .cs ou .vb selon le langage utilisé.
Procédure
1.
Si le formulaire Form1 n'est pas affiché dans la fenêtre principale, cliquez deux fois sur Form1 dans
l'Explorateur de solutions.
29
Le formulaire Form1 s'ouvre dans le Designer.
2.
Le mode code de la classe Form1 s'affiche. Il varie selon que votre application Windows est écrite en langage
Visual Basic ou C#.
En langage C#, la classe Form1 affiche les éléments suivants :
○
La signature de classe.
○
Un constructeur (Form1).
En langage Visual Basic, la classe Form1 affiche les éléments suivants :
○
La signature de classe (classe Form1).
Remarque
Des méthodes et variables supplémentaires de la classe Form1 sont contenues dans une classe
"partielle" séparée. (Ceci vaut pour C# et Visual Basic.) Les classes partielles sont expliquées
ultérieurement dans Configuration d'un projet Windows.
1.2.2.2.3.2
Pour ajouter une méthode d'assistance privée
pour le code de configuration de SAP Crystal Reports
Procédure
1.
Ajoutez à cette classe Form1 une nouvelle méthode d'assistance privée nommée
ConfigureCrystalReports(), sans valeur renvoyée.
End Sub
{
}
Ajoutez ensuite un gestionnaire d'événements Form_Load, puis insérez un appel de la méthode
ConfigureCrystalReports() dans le gestionnaire d'événements Form_Load. La méthode
ConfigureCrystalReports() s'exécutera ainsi automatiquement lors du chargement du formulaire.
2.
Dans le menu Affichage, cliquez sur Concepteur.
3.
Cliquez deux fois sur Form1.
Vous repassez en mode code. Comme vous avez cliqué deux fois sur Form1, un gestionnaire d'événements
Form1_Load est automatiquement généré dans la classe Form1.
4.
Dans le gestionnaire d'événements Form1_Load, saisissez un appel à la méthode
ConfigureCrystalReports().
30
5.
1.2.2.2.4
Ajout d'un contrôle CrystalReportViewer
1.2.2.2.4.1
Pour ajouter un contrôle CrystalReportViewer à
une application Windows
Procédure
1.
Ouvrez un Windows Form dans l'onglet Conception.
2.
Remarque
Dans les versions précédentes de Visual Studio, le contrôle CrystalReportViewer apparaissait dans le
nœud Crystal Reports.
3.
Faites glisser le contrôle CrystalReportViewer sur le formulaire.
4.
Résultats
1.2.2.2.4.2
Pour ajouter des instructions Imports et Using
aux espaces de noms de référence
Procédure
1.
Si le dossier Références n'est pas affiché dans l'Explorateur de solutions, cliquez sur Afficher tous les fichiers
dans la barre d'outils de l'Explorateur de solutions afin d'afficher tous les fichiers de projet.
2.
Dans l'Explorateur de solutions, développez le dossier Références.
3.
Vérifiez que les assemblies SAP Crystal Reports suivantes ont été ajoutées :
○
CrystalDecisions.CrystalReports.Engine
○
CrystalDecisions.Shared
31
4.
Sélectionnez Form1, puis dans le menu Affichage, cliquez sur Code.
5.
début de la classe contenant les espaces de noms SAP Crystal Reports suivants.
1.3
Principes fondamentaux du SDK
1.3.1
1.3.1.1
Architecture
Choisir le modèle d'objet correct pour votre projet
Pour choisir le modèle d'objet approprié à votre projet, vous devez comprendre les conventions relatives à
l'utilisation du contrôle CrystalReportViewer, ainsi que la manière dont ce contrôle interagit avec les autres
modèles d'objet.
Remarque
Dans cette documentation, un modèle d'objet fait référence à une classe principale et aux classes qui lui sont
associées, le tout formant un modèle de programmation. Dans SAP Crystal Reports, ces modèles d'objet sont
axés sur une classe principale qui encapsule un fichier de définition de rapport. Cette classe principale et le
modèle d'objet associé permettent d'interagir avec le rapport en le programmant.
Conventions relatives à l'utilisation du contrôle CrystalReportViewer
Une application Web efficace établit une séparation nette entre sa couche présentation et sa couche logique
métier sous-jacente.
La structure du contrôle ASP.NET va naturellement dans le sens de ce modèle de conception. Il encapsule les
informations de présentation dans le contrôle, puis lie ce contrôle à un objet ou un modèle d'objet sous-jacent qui
crée la logique métier.
CrystalReportViewer est un contrôle .NET conforme à cette architecture. Il fonctionne comme un objet
d'affichage dans le Web Form ou le Windows Form (couche présentation) et peut être lié à n'importe lequel des
modèles d'objet suivants :
●
Modèle d'objet ReportDocument
●
Modèle d'objet ReportClientDocument (Report Application Server)
32
●
Modèle d'objet InfoObject (fourni avec SAP Crystal Reports Server ou la plateforme SAP BusinessObjects
Business Intelligence)
Dans un scénario qui respecte les conventions, le contrôle CrystalReportViewer se lie à l'un des modèles d'objet
qui créent la logique métier, généralement pour la manipulation des rapports.
Dans ce scénario, l'interaction par programmation du contrôle CrystalReportViewer se limite à modifier les
paramètres d'affichage (masquer ou afficher la barre d'outils du visualiseur ou l'un des boutons qui la composent
par exemple).
Modèle d'objet CrystalReportViewer
Le contrôle CrystalReportViewer contient des propriétés et des méthodes qui permettent d'interagir sur la
manière dont ce dernier affiche les rapports. Il comporte également un petit nombre de propriétés et de
méthodes qui permettent d'interagir avec les rapports auxquels il est lié. Ces propriétés et méthodes constituent
un modèle d'objet limité.
Certains scénarios de liaison de rapports font appel au modèle d'objet CrystalReportViewer. Dans ces scénarios,
le contrôle CrystalReportViewer est directement lié à un rapport (en indiquant le chemin d'accès au rapport dans
un répertoire de fichiers par exemple) sans avoir préalablement encapsulé ce rapport dans un modèle d'objet.
Dans ce cas, étant donné que le contrôle CrystalReportViewer encapsule directement le rapport, vous devez
utiliser son modèle d'objet limité pour interagir avec le rapport.
Toutefois, dans la plupart des scénarios de liaison de rapports, l'utilisation de CrystalReportViewer en tant que
modèle d'objet est déconseillée. Il est préférable de faire appel au modèle d'objet ReportDocument pour les
raisons suivantes :
●
Le modèle d'objet CrystalReportViewer peut engendrer des conflits entre modèles d'objet. Ne mélangez pas
le modèle d'objet CrystalReportViewer avec d'autres modèles d'objet.
●
Le modèle d'objet CrystalReportViewer ne permet qu'une interaction limitée avec les rapports. Il ne contient
que quelques-uns unes des fonctionnalités disponibles dans le modèle d'objet ReportDocument.
●
Dans le modèle d'objet CrystalReportViewer, la séparation entre la couche présentation et la logique métier
sous-jacente n'est pas clairement établie.
ReportDocument est un modèle d'objet plus puissant et plus complet que CrystalReportViewer. Il fait partie du
SDK de Crystal Reports .NET et permet une manipulation étendue du code des rapports.
Quel modèle d'objet utiliser ?
Si vous n'envisagez pas de mise à niveau vers SAP Crystal Reports Server ou vers la plateforme SAP
BusinessObjects Business Intelligence, il est recommandé d'utiliser le modèle d'objet ReportDocument pour vos
tâches de développement avec le SDK de SAP Crystal Reports.
33
Remarque
Dans SAP Crystal Reports 10 ou versions ultérieures et dans SAP Crystal Reports pour Visual Studio 2005 et
versions ultérieures, le modèle d'objet ReportDocument a été associé au modèle d'objet
ReportClientDocument pour faciliter la mise à niveau vers une solution de reporting gérée.
1.3.1.2
Eviter de mélanger les modèles d'objet
Ne mélangez pas le modèle d'objet CrystalReportViewer avec d'autres modèles d'objet.
Utilisé en tant que modèle d'objet limité, CrystalReportViewer fonctionne correctement, à condition qu'il soit
directement lié au rapport par le biais du chemin d'accès à ce dernier.
En revanche, si vous encapsulez le rapport dans un autre modèle d'objet (tel que ReportDocument ou
ReportClientDocument), puis si vous liez le contrôle à ce modèle d'objet, n'utilisez plus le modèle d'objet
CrystalReportViewer. Le modèle d'objet fourni par le contrôle CrystalReportViewer devient alors redondant par
rapport au modèle d'objet plus puissant auquel il est lié. Par ailleurs, les paramètres appliqués au modèle d'objet
CrystalReportViewer sont visibles par l'autre modèle d'objet, ce qui peut engendrer des comportements
inattendus et des exceptions.
Supposons que vous utilisiez le modèle d'objet ReportDocument pour exporter ou imprimer un rapport mensuel à
partir du serveur. Si vous avez défini un paramètre de mois dans ce rapport à l'aide du modèle d'objet
CrystalReportViewer, il se peut que vous rencontriez des problèmes. Le modèle d'objet ReportDocument ne peut
pas voir les paramètres appliqués dans le modèle d'objet CrystalReportViewer. Il tente d'exporter ou d'imprimer le
rapport sans avoir connaissance du paramètre de mois défini, et affiche ensuite le mauvais mois ou génère une
exception.
La meilleure solution consiste donc à limiter l'utilisation du contrôle CrystalReportViewer aux paramètres
d'affichage du rapport uniquement lorsque ce contrôle a été lié à l'un des modèles d'objet sous-jacents.
1.3.1.3
SAP Crystal Reports Designer incorporé
Le SAP Crystal Reports Designer incorporé permet de créer ou de modifier des rapports. Il se compose d'une
interface utilisateur graphique pour la conception de rapports en WYSIWYG et d'une série d'experts conçus pour
simplifier la connectivité entre les données, leur tri, leur regroupement et d'autres opérations complexes de
conception de rapports. SAP Crystal Reports Developer contient une version améliorée du concepteur incorporé
qui permet de créer des rapports et des applications de reporting performants. Le concepteur incorporé inclus
dans SAP Crystal Reports, version développeur pour Microsoft Visual Studio contient plusieurs fonctionnalités
présentes dans SAP Crystal Reports Designer.
Rôle du SAP Crystal Reports Designer incorporé dans l'architecture
Le SAP Crystal Reports Designer incorporé est inclus dans la description de l'architecture, car il joue un rôle
primordial dans SAP Crystal Reports, version développeur pour Microsoft Visual Studio : il permet en effet de
34
créer les fichiers de rapport à afficher. Toutefois, le SAP Crystal Reports Designer incorporé n'intervient qu'au
moment de la conception. L'interaction avec les rapports et leur affichage, qui interviennent au moment de
l'exécution, sont assurés par le SDK de SAP Crystal Reports. Par conséquent, si le concepteur incorporé permet
de créer des rapports qui sont utilisés dans l'architecture, il ne fait pas partie de l'architecture elle-même.
Utilisation du SAP Crystal Reports Designer incorporé [page 647]
1.3.1.4
Contrôles du visualiseur de rapports
SAP Crystal Reports, version développeur pour Microsoft Visual Studio inclut des contrôles de format standard
pour l'affichage des rapports. Chaque contrôle encapsule des informations complexes liées à la présentation des
rapports dans un objet GUI, dans la boîte à outils.
Deux contrôles sont fournis :
Le contrôle CrystalReportViewer.
Ce contrôle affiche le rapport en utilisant une présentation de type page,
avec la possibilité de naviguer entres les pages.
Le contrôle
CrystalReportPartsViewer.
Ce contrôle affiche les informations de résumé sur le rapport dans une
petite fenêtre de type portail, avec la possibilité d'explorer le rapport en
profondeur par le biais d'une série de parties liées.
Pour afficher un rapport, il suffit de faire glisser le contrôle de la boîte à outils vers le Web Form ou le Windows
Form, puis d'affecter la propriété ReportSource de ce contrôle à un rapport.
Comment utiliser les contrôles visualiseur de rapports ? [page 43]
1.3.1.5
Modèles d'objet
SAP Crystal Reports, version développeur pour Microsoft Visual Studio, inclut un SDK qui contient deux modèles
d'objets. Avec un supplément de licence, le SDK peut être étendu à quatre modèles d'objet.
Les contrôles du visualiseur de rapports fournissent le point d'entrée dans le SDK. Cela est dû au fait que le
visualiseur de rapports affiche les rapports en les liant à un objet de rapport. Tous les modèles d'objet contenus
dans le SDK exposent et manipulent des objets de rapport.
Chaque modèle d'objet offre un degré de puissance et de complexité croissant :
●
Le modèle d'objet le plus simple est CrystalReportViewer.
35
Le contrôle CrystalReportViewer d'un Web Form ou d'un Windows Form possède par définition une classe
sous-jacente du même nom. Cette classe CrystalReportViewer expose les propriétés et les méthodes qui
permettent de modifier la fonctionnalité d'affichage du contrôle et d'interagir avec les classes qui gèrent les
connexions à la base de données, les paramètres et les formules de sélection. Cet ensemble de classes
constitue le modèle d'objet le plus simple. La classe CrystalReportViewer se présente sous deux formes
différentes : l'une dans un espace de noms Windows et l'autre dans un espace de noms Web. De nombreux
éléments de ce modèle d'objet se retrouvent par conséquent en double dans les deux espaces de noms, avec
certaines différences propres aux plates-formes Windows et Web.
Les classes de ce modèle d'objet sont contenues dans l'espace de noms CrystalDecisions.Web pour la
version Web Form de ce contrôle, et dans l'espace de noms CrystalDecisions.Windows pour la version
Windows Form du contrôle.
●
ReportDocument est un modèle d'objet plus complet.
La classe ReportDocument constitue une passerelle vers un ensemble de classes contenues dans l'espace
de noms Engine et qui incluent Database, DataDefinition, ExportOptions, PrintOptions,
ReportDefinition, ReportOptions et SummaryInfo. Il s'agit d'un ensemble complet de classes qui offre
des fonctionnalités plus puissantes de personnalisation et d'interaction avec le rapport.
Les classes de ce modèle d'objet sont contenues dans l'espace de noms
CrystalDecisions.CrystalReports.Engine.
●
Les modèles d'objet suivants sont disponibles par le biais d'une mise à niveau :
○
ReportClientDocument, modèle d'objet offrant des fonctionnalités de modification de rapport plus
avancées.
Cette classe sert de passerelle vers un modèle d'objet plus volumineux constitué de nombreuses classes
contenues dans plusieurs espaces de noms. Elle expose la structure du rapport dans son intégralité via le
SDK, ce qui permet de créer ou de modifier par programmation chaque aspect du rapport au moment de
l'exécution.
Les classes de ce modèle d'objet sont contenues dans le groupe d'espaces de noms
CrystalDecisions.ReportAppServer.
Le modèle d'objet ReportClientDocument est fourni avec un RAS (Report Application Server) qui
nécessite l'acquisition d'une licence supplémentaire. Un Report Application Server est fourni avec
SAP Crystal Reports Server et la plateforme SAP BusinessObjects Business Intelligence.
○
InfoObject, un modèle d'objet complet pour interagir avec les fonctions de niveau plateforme de
SAP Crystal Reports Server ou de la plateforme SAP BusinessObjects Business Intelligence est
également disponible. Ce modèle est fourni avec la licence SAP Crystal Reports Server ou de plateforme
SAP BusinessObjects Business Intelligence.
Cette classe sert de passerelle vers le modèle d'objet de plateforme complet de
SAP Crystal Reports Server ou de la plateforme SAP BusinessObjects Business Intelligence.
Les classes de ce modèle d'objet sont contenues dans le groupe d'espaces de noms
CrystalDecisions.Enterprise.
Remarque
Le modèle d'objet InfoObject est fourni uniquement avec SAP Crystal Reports Server et la plateforme
SAP BusinessObjects Business Intelligence, qui nécessitent l'acquisition d'une licence supplémentaire.
Choisir le modèle d'objet correct pour votre projet [page 32]
36
Comparaison des solutions de reporting de SAP BusinessObjects Business Intelligence [page 66]
1.3.1.5.1
Modèle d'objet CrystalReportViewer
La classe CrystalReportViewer a deux rôles :
●
Dans un Web Form ou un Windows Form, la classe CrystalReportViewer est exposée comme un contrôle .NET
et peut être ajoutée au formulaire pour afficher un rapport. Pour avoir des informations spécifiques sur le rôle
de cette classe en tant que contrôle .NET, voir Contrôles du visualiseur de rapports [page 35].
●
Dans le code sous-jacent du Web Form ou du Windows Form, la classe CrystalReportViewer fournit le modèle
d'objet le plus simple du SDK. Ce modèle d'objet sera examiné plus loin dans cette section.
La manière la plus simple d'insérer un rapport dans un Web Form ou Windows Form consiste à ajouter le contrôle
CrystalReportViewer au formulaire, puis, dans la classe code-behind, à affecter à la propriété ReportSource de la
classe CrystalReportViewer le chemin d'accès au rapport sous forme de chaîne.
En affectant le chemin du rapport directement au contrôle (plutôt que de placer le rapport dans un modèle d'objet
plus complexe tel que ReportDocument ou ReportClientDocument), vous limitez l'interface au modèle d'objet le
plus simple : CrystalReportViewer.
Comparaison de modèles d'objet CrystalReportViewer
CrystalReportViewer possède deux diagrammes de modèle d'objet, car le même nom de classe et de contrôle (et
par conséquent son modèle d'objet sous-jacent) est utilisé pour les applications Windows et Web. Ainsi, le modèle
d'objet CrystalReportViewer se répète-t-il (à quelques différences près) dans deux espaces de noms différents.
La version Windows du modèle d'objet CrystalReportViewer comporte les principales classes et les principaux
événements partagés par les versions Windows et Web du modèle d'objet.
La version Web du modèle d'objet CrystalReportViewer contient les mêmes classes et événements que la version
Windows, auxquels s'ajoutent les événements suivants relatifs au mode de chargement des pages ASPX.
Contrôles du visualiseur de rapports [page 35]
Liaison de rapports à l'aide du modèle d'objet CrystalReportViewer [page 172]
1.3.1.5.2
La classe ReportDocument fournit un modèle d'objet plus complet pour le SDK que le modèle d'objet
CrystalReportViewer.
37
La classe ReportDocument fait partie de l'espace de noms CrystalDecisions.CrystalReports.Engine.
Elle sert de passerelle vers un ensemble de classes contenues dans l'espace de noms Engine, ce qui offre une
palette d'outils de programmation plus large pour manipuler un rapport.
Dans la section précédente, vous avez appris à utiliser le modèle d'objet de base CrystalReportViewer en
affectant directement au contrôle CrystalReportViewer le chemin d'accès à un rapport.
Au niveau suivant, vous allez utiliser le modèle d'objet ReportDocument pour encapsuler le rapport dans une
instance de ReportDocument avant de l'affecter au contrôle. Vous accédez ainsi au modèle d'objet plus
complexe et puissant fourni par ReportDocument.
Remarque
Etant donné que les modèles d'objet CrystalReportViewer et ReportDocument sont tous deux impliqués
dans ce processus (le premier pour charger et afficher le rapport, le second pour encapsuler et manipuler le
rapport), il est fréquent de confondre leur rôle respectif. Une fois le rapport encapsulé à l'aide du modèle
d'objet ReportDocument, toutes les manipulations portant sur le rapport doivent être limitées à ce modèle. Si
vous essayez d'utiliser les propriétés et les méthodes de CrystalReportViewer pour manipuler le rapport,
les deux modèles d'objet entrent en conflit et se comportent de manière imprévisible.
Une fois que vous avez ajouté un modèle d'objet, limitez l'utilisation du code de CrystalReportViewer à la
définition des propriétés d'affichage.
ReportDocument et ReportClientDocument (RAS)
Dans SAP Crystal Reports 9, ces deux modèles étaient complètement séparés. Dans SAP Crystal Reports 10 et
versions ultérieures, cette séparation essentielle entre les deux modèles d'objet a été supprimée. Le modèle
d'objet ReportDocument fonctionne désormais comme un proxy vers un sous-ensemble de fonctionnalités à
partir du modèle d'objet ReportClientDocument.
SAP Crystal Reports 2008 permet d'accéder à une version limitée du modèle d'objet ReportClientDocument
via la propriété ReportDocument.ReportClientDocument.
Tutoriels du modèle d'objet ReportDocument [page 340]
Cette section présente divers tutoriels basés sur le modèle d'objet ReportDocument.
Liaison de rapports à l'aide du modèle d'objet ReportDocument [page 200]
Modèle d'objet CrystalReportViewer [page 37]
38
1.3.1.5.3
Modèle d'objet ReportClientDocument (RAS)
ReportClientDocument est le modèle d'objet le plus puissant et le plus complet pour manipuler les rapports. Ce
modèle d'objet n'est fourni qu'avec un RAS (Report Application Server), disponible sous la forme d'un RAS
BusinessObjects Enterprise géré ou non géré.
Le modèle d'objet ReportClientDocument est constitué de nombreuses classes contenues dans divers espaces
de noms. Chaque espace de noms a pour préfixe CrystalDecisions.ReportAppServer. Ce modèle d'objet
expose la structure du rapport dans son intégralité dans le SDK. Ainsi, vous pouvez créer et modifier par
programmation chaque aspect du rapport au moment de l'exécution, ainsi qu'en enregistrer les modifications.
Une instance de ReportClientDocument comprend un rapport qui peut être modifié par programmation en
fonction de ses propriétés de classe. Ces propriétés sont liées à une série d'autres bibliothèques dans le SDK qui
contiennent des contrôleurs, des modèles de définition de données et des modèles de définition de rapport :
●
ReportDefinition correspond à la présentation du rapport, tel qu'indiqué dans le
●
DataDefinition correspond à l'Explorateur de champs dans le SAP Crystal Reports Designer.
●
RowsetController correspond aux valeurs de données traitées de chaque ligne de détails, lors de la
SAP Crystal Reports Designer.
visualisation du rapport au moment de l'exécution.
Les instances de ReportClientDocument peuvent être des instanciations :
●
d'un fichier .rpt existant chargé à partir d'un répertoire, puis modifié avec les classes de définition de rapport
et de définition de données du SDK ReportClientDocument ;
●
d'un nouveau rapport entièrement vide créé avec les classes de définition de rapport et de définition de
données du SDK ReportClientDocument.
Cette instance de classe ReportClientDocument peut être chargée uniquement durant le temps nécessaire
pour transmettre l'instance au visualiseur pour affichage, avant qu'elle ne soit mise hors de portée. Toutefois,
vous pouvez également modifier l'instance de classe, puis l'enregistrer en tant que rapport (.rpt) dans un
répertoire avec l'une des classes du contrôleur.
Pour obtenir des informations détaillées sur le modèle d'objet ReportClientDocument, consultez la
documentation du SDK .NET RAS de SAP BusinessObjects.
ReportClientDocument dans SAP Crystal Reports 9
Avec l'application SAP Crystal Reports 9 (version Advanced) fournie avec le RAS non géré et les assemblys
RAS .NET, il était nécessaire de programmer le modèle d'objet ReportClientDocument. Les développeurs
pouvaient ainsi créer des projets .NET qui exploitaient le modèle d'objet ReportClientDocument.
Toutefois, cela impliquait également que les projets initialement créés avec le modèle d'objet ReportDocument
fourni avec SAP Crystal Reports devaient être intégralement reprogrammés pour être utilisés avec le modèle
d'objet ReportClientDocument inclus dans le RAS. Cela tenait au fait que les deux modèles d'objet étaient
complètement séparés.
39
ReportClientDocument dans SAP Crystal Reports 10 et versions ultérieures
Dans SAP Crystal Reports 10, cette séparation essentielle entre les deux modèles d'objet a été supprimée. Pour
ce faire, le modèle d'objet ReportDocument a été réécrit de façon à ce qu'il fonctionne comme un proxy vers un
sous-ensemble de fonctionnalités à partir du modèle d'objet ReportClientDocument. Les classes du modèle
d'objet ReportDocument exposent les mêmes signatures de propriété et de méthode qu'avant, mais la
fonctionnalité sous-jacente a été modifiée de manière à rediriger chaque propriété et chaque méthode vers les
propriétés et les méthodes du modèle d'objet ReportClientDocument plus puissant.
Cela ne signifie pas pour autant qu'une version de base de SAP Crystal Reports Developer offre un accès intégral
à un serveur RAS non géré ou au modèle d'objet ReportClientDocument. La version de base de
SAP Crystal Reports permet toujours de n'accéder qu'au modèle d'objet ReportDocument (même si le modèle
d'objet ReportDocument fonctionne comme un proxy vers un sous-ensemble du modèle d'objet
ReportClientDocument). Le moteur de création de rapports d'origine fourni dans les précédentes versions de
SAP Crystal Reports a été remplacé par une version limitée et incorporée du moteur de création de rapports RAS.
Vous ne pouvez installer le modèle d'objet ReportClientDocument et y accéder directement qu'en acquérant
une licence mise à niveau du serveur RAS non géré. A ce stade, tout le code correspondant au modèle d'objet
ReportDocument peut être facilement redirigé vers le serveur RAS distinct en définissant deux propriétés de
n'importe quelle instance de rapport donnée, et le modèle d'objet ReportClientDocument sous-jacent est
désormais accessible directement, lorsque vous l'extrayez de la propriété de la classe ReportDocument.
1.3.1.5.4
Modèle d'objet InfoObject (BOE)
Le modèle d'objet InfoObject est fourni avec les mises à niveau de SAP Crystal Reports Server et de la plateforme
Remarque
Pour en savoir plus, voir Solutions de reporting de SAP BusinessObjects Business Intelligence [page 65].
InfoObject offre un modèle d'objet de niveau plateforme pour le SDK. InfoObject fonctionne comme une
classe de base dans laquelle de nombreux objets Enterprise sont encapsulés dans des classes dérivées. La
classe dérivée qui représente les rapports est la classe CrystalDecisions.Enterprise.Desktop.Report.
Le SDK de la plateforme SAP BusinessObjects Business Intelligence est construit autour de la classe d'objet
InfoObject et des classes assurant sa prise en charge.
Classe InfoObject
La classe InfoObject est utilisée dans le SDK pour représenter un large éventail d'entités d'informations. Cela
inclut à la fois des entités physiques, telles que des fichiers de rapport ou des fichiers PDF, et des entités du
réseau, telles que les utilisateurs, les serveurs ou les connexions FTP.
40
La classe InfoObject est une classe de base pour de nombreuses classes étendues correspondant à ces entités
d'informations de façon plus détaillée. Les classes étendues qui héritent d'InfoObject sont les suivantes :
Report, User, Server, Folder, Program, Ftp, Smtp, Word, Excel et Pdf.
La manipulation des instances de classes étendues et de classes InfoObject vous permet de créer une application
cliente ou une application de bureau.
Classes assurant la prise en charge
Deux autres classes prennent en charge la classe InfoObject.
La classe InfoStore La classe InfoStore fait office de contrôleur, ou passerelle, vers le référentiel CMS (Central
Management Server) (qui est une base de données), où sont stockées toutes les instances
d'InfoObject. La classe InfoStore est utilisée pour instancier, extraire et valider toutes les
instances de classe InfoObject stockées dans le référentiel CMS.
La classe indexée
InfoObjects
La classe indexée InfoObjects contient plusieurs instances d'InfoObject. Elle est utilisée par
InfoStore pour déplacer les instances InfoObject vers et depuis le référentiel CMS.
La classe Infostore ne peut pas gérer directement les instances InfoObject. Elles doivent être d'abord encapsulées
dans la classe indexée InfoObjects. Par le biais de cette classe indexée, chaque instance d'InfoObject peut être
ajoutée, extraite, mise à jour ou planifiée.
Remarque
Pour en savoir plus sur le SDK de SAP Crystal Reports Server ou de la plateforme SAP BusinessObjects
Business Intelligence, consultez la documentation correspondante.
1.3.1.6
Comparaison des architectures dans les solutions de
reporting SAP Business Intelligence
Quatre solutions de reporting SAP Business Intelligence sont disponibles :
●
●
SAP Crystal Reports Developer
●
Report Application Server non géré (RAS)
●
SAP Crystal Reports Server ou plateforme SAP BusinessObjects Business Intelligence
Une différence d'architecture fondamentale entre chaque solution de reporting repose sur la façon dont le moteur
de rapport est placé et implémenté.
41
Définition du moteur de rapport
Le moteur de rapport est une composante essentielle de chaque solution de reporting. Il traite toutes les
demandes utilisateur et génère en sortie les informations concernant les rapports.
La capacité maximale de traitement simultané des demandes utilisateur varie d'une solution à l'autre. Dans
certaines solutions, elle est conditionnée par la conception de l'architecture ou par les licences.
Les autres pièces maîtresses de chaque solution de reporting sont les suivantes :
●
le fichier de définition de rapport (.rpt) ;
●
la source de données ;
●
le visualiseur de rapports ;
●
le SDK ;
●
Une structure de plateforme (qui figure dans SAP Crystal Reports Server ou la plateforme SAP
BusinessObjects Business Intelligence).
Interaction du moteur de rapport avec les autres pièces maîtresses
Le moteur de rapport utilise le fichier de définition de rapport (.rpt) comme modèle. Il extrait ensuite les données
de la source de données et utilise la définition de rapport pour fournir le rendu du rapport demandé, puis le
transmet au visualiseur de rapports. Les informations reçues du visualiseur ou codées à l'aide du SDK d'interface
déclenchent des traitements supplémentaires de la part du moteur de rapport qui exécute d'autres opérations sur
le rapport.
Différences de configuration du moteur de rapport entre les solutions de
reporting SAP Business Intelligence
●
Le moteur de rapport est incorporé.
Dans SAP Crystal Reports, version développeur pour Microsoft Visual Studio, le moteur de rapport est
incorporé dans l'application.
La capacité maximale de traitement simultané de ce moteur de rapport incorporé est limitée à trois
demandes utilisateur. Cela n'est pas dû à une limite de licence arbitraire, mais à une restriction liée à
l'architecture du moteur de rapport incorporé.
●
Le moteur de rapport est extrait dans un processus serveur de rapports distinct.
Dans la solution qui fait appel au Report Application Server (RAS) non géré, le moteur de rapport est extrait
dans un processus serveur distinct. Ce processus serveur peut s'exécuter sur le même ordinateur ou être
placé sur un ordinateur distinct de manière à augmenter les performances en déchargeant le traitement de
votre serveur d'applications. Le serveur RAS non géré n'est plus disponible en tant qu'option de mise à
niveau. Il est recommandé d'effectuer à la place une mise à niveau vers SAP Crystal Reports Server. Pour en
savoir plus, voir Solutions de reporting de SAP BusinessObjects Business Intelligence [page 65].
●
Le processus serveur de rapports distinct est encapsulé dans une architecture de plateforme complète.
Dans la solution SAP Crystal Reports Server ou de plateforme SAP BusinessObjects Business Intelligence,
une architecture de plateforme complète, qui encapsule le processus serveur de rapports distinct (RAS), a
été ajoutée. Le Report Application Server (RAS) géré devient alors un simple serveur, parmi les nombreux
42
autres serveurs qui constituent l'architecture de plateforme. Ce type d'architecture offre une large palette de
fonctionnalités supplémentaires, telles que la planification, l'équilibrage des charges, le basculement et une
évolutivité à la fois verticale et horizontale.
1.3.2
Contrôle CrystalReportViewer
Pour afficher un rapport Crystal, vous devez ajouter un contrôle CrystalReportViewer à votre application. Le
contrôle CrystalReportViewer permet de lier et d'afficher des rapports dans le .NET Framework. Le contrôle
CrystalReportViewer par défaut inclut des éléments d'interface utilisateur pour vous aider à afficher, enregistrer
et parcourir un rapport.
Les deux contrôle CrystalReportViewer les plus fréquemment utilisés sont le contrôle CrystalReportViewer pour
les applications Windows, auquel on accède via la classe
CrystalDecisions.Windows.Forms.CrystalReportViewer, et le contrôle CrystalReportViewer pour les
sites Web, auquel on accède via la classe CrystalDecisions.Web.CrystalReportViewer. Pour en savoir
plus, voir la Référence de l'API .NET SAP Crystal Reports.
Remarque
Un contrôle CrystalReportViewer n'est nécessaire que si vous avez l'intention d'afficher des rapports Crystal.
Personnalisation du contrôle CrystalReportViewer
En fonction de votre application, vous pouvez modifier certains éléments du contrôle par défaut.
SAP Crystal Reports vous permet de personnaliser l'aspect et la convivialité du visualiseur dans votre application
de différentes manières, notamment :
●
La barre d'outils CrystalReportViewer peut être supprimée du visualiseur.
●
Les boutons de la barre d'outils CrystalReportViewer peuvent être ajoutés ou supprimés par programmation.
●
Le contrôle CrystalReportViewer prend en charge la personnalisation via la CSS ou Thèmes.
Personnalisation du contrôle CrystalReportViewer [page 225]
Visualisation d'un rapport [page 165]
1.3.2.1
Comment utiliser les contrôles visualiseur de
rapports ?
Les contrôles visualiseur de rapports sont des contrôles .NET qui peuvent être ajoutés à un formulaire dans une
application Web ou Windows pour afficher des rapports dans ce formulaire.
43
Lorsque vous envisagez de générer une application à l'aide du SDK de SAP Crystal Reports, l'un des points les
plus importants à déterminer concerne l'utilisation des contrôles visualiseur de rapports. Connaître les principes
fondamentaux du SDK qui influencent ces contrôles vous aidera à choisir la structure la mieux adaptée à votre
projet SAP Crystal Reports, version développeur pour Microsoft Visual Studio.
Définition des contrôles .NET
Les contrôles Microsoft .NET forment une classe particulière de contrôles qui s'affichent dans la boîte à outils
Visual Studio. Ils sont ajoutés à un Web Form ou un Windows Form en tant qu'objets GUI et héritent des
caractéristiques d'une classe de contrôles de base commune. Les contrôles .NET classiques sont notamment
Button, DropDownList, CheckBox, TextBox ou DataGrid.
Les contrôles Microsoft .NET respectent la convention selon laquelle la couche présentation doit être séparée de
la couche logique métier. Les informations d'affichage sont encapsulées dans le contrôle lui-même dans le
Web Form ou le Windows Form. Dans la classe code-behind, le contrôle .NET est instancié en tant qu'instance de
niveau classe. Cette variable d'instance permet d'accéder aux propriétés, méthodes et événements du contrôle.
Les contrôles Microsoft .NET sont identiques d'un point de vue fonctionnel pour les Windows Forms comme pour
les Web Forms. Le .NET Framework permet de visualiser chaque page Web sous la forme d'un formulaire
contenant des contrôles, comme dans une application Windows.
Pourquoi SAP Crystal Reports utilise-t-il des contrôles .NET pour la
visualisation des rapports ?
L'un des avantages des outils de création de rapports tient au fait qu'ils encapsulent toutes les opérations
complexes liées à la structure, à la conception et au rendu des rapports dans un outil GUI très simple. De la même
manière, les contrôles .NET encapsulent des opérations complexes d'affichage et de remplissage de données
dans un objet GUI simple dans un Web Form ou un Windows Form.
L'utilisation de contrôles .NET permet de regrouper les opérations complexes d'affichage et de création de
rapports. Toutes les informations complexes liées aux rapports, qui étaient auparavant encapsulées uniquement
dans l'application SAP Crystal Reports autonome, sont désormais encapsulées dans un contrôle .NET comme
visualiseur de rapports.
Combien y a t'il de contrôles visualiseur de rapports ?
SAP Crystal Reports, version développeur pour Microsoft Visual Studio contient deux versions du contrôle
CrystalReportViewer : une pour les applications Web et l'autre pour les applications Windows. Le contrôle
CrystalReportViewer, situé dans l'espace de noms CrystalDecisions.Web, est utilisé par les projets Web ASP.NET.
Le contrôle CrystalReportViewer, situé dans l'espace de noms CrystalDecisions.Windows.Forms, est utilisé par
les projets Windows.
Le contrôle CrystalReportPartsViewer permet d'afficher seulement quelques parties des rapports dans une page
Web.
44
Affichage d'un rapport à l'aide du contrôle CrystalReportViewer
Le contrôle CrystalReportViewer n'affiche qu'un rapport à la fois. Le rapport affiché par le contrôle dépend du
rapport que vous avez lié à votre code. Pour indiquer au contrôle le rapport qu'il doit afficher, vous devez lier sa
propriété ReportSource à un rapport particulier. Au moment de l'exécution, le contrôle charge le rapport lié à sa
propriété ReportSource et l'affiche.
Dans sa forme la plus simple, l'affectation se présente de la manière suivante :
crystalReportViewer1.ReportSource = "C:\WorldSalesReport.rpt"
crystalReportViewer1.ReportSource = "C:\\WorldSalesReport.rpt";
Dans cet exemple, le rapport est lié au contrôle directement à partir de son chemin d'accès au répertoire de
fichiers.
Il s'agit de la manière la plus élémentaire de lier un rapport au contrôle CrystalReportViewer.
Est-ce le cas du contrôle CrystalReportViewer ?
Non. Le contrôle CrystalReportViewer se lie à un objet de rapport et non à un objet de données.
En fait, le rôle du contrôle CrystalReportViewer est différent de celui des autres contrôles .NET. Les autres
contrôles .NET se lient aux données et mettent en forme les données brutes sur la page. Dans la mesure où le
composant SAP Crystal Reports Designer incorporé effectue cette opération automatiquement chaque fois qu'il
crée un rapport (qui, par définition, encapsule l'extraction et l'affichage des données), le contrôle
CrystalReportViewer n'intervient que dans l'affichage d'un objet de rapport.
Le tableau suivant effectue une comparaison entre la liaison à un contrôle de données .NET par rapport à la liaison
à un contrôle CrystalReportViewer.
Type de contrôle
Se lie à
Connectivité à la couche suivante
Contrôle de données .NET (tel que
le contrôle DataGrid)
un objet de données (DataSet, Data Aucun
Reader, DataView, IDictionary, ICol
lection, DataTable).
Contrôle visualiseur de rap
un objet de rapport (qui encapsule
ports .NET (tel que le contrôle Crys un fichier de rapport Crystal).
talReportViewer)
La connectivité entre données est
intégrée au fichier de rapport Crys
tal, ce qui permet une connexion à
diverses sources de données, telles
que ODBC et OleDb, ainsi qu'aux
objets DataReader et DataSet.
Pour vous aider à vous souvenir qu'un contrôle CrystalReportViewer se lie à un objet de rapport et non à un objet
de données, la propriété source du contrôle visualiseur de rapports s'appelle ReportSource (et non DataSource).
45
Liaison de rapports automatique
Le contrôle CrystalReportViewer se distingue également de la plupart des autres contrôles .NET en ce sens qu'il
est inutile d'appeler manuellement une méthode de liaison pour effectuer une liaison. Ce contrôle lie en effet
automatiquement le visualiseur de rapports à l'objet de rapport.
Visualisation d'un rapport [page 165]
1.3.2.1.1
Pour ajouter un contrôle CrystalReportViewer à une
application Windows
Procédure
1.
Ouvrez un Windows Form dans l'onglet Conception.
2.
Remarque
Dans les versions précédentes de Visual Studio, le contrôle CrystalReportViewer apparaissait dans le
nœud Crystal Reports.
3.
Faites glisser le contrôle CrystalReportViewer sur le formulaire.
4.
Résultats
1.3.2.1.2
site Web
Pour ajouter un contrôle CrystalReportViewer à un
Procédure
1.
46
2.
Cliquez sur le bouton Design au bas du formulaire.
3.
Remarque
Dans les versions précédentes de SAP Crystal Reports, version développeur pour Microsoft Visual Studio,
le contrôle CrystalReportViewer apparaissait dans le nœud Crystal Reports.
4.
Faites glisser le contrôle CrystalReportViewer sur le Web Form.
5.
Résultats
1.3.2.1.3
Liaison du contrôle CrystalReportViewer à un
fichier sur disque
Contexte
La manière la plus simple de lier un contrôle CrystalReportViewer à un rapport Crystal est de définir la propriété
ReportSource sur un emplacement du disque. Ce rapport non incorporé est affiché lors de l'exécution de
l'application.
Cette opération lie le rapport directement au contrôle. Toutes les interactions par programmation avec le rapport
doivent être effectuées dans le modèle d'objet limité CrystalReportViewer.
Procédure
1.
Ajoutez un contrôle CrystalReportViewer à l'application Windows ou au site Web.
2.
Ouvrez le Web Form ou Windows Form.
3.
4.
Définissez la propriété ReportSource sur l'emplacement du rapport sur votre système de fichiers local.
○
Lors de l'utilisation d'une application Windows Form ou d'un site Web :
myCrystalReportViewer.ReportSource = "C:\MyReport.rpt"
crystalReportViewer.ReportSource = "C:\\MyReport.rpt";
47
○
Lors de l'utilisation d'une application WPF :
myCrystalReportViewer.ViewerCore.ReportSource = "C:\MyReport.rpt"
crystalReportViewer.ViewerCore.ReportSource = "C:\\MyReport.rpt";
1.3.2.2
Panneau Tâches guidées
Dans Visual Studio 2005 ou versions ultérieures, lorsque vous ajoutez un contrôle .NET à un Web Form ou un
Windows Form, le panneau des tâches guidées s'affiche. Il s'agit d'un petit panneau fixé dans l'angle supérieur
droit du contrôle .NET. Il contient des cases à cocher et des listes déroulantes qui permettent aux développeurs
de sélectionner des options de connectivité et d'autres types d'option pour le contrôle. Cette fonctionnalité réduit
considérablement le temps consacré par le développeur à l'écriture du code.
Dans un site Web, les sélections effectuées dans le panneau des tâches guidées génèrent automatiquement du
code XML dans la page ASPX.
Dans un projet Windows, les sélections effectuées dans le panneau des tâches guidées génèrent
automatiquement du code dans un fichier de classe masqué. Ce fichier de classe masqué est une classe
"partielle" qui sert d'addenda à la classe Windows Form existante. Les classes partielles sont une nouvelle
fonctionnalité de .NET Framework version 2.0.
Le panneau Tâches guidées permet de lier rapidement et facilement le contrôle CrystalReportViewer au contrôle
CrystalReportSource. Lorsque vous ajoutez le contrôle CrystalReportViewer à la page, le panneau des tâches
guidées s'affiche automatiquement en indiquant une série d'étapes permettant de créer et de configurer le
contrôle CrystalReportSource.
Le contrôle CrystalReportViewer fait très fréquemment appel au panneau des tâches guidées. Les sélections
accessibles dans ce panneau diffèrent selon que vous travaillez sur un projet Web ou sur un projet Windows.
Limites des tâches guidées avec le modèle de programmation allégée
Les tâches guidées facilitent l'utilisation d'un modèle de programmation allégée qui génère le code
automatiquement plutôt que d'avoir à l'écrire manuellement.
L'auto-génération du code permet, au premier abord, de gagner du temps mais il est ensuite difficile de passer
d'un mode de codage allégé à un mode classique lorsque vous voulez rendre un projet plus puissant ou flexible.
1.3.2.2.1
Panneau des tâches guidées CrystalReportViewer
pour projets Windows
Le panneau des tâches guidées CrystalReportViewer pour projets Windows permet de créer, de sélectionner
ou de modifier un rapport Crystal. Il offre également la possibilité de personnaliser le contrôle
48
Le panneau des tâches guidées pour projets Windows comporte les fonctionnalités suivantes :
Créer un rapport Crystal...
Cette commande de menu permet de créer un rapport à l'aide du composant SAP Crystal Reports Designer
incorporé.
Une fois l'opération terminée, le code du rapport est généré automatiquement de manière à lier ce dernier au
contrôle CrystalReportViewer pour un affichage immédiat.
Modifier le rapport Crystal actuel
Cette commande de menu permet de modifier plus en détail le rapport qui a été sélectionné ou créé pour la
source de rapport.
Choisir un rapport Crystal
Cette commande de menu vous permet de sélectionner un rapport Crystal ou un objet ReportDocument en tant
que source de rapport du contrôle CrystalReportViewer.
Effacer la source du rapport
Cette commande de menu efface la propriété ReportSource du contrôle CrystalReportViewer.
Choisissez une vue du volet des outils :
Cette commande de menu permet de sélectionner le volet des outils à afficher par défaut lors du chargement du
rapport. Vous pouvez sélectionner l'arborescence des groupes ou le panneau des paramètres ou encore choisir
de laisser vide le volet des outils.
Afficher la barre d'outils
Cette case à cocher permet d'afficher ou de masquer la barre d'outils du contrôle CrystalReportViewer.
49
Afficher la barre d'état
Cette case à cocher permet d'afficher ou de masquer la barre d'état dans le contrôle CrystalReportViewer.
Annuler l'ancrage dans le conteneur parent
Cette commande de menu permet de définir la propriété Dock sur "None" ou sur "Fill". Par défaut, lorsqu'un
contrôle CrystalReportViewer est placé dans un Windows Form, la propriété Dock est définie sur "Fill". Si cette
commande de menu est sélectionnée et si la propriété Dock est définie sur "None", le contrôle
CrystalReportViewer peut être déplacé et redimensionné dans le Windows Form ou dans d'autres conteneurs
(contrôle Panel dans un Windows Form par exemple).
1.3.2.2.2
Panneau des tâches guidées CrystalReportViewer
pour sites Web
Le panneau des tâches guidées CrystalReportViewer pour sites Web permet de créer, de sélectionner ou de
modifier un rapport Crystal. Il offre également la possibilité de personnaliser le contrôle CrystalReportViewer et
d'activer la consignation des erreurs liées aux connexions à la base de données et aux valeurs de paramètre.
Le panneau des tâches guidées pour sites Web comporte les fonctionnalités suivantes :
Sélection de la source du rapport
Cette liste déroulante permet de sélectionner n'importe quelle source de rapport existante ou d'en créer une
nouvelle.
Configurer la source de rapport...
Cette commande de menu permet de configurer plus en détail la source de rapport qui a été sélectionnée ou
créée.
Modifier le rapport...
Cette commande de menu permet de modifier plus en détail le rapport qui a été sélectionné ou créé pour la
source de rapport.
50
Choisissez une vue du volet des outils :
Cette commande de menu permet de sélectionner le volet des outils à afficher par défaut lors du chargement du
rapport. Vous pouvez sélectionner l'arborescence des groupes ou le panneau des paramètres ou encore choisir
de laisser vide le volet des outils.
Activer la barre d'outils
Cette case à cocher permet d'afficher ou de masquer la barre d'outils du contrôle CrystalReportViewer.
Activer la vue de rapport
Cette case à cocher permet d'afficher ou de masquer la vue de rapport dans le contrôle CrystalReportViewer.
Remarque
Vous pouvez désactiver la vue de rapport si vous souhaitez utiliser l'arborescence des groupes seule dans un
Web Form.
Activer l'invite de connexion à la base de données
Cette case à cocher permet d'activer ou de désactiver la consignation des erreurs liées aux connexions à la base
de données. Lorsqu'un rapport ne fournit pas toutes les informations nécessaires à sa connexion à une base de
données SQL Server, le message d'erreur "Echec de la connexion" est renvoyé. Toutefois, si la case à cocher est
activée, une fenêtre vous invitant à saisir les informations de connexion requises s'affiche.
Activer l'invite de saisie de paramètre
Cette case à cocher permet d'activer ou de désactiver la consignation des erreurs liées aux valeurs de paramètre.
Lorsqu'un rapport ne fournit pas toutes les informations nécessaires pour désigner un paramètre utilisé dans des
critères de sélection, le message d'erreur "Valeurs de paramètres manquantes" est renvoyé. Toutefois, si la case
à cocher est activée, une fenêtre vous invitant à saisir les informations requises sur le paramètre s'affiche.
Réutiliser la valeur des paramètres lors de l'actualisation du rapport
Cette case à cocher permet d'activer ou de désactiver la persistance des paramètres lors de l'actualisation des
rapports. Lorsque cette case à cocher est activée, les valeurs de paramètre transmises à un rapport lors de son
51
premier chargement son rendues persistantes. En revanche lorsqu'elle est désactivée, vous devez écrire du code
pour que les valeurs de paramètre soient transmises au rapport lors de chaque actualisation ultérieure.
Panneau des tâches guidées CrystalReportViewer pour projets Windows [page 48]
1.3.2.3
Contrôle CrystalReportPartsViewer
Dans le .NET Framework, le contrôle CrystalReportPartsViewer permet de lier et d'afficher un rapport
Crystal sous la forme d'une série de parties liées. Ceci réduit considérablement la zone requise pour afficher les
informations du rapport et est idéal pour afficher de petites quantités d'informations sur une page Web du portail.
Remarque
Les parties de rapport sont utilisées uniquement dans les sites Web ; elles ne sont pas disponibles pour les
projets Windows.
Le contrôle CrystalReportPartsViewer a été amélioré pour prendre en charge la structure des composants
WebPart, une infrastructure de portail introduite avec la version 2.0 d'ASP.NET.
La structure des composants WebPart permet aux développeurs d'encapsuler des contrôles de la page au sein de
composants WebPart configurables.
Tutoriel : Affichage de parties de rapport à l'aide du contrôle CrystalReportPartsViewer [page 499]
Dans ce tutoriel, vous allez apprendre à diviser le rapport en plusieurs parties et à afficher chaque partie en
cliquant sur une série de liens hypertexte successifs.
1.3.2.4
Contrôle CrystalReportSource
Le contrôle CrystalReportSource est un élément du modèle de développement d'applications avec balises fourni
avec ASP.NET version 2.0.
Remarque
Le contrôle CrystalReportSource n'est disponible que pour les sites Web.
Dans la structure de contrôle DataSource, les contrôles .NET visuels se connectent aux contrôles DataSource non
visuels (contrôles qui ne gèrent pas les informations d'affichage). Cette nouvelle structure DataSource encapsule
52
les informations de connectivité des données écrites sous forme de lignes de code dans les contrôles .NET insérés
dans le Web Form.
Dans la fenêtre Design, Visual Studio affiche le nom des contrôles connectés les uns aux autres.
Les fournisseurs de données .NET possèdent leur propre implémentation du contrôle DataSource. Par exemple,
le contrôle SqlDataSource accède à Microsoft SQL Server, tandis que le contrôle OracleDataSource accède à
Oracle.
En ce qui concerne SAP Crystal Reports, le contrôle est implémenté en tant que contrôle CrystalReportSource.
Cette conception s'inspire de la conception d'ASP.NET version 1.0 dans laquelle le contrôle CrystalReportViewer
contient une propriété ReportSource au lieu d'une propriété DataSource plus classique.
La différence entre le contrôle CrystalReportSource et le contrôle DataSource réside dans le fait que le premier
contient un rapport qui encapsule les données, tandis que le second (tel que SqlDataSource) contient les données
elles-mêmes.
1.3.3
Quelle méthode de persistance utiliser avec
SAP Crystal Reports ?
Lorsque vous envisagez de générer une application Web à l'aide du SDK de SAP Crystal Reports, l'un des points
les plus importants à prendre en considération concerne la méthode de persistance que vous allez utiliser.
Qu'est ce que la persistance ?
Les pages Web ne conservent ni le statut ni les informations d'identification d'un utilisateur lorsqu'il se connecte à
un site Web. Chaque page Web est demandée à partir d'un serveur, envoyée à l'utilisateur et le processus s'arrête
là. Cela fonctionne tant qu'il est question de lire des données texte, mais devient problématique lorsqu'il s'agit de
concevoir une application Web qui doit conserver les informations sur un utilisateur au fur et à mesure que les
pages sont rechargées et redirigées.
La persistance fait référence à l'utilisation d'un mécanisme qui conserve le statut de chaque utilisateur (tel que la
page de rapport actuelle visualisée par chaque utilisateur) indépendamment du fait que les pages sont rechargées
et redirigées.
Conventions relatives à la persistance
Cette section décrit les conventions utilisées pour rendre persistantes des modifications apportées à un rapport
Crystal dans une page Web tandis que ce rapport est actualisé au cours du rechargement de la page Web. Ces
changements peuvent aller du plus simple, comme accéder à la page suivante après que l'utilisateur a cliqué sur
le bouton Page suivante du visualiseur de rapports, au plus complexe, comme afficher des données
complètement différentes après modification des paramètres d'un rapport.
La persistance doit s'appliquer à ce qui suit :
53
●
Le contrôle CrystalReportViewer.
●
le rapport lié au contrôle CrystalReportViewer.
Comment assurer la persistance du statut dans les applications ASP et
ASP.NET
Dans les applications ASP et ASP.NET classiques, la persistance du statut est assurée soit par le navigateur Web,
soit par le serveur Web comme indiqué dans le tableau suivant.
Environnement
Client ou serveur ?
Nom
Méthode
ASP*
Navigateur client
Champs de formulaire
Transmet des paires nom/
valeur au fil des pages
Web par le biais de
champs de soumission de
formulaire.
ASP*
Navigateur client
Arguments URL
Transmet des paires nom/
valeur au fil des pages
Web par le biais d'argu
ments URL.
ASP*
Navigateur client
Cookie
Affecte des paires nom/
valeur à un cookie sur le
navigateur client, puis ex
trait le cookie dans une
nouvelle page.
ASP*
Serveur Web
Objet Session
Affecte des objets instan
ciés à l'objet Session sur le
serveur, puis extrait le
contenu de cet objet Ses
sion dans une nouvelle
page.
ASP*
Serveur Web
Objet Application
Affecte des objets instan
ciés à l'objet Application
sur le serveur, puis extrait
le contenu de cet objet Ap
plication dans une nou
velle page.
ASP.NET
Navigateur client
Objet ViewState
Affecte des valeurs de
chaîne à l'objet ViewState
du Web Form ASP.NET.
ASP.NET
Serveur Web
Objet Cache
Identique à l'objet Applica
tion, mais avec des fonc
tionnalités avancées.
* Toutes les méthodes de persistance ASP continuent à fonctionner dans ASP.NET.
54
Quelles sont les méthodes de persistance les mieux adaptées à
SAP Crystal Reports ?
Les méthodes de persistance les mieux adaptées à SAP Crystal Reports sont ViewState, Session et Cache.
ViewState et persistance du modèle d'objet CrystalReportViewer [page 55]
1.3.3.1
ViewState et persistance du modèle d'objet
CrystalReportViewer
Définition de ViewState
ViewState est une méthode basée sur le navigateur utilisée dans ASP.NET pour rendre persistant le statut de
visualisation, c'est-à-dire le Web Form. Sa fonction principale consiste à assurer la persistance des contrôles Web.
Les contrôles Web (également appelés contrôles serveur Web) sont calqués sur les contrôles Windows introduits
dans Visual Basic. Les contrôles Windows sont des objets contenus dans le formulaire qui encapsulent une partie
de fonctionnalité d'affichage telle qu'un champ de texte, un bouton ou une table de données.
Les contrôles Web sont semblables aux contrôles Windows. Tout comme les contrôles Windows, ils agissent sur
deux niveaux : dans la page Web et dans la classe code-behind qui prend en charge cette page Web. Tout comme
les contrôles classiques des Windows Forms, les contrôles Web encapsulent des parties discrètes de
fonctionnalités d'affichage dans des objets GUI : Button, TextField, DropDownList, DataGrid, etc. Dans la classe
code-behind, ces mêmes contrôles sont semblables aux classes qui exposent les propriétés et les méthodes.
Une page Web se distingue d'un Windows Form par le fait qu'il s'agit d'un environnement sans statut. Il est donc
nécessaire de recourir à un mécanisme de persistance afin de préserver le statut de la page Web au fil de ses
rechargements successifs.
ViewState conserve le statut des contrôles d'une page Web de la même manière que Session pour les objets
instanciés sur le serveur.
Remarque
ViewState conserve automatiquement le statut de tous les contrôles Web. Pour cela, ViewState doit stocker
chaque contrôle basé sur la propriété EnableViewState du contrôle (auquel la valeur True a été attribuée par
défaut).
Etant donné que ViewState stocke le statut des données à partir des contrôles Web de la page, l'objet ViewState
doit être inclus intégralement dans la page lorsque cette dernière est transférée du navigateur vers le serveur
Web et vice-versa. Cela s'obtient en cryptant l'intégralité de l'objet ViewState sous forme de chaîne, puis en
plaçant cette chaîne dans la valeur d'une balise de formulaire masquée dans la page. Par exemple, le code HTML
55
de l'objet ViewState pour une page Web ASP.NET contenant uniquement un contrôle Button se présente sous la
forme suivante :
<input type="hidden" name="__VIEWSTATE"
value="dDwtNTMwNzcxMzI0Ozs+I7GfLyg3p44eTLFCiVEiRKUBzFw=" />
ViewState ne stocke que les informations qui peuvent être converties au format chaîne.
Persistance de l'affichage de rapports du contrôle CrystalReportViewer
Le rôle du contrôle CrystalReportViewer consiste à afficher les rapports Crystal. Il convertit les rapports au format
HTML dans une page qui comporte une barre d'outils et une arborescence permettant de manipuler l'affichage
des rapports. La barre d'outils contient des boutons qui permettent d'effectuer des zooms, d'accéder à la page
suivante, d'imprimer, d'exporter, etc. L'arborescence peut être développée pour afficher des groupes de données
imbriqués.
En rendant les informations du contrôle persistantes, ViewState assure par conséquent la persistance du statut
de toutes les informations d'affichage des rapports (événements de la barre d'outils et de l'arborescence
compris) pour le contrôle CrystalReportViewer au fur et à mesure que les pages sont rechargées.
Supposons par exemple qu'un utilisateur soit en train de consulter la page 3 d'un rapport et qu'il clique sur le
bouton Page suivante de la barre d'outils du contrôle CrystalReportViewer, ViewState rendrait persistant le statut
des deux éléments d'information suivants :
●
le numéro de page actuel ;
●
le statut du bouton Page suivante (sur lequel l'utilisateur a cliqué).
Au cours du rechargement de la page, ViewState restaurerait le contrôle CrystalReportViewer à la page 3, puis
l'événement de clic sur Page suivante, ce qui entraînerait l'affichage de la page 4 du rapport par le contrôle.
Persistance du modèle d'objet du contrôle CrystalReportViewer
Outre l'affichage des rapports, le contrôle CrystalReportViewer joue un deuxième rôle : celui de modèle d'objet
limité (contenu dans la classe du contrôle CrystalReportViewer). Ce modèle d'objet limité peut être utilisé pour
interagir par programmation avec les rapports.
ViewState rend persistant le statut de ces deux rôles :
●
affichage des rapports
●
modèle d'objet CrystalReportViewer
Sachez toutefois que l'utilisation du modèle d'objet CrystalReportViewer est généralement déconseillée au profit
du modèle d'objet ReportDocument, plus complet. Cet autre modèle d'objet n'est pas contenu dans le contrôle,
mais il fait partie des bibliothèques de classes du SDK.
56
Partage des mécanismes de persistance
Si vous utilisez le contrôle CrystalReportViewer dans ses deux rôles (affichage des rapports et modèle d'objet),
ViewState les rend tous deux persistants et vous n'avez pas à recourir à un autre mécanisme de persistance.
Remarque
Un exemple de ce cas consisterait à lier le contrôle CrystalReportViewer au chemin d'accès d'un répertoire de
fichiers. Voir Liaison au chemin d'accès d'un répertoire de fichiers par code [page 172].
Si vous décidez toutefois d'utiliser le contrôle CrystalReportViewer uniquement pour afficher les rapports, puis si
vous le liez à un modèle d'objet externe (tel que ReportDocument), vous devrez faire appel à un autre mécanisme
de persistance afin de rendre le modèle d'objet externe persistant. En général, cet autre mécanisme de
persistance est Session (ou plus occasionnellement Cache).
Quelle méthode de persistance utiliser avec SAP Crystal Reports ? [page 53]
Session et persistance du modèle d'objet ReportDocument [page 57]
1.3.3.2
Session et persistance du modèle d'objet
ReportDocument
Définition de Session
Session est une méthode de persistance du statut basée sur un serveur Web et utilisée à la fois dans ASP et
ASP.NET. Session permet de rendre persistant n'importe quel objet durant toute la session d'un utilisateur en
stockant cet objet dans la mémoire du serveur Web.
Cette méthode est généralement employée pour effectuer l'une des opérations suivantes :
●
Stocker des informations dont le statut doit être rendu persistant durant toute la durée d'une session
utilisateur, telles que les informations de connexion ou d'autres données requises pour permettre à
l'utilisateur de naviguer dans l'application Web.
●
Stocker un objet dont le statut doit être rendu persistant uniquement au cours du rechargement d'une page
ou d'un ensemble de pages regroupées pour des raisons fonctionnelles.
L'avantage de la méthode Session tient au fait qu'elle conserve sur le serveur Web les informations de statut de
l'utilisateur pour un accès à tout moment et depuis n'importe quelle page. Etant donné que ces informations ne
sont pas stockées par le navigateur, n'importe quel navigateur peut être utilisé, même des dispositifs de
navigation tels que des assistants personnels ou des téléphones portables.
57
Limites de cette méthode de persistance
●
La quantité de mémoire serveur requise par la méthode Session augmente au fur et à mesure que les
utilisateurs se connectent.
●
Chaque utilisateur qui accède à l'application Web génère un objet Session distinct. La "durée de vie" de
chaque objet Session correspond à la durée de la session de l'utilisateur plus une période d'inactivité.
●
Si de nombreux objets sont rendus persistants dans chaque Session et si de nombreux utilisateurs emploient
simultanément l'application Web (générant ainsi beaucoup d'objets Session), la quantité de mémoire serveur
consacrée à la méthode de persistance Session peut devenir significative et limiter l'évolutivité.
Pour en savoir plus sur les autres méthodes de persistance, voir les sections suivantes :
●
●
Cache et persistance du modèle d'objet ReportDocument [page 59]
Persistance du modèle d'objet ReportDocument à l'aide de Session
Si le rapport a été encapsulé dans le modèle d'objet ReportDocument, ce modèle d'objet doit être rendu
persistant à l'aide d'une méthode basée sur le serveur, telle que Session ou Cache.
Pour rendre persistant un rapport encapsulé dans le modèle d'objet ReportDocument à l'aide de Session,
instanciez ReportDocument, puis affectez-le à Session.
De par sa simplicité, Session est la méthode recommandée lorsque vous apprenez à générer une application Web
ASP.NET à l'aide de SAP Crystal Reports. Elle est également conseillée pour stocker des instances de
ReportDocument qui présentent un faible potentiel de partage.
Limites de la persistance du modèle d'objet ReportDocument à l'aide de
Session
Chaque fois qu'une instance de ReportDocument présente un faible potentiel de partage, utilisez la méthode de
persistance Cache à la place de Session.
Différence entre Session et ViewState
La fonction principale de Session consiste à rendre persistant le statut des objets dans la classe code-behind. Le
rôle principal de ViewState consiste à assurer la persistance du statut des contrôles d'une page Web. Lorsqu'un
contrôle d'une page Web est lié à un objet contenu dans la classe code-behind et que tous deux doivent être rendu
persistants d'un rechargement de page à un autre, Session et ViewState "se partagent les rôles".
Dans ce cas, ViewState assure la persistance d'un contrôle CrystalReportViewer, et Session celle d'un objet
ReportDocument lié à ce contrôle.
58
Tutoriel : Persistance du modèle d'objet ReportDocument à l'aide de Session [page 341]
Dans ce tutoriel, vous allez utiliser le modèle d'objet ReportDocument et effectuer des modifications par
programmation sur un rapport au moment de l'exécution.
1.3.3.3
Cache et persistance du modèle d'objet
ReportDocument
Cache est une méthode de persistance du statut basée sur un serveur et utilisée dans ASP.NET. D'un point de vue
fonctionnel, Cache est identique à l'objet Application utilisé dans ASP comme dans ASP.NET :
●
L'objet Application permet de rendre persistant n'importe quel objet sur toute la portée de l'application.
●
L'objet Application n'est pas conçu pour conserver les informations propres aux utilisateurs.
Cache partage ces fonctionnalités avec Application, mais offre une intelligence plus avancée au niveau de la
gestion des données provisoires :
●
Un objet ajouté au cache peut-être configuré à l'aide de dépendances basées sur des fichiers, des clés ou des
délais. Si le fichier ou la clé associé(e) est modifié, ou si un certain délai arrive à expiration, l'objet est
automatiquement supprimé du cache, et une version mise à jour est placée dans le cache à la prochaine
requête portant sur l'objet.
●
Un objet placé dans le cache qui ne possède aucune dépendance et qui est inutilisé arrive automatiquement à
expiration.
●
Lorsqu'un objet est supprimé du cache, cela déclenche un événement. Vous pouvez écrire du code pour qu'il
s'exécute avec cet événement et charge une version mise à jour de l'objet dans le Cache.
Si une autre version d'un objet est ajoutée à l'aide de la chaîne clé d'origine, elle écrase la version précédente.
Pour éviter cette suppression, concaténez l'autre définition au niveau de la chaîne clé afin de rendre chaque
version de l'objet unique.
Comme l'objet Application, l'objet Cache stocke des informations accessibles à tous les utilisateurs, mais son
avantage sur Application tient au fait qu'il se met jour automatiquement en fonction des modifications apportées
à ses dépendances.
Comportement de l'objet Cache dans .Net 2.0 Framework
Le cache dans .Net 2.0 Framework est plus efficace et sûr, car il est géré par utilisateur et par session.
En d'autres termes, lorsqu'un utilisateur affiche un rapport, une copie du rapport est enregistrée dans le cache et
affichée pour cet utilisateur. Si l'utilisateur rouvre le rapport alors que la section en cours est active, l'application
affiche le rapport mis en cache. Cela évite de devoir exécuter le rapport à chaque fois qu'un même utilisateur
l'affiche. Si un autre utilisateur se connecte et ouvre le même rapport, l'application exécute le rapport une
seconde fois, enregistre une seconde copie du rapport dans le cache et l'affiche pour cet utilisateur. Tous les
utilisateurs ont leurs propres copies en cache du rapport pour leur session. Cela évite que plusieurs utilisateurs
partagent le même rapport.
59
Limites de cette méthode de persistance
Les développeurs encore peu familiers de la méthode Cache peuvent être tentés de l'utiliser tout le temps pour
assurer la persistance, au détriment de la méthode Session. Or la méthode Cache n'est pas interchangeable avec
la méthode Session. Tenter d'émuler le caractère unique de Session en concaténant des données propres à
l'utilisateur au niveau de la clé du Cache charge le Cache avec des objets utilisateur qui, contrairement à ce qui ce
passe avec Session, n'arrivent pas à expiration une fois échu le délai d'attente utilisateur. Par conséquent, la
mémoire du serveur Web est plus fortement sollicitée par l'objet Cache que par l'objet Session.
Pour rendre persistantes des données propres à l'utilisateur, utilisez l'objet Session.
Pour en savoir plus sur les autres méthodes de persistance, voir :
●
●
Persistance du modèle d'objet ReportDocument à l'aide de Cache
Si le rapport a été encapsulé dans le modèle d'objet ReportDocument, ce modèle d'objet doit être rendu
persistant à l'aide d'une méthode basée sur le serveur, telle que Session ou Cache.
Un rapport encapsulé dans le modèle d'objet ReportDocument peut être rendu persistant à l'aide de l'objet Cache
de l'une des manières suivantes :
●
Instanciez le rapport, puis affectez-le à l'objet Cache à l'aide de la même syntaxe que celle utilisée pour
affecter un rapport à l'objet Session.
Cette méthode fonctionne uniquement pour un rapport présentant un fort potentiel de partage, pour lequel
l'instance de ReportDocument ne se produit qu'une seule fois, en utilisant un ensemble de paramètres et de
références de connexion unique. Avec une instance de ReportDocument qui se produit plusieurs fois en
raison de modifications apportées à ses paramètres et à ses informations de connexion, le fait de réaffecter le
rapport à l'objet Cache en utilisant la même chaîne clé écrase la version précédente de l'instance de
ReportDocument.
●
Instanciez une version de la classe de rapport qui implémente l'interface ICachedReport.
Le SDK de SAP Crystal Reports comporte une structure intégrée de mise en mémoire cache des rapports.
Chaque rapport qui implémente l'interface ICachedReport est automatiquement ajouté au cache à l'aide
d'une clé unique basée sur les paramètres et références de connexion de l'utilisateur. Cette méthode
fonctionne avec n'importe quel rapport qui présente un fort potentiel de partage, mais peut donner quelques
variations en raison de modifications mineures apportées aux paramètres et aux références de connexion. En
ce qui concerne les rapports qui présentent un faible potentiel de partage (qui sont propres à l'utilisateur),
affectez-les à l'objet Session.
Limites de la persistance du modèle d'objet ReportDocument à l'aide de Cache
Cache est la méthode la mieux adaptée pour rendre persistantes des instances de ReportDocument qui
présentent un fort potentiel de partage pour les utilisateurs. Si le rapport est spécifique à l'utilisateur, Cache
consommera inutilement de la mémoire serveur en créant des instances basées sur l'utilisateur au niveau de
60
l'application qui resteront stockées dans la mémoire du serveur une fois échu le délai d'attente utilisateur. Les
rapports spécifiques à l'utilisateur doivent être affectés à l'objet Session.
Remarque
Dans la plupart des cas, utilisez Session pour rendre persistantes les instances de ReportDocument. Utilisez
Cache (ou plus spécifiquement, l'interface ICachedReport) uniquement lorsqu'un rapport présente un fort
potentiel de partage et qu'il est très volumineux, ou tellement complexe que l'extraction de ses données prend
plusieurs minutes.
Différence entre Cache et ViewState
La fonction principale de Cache consiste à rendre persistant le statut des objets dans la classe code-behind. Le
rôle principal de ViewState consiste à assurer la persistance du statut des contrôles d'une page Web. Lorsqu'un
contrôle d'une page Web est lié à un objet contenu dans la classe code-behind et que tous deux doivent être
rendus persistants au fur et à mesure que la page est rechargée, Cache et ViewState "se partagent les rôles".
Dans ce cas, ViewState assure la persistance d'un contrôle CrystalReportViewer, et Cache celle d'un objet
ReportDocument lié à ce contrôle.
Limites de la persistance lors de la liaison de rapports avec le gestionnaire d'événements Page_Load [page 62]
1.3.3.3.1
Pour rendre persistant un rapport incorporé qui
implémente ICachedReport
Procédure
1.
Ajoutez le rapport au projet.
Une classe de rapport incorporé est alors créée. Est également créée une classe de rapport mis en cache qui
charge et renvoie une instance mise en cache de la classe de rapport incorporé.
2.
Instanciez la classe de rapport mis en cache.
3.
Affectez l'instance de la classe de rapport mis en cache au contrôle CrystalReportViewer.
Liaison à une classe de rapport incorporé et mis en cache [page 205]
61
1.3.3.3.2
Pour rendre persistant un rapport non incorporé
par le biais d'une classe utilitaire qui implémente
ICachedReport
Procédure
1.
Créez votre propre classe utilitaire de gestion du cache et configurez-la de sorte qu'elle implémente
ICachedReport.
2.
Dans cette classe utilitaire, chargez le rapport non incorporé à partir d'une chaîne chemin d'accès à l'aide de
la méthode ReportDocument.Load().
3.
Codez la méthode d'implémentation CreateReport() de manière à ce qu'elle renvoie l'instance
ReportDocument du rapport non incorporé.
4.
Instanciez la classe utilitaire de gestion du cache du rapport.
5.
Affectez l'instance de cette classe au contrôle CrystalReportViewer.
Liaison à un rapport non incorporé chargé dans une classe utilitaire de gestion du cache [page 207]
1.3.3.4 Limites de la persistance lors de la liaison de
rapports avec le gestionnaire d'événements Page_Load
Dans les applications Web ASP.NET, il est courant de placer tout le code concernant le lancement d'une page
dans le gestionnaire d'événements Page_Load (ce code étant appelé par l'événement Page.Load).
En particulier, le code concernant la liaison des données de contrôle est généralement stocké dans le gestionnaire
d'événements Page_Load. Toutefois, le fait de placer le code de liaison dans ce gestionnaire d'événements génère
un problème avec ViewState. Ce problème, et la solution généralement adoptée, sont décrits ci-après :
●
ViewState est utilisé pour assurer la persistance de deux éléments au fur et à mesure que les pages sont
rechargées : les données liées au contrôle et les événements de clic de souris effectués sur ce contrôle.
●
ViewState étant une chaîne, les données et les événements de clic de souris doivent être sérialisés.
●
Lors du rechargement des pages, les données tout comme les événements de clic sont restaurés à partir de
ViewState.
●
L'événement Page.Load s'exécute une fois la restauration de ViewState effectuée. Si le gestionnaire
d'événements Page_Load contient du code concernant la liaison du contrôle, ce code écrase le contenu de
ViewState lors du rechargement des pages, entraînant la perte des événements de clic et des données
d'origine.
●
Ce problème se manifeste en général sous la forme de contrôles ignorant les clics de souris (sélection
DropDownList par exemple) lorsqu'une page est rechargée.
●
Pour éviter que les données et les événements de clic ne soient écrasés, tout code de liaison dans le
gestionnaire d'événements Page_Load est placé dans un bloc conditionnel Not IsPostBack qui empêche que
le code ne soit appelé lors des publications.
62
Cette solution se fonde toutefois sur le principe capital selon lequel les données comme les événements de clic de
souris peuvent être sérialisés dans ViewState. Or, le contrôle CrystalReportViewer se lie à des objets qui ne
peuvent pas être sérialisés (tout particulièrement les classes ReportDocument, ReportClientDocument ou
InfoObject).
Remarque
Il existe toutefois une exception : lorsque le contrôle CrystalReportViewer est lié à un rapport par le biais de son
chemin d'accès au répertoire de fichiers, la chaîne du chemin d'accès peut être rendue persistante dans
ViewState. Dans ce scénario, uniquement le contrôle CrystalReportViewer pourrait être placé dans un bloc
conditionnel Not IsPostBack. Ce scénario de liaison de rapports est toutefois moins puissant et moins utilisé
que les scénarios de liaison aux classes de rapports mentionnés ci-dessus.
Dans la mesure où seuls les événements de clic de souris du contrôle CrystalReportViewer peuvent être sérialisés
dans ViewState, la liaison à une classe de rapport qui ne peut être sérialisée engendre un problème insoluble lors
du rechargement des pages :
●
Si le code de liaison du rapport est placé dans un bloc conditionnel Not IsPostBack, les événements de clic de
souris provenant de ViewState sont conservés, mais la liaison du rapport n'a pas lieu, et une exception est
alors renvoyée.
●
Si le code de liaison du rapport est placé hors du bloc conditionnel, le rapport est lié correctement, mais le
contenu de ViewState est écrasé lors du processus, et les événements de clic de souris sont alors perdus.
Remarque
Cette situation se produit le plus souvent lorsque des clics sont effectués dans un rapport à plusieurs
pages au niveau du contrôle CrystalReportViewer. Le rapport ne cesse alors de revenir mystérieusement
en page 1.
Solution recommandée : placer le code de liaison du contrôle
CrystalReportViewer dans l'événement Init
La solution concernant le contrôle CrystalReportViewer consiste à placer le code de liaison de votre rapport dans
l'événement Init qui s'exécute avant que ViewState ne soit restauré.
Cette solution engendre toutefois une complication. Dans la mesure où l'événement Init est codé moins souvent
que l'événement Load, il est plus difficile d'accès. Dans les projets Web ou Windows pour Visual Studio .NET 2003,
le code qui gère l'événement Init se trouve dans la zone Code généré par le Concepteur Web Form, zone
généralement masquée et réservée au code généré.
Pour contourner le problème, procédez comme suit :
●
Extrayez tout le code de configuration et de liaison du contrôle CrystalReportViewer dans une méthode
d'assistance privée dénommée ConfigureCrystalReports().
●
Dans la zone Code généré par le Concepteur Web Form, placez une seule ligne de code dans le gestionnaire
d'événements Page_Init() ou dans la méthode de déclenchement d'événement OnInit() : un appel à la
méthode d'assistance ConfigureCrystalReports().
Les instructions concernant la création de la méthode d'assistance ConfigureCrystalReports() et son
remplissage sont indiquées dans la section Configuration d'un projet [page 15].
63
1.3.4
Evolutivité de l'application
Lorsque vous planifiez la création d'une application à l'aide du SDK de SAP Crystal Reports, l'un des points les
plus importants à déterminer concerne la manière d'optimiser l'évolutivité de cette application. Vous pouvez faire
évoluer votre application de deux façons :
●
Optimiser les performances de votre application.
●
Optimiser les performances de votre rapport.
La mise en application de ces conventions est décrite dans les sections ci-après.
Evolutivité du code d'application
Avec le SDK de SAP Crystal Reports .Net, l'évolutivité peut être accrue en appliquant les meilleures pratiques
d'amélioration des performances suivantes :
●
Limiter l'utilisation des DataSets.
●
Tirer parti de la mise en cache des rapports.
●
Libérer le rapport de la mémoire après utilisation.
●
Partager le traitement entre les serveurs.
Evolutivité de l'application en réduisant la complexité du rapport
Lorsque vous concevez vos rapports et en particulier lorsque vous concevez des rapports pour le Web, vous
devez tenir compte de leur évolutivité. Les meilleures pratiques suivantes permettent d'optimiser l'évolutivité d'un
rapport.
●
Réduire si possible la taille et la complexité des rapports.
●
Transférer la sélection d'enregistrements vers le serveur de base de données.
●
Utiliser des sous-rapports à la demande.
64
1.3.4.1
Options de mise à niveau
1.3.4.1.1
Solutions de reporting de SAP BusinessObjects
Business Intelligence
La ligne de produits SAP BusinessObjects Business Intelligence contient plusieurs solutions de reporting. La
gamme des produits et les différentes licences de déploiement qui les accompagnent sont conçues pour
répondre à tous les besoins inhérents à une solution de création de rapports en terme d'évolutivité .
Cette page offre un aperçu de chacune de ces solutions de reporting. Vous trouverez des informations
complémentaires sur le site Web de SAP BusinessObjects.
SAP Crystal Reports, version développeur pour Microsoft Visual Studio permet aux développeurs de créer et
d'intégrer rapidement et efficacement des rapports soigneusement présentés dans des applications, tout en
restant dans l'environnement de développement familier de Visual Studio.
SAP Crystal Reports, version développeur pour Microsoft Visual Studio contient la plupart des fonctionnalités
présentes dans SAP Crystal Reports. Celles-ci permettent notamment de créer des rapports, de les connecter à
un contrôle CrystalReportViewer et d'interagir avec eux par programme à l'aide du SDK de SAP Crystal Reports.
SAP Crystal Server ou plateforme SAP BusinessObjects Business Intelligence
Le serveur RAS inclus dans SAP Crystal Reports Server et dans la plateforme SAP BusinessObjects Business
Intelligence améliore considérablement les performances et l'évolutivité en termes de création, de manipulation
et de gestion des rapports.
SAP Crystal Reports Server est un logiciel peu coûteux qui offre tout ce dont vous avez besoin pour créer, gérer et
déployer en toute sécurité des rapports sur le Web. Il prend en charge toutes les étapes du processus de
reporting, de l'accès aux données à la conception, la gestion et la distribution des rapports, en passant par
l'intégration des rapports via des portails et des applications, facilitant ainsi le partage sur le Web de rapports
Crystal nouveaux ou existants.
La plateforme SAP BusinessObjects Business Intelligence est une plateforme multiserveur de Business
Intelligence (BI) conçue pour prendre en charge le reporting à grande échelle et les exigences en matière de BI.
Son environnement multiserveur offre le système de tolérance des pannes, l'équilibrage de la charge, l'évolutivité
et la fiabilité nécessaires pour mener à bien des projets plus stratégiques et de plus grande envergure. La
plateforme SAP BusinessObjects Business Intelligence est également recommandée pour ses fonctionnalités de
reporting avancées telles que l'auditing, l'Explorateur SAP Crystal Reports, le composant Encyclopedia pour
logiciels BusinessObjects Enterprise Premium et Process Tracker.
Pour créer, gérer et déployer en toute sécurité des rapports dans un environnement de petite ou moyenne
envergure, utilisez SAP Crystal Reports Server. Pour des applications stratégiques, des outils de Business
Intelligence supplémentaires et un maximum d'évolutivité, utilisez la plateforme SAP BusinessObjects Business
Intelligence.
65
1.3.4.1.2
Comparaison des solutions de reporting de SAP
BusinessObjects Business Intelligence
Cette table contient des informations qui vous aideront à choisir la solution de reporting SAP BusinessObjects
Business Intelligence adaptée à vos besoins en termes d'évolutivité.
Fonction
SAP Crystal Reports, ver SAP Crystal Reports
sion développeur pour
Microsoft Visual Studio
SAP Crystal Reports Ser
ver ou plateforme SAP
BusinessObjects Busi
ness Intelligence
Prise en charge ASP.NET
X
X
X
Visualisation interactive
des rapports
X
X
X
Connexion unique
X
X
X
Prise en charge des appli
cations Windows
X
X
X
Report Designer amélioré
X
X
Prise en charge de péri
phériques mobiles
X
X
Pilotes de base de don
nées natifs
X
X
Sources de données OLAP
X
X
Vérification des dépen
dances des rapports
X
X
Modèles
X
X
Paramètres de mise en
cascade dynamiques
X
X
Déploiement multi-plate
forme
X
Système de gestion de la
distribution des informa
tions
X
Sécurité intégrée
X
Equilibrage de la charge
X
Référentiel d'objets rap
port
X
Planification des rapports
X
Création et modification
des rapports par program
mation
66
X
X
Fonction
SAP Crystal Reports, ver SAP Crystal Reports
sion développeur pour
Microsoft Visual Studio
SAP Crystal Reports Ser
ver ou plateforme SAP
BusinessObjects Busi
ness Intelligence
Modèle d'objet CrystalRe
portViewer
X
X
X
Modèle d'objet ReportDo
cument
X
X
X
X
X
Modèle d'objet Report
ClientDocument
Serveur RAS
X
Modèle d'objet InfoObject
X
Evolutivité
Faible
Prise en charge de plu
sieurs versions de .Net
Framework
Faible
Moyenne à élevée
X
X
Comparaison des architectures dans les solutions de reporting SAP Business Intelligence [page 41]
1.3.4.1.3
Report Application Server (RAS)
Le serveur RAS peut être utilisé pour créer et modifier des rapports Crystal, ainsi que pour traiter des requêtes
liées aux pages.
Report Application Server (RAS) est l'une des technologies de SAP BusinessObjects. Il s'agit à la fois d'un SDK
client et d'un serveur. Le serveur RAS peut être utilisé pour créer et modifier des rapports Crystal, ainsi que pour
traiter des requêtes liées aux pages. Lorsqu'un processus serveur extrait un rapport demandé, le RAS le transmet
au visualiseur de rapports.
Le serveur RAS n'est disponible qu'en tant que composant de SAP Crystal Reports Server ou de la plateforme
Serveur RAS géré
On appelle serveur RAS géré un serveur RAS dont le fonctionnement est contrôlé par d'autres composants de la
structure Enterprise. SAP Crystal Reports Server et SAP BusinessObjects Enterprise offrent un environnement de
serveurs qui facilite la gestion et la distribution de rapports sur le Web à l'échelle de l'entreprise. Le serveur RAS
géré est l'un des nombreux serveurs de cet environnement. Il peut traiter des rapports situés sur le même
67
ordinateur que le serveur Web et le SDK du RAS (rapports non gérés) ou sur un serveur de référentiel de rapports
distinct (rapports gérés).
Le serveur RAS géré peut utiliser les modèles d'objet ReportClientDocument et InfoObject.
Utilisation de l'API RAS sans serveur RAS
Dans SAP Crystal Reports, vous pouvez accéder à la fonctionnalité avancée de création et de modification de
rapport de l'objet de modèle ReportClientDocument à partir du SDK CR .NET. Le module de déploiement de ce
scénario exige uniquement les assemblys .NET, ce qui signifie que vous utilisez l'API RAS contenue dans les
processus.
Cependant, si vous utilisez l'API RAS contenue dans les processus, vous perdez les avantages de performance et
de stabilité offerts par un système hors processus, orienté serveur. Pour bénéficier de ces avantages, utilisez l'API
RAS conjointement avec un serveur RAS dans un environnement SAP Crystal Reports Server ou de plateforme
Pour en savoir plus et consulter un exemple de code, voir la propriété ReportClientDocument de la classe
CrystalDecisions.CrystalReports.Engine.ReportDocument dans le document de référence de l'API.
Comparaison des architectures dans les solutions de reporting SAP Business Intelligence [page 41]
Modèle d'objet ReportClientDocument (RAS) [page 39]
1.3.4.2
1.3.4.2.1
simples
Optimisation du code
Eviter d'utiliser des DataSets pour des requêtes
La création de rapports à partir de DataSets offre des avantages, mais ces derniers ne doivent pas
nécessairement être utilisés en tant que mécanisme d'accès aux données lorsque l'évolutivité d'une application
est en jeu. Si votre application crée un DataSet uniquement pour un rapport, et plus particulièrement si la requête
utilisée est une requête simple telle que SELECT field 1, field 2 FROM table, l'emploi d'un DataSet
présente peu d'intérêt.
Dans des cas semblables, faire en sorte que SAP Crystal Reports se connecte directement à la base de données
et effectue la requête (comme cela se produit par défaut pour tout rapport créé à l'aide du
SAP Crystal Reports Designer) s'avère plus rapide et consomme moins de mémoire.
Les DataSets sont utiles lorsque :
●
Les données de plusieurs sources de données doivent être combinées.
●
Les données du DataSet doivent être modifiées après l'exécution de la requête.
68
Tutoriel : Connexion aux DataSets ADO.NET [page 549]
1.3.4.2.2
En cas d'utilisation des DataSets, les mettre en
mémoire cache
Les DataSets sont encore plus efficaces en termes d'évolutivité lorsqu'ils sont mis en cache,
Au moment de l'exécution, lorsqu'un rapport est chargé, le moteur de rapport SAP Crystal Reports tente de
regrouper les connexions à la base de données. Par exemple, si trois utilisateurs consultent la même page ASPX
avec le même rapport, ces trois requêtes sont regroupées dans une seule connexion à la base de données.
Toutefois, la requête elle-même n'est pas regroupée. Même si elle est identique dans les trois cas, la requête doit
être exécutée chaque fois qu'un rapport est demandé par le moteur de rapport. Dans le cas d'une requête lente ou
d'un ensemble de données volumineux, ce mode de requête par utilisateur peut constituer un goulot
d'étranglement pour l'application.
L'exécution répétée de cette même requête par utilisateur pour remplir un DataSet de manière redondante
s'avèrerait encore pire au niveau de la charge de mémoire.
Pour réduire le nombre de requêtes envoyées à la base de données, placez le DataSet dans l'objet Cache ASP.NET
après la première requête de sorte que toutes les tâches de rapport partagent ce même DataSet dans le Cache.
Connexion aux DataSets ADO.NET [page 159]
Création de rapports à partir de DataSets ADO.NET [page 667]
Explique comment connecter votre rapport à un DataSet ADO.NET.
1.3.4.2.3
Utiliser la méthode Close() pour libérer le rapport
Utilisez l'une des méthodes Close() disponibles pour libérer la mémoire utilisée par le rapport.
Une autre façon d'optimiser l'évolutivité dans un projet SAP Crystal Reports, version développeur pour Microsoft
Visual Studio consiste à utiliser l'une des méthodes Close() disponibles pour libérer la mémoire utilisée par le
rapport.
Deux méthodes Close() sont disponibles :
●
ReportDocument.Close() qui est utilisée avec SAP Crystal Reports ;
●
ReportClientDocument.Close() qui est utilisée avec le SDK du RAS.
69
Méthode ReportDocument.Close()
Vous pouvez utiliser la méthode ReportDocument.Close() pour libérer la mémoire consommée par le rapport
Crystal sur le serveur Web.
Le mode d'accès à la méthode ReportDocument.Close() varie selon que le rapport est incorporé ou non
incorporé :
●
Si le rapport est incorporé, une classe wrapper de rapport est générée pour représenter le rapport dans du
code. Cette classe wrapper de rapport hérite de ReportDocument et permet d'accéder à la méthode Close()
par héritage.
●
Si le rapport est non incorporé, il est chargé depuis le répertoire de fichiers dans une instance de
ReportDocument, ce qui permet d'accéder à la méthode Close() directement à partir de la classe
ReportDocument.
Le rapport Crystal et l'instance ReportDocument consomment tous deux de la mémoire. Une fois que l'instance
ReportDocument est libérée de la mémoire, le rapport continue d'utiliser la mémoire.
Ainsi, l'instance ReportDocument est mise hors de portée lorsque le chargement de la page Web est terminé.
Lorsque le garbage collection .NET supprime l'instance ReportDocument, la mémoire utilisée par celle-ci est
libérée sur le serveur Web.
Le rapport demeure quant à lui en mémoire sur le serveur Web. Il ne peut pas être supprimé, car il n'existe plus
d'instance ReportDocument pour y accéder. Lorsque ces circonstances se répètent à grande échelle, la mémoire
du serveur Web se remplit de rapports auxquels on ne peut plus accéder.
Pour résoudre ce problème, appelez la méthode ReportDocument.Close(). Le rapport est ainsi fermé sur le
serveur Web et la mémoire est libérée pour d'autres rapports.
A quel moment appeler la méthode ReportDocument.Close()
La méthode ReportDocument.Close() ne doit pas être appelée sur la page avant que le rapport n'ait été affiché,
car même si le rapport a été fermé, ReportDocument le rouvrira s'il est de nouveau référencé. La méthode Close()
ne doit être appelée qu'une fois le processus d'affichage terminé.
L'événement Page_Unload représente le moment adéquat pour appeler la méthode Close().
Méthode ReportClientDocument.Close()
Lorsque vous utilisez un serveur RAS géré ou non géré, les rapports sont stockés sur le Report Application Server,
mais ils sont représentés sur le serveur Web par une instance de ReportClientDocument. Si l'instance
ReportClientDocument est mise hors de portée sans avoir appelé la méthode ReportClientDocument.Close(), le
Report Application Server conserve le rapport ouvert en mémoire, même lorsque l'on ne peut plus y accéder.
Lorsque ces circonstances se répètent à grande échelle, la mémoire du Report Application Server se remplit de
rapports auxquels on ne peut plus accéder sur le serveur Web.
Pour résoudre ce problème, appelez la méthode ReportClientDocument.Close(). Le rapport est fermé sur le
Report Application Server et la mémoire est libérée pour d'autres rapports.
70
A quel moment appeler la méthode ReportClientDocument.Close()
La méthode Close() ne doit pas être appelée sur la page avant que le rapport n'ait été affiché, car le rapport doit
rester ouvert sur le serveur jusqu'à la fin du processus d'affichage.
Pour une instance ReportClientDocument, la méthode Close() ferme immédiatement le rapport, qui ne peut alors
plus être rouvert. Par conséquent, si la méthode Close() est appelée avant l'affichage du rapport, celui-ci sera
inaccessible et une exception sera renvoyée.
L'événement Page_Unload représente le moment adéquat pour appeler la méthode Close().
Comparaison des rapports incorporés et non incorporés [page 165]
1.3.4.2.4 Configurer une batterie de serveurs Web ou un
jardin Web
Une batterie de serveurs Web permet d'étendre un site Web sur plusieurs serveurs. Un jardin Web permet
d'étendre un site Web sur plusieurs ordinateurs sur un seul serveur. Etendre la charge du processus de rapport à
travers plusieurs CPU ou plusieurs serveurs peut améliorer la performance de votre application Web de reporting.
Utilisation de SAP Crystal Reports dans une batterie de serveurs Web ou un jardin Web [page 75]
1.3.4.3
1.3.4.3.1
Optimisation des rapports
Utiliser des rapports moins volumineux
Visual Studio, consiste à réduire la taille des rapports.
Faites en sorte, si possible, que vos rapports contiennent moins de 15 pages. Dans les applications Web, les
utilisateurs souhaitent souvent ne consulter que quelques informations importantes et non des pages et des
pages de données.
Il se peut que les rapports utilisés dans les applications de bureau ne soient plus adaptés aux applications Web.
Pour réduire la taille des rapports, utilisez des formules de sélection d'enregistrements afin de limiter le nombre
d'enregistrements renvoyés dans les rapports. Vous avez pour cela le choix entre trois possibilités :
71
●
Vous pouvez coder en dur une formule de sélection d'enregistrements dans le rapport à l'aide du
SAP Crystal Reports Designer incorporé.
●
Vous pouvez filtrer par programmation de manière encore plus précise les enregistrements qui ont été
extraits du rapport.
○
Avec le modèle d'objet CrystalReportViewer, utilisez la propriété SelectionFormula ou
ViewTimeSelectionFormula de CrystalReportViewer.
○
Avec le modèle d'objet ReportDocument, utilisez la propriété RecordSelectionFormula de
ReportDocument.
Tutoriel : Filtrage des données à l'aide des formules de sélection [page 290]
Dans ce tutoriel, vous allez apprendre à utiliser des formules de sélection afin de filtrer les enregistrements à
afficher dans un rapport Crystal.
1.3.4.3.2
Utiliser des graphiques moins volumineux
Visual Studio, consiste à réduire la taille des graphiques utilisés dans les rapports.
Il ne s'agit pas de supprimer les graphiques des rapports lorsque l'évolutivité d'une application est en question,
mais vous devez les utiliser avec modération en raison de leur forte consommation de ressources système.
Lorsqu'un rapport contenant un graphique (diagramme ou image) est affiché dans un contrôle
CrystalReportViewer, le moteur de rapport doit créer un fichier JPG temporaire (dans le dossier dynamic_images)
et le navigateur doit effectuer une demande distincte auprès du serveur Web pour pouvoir l'extraire.
Le contrôle CrystalReportViewer recherche également de façon régulière des anciennes images dans le dossier
dynamic_images afin de les supprimer. Cet accès au disque peut réduire les performances du rapport. Une
utilisation limitée des diagrammes et des images réduit l'accès au disque à son minimum.
Configuration du fichier Web.Config [page 20]
Répertoire des visualiseurs [page 14]
72
1.3.4.3.3
demande
Redéfinir les sous-rapports pour réduire la
Le fait de modifier la méthode d'utilisation des sous-rapports dans votre application peut avoir un impact
important sur les performances de votre application.
Visual Studio, consiste à refactoriser les appels aux sous-rapports afin de réduire la demande.
A propos de l'utilisation des sous-rapports
Si les sous-rapports peuvent être fréquemment utilisés pour créer des rapports complexes, ils représentent une
charge considérable. Cela ne veut pas dire pour autant que vous ne devez pas en utiliser. Toutefois, leur utilisation
doit être limitée.
Notez également que lorsque des sous-rapports sont placés dans des sections qui se répètent (en-têtes de
groupes ou section Détails par exemple), chaque instance de sous-rapport requiert sa propre tâche de rapport.
Cela signifie qu'un rapport contenant 100 enregistrements avec un sous-rapport dans la section Détails implique
en réalité l'exécution de 101 tâches de rapport.
Refactorisation des sous-rapports en tant que contrôle DataGrid .NET lié à des
rapports
Les sous-rapports sont généralement utilisés dans un modèle résumé/détails :
●
Le rapport principal affiche les lignes de résumé.
●
Chaque ligne est liée à un sous-rapport qui contient un rapport de détails.
S'il n'est pas nécessaire d'imprimer les données de résumé, présentez-les dans une liste de lignes plutôt que dans
un rapport. En d'autres termes, au lieu d'utiliser en tant que résumé un rapport lié à plusieurs sous-rapports pour
les détails, utilisez un contrôle DataGrid .NET qui se lie à plusieurs rapports standard pour les détails. L'utilisation
du contrôle DataGrid .NET en tant que résumé constitue une solution plus simple et plus évolutive.
Pour cela, liez un jeu de résultats de données à un contrôle DataGrid, avec un lien permettant d'accéder au
rapport sur chaque ID de ligne. Un seul rapport est ainsi utilisé pour chaque ligne (avec un paramètre qui accepte
un ID unique qui lui a été transmis par l'URL de l'ID de ligne du contrôle DataGrid).
Dans ce scénario, aucun traitement de rapport n'est effectué lorsque le contrôle DataGrid s'affiche. Il intervient
uniquement lorsque l'un des liens contenus dans le contrôle DataGrid est sélectionné.
73
1.3.4.3.4 Ne pas utiliser de champs bloquant le traitement à
la demande
Visual Studio, consiste à ne pas utiliser de champs qui bloquent le traitement à la demande.
SAP Crystal Reports traite les rapports à la demande. Par exemple, si la première page d'un rapport doit être
affichée, Crystal Reports ne traite que cette première page, et non le rapport dans son intégralité. Toutefois, le fait
d'insérer dans la première page d'un rapport des champs ou des formules qui impliquent que le rapport soit traité
en entier empêche le traitement à la demande.
Si par exemple le champ spécial "Page N/M" est placé dans la première page d'un rapport, ce dernier doit être
traité dans son intégralité pour déterminer son nombre total de pages et ainsi assurer le rendu du champ. La
première page doit donc attendre que la totalité du rapport ait été traitée avant de pouvoir s'afficher. Il se produit
la même chose lorsque vous utilisez un champ pourcentage de résumé pour vos calculs.
Il est donc déconseillé d'utiliser ces types de champ.
1.3.4.3.5
Sélection de l'option Aucune imprimante sous
Configuration de l'impression
La sélection de l'option Aucune imprimante sous Configuration de l'impression est une autre façon d'optimiser
l'évolutivité dans un projet SAP Crystal Reports, version développeur pour Microsoft Visual Studio.
Option Aucune imprimante
Généralement, lorsque vous créez un rapport Crystal, une imprimante par défaut a été sélectionnée sur
l'ordinateur de développement. Cette imprimante par défaut détermine la présentation des images, des polices et
des champs de base de données du rapport.
La sélection d'une imprimante par défaut a pour avantage d'assurer l'uniformité de l'affichage des rapports : ceuxci s'affichent selon la présentation définie au niveau de l'imprimante par défaut. L'inconvénient est que cela peut
poser un problème en termes d'évolutivité.
Par exemple, certains pilotes d'impression présentent des fuites de mémoire ou des fuites de descripteurs de
fichiers. Si un rapport est configuré pour un pilote d'impression présentant l'un de ces problèmes, les
performances du rapport seront également affectées.
Par conséquent, pour assurer l'évolutivité, il est recommandé de modifier le rapport de manière à ce qu'il n'utilise
aucun pilote d'impression.
Remarque
Le fait de ne configurer aucun pilote d'impression pour votre rapport peut notamment avoir pour conséquence
une différence de présentation du rapport par rapport au résultat obtenu depuis l'imprimante souhaitée. Après
avoir défini l'option Aucune imprimante pour le rapport, il est recommandé de le tester sur l'imprimante
souhaitée. Si nécessaire, modifiez la présentation du rapport.
74
Suppression du pilote de l'imprimante par défaut de votre rapport [page 123]
1.3.5
Utilisation de SAP Crystal Reports dans une batterie de
serveurs Web ou un jardin Web
Cette section présente brièvement comment utiliser un site Web SAP Crystal Reports, version développeur pour
Microsoft Visual Studio, dans une batterie de serveurs Web ou dans un jardin Web.
Une batterie de serveurs Web permet d'étendre un site Web sur plusieurs serveurs. Un jardin Web permet
d'étendre un site Web sur plusieurs processeurs au sein d'un serveur unique. La répartition de la charge de travail
liée au traitement de rapport sur plusieurs processeurs ou plusieurs serveurs peut améliorer les performances de
votre application de reporting basée sur le Web.
1.3.5.1
Architecture d'une batterie de serveurs Web ou d'un
jardin Web
Architecture de la batterie de serveurs Web
Une batterie de serveurs Web se compose de plusieurs serveurs exposés aux navigateurs clients sous la forme
d'un serveur virtuel unique, avec une carte Media Access virtuelle et une adresse TCP/IP.
Derrière cette couche virtuelle, chaque serveur de la batterie de serveurs Web reçoit tous les paquets du réseau,
mais ne traite qu'un sous-ensemble de ces paquets. La capacité à partager de manière égale la charge de travail
est ce qui confère aux batteries de serveurs Web une puissance de traitement extrêmement performante.
Cette distribution des paquets est gérée par l'équilibrage de la charge réseau. L'équilibrage de la charge réseau
effectue les opérations suivantes :
●
Répartit équitablement les demandes du client entre les serveurs.
●
Détermine quel serveur traitera une demande donnée.
●
Vérifie que l'utilisation des ressources du serveur et les temps d'attente du client sont optimisés.
●
Offre des alternatives performantes à l'affinité du client.
Remarque
Dans un scénario d'affinité du client, les clients qui se connectent sont limités de sorte qu'ils reviennent
chaque fois vers le même serveur.
L'affinité du client est généralement désactivée car elle peut créer un goulot d'étranglement en raison des
demandes destinées à un serveur particulier.
Chaque serveur d'une batterie de serveurs Web dispose d'un pilote de périphérique réseau d'équilibrage de la
charge réseau qui communique avec les autres serveurs, et chaque serveur est généralement doté de deux cartes
75
réseau. La seconde carte permet les communications internes pour que l'équilibrage de la charge réseau puisse
s'effectuer sur un autre réseau interne.
Le pilote de périphérique réseau d'équilibrage de la charge réseau est fourni avec la famille Windows Server des
systèmes d'exploitation.
Architecture du jardin Web
Un jardin Web est identique à une batterie de serveurs Web, excepté qu'au lieu d'utiliser plusieurs serveurs reliés
entre eux, il utilise un seul ordinateur doté de plusieurs processeurs.
Le serveur SMP (multitraitement symétrique) unique utilise ASP.NET pour exécuter un processus de traitement
ASP.NET séparé sur chaque processeur. Ce serveur gère plusieurs demandes de clients sur ses différents
processeurs.
1.3.5.2
Processus de traitement ASP.NET
ASP.NET s'exécute dans le cadre d'un processus appelé processus de traitement ASP.NET. Toutes les
fonctionnalités ASP.NET s'exécutent dans le cadre de ce processus.
Un serveur Web standard contient un seul processus de traitement ASP.NET. Ce n'est pas le cas des batteries de
serveurs Web et des jardins Web :
●
Une batterie de serveurs Web contient plusieurs processus de traitement ASP.NET.
Chaque serveur du groupe de serveurs gère un processus de traitement ASP.NET séparé.
●
Un jardin Web contient plusieurs processus de traitement ASP.NET.
Chaque processeur du serveur SMP gère un processus de traitement ASP.NET séparé.
Choix d'un processus de traitement ASP.NET
Lorsqu'un client Web se connecte à une batterie de serveurs Web ou un jardin Web, l'un des différents processus
de traitement ASP.NET est sélectionné pour exécuter la demande.
●
Dans une batterie de serveurs Web, l'équilibrage de la charge réseau détermine le processus de traitement
ASP.NET sélectionné.
●
Dans un jardin Web, le processus de traitement ASP.NET sélectionné est déterminé par ASP.NET.
Gestion de l'état avec plusieurs processus de traitement ASP.NET
Lorsque l'on passe d'un scénario avec un seul processus de traitement ASP.NET (un serveur Web standard) à un
scénario avec plusieurs processus de traitement ASP.NET (une batterie de serveurs Web ou un jardin Web), des
complications apparaissent au niveau de la gestion de l'état.
76
Les pages Web sont sans état ; un serveur Web doit donc assurer la persistance de l'état par d'autres moyens. Les
moyens les plus courants de gérer un état sur le serveur Web sont l'état de session et le cache ASP.NET.
Session et Cache sont tous deux contenus dans l'espace mémoire d'un seul processus de traitement ASP.NET.
Mais dans une batterie de serveurs Web ou un jardin Web, plusieurs processus de traitement ASP.NET
fonctionnent simultanément. Ni Session ni Cache ne peuvent gérer l'état de plusieurs processus au sein d'un seul
processus de traitement ASP.NET.
Par conséquent, une couche supplémentaire est requise pour la gestion de l'état : un serveur d'état de session
hors processus qui stocke et extrait les informations sur l'état de chaque processus de traitement ASP.NET dans
la batterie de serveurs Web ou l
Etat de session hors processus [page 77]
1.3.5.3
Etat de session hors processus
Dans les batteries de serveurs Web et les jardins Web, l'état de session doit être partagé à travers plusieurs
serveurs à l'aide d'une forme d'état de session hors processus.
Deux solutions sont couramment utilisées :
●
Déployer le serveur d'état de session hors processus fourni avec ASP.NET.
●
Configurer manuellement chaque serveur Web pour stocker les données d'état de session sur un serveur SQL
Server.
Obligation de sérialisation
Dans les deux solutions, tous les objets à stocker doivent être sérialisables. Si un objet ne peut pas être sérialisé, il
ne peut pas être rendu persistant sur un serveur d'état hors processus.
Remarque
Tous les modèles d'objet du SDK de SAP Crystal Reports ne peuvent pas être sérialisés. Toutefois, SAP fournit
une solution de mise à niveau pour gérer l'état des rapports à l'aide d'un serveur hors processus.
Modèles d'objet sérialisables dans SAP Crystal Reports [page 78]
77
1.3.5.4
Modèles d'objet sérialisables dans
SAP Crystal Reports
Quatre modèles d'objet sont disponibles pour SAP Crystal Reports : deux sont fournis avec SAP Crystal Reports
et deux sont disponibles par mise à niveau.
Cette section explique quels modèles d'objet peuvent être sérialisés pour être utilisés avec un serveur d'état de
session hors processus.
Remarque
Pour une présentation de l'état de session hors processus, voir Etat de session hors processus [page 77].
Sérialisation et modèle d'objet CrystalReportViewer
Le modèle d'objet CrystalReportViewer est un modèle d'objet limité inclus avec l'API du contrôle
CrystalReportViewer. En raison de la portée limitée de ce modèle d'objet, il n'est généralement pas
recommandé. On conseille plutôt d'utiliser le modèle d'objet plus puissant ReportDocument.
Toutefois, le modèle d'objet CrystalReportViewer peut être utilisé dans une batterie de serveurs Web ou un
jardin Web. En effet, CrystalReportViewer est contenu dans un contrôle Web et la persistance du contrôle
Web est gérée côté client, avec ViewState. La persistance ViewState place l'état des contrôles serveur Web
ASP.NET dans une chaîne cryptée, puis inclut cette chaîne cryptée sous la forme d'un champ de formulaire
masqué dans la page ASPX durant le rechargement de la page. Les informations sur l'état peuvent être fournies à
n'importe quel processus de traitement ASP.NET.
Remarque
Cette forme de persistance du client fonctionne uniquement au moment du rechargement de la page.
ViewState ne peut pas assurer la persistance des informations à travers les pages.
Sérialisation et modèle d'objet ReportDocument
Le modèle d'objet ReportDocument est plus puissant que CrystalReportViewer et son utilisation est par
conséquent généralement recommandée dans SAP Crystal Reports.
Toutefois, dans SAP Crystal Reports versions 9 et antérieures, la classe ReportDocument n'a pas pu être
sérialisée et par conséquent, n'a pas pu être utilisée avec un serveur d'état de session hors processus dans une
batterie de serveurs Web ou un jardin Web.
Ce problème a été résolu dans SAP Crystal Reports 10 et versions ultérieures en rapprochant le modèle d'objet
ReportDocument d'un objet sérialisable, ReportClientDocument.
Le modèle d'objet ReportClientDocument est accessible de plusieurs manières.
78
Pour utiliser le modèle d'objet ReportDocument dans une batterie de serveurs Web ou un jardin Web, il faut que
le serveur d'état de session hors processus ASP.NET stocke l'état de l'instance ReportDocument sérialisée et
que le serveur RAS non géré stocke le fichier de rapport Crystal .rpt.
Remarque
Vous ne pouvez sérialiser le modèle d'objet ReportDocument que si vous avez installé le serveur RAS et
configuré les propriétés ReportDocument.ReportAppServer et ReportDocument.EnterpriseSession
de telle sorte qu'elles désignent ce serveur.
Sérialisation et modèle d'objet ReportClientDocument
Le modèle d'objet ReportClientDocument peut être sérialisé. Le modèle d'objet ReportClientDocument est
accessible de plusieurs manières.
Modèle d'objet InfoObject
Le modèle d'objet InfoObject fait partie de la solution de mise à niveau de Crystal, de
SAP Crystal Reports Server et la plateforme SAP BusinessObjects Business Intelligence sont des solutions
d'entreprise multiserveur qui servent généralement d'alternative à une batterie de serveurs Web ou un jardin Web
existant.
Utilisation de SAP Crystal Reports dans une batterie de serveurs Web ou un jardin Web [page 75]
1.3.5.5
Configuration de SAP Crystal Reports pour une
batterie de serveurs Web ou un jardin Web
Serveurs supplémentaires
En plus des serveurs de la batterie de serveurs Web ou du jardin Web, deux serveurs supplémentaires sont
nécessaires :
●
Le serveur d'état de session hors processus ASP.NET, pour stocker l'état de l'instance ReportDocument
sérialisée.
79
●
Un serveur RAS non géré pour stocker le fichier de rapport Crystal .rpt.
Remarque
Pour en savoir plus, voir Solutions de reporting de SAP BusinessObjects Business Intelligence [page 65].
Utilisation particulière de ReportDocument
La batterie de serveurs Web ou le jardin Web utilise le serveur d'état de session hors processus ASP.NET pour
stocker l'objet ReportDocument sérialisé. Dans ce scénario, l'objet ReportDocument n'est pas utilisé de la même
façon que dans une installation classique de SAP Crystal Reports.
En effet, la méthode ReportDocument.Load() ou la propriété ReportDocument.FileName lie l'instance
ReportDocument à un rapport hors processus stocké sur le serveur RAS non géré. Pour avoir des exemples de
l'utilisation de ces solutions, voir les informations de configuration ci-dessous.
Remarque
Le stockage du fichier de rapport .rpt sur le serveur RAS non géré hors processus signifie que chaque
processus de traitement ASP.NET dans la batterie de serveurs Web ou le jardin Web peut accéder au même
fichier de rapport .rpt à partir d'un emplacement central.
Configuration de ReportDocument pour le serveur RAS non géré
La relation entre l'instance ReportDocument et le serveur RAS non géré peut être configurée de l'une des
manières suivantes :
●
Chargez le rapport Crystal incorporé local de l'instance ReportDocument sur le serveur RAS non géré au
moment de l'exécution. Ceci permet de stocker temporairement le fichier de rapport .rpt sur le serveur RAS
non géré hors processus.
●
Associez un rapport externe stocké en permanence sur le serveur RAS non géré hors processus à l'instance
ReportDocument, en affectant le chemin d'accès au répertoire du fichier de rapport sur le serveur RAS non
géré à la propriété FileName de l'instance ReportDocument.
Instance ReportDocument sur le serveur d'état de session, fichier .rpt sur le
serveur RAS non géré
L'instance ReportDocument, qui peut être sérialisée lorsqu'elle est utilisée en coopération avec la solution de mise
à niveau Crystal du RAS non géré, est stockée sur le serveur d'état de session hors processus ASP.NET.
Etant donné que l'instance ReportDocument reste active sur le serveur d'état de session, le fichier de rapport
Crystal .rpt associé à l'instance ReportDocument reste ouvert sur le serveur RAS non géré.
80
Dans la batterie de serveurs Web ou le jardin Web, lorsqu'un autre processus de traitement ASP.NET extrait
l'instance ReportDocument à partir du serveur d'état de session hors processus, l'instance ReportDocument
accède au fichier .rpt associé à partir du serveur RAS non géré.
Ecriture d'image sur le partage réseau
Il vous faut configurer un détail supplémentaire lorsque vous utilisez une batterie de serveurs Web.
Les images qui sont écrites durant le processus de création de rapports (telles que les diagrammes dynamiques)
doivent être placées sur un partage réseau commun pour que n'importe quel processus de traitement ASP.NET
puisse y accéder. Chaque ordinateur doit être configuré pour écrire les images sur le même partage réseau et
pour accorder des autorisations d'accès au compte de traitement ASP.NET sur chaque ordinateur qui écrit sur ce
partage.
Pour configurer un ordinateur afin qu'il puisse accéder à ce répertoire, ajoutez les informations ci-dessous à votre
registre.
[HKEY_LOCAL_MACHINE\SOFTWARE\Business Objects\Suite 12.0\Report Application Server
\Viewer]
"CrystalImageDir"="\\fileserver\images"
Instructions de configuration détaillées
Pour des informations détaillées sur les problèmes de configuration posés par l'exécution de SAP Crystal Reports
dans une batterie de serveurs Web ou un jardin Web, consultez le site Web du support technique.
1.3.6
Utilisation de Crystal Reports en tant que service Web
Cette section explique comment utiliser des rapports Crystal qui ont été publiés en tant que services Web de
rapports.
Les services Web permettent de partager les données et les fonctionnalités de différentes applications. Un logiciel
de comptabilité peut ainsi être connecté à un logiciel de gestion de commandes client par exemple. Les services
Web peuvent également être utilisés entre différentes sociétés afin de partager leurs données et leurs
applications.
Les services Web sont indépendants de toute technologie de composants ou convention d'appel d'objets pour les
raisons suivantes :
●
Ils utilisent le protocole HTTP en tant que protocole Web.
●
Ils font appel au langage XML.
●
Ils prennent en charge SSL (Secure Socket Layer).
Tout programme peut accéder aux services Web, quels que soient son langage de programmation, le modèle de
composant ou le système d'exploitation utilisé.
81
SAP Crystal Reports permet de publier et d'utiliser facilement des rapports en tant que services Web de rapports.
Les applications Web et Windows peuvent être connectées à un service Web de rapports et afficher le rapport
Crystal exposé par ce service.
1.3.6.1
Publication et utilisation d'un rapport en tant que
service Web
Dans SAP Crystal Reports, version développeur pour Microsoft Visual Studio, vous pouvez publier des rapports
Crystal en tant que services Web.
Publication d'un rapport en tant que service Web de rapports
Dans SAP Crystal Reports, version développeur pour Microsoft Visual Studio, lorsque vous sélectionnez l'option
permettant de publier un rapport Crystal dans un service Web de rapports, ce dernier est compilé en DLL et un
fichier XML portant l'extension ".asmx" (fichier des services Web .NET) est alors généré. Ce fichier .ASMX décrit
les fonctions publiques, les paramètres d'entrée, les types de données et les types de données renvoyées qui sont
exposés par le service Web de rapports. Les fichiers DLL et ASMX sont publiés sur le serveur Web en tant que
services Web de rapports. Le service Web de rapports peut désormais être appelé par l'intermédiaire de son URL
par une application cliente à partir d'un navigateur Web. Les données sont transmises depuis et vers le service
Web via le protocole HTTP sous forme de langage XML.
Utilisation du rapport en tant que fichier de service Web de rapports dans une
application cliente
Pour accéder à partir d'une application cliente au service Web de rapports publié, vous devez transmettre la
chaîne URL de ce dernier à la propriété ReportSource du contrôle CrystalReportViewer à partir d'un site Web ou
d'un projet Windows.
Utilisation des services Crystal [page 84]
Utilisation de Crystal Reports en tant que service Web [page 81]
82
1.3.6.1.1
Pour publier un service Web de rapports
Prérequis
Avant de commencer, vous devez disposer d'un rapport Crystal existant. Le rapport est publié en tant que service
Web, qui peut ensuite être utilisé par la propriété CrystalReportViewer.ReportSource.
Procédure
1.
Démarrez Visual Studio.
2.
Dans le menu Fichier, sélectionnez Nouveau, puis cliquez sur Site Web.
3.
Dans la liste Modèles Visual Studio installés, cliquez sur Service Web ASP.NET.
4.
Dans le champ Emplacement, saisissez le nom et le chemin d'accès du répertoire de fichiers de votre service
Web.
C:\WebServices\MyCrystalReportsWebServices
5.
Cliquez sur OK.
6.
Dans l'Explorateur de solutions, cliquez avec le bouton droit de la souris sur le nom de projet affiché en gras,
puis sélectionnez Ajouter un élément existant.
7.
Dans la boîte de dialogue Ajouter un élément existant, sélectionnez Tous les fichiers (*.*) sous Types de
fichiers.
8.
Ajoutez un rapport existant Crystal à votre projet.
9.
Cliquez avec le bouton droit de la souris sur le rapport, puis sélectionnez Publier en tant que service Web.
Un nouveau service est créé.
10. Cliquez avec le bouton droit de la souris sur Service Web, puis sélectionnez Définir comme page de début.
Lorsque vous exécutez votre application, le nouveau service Web s'affiche dans le navigateur Web. Vous
pouvez utiliser l'URL du service Web en tant que source du rapport pour un contrôle CrystalReportViewer.
Remarque
Dans Visual Studio 2005 et versions ultérieures, le serveur Web utilisé par défaut pour afficher l'aperçu des
sites et des services Web n'est pas IIS, mais le serveur Web Visual Web Developer. Lorsque vous utilisez ce
serveur Web, l'URL contient uniquement un numéro de port temporaire et aléatoire, valide uniquement au
moment de la compilation. Pour accéder à l'URL du service Web à partir d'une application cliente, vous
devez tout d'abord configurer le répertoire de fichiers du projet de service Web en tant que répertoire
virtuel dans IIS. Ce répertoire virtuel fournit alors une URL cohérente qu'il est possible d'appeler à partir de
l'application cliente.
83
1.3.6.1.2
Pour utiliser le service Web de rapports à partir
d'un projet client
Prérequis
Avant de commencer, vous devez disposer d'un accès à un rapport ayant déjà été publié en tant que service Web.
Procédure
1.
Ajoutez le contrôle CrystalReportViewer à votre site Web ou votre application Windows.
2.
3.
Affectez l'URL d'un service Web de rapports à la propriété ReportSource de la classe
myCrystalReportViewer.ReportSource =
"http://localhost/MyCrystalReportsWebService/Hierarchical_GroupingService.asmx"
crystalReportViewer.ReportSource =
"http://localhost/MyCrystalReportsWebService/Hierarchical_GroupingService.asmx";
Résultats
Lorsque vous exécutez votre application, le contrôle CrystalReportViewer affiche le rapport publié par le service
Web.
1.3.6.2
Utilisation des services Crystal
SAP Crystal Reports, version développeur pour Microsoft Visual Studio, permet de se connecter par
programmation aux rapports via le service Web des services Crystal. Les services Crystal facilitent la connexion
aux rapports exposés par différents serveurs du réseau.
Les sources des rapports sous-jacentes et les classes que ces derniers génèrent (lorsqu'ils sont déplacés par
glissement dans un Web Form ou un Windows Form) varient au fil des versions successives de SAP Crystal
Reports.
84
Utilisation des services Crystal avec SAP Crystal Reports 2005 ou une version
plus récente
Dans Visual Studio 2005, les services Crystal sont accessibles par programmation. Ils permettent de générer une
liste de rapports disponibles sur un ordinateur local ou distant, ainsi que d'accéder à ces rapports via un service
Web.
Le code de connexion doit être saisi manuellement dans SAP Crystal Reports, version développeur pour Microsoft
Visual Studio.
Les services Crystal utilisent le protocole des services Web de rapports pour accéder à un répertoire virtuel du
serveur, appelé répertoire virtuel des visualiseurs.
Utilisation des services Crystal avec SAP Crystal Reports pour
Visual Studio .NET 2003
Dans SAP Crystal Reports pour Visual Studio 2003, les services Crystal étaient accessibles à partir de
l'Explorateur de serveurs.
Le sous-nœud Services Crystal de chaque serveur se développe pour afficher d'autres sous-nœuds. Le nom de
ces sous-nœuds varie en fonction des versions de SAP Crystal Reports, mais ils ont un comportement commun :
chaque sous-nœud Services Crystal se développe pour afficher une liste de rapports à partir du répertoire de
fichiers de l'ordinateur local ou à partir des serveurs du réseau.
Un sous-nœud Services Crystal peut parfois utiliser le protocole des services Web de rapports. Dans ce cas, il
l'utilise pour accéder à un répertoire virtuel du serveur, appelé répertoire virtuel des visualiseurs.
Dans d'autres cas, une connexion directe est établie avec un serveur RAS non géré, SAP Crystal Reports Server
ou la plateforme SAP BusinessObjects Business Intelligence. Dans ce cas, le protocole des services Web de
rapports n'est pas utilisé.
Il se peut que vous deviez ajuster vos paramètres de pare-feu afin d'accéder au CMS de la plateforme SAP
BusinessObjects Business Intelligence. Le port par défaut pour le CMS est 6400. Contactez votre administrateur
système pour plus d'informations sur l'adresse réseau et les paramètres de port de votre système de plateforme
SAP BusinessObjects Business Intelligence. Pour plus d'informations sur la personnalisation des ports, voir le
Guide d'administration de la plateforme SAP BusinessObjects Business Intelligence.
Remarque
Les nœuds disponibles dépendent de la configuration et du contrat de licence dont vous disposez.
Un rapport exposé via le nœud Services Crystal peut être déplacé par une simple opération glisser-déplacer vers
la barre d'état des composants d'un Web Form ou d'un Windows Form dans Visual Studio NET 2003.
85
1.3.6.3
Crystal
Configuration des fichiers serveur dans les services
Parmi les groupes de services Crystal fournis avec SAP Crystal Reports, version développeur pour Microsoft
Visual Studio, figurent les fichiers serveur. Les fichiers serveur constituent un ensemble de services Web de
rapports qui sont exposés par le biais d'un répertoire virtuel à partir du chemin d'accès à un répertoire de fichiers
situé sur le disque dur.
Différentes conditions d'implémentation sont requises pour chaque version de Visual Studio.
1.3.6.3.1
Configuration des fichiers serveur dans Visual
Studio .NET 2003
Les fichiers serveur correspondent à un ensemble de services Web de rapports qui sont exposés à partir du
répertoire virtuel des visualiseurs dans IIS. Les fichiers serveur étaient à l'origine fournis sous la forme d'un nœud
Services Crystal dans SAP Crystal Reports pour Visual Studio .NET 2002, mais ce nœud a depuis été supprimé.
Chaque nouvelle version de SAP Crystal Reports continue à prendre en charge les fichiers serveur dans le SDK,
mais leur utilisation nécessite une configuration particulière pour chaque version.
Les fichiers serveur sont générés à partir des fichiers de rapport sous-jacents figurant dans le dossier des
exemples de rapports (ou tout autre dossier désigné) du chemin d'accès au répertoire de fichiers du serveur Web.
Vous pouvez accéder aux fichiers serveur de deux manières :
●
Via un nœud visible sous Services Crystal.
Ce mode d'accès est uniquement disponible dans SAP Crystal Reports pour Visual Studio 2003.
●
En programmant la classe ServerFileReport dans le SDK.
Vous pouvez accéder aux fichiers serveur par le biais du SDK avec toutes les versions de
SAP Crystal Reports .NET.
Les fichiers serveur sont exposés par le biais d'un répertoire virtuel dans IIS. La connexion aux fichiers de rapport
sous-jacents nécessite la configuration des droits d'accès au dossier.
Les droits d'accès sont configurés par le biais d'une entrée de fichier web.config.
Configuration des fichiers serveur dans Visual Studio .NET 2003
Dans Visual Studio .NET 2003, le dossier de configuration des fichiers serveur est devenu obsolète et remplacé
par l'ajout d'une entrée de configuration au fichier web.config.
Vous pouvez ajouter cette entrée de configuration au fichier web.config de chaque projet, l'un après l'autre. Il est
toutefois recommandé de l'ajouter au fichier web.config situé dans le répertoire virtuel des visualiseurs de
SAP Crystal Reports afin de rendre cette information accessible à tous les projets Visual Studio .NET. Avant
d'effectuer cette opération, lisez la section suivante pour en savoir plus sur le répertoire virtuel des visualiseurs.
86
Fichiers serveur et répertoire virtuel des visualiseurs
Les fichiers serveur sont pris en charge en dehors d'IIS (Internet Information Services) à partir d'un service Web
centralisé situé dans un répertoire virtuel des visualiseurs spécial. Chaque nouvelle version de
SAP Crystal Reports crée un répertoire virtuel des visualiseurs supplémentaire dans IIS, ce qui permet de
conserver plusieurs versions de SAP Crystal Reports.
Un problème de maintenance se pose si vous avez codé les fichiers serveur dans un projet d'une version
antérieure de SAP Crystal Reports et si vous procédez à une mise à niveau vers une version ultérieure. Pour
permettre le fonctionnement des instances de ServerFileReport, dans votre code, le nom du répertoire virtuel des
visualiseurs dans la propriété WebServiceURL de chaque instance de ServerFileReport doit être remplacé par le
répertoire virtuel des visualiseurs actuel.
Configuration des fichiers serveur dans Visual Studio 2005 et les versions plus récentes [page 89]
1.3.6.3.1.1
Pour modifier le répertoire virtuel des
visualiseurs dans la propriété WebServiceURL des instances de
ServerFileReport
Procédure
1.
Recherchez dans votre projet toutes les occurrences dans lesquelles la propriété WebServiceURL d'une
instance de ServerFilesReport a été affectée.
2.
Comparez le nom du répertoire virtuel des visualiseurs actuellement affecté dans votre code à celui utilisé
dans les versions précédentes
3.
Changez le nom du répertoire virtuel des visualiseurs utilisé dans la version de SAP Crystal Reports la plus
récente.
4.
Recompilez l'application et vérifiez que les rapports se chargent correctement.
Étapes suivantes
Modifiez le fichier web.config du répertoire virtuel des visualiseurs de manière à configurer correctement les
fichiers serveur dans toutes les versions postérieures à Visual Studio .NET 2002.
87
1.3.6.3.1.2
Pour ajouter l'entrée de configuration des fichiers
serveur au fichier web.config du répertoire virtuel des
visualiseurs (toutes les versions postérieures à Visual
Studio .NET 2002)
Procédure
1.
Localisez le répertoire virtuel des visualiseurs de la version SAP Crystal Reports la plus récente.
2.
Pour vous assurer que le répertoire virtuel des visualiseurs fonctionne, ouvrez un navigateur, puis saisissez
l'URL du service Web de rapports publié dans le répertoire virtuel des visualiseurs.
Option
Description
Visual Studio 2003
http://localhost/CrystalReportWebFormViewer2/
ServerFileReportService.asmx?wsdl
SAP Crystal Reports 2008 http://localhost/crystalreportviewers12/
ServerFileReportService.asmx?wsdl
3.
Ouvrez le fichier web.config situé dans le répertoire virtuel des visualiseurs dans un éditeur de texte.
Remarque
Si vous le souhaitez, vous pouvez également apporter ces modifications uniquement dans le fichier
web.config de l'application Web cliente qui accèdera à ces rapports des fichiers serveur.
4.
Au tout début du fichier web.config, à l'intérieur de la balise configuration, ajoutez une entrée configSections
qui déclare un nouveau type sectionGroup (crystalDecisions) et sa section (serverFileReportManager).
<configSections>
type="System.Configuration.NameValueSectionHandler, System,
Version=1.0.3300.0, Culture=neutral,
PublicKeyToken=b77a5c561934e089, Custom=null" />
</sectionGroup>
</configSections>
5.
Après la balise de fermeture de configSections, ajoutez le nouveau type sectionGroup et la section que vous
avez déclarés à l'étape précédente.
Dans l'exemple ci-dessous, remplacez la valeur du répertoire racine par celle du répertoire dans lequel vous
avez stocké vos rapports. Pour cet exemple, le chemin du fichier est le suivant : C:\program files
\Microsoft Visual Studio .NET 2003\Crystal Reports\Samples\Reports\Feature Examples.
<crystalDecisions>
<add key="rootDirectory"
value="C:\program files\Microsoft Visual Studio .NET 2003\Crystal Reports\Samples
\En\Reports\Feature Examples" />
</crystalDecisions>
88
Remarque
Vous devez saisir le chemin d'accès du répertoire de fichiers au dossier de rapports dans le champ de
valeur.
6.
Enregistrez les modifications apportées au fichier web.config.
1.3.6.3.2
Configuration des fichiers serveur dans Visual
Studio 2005 et les versions plus récentes
Les fichiers serveur correspondent à un ensemble de services Web de rapports qui exposent des rapports sur un
serveur IIS. Les fichiers serveur étaient à l'origine fournis sous la forme d'un nœud Services Crystal dans
SAP Crystal Reports pour Visual Studio .NET 2002, mais ce nœud a depuis été supprimé. Chaque nouvelle
version de SAP Crystal Reports continue à prendre en charge les fichiers serveur dans le SDK, mais leur utilisation
nécessite une configuration particulière pour chaque version.
Les fichiers serveur sont générés à partir des fichiers de rapport sous-jacents figurant dans le dossier des
exemples de rapports (ou tout autre dossier désigné) du répertoire de fichiers du serveur Web.
Configuration des fichiers serveur
La configuration des fichiers serveur pour Visual Studio 2005 ou une version plus récente s'effectue en deux
étapes. La première étape consiste à créer le service Web de rapports qui va exposer les rapports. La deuxième
étape consiste à modifier le fichier web.config correspondant au nouveau service Web. Dans Visual Studio 2005,
l'utilisation du dossier de configuration pour les fichiers serveur qui se faisait dans Visual Studio .NET 2002 a été
déconseillée au profit de l'ajout d'une entrée de configuration dans le fichier web.config.
Vous pouvez ajouter l'entrée de configuration au fichier web.config de chaque projet, l'un après l'autre. Il est
toutefois recommandé d'ajouter cette entrée de configuration au fichier web.config situé dans le répertoire virtuel
qui contient les services Web de rapports.
Connexion aux services Web de rapports à partir d'un site Web sécurisé [page 93]
89
1.3.6.3.2.1
Pour créer les services Web de rapports requis
pour les fichiers serveur
Procédure
1.
2.
3.
Dans la boîte de dialogue Nouveau site Web, sélectionnez Visual C# dans la liste Langage.
4.
Dans la liste Modèles, cliquez sur Service Web ASP.NET.
5.
Dans le champ Emplacement, remplacez le nom de projet par défaut par le nom de votre projet.
Pour cet exemple, le projet sera enregistré dans C:\InetPub\wwwroot\ sous le nom
CrystalReportsWebServices.
C:\InetPub\wwwroot\CrystalReportsWebServices\
6.
Cliquez sur OK.
7.
Dans le menu Déboguer, cliquez sur Démarrer le débogage.
Une boîte de dialogue indiquant que le fichier web.config doit être modifié s'affiche alors. Cliquez sur le
bouton OK pour activer le débogage.
8.
Une fois le débogage terminé, revenez à l'application.
9.
Dans l'Explorateur de solutions, cliquez avec le bouton droit de la souris sur Service.asmx, puis cliquez sur
Supprimer.
10. Dans l'Explorateur de solutions, développez le dossier App_Code, cliquez avec le bouton droit de la souris sur
Service.cs, puis cliquez sur Supprimer.
11. Dans l'Explorateur de solutions, cliquez avec le bouton droit de la souris sur le nom du projet affiché en gras,
puis cliquez sur Ajouter un nouvel élément.
12. Dans la boîte de dialogue Ajouter un nouvel élément, procédez de la manière suivante :
a) Dans le champ Modèles, sélectionnez Service Web.
b) Dans le champ Nom, saisissez ServerFileReportService.asmx.
c) Désactivez la case à cocher Placer le code dans un fichier distinct.
d) Cliquez sur Ajouter.
13. Remplacez le contenu du fichier ServerFileReportService.asmx par la ligne suivante :
<%@ WebService language="C#"
class="CrystalDecisions.Web.Services.ServerFileReportService" %>
14. Dans le menu Fichier, cliquez sur Enregistrer tout.
15. Dans l'Explorateur de solutions, cliquez avec le bouton droit de la souris sur le nom du projet affiché en gras,
puis cliquez sur Ajouter un nouvel élément.
16. Dans la boîte de dialogue Ajouter un nouvel élément :
a) Dans le champ Modèles, sélectionnez Service Web.
b) Dans le champ Nom, saisissez ServerFileReportManager.asmx.
c) Désactivez la case à cocher Placer le code dans un fichier distinct.
90
d) Cliquez sur Ajouter.
17. Remplacez le contenu du fichier ServerFileReportManager.asmx par la ligne suivante :
<%@ WebService language="C#"
class="CrystalDecisions.Web.Services.ServerFileReportManager" %>
1.3.6.3.2.2
Pour modifier le répertoire virtuel des
visualiseurs dans la propriété WebServiceURL des instances de
ServerFileReport
Procédure
1.
Recherchez dans votre projet toutes les occurrences dans lesquelles la propriété WebServiceURL d'une
instance de ServerFilesReport a été affectée.
2.
Comparez le nom du répertoire virtuel des visualiseurs actuellement affecté dans votre code à celui utilisé
dans les versions précédentes
3.
Changez le nom du répertoire virtuel des visualiseurs utilisé dans la version de SAP Crystal Reports la plus
récente.
Si votre version de SAP Crystal Reports la plus récente est SAP Crystal Reports pour Visual Studio 2005,
saisissez le chemin d'accès au service Web de rapports que vous avez précédemment créé dans ce tutoriel.
4.
Recompilez l'application et vérifiez que les rapports se chargent correctement.
1.3.6.3.2.3
Pour ajouter l'entrée de configuration des fichiers
serveur au fichier web.config
Procédure
1.
Dans l'Explorateur de solutions, ouvrez le fichier Web.Config.
2.
Remplacez le contenu intégral du fichier Web.Config par le code XML ci-après.
91
Dans l'exemple ci-dessous, remplacez la valeur du répertoire racine par celle du répertoire dans lequel vous
avez stocké vos rapports. Pour cet exemple, le chemin de fichier défini est C:\program files\Microsoft
Visual Studio 8\Crystal Reports\Samples\fr\Reports\Feature Examples.
<configuration
xmlns="http://schemas.microsoft.com/.NetConfiguration/v2.0">
<configSections>
type="System.Configuration.NameValueSectionHandler, System,
Version=1.0.3300.0, Culture=neutral,
PublicKeyToken=b77a5c561934e089, Custom=null"/>
</sectionGroup>
</configSections>
<crystalDecisions>
<add key="rootDirectory" value="C:\program files\Microsoft Visual
Studio 8\Crystal Reports\Samples\fr\Reports\Feature Examples"/>
</crystalDecisions>
<appSettings/>
<system.web>
<assemblies>
<add assembly="CrystalDecisions.Web, Version=12.1.2000.0,
</assemblies>
</compilation>
</system.web>
</configuration>
Remarque
Vous devez saisir le chemin d'accès du répertoire de fichiers au dossier des rapports à l'endroit où vous
voyez l'énoncé PUT_FILE_DIRECTORY_PATH_TO_REPORTS_FOLDER_HERE.
3.
Enregistrez les modifications apportées au fichier web.config.
4.
Pour vous assurer que le répertoire virtuel des visualiseurs fonctionne, ouvrez un navigateur, puis saisissez
l'URL du service Web de rapports publié.
http://localhost/CrystalReportsWebServices/ServerFileReportService.asmx?wsdl
1.3.6.3.2.4
Anciens fichiers serveur et répertoire virtuel des
visualiseurs
Dans les précédentes versions de SAP Crystal Reports, les fichiers serveur étaient pris en charge en dehors d'IIS,
à partir d'un service Web centralisé situé dans le répertoire virtuel des visualiseurs. Chaque nouvelle version de
SAP Crystal Reports crée un répertoire virtuel des visualiseurs supplémentaire dans IIS, ce qui permet de
conserver plusieurs versions de SAP Crystal Reports.
92
Un problème de maintenance se pose si vous avez codé les fichiers serveur dans un projet d'une version
antérieure de SAP Crystal Reports et si vous procédez à une mise à niveau vers une version ultérieure. Pour
permettre le fonctionnement des instances de ServerFileReport, dans votre code, le nom du répertoire virtuel des
visualiseurs dans la propriété WebServiceURL de chaque instance de ServerFileReport doit être remplacé par
l'emplacement actuel du service Web de rapports.
1.3.6.4 Connexion aux services Web de rapports à partir d'un
site Web sécurisé
Dans SAP Crystal Reports, version développeur pour Microsoft Visual Studio, vous pouvez publier des rapports
Crystal en tant que services Web.
Dans la mesure où les services Web sont accessibles via le Web, vous souhaiterez peut-être les protéger de tout
accès anonyme.
Cette section explique comment supprimer l'accès anonyme d'un répertoire virtuel contenant un service Web de
rapports, puis comment écrire du code permettant de placer ce service dans une classe RemoteReportProxy qui
peut être configurée de manière à traiter l'authentification NT sur le serveur IIS (Internet Information Services).
Deux types de service Web de rapports nécessitent un code d'authentification : les services Web de rapports
standard et les fichiers serveur.
Publication et utilisation d'un rapport en tant que service Web [page 82]
Configuration des fichiers serveur dans les services Crystal [page 86]
1.3.6.4.1
Services Web de rapports et authentification NT
1.3.6.4.1.1
Ajout de l'authentification NT à un service Web
de rapports
Avant d'apporter quelque modification que ce soit en vue de l'authentification NT, vous devez créer un projet qui
publie et utilise un service Web de rapports comme indiqué dans la section Publication et utilisation d'un rapport
en tant que service Web [page 82].
93
Dans cette section, vous allez apprendre à supprimer l'accès anonyme du répertoire qui contient le service Web
de rapports que vous avez créé précédemment.
1.3.6.4.1.1.1
Pour supprimer l'accès anonyme du répertoire
contenant le service Web de rapports
Procédure
1.
Dans le Panneau de configuration, cliquez deux fois sur Outils d'administration, puis sur Gestionnaire des
services Internet.
2.
Dans la fenêtre Services Internet (IIS), développez les nœuds supérieurs, puis le nœud Site Web par défaut.
3.
Recherchez le répertoire virtuel contenant le Report Web Service que vous avez créé précédemment.
4.
Cliquez sur ce répertoire virtuel avec le bouton droit de la souris, puis sélectionnez Propriétés.
5.
Dans la boîte de dialogue Propriétés, dans l'onglet Sécurité de répertoire, cliquez sur Modifier.
6.
Désactivez la case à cocher Accès anonyme, puis cliquez sur OK.
7.
Cliquez sur OK pour fermer la boîte de dialogue Propriétés.
8.
Fermez la fenêtre Services Internet (IIS).
Résultats
A ce stade, si vous souhaitez qu'un utilisateur réseau en particulier puisse accéder au répertoire par
authentification, vous devez attribuer à cet utilisateur une autorisation individuelle sur le dossier à partir de
l'Explorateur Windows.
1.3.6.4.1.1.2
Pour attribuer à un utilisateur réseau en
particulier des autorisations sur le dossier
Procédure
1.
Dans l'Explorateur Windows, recherchez le dossier contenant le service Web.
2.
Cliquez avec le bouton droit de la souris sur le dossier, puis sélectionnez Propriétés.
94
3.
Dans la boîte de dialogue Propriétés, dans l'onglet Sécurité, cliquez sur Ajouter.
4.
Dans la boîte de dialogue Sélectionner les utilisateurs, les ordinateurs ou les groupes, dans le panneau
<<Entrez des noms séparés par des points-virgules ou choisissez à partir de la liste>>, saisissez le nom de
l'utilisateur réseau.
5.
Cliquez sur Vérifier les noms.
6.
Vérifiez que le nom de l'utilisateur a été correctement ajouté, puis cliquez sur OK.
7.
Dans le panneau Autorisations, activez la case à cocher Autoriser pour l'autorisation Lecture.
1.3.6.4.1.2
Modification de l'application cliente pour ajouter
un accès sécurisé
Dans cette section, vous allez modifier l'application cliente afin qu'elle puisse accéder au service Web de rapports
de façon sécurisée par le biais de l'authentification NT. Vous devez pour cela ajouter des assemblys, des espaces
de noms et du code.
1.3.6.4.1.2.1
Vérification de l'impossibilité pour votre
application cliente d'accéder au service Web sécurisé
Procédure
1.
Rouvrez l'application cliente que vous avez créée pour utiliser le service Web de rapports (dans la section
Publication et utilisation d'un rapport en tant que service Web [page 82]).
2.
Exécutez l'application afin de vous assurer que vous n'êtes plus autorisé à accéder de manière anonyme au
service Web de rapports contenu dans ce répertoire.
Le message d'erreur suivant s'affiche : "La demande a échoué avec l'état HTTP 401 : accès refusé".
1.3.6.4.1.2.2
Pour ajouter de nouveaux assemblys ainsi que
les références à ces assemblys
Procédure
1.
Cliquez avec le bouton droit de la souris sur le dossier References, puis sélectionnez Ajouter une référence.
2.
Dans la boîte de dialogue Add Reference, dans l'onglet .NET, cliquez sur les assemblys suivants tout en
maintenant la touche CTRL enfoncée :
3.
○
CrystalDecisions.ReportSource
○
System.Web.Services
Cliquez sur Select sur le côté droit de la boîte de dialogue.
95
4.
Vérifiez que les deux assemblys ont bien été ajoutés au panneau Selected Components, puis cliquez sur
OK.
5.
Ouvrez le Web Form ou le Windows Form que vous avez créé dans Configuration d'un projet [page 15].
6.
Dans le menu View, cliquez sur Code.
7.
Au-dessus de la signature de classe, ajoutez trois déclarations "Imports" [Visual Basic] ou "using" [C#] au
début de la classe pour les espaces de noms suivants.
Imports CrystalDecisions.ReportSource
Imports System.Net
Imports System.Web.Services
using CrystalDecisions.ReportSource;
using System.Net;
using System.Web.Services;
Étapes suivantes
Vous allez ensuite apprendre à ajouter du code pour configurer une classe RemoteReportProxy de sorte qu'elle
transmette les références de connexion de l'utilisateur au répertoire sécurisé du service Web de rapports.
1.3.6.4.1.2.3
Codage de la méthode
GetReportWebServiceWithAuthentication()
Contexte
La méthode GetReportWebServiceWithAuthentication() permet de configurer le proxy du rapport distant
et de gérer l'authentification NT.
Dans cette section, vous allez apprendre à coder la méthode GetReportWebServiceWithAuthentication()
pour définir les valeurs des propriétés URL et Credentials. Vous devez ajouter la méthode
GetReportWebServiceWithAuthentication() à la propriété ReportSource du contrôle
CrystalReportViewer pour la déclaration et l'instanciation de la classe RemoteReportProxy.
Cette méthode ajoute en option des paramètres de proxy pare-feu à l'instance RemoteReportProxy.
Procédure
1.
Au bas de la classe, créez la méthode d'assistance privée GetReportWebServiceWithAuthentication()
qui renvoie une classe RemoteReportProxy.
Private Function GetReportWebServiceWithAuthentication() As
96
RemoteReportProxy
End Function
private RemoteReportProxy GetReportWebServiceWithAuthentication()
{
}
2.
Dans la méthode ConfigureCrystalReports(), sélectionnez la chaîne URL de service Web actuellement
affectée à la propriété ReportSource du contrôle CrystalReportViewer. Coupez cette chaîne dans le
Presse-papiers.
Remarque
Plus loin dans cette procédure, vous affecterez une nouvelle valeur à la propriété ReportSource du
contrôle CrystalReportViewer.
3.
Déclarez une variable chaîne reportWebServiceURL et collez la chaîne URL.
Dim reportWebServiceURL As String =
"http://mywebserviceserver.com/MyWebServiceDirectory/Hierarchical
%20GroupingService.asmx"
string reportWebServiceURL =
"http://mywebserviceserver.com/MyWebServiceDirectory/Hierarchical
%20GroupingService.asmx";
4.
Déclarez et instanciez la classe RemoteReportProxy.
Dim myRemoteReportProxy As RemoteReportProxy = New RemoteReportProxy()
RemoteReportProxy remoteReportProxy = new RemoteReportProxy();
5.
Affectez la variable reportWebServiceURL à la propriété URL de l'instance RemoteReportProxy.
myRemoteReportProxy.Url = reportWebServiceURL
remoteReportProxy.Url = reportWebServiceURL;
6.
Appelez la méthode ConfigureAuthentication() (que vous allez créer dans les procédures suivantes) et
transmettez-lui la valeur Boolean True et la variable reportWebServiceURL. Affectez cette méthode à la
propriété Credentials de l'instance RemoteReportProxy.
myRemoteReportProxy.Credentials = ConfigureAuthentication(True,
reportWebServiceURL)
remoteReportProxy.Credentials = ConfigureAuthentication(true,
reportWebServiceURL);
97
7.
Appelez la méthode AddFirewallProxySettings() (que vous allez créer dans les procédures suivantes)
et transmettez-lui la valeur booléenne False, la chaîne URI d'un serveur proxy pare-feu et l'instance
RemoteReportProxy.
Remarque
Remplacez la chaîne URI par votre serveur proxy pare-feu.
myRemoteReportProxy = AddFirewallProxySettings(False, "<<
http://firewallproxyserver:8080>>",
myRemoteReportProxy)
remoteReportProxy = AddFirewallProxySettings(false, "<<
http://firewallproxyserver:8080>>",
remoteReportProxy);
8.
Renvoyez l'instance RemoteReportProxy à partir de la méthode.
Return myRemoteReportProxy
return remoteReportProxy;
1.3.6.4.1.2.4
ConfigureAuthentication()
Contexte
Dans cette section, vous allez apprendre à coder la méthode ConfigureAuthentication() et ainsi découvrir
deux approches pour configurer l'authentification.
Dans la première approche, vous allez utiliser un nom d'utilisateur, un mot de passe et un nom de domaine
spécifiques conformément aux autorisations utilisateur (droits d'accès) que vous avez ajoutées dans Ajout de
l'authentification NT à un service Web de rapports [page 93]. La seconde approche est basée sur l'autorisation
NTLM.
Lorsqu'une valeur True Boolean est transmise à cette méthode, les références de connexion propres à
l'utilisateur sont communiquées pour permettre l'accès aux services Web. La transmission d'une valeur Boolean
False entraîne l'appel du code des références de connexion NTLM pour accéder aux services Web.
La méthode ConfigureAuthentication() est appelée à partir de la méthode
GetReportWebServiceWithAuthentication().
98
Procédure
1.
Au bas de la classe, créez la méthode d'assistance privée ConfigureAuthentication() qui renvoie
l'interface ICredentials. Cette méthode fait appel à deux paramètres, une valeur booléenne nommée
isUserSpecific et la chaîne reportWebServiceURL.
Private Function ConfigureAuthentication(ByVal isUserSpecific As
Boolean, ByVal reportWebServiceURL As String) As ICredentials
End Function
private ICredentials ConfigureAuthentication(bool isUserSpecific,
string reportWebServiceURL)
{
}
2.
Dans la méthode, créez un bloc conditionnel qui teste le paramètre de méthode Boolean isUserSpecific.
If isUserSpecific Then
Else
End If
if(isUserSpecific)
{
}
else
{
}
3.
Recueillez les informations suivantes : nom de domaine réseau, nom et mot de passe de l'utilisateur auquel
vous avez accordé les droits d'accès au répertoire qui contient le service Web de rapports.
4.
Dans le bloc If, déclarez et affectez les valeurs appropriées aux variables chaîne de nom d'utilisateur, de mot
de passe et de domaine.
Dim userName As String = "fchen"
<NonSerialized()> Dim password As String = "1234"
Dim domain As String = "Enterprise"
string userName = "fchen";
[NonSerialized()] string password = "1234";
string domain = "Enterprise";
5.
Déclarez et instanciez la classe NetworkCredential et transmettez-lui les variables chaîne de nom
d'utilisateur, de mot de passe et de domaine.
Dim myNetworkCredential As NetworkCredential = New
NetworkCredential(userName, password, domain)
NetworkCredential networkCredential = new
NetworkCredential(userName, password, domain);
99
6.
Renvoyez l'instance NetworkCredential à partir du blocIf.
Dans le bloc Else, créez trois autres valeurs : un URI pour le service Web de rapports, une chaîne indiquant
que le type d'authentification est NTLM et une instance NetworkCredential. Chacune de ces valeurs est
transmise au cache des références de connexion.
Return myNetworkCredential
return networkCredential;
7.
Dans le bloc Else, déclarez et instanciez la classe CredentialCache.
Dim myCredentialCache As CredentialCache = New CredentialCache()
CredentialCache credentialCache = new CredentialCache();
8.
Déclarez et instanciez la classe Uri et transmettez-lui le paramètre reportWebServiceURL à partir de la
méthode ConfigureAuthentication().
Dim myUri As Uri = New Uri(reportWebServiceURL)
Uri uri = new Uri(reportWebServiceURL);
9.
Affectez la valeur "NTLM" à une variable chaîne nommée "ntlmAuthorization".
Dim ntlmAuthorization As String = "NTLM"
string ntlmAuthorization = "NTLM";
10. Déclarez et instanciez la classe NetworkCredential.
Dim myNetworkCredential As NetworkCredential = New
NetworkCredential()
NetworkCredential networkCredential = new NetworkCredential();
11. Transmettez l'instance Uri, la chaîne ntlmAuthorization et l'instance NetworkCredential à la méthode Add()
de l'instance CredentialCache.
myCredentialCache.Add(myUri, ntlmAuthorization,
myNetworkCredential)
credentialCache.Add(uri, ntlmAuthorization, networkCredential);
100
12. Renvoyez l'instance ICredentials à partir de la propriété DefaultCredentials de la classe
CredentialCache du bloc Else.
Return CredentialCache.DefaultCredentials
return CredentialCache.DefaultCredentials;
1.3.6.4.1.2.5
AddFirewallProxySettings()
Contexte
Dans cette section, vous allez apprendre à coder la méthode AddFirewallProxySettings() avec l'instance
RemoteReportProxy en tant que paramètre. Vous apprendrez également à ajouter des paramètres proxy Web à
l'instance RemoteReportProxy.
La méthode AddFirewallProxySettings() est appelée à partir de la méthode
Cette méthode ne s'exécute que lorsque vous avez besoin d'accéder au service Web de rapports par le biais d'un
serveur proxy pare-feu.
Procédure
1.
Au bas de la classe, créez la méthode d'assistance privée AddFirewallProxySettings() qui renvoie la
classe RemoteReportProxy et transmettez-lui une variable booléenne, une variable chaîne et l'instance
RemoteReportProxy.
Private Function AddFirewallProxySettings(ByVal isFirewallProxy As
Boolean, ByVal webProxyURI As String, ByVal remoteReportProxy As
RemoteReportProxy) As RemoteReportProxy
End Function
private RemoteReportProxy AddFirewallProxySettings(bool
isFirewallProxy, string webProxyURI, RemoteReportProxy
remoteReportProxy)
{
}
2.
Dans la méthode, créez un bloc conditionnel qui teste la variable Boolean isFirewallProxy.
If isFirewallProxy Then
End If
101
if(isFirewallProxy)
{
}
3.
Dans le bloc conditionnel, déclarez et instanciez la classe WebProxy et transmettez-lui la chaîne
webProxyURI et la valeur BooleanTrue.
Dim myWebProxy As WebProxy = New WebProxy(webProxyURI, True)
WebProxy webProxy = new WebProxy(webProxyURI, true);
4.
Affectez l'instance WebProxy à la propriété Proxy de l'instance RemoteReportProxy qui a été transmise à la
méthode en tant que paramètre.
myRemoteReportProxy.Proxy = myWebProxy
remoteReportProxy.Proxy = webProxy;
5.
En dehors du bloc conditionnel, renvoyez l'instance RemoteReportProxy.
Return myRemoteReportProxy
return remoteReportProxy;
Résultats
Lorsqu'une valeur booléenne False est transmise au paramètre isFireWallProxy, les paramètres du proxy
pare-feu ne sont pas ajoutés. Il est conseillé de tester cette version du projet avec la configuration
d'authentification NT la plus simple et sans pare-feu entre le client test et le service Web.
Lorsque vous testez ce projet avec un pare-feu, placez l'application cliente en dehors du pare-feu, puis modifiez le
paramètre booléen isFireWallProxy en lui attribuant la valeur True. Vous devez affecter au paramètre chaîne
webProxyURI une valeur URI de proxy Web correcte et continuer à tester ce code via un pare-feu.
102
1.3.6.4.1.3
Test du code d'authentification NT et des
références de connexion NTLM
1.3.6.4.1.3.1
Vérification de l'authentification NT
Prérequis
Pour pouvoir tester le code, vous devez auparavant modifier le code de liaison de rapport dans la méthode
●
Dans la méthode ConfigureCrystalReports(), affectez à la propriété ReportSource du contrôle
CrystalReportViewer un appel à la méthode GetReportWebServiceWithAuthentication().
myCrystalReportViewer.ReportSource =
GetReportWebServiceWithAuthentication()
GetReportWebServiceWithAuthentication();
Vous êtes maintenant prêt à tester le code d'authentification NT que vous avez ajouté au projet client de service
Web.
Contexte
Pour tester le code d'authentification NT du projet client de service Web
Procédure
1.
Dans le menu Générer, sélectionnez Générer la solution.
2.
Si vous rencontrez des erreurs lors de la génération, corrigez-les.
3.
Dans le menu Déboguer, cliquez sur Démarrer.
L'application cliente se connecte au service Web et, si les nom d'utilisateur, mot de passe et nom de domaine
sont corrects, le rapport s'affiche.
4.
Revenez dans Visual Studio, puis cliquez sur Arrêter pour quitter le mode débogage.
Résultats
Vous venez de vous connecter au répertoire sécurisé à l'aide des références de connexion réseau propres à
l'utilisateur. Vous allez maintenant apprendre à tester la connexion via les références de connexion NTLM.
103
Remarque
Pour configurer les paramètres du proxy pare-feu, vous pouvez modifier la valeur Boolean transmise à la
méthode AddFirewallProxySettings() en tant que paramètre.
Fichiers serveur et authentification NT [page 104]
1.3.6.4.1.3.2
Pour tester les références de connexion NTLM
du projet client de service Web
Procédure
1.
Recherchez l'appel à la méthode ConfigureAuthentication() dans la méthode
2.
Dans l'appel à la méthode ConfigureAuthentication(), remplacez la valeur booléenne True du premier
paramètre par False.
3.
4.
5.
L'application cliente se connecte au service Web à l'aide de l'authentification NTLM.
6.
Résultats
Vous êtes maintenant capable de vous connecter depuis votre client de services Web à un service Web de
rapports situé dans un répertoire sécurisé. Pour cela, vous avez configuré des valeurs dans l'instance
RemoteReportProxy, puis transmis cette instance à la propriété ReportSource du contrôle
1.3.6.4.2
Fichiers serveur et authentification NT
Vous pouvez utiliser les fichiers serveur pour vous connecter facilement aux rapports stockés sur un ordinateur
distant.
Toutefois, si le répertoire virtuel qui fournit les rapports stockés dans les fichiers serveur est protégé par un
mécanisme d'authentification NT, vous devez ajouter du code à l'application cliente pour désigner ces rapports et
fournir les références de connexion réseau nécessaires.
104
1.3.6.4.2.1
Création d'un projet pour désigner un répertoire
de fichiers serveur non sécurisé
Prérequis
Pour créer un projet qui désigne un répertoire non sécurisé, les fichiers serveur doivent être configurés pour la
version de Visual Studio dont vous disposez.
Suivez les instructions de la section appropriée et notez le chemin d'accès au répertoire de vos rapports (vous en
aurez besoin pour les procédures suivantes) :
●
Configuration des fichiers serveur dans Visual Studio .NET 2003 [page 86]
●
Accédez au répertoire de rapports de votre projet et identifiez le nom d'un rapport que vous voulez visualiser via
les fichiers serveur.
Dans les étapes suivantes, le rapport utilisé en exemple s'appelle Hierarchical Grouping.rpt.
Remarque
Les instructions ci-dessous ne s'appliquent qu'à un projet créé dans la section Configuration d'un projet [page
15].
Contexte
Dans cette section, vous allez apprendre à définir les références de connexion réseau dont vous avez besoin.
Vous allez commencer par créer une application cliente qui accède aux rapports stockés dans les fichiers serveur
et qui autorise un accès non sécurisé au répertoire de services Web. Après avoir vérifié que votre application
cliente fonctionne, vous pourrez sécuriser l'accès au répertoire virtuel, puis ajouter du code à l'application cliente
pour fournir les références de connexion nécessaires à l'authentification NT.
Pour créer une application cliente afin d'accéder aux rapports des fichiers serveur :
Procédure
1.
2.
105
3.
Localisez la méthode ConfigureCrystalReports() que vous avez créée dans la section Configuration d'un
projet [page 15].
4.
Dans la méthode, déclarez et instanciez la classe ServerFileReport.
Dim myServerFileReport As ServerFileReport = New ServerFileReport()
ServerFileReport serverFileReport = new ServerFileReport();
5.
Affectez à la propriété ReportPath de l'instance ServerFileReport le nom du rapport que vous voulez
afficher à partir du répertoire de rapports.
Remarque
Il s'agit du répertoire que vous avez configuré pour les rapports de fichiers serveur dans le fichier
Web.config.
Lorsque vous avez configuré le répertoire virtuel des visualiseurs, vous avez testé le paramètre wsdl en
entrant l'URL du service Web ServerFileReportServer.asmx à partir du chemin d'accès du répertoire virtuel.
Dans l'étape suivante, vous allez saisir cette URL en tant que valeur dans le code.
L'exemple de code ci-dessous utilise le rapport Hierarchical Grouping, qui figure dans le sous-répertoire
Feature Examples du dossier des exemples de rapports. Veillez à saisir le nom du sous-répertoire, suivi d'une
barre oblique inverse.
myServerFileReport.ReportPath = "Feature Examples\Hierarchical
Grouping.rpt"
serverFileReport.ReportPath = "Feature Examples\\Hierarchical
Grouping.rpt";
6.
Localisez la version correcte de l'URL du service Web ServerFileReportService.asmx en fonction de
votre version de SAP Crystal Reports.
Si vous disposez de SAP Crystal Reports, version développeur pour Microsoft Visual Studio, cet emplacement
correspond au répertoire virtuel du visualiseur de la version installée de SAP Crystal Reports.
Si vous avez installé SAP Crystal Reports, mais pas SAP Crystal Reports, version développeur pour Microsoft
Visual Studio, il s'agit de l'URL du service Web de rapports que vous avez créé dans Configuration des fichiers
serveur dans Visual Studio 2005 et les versions plus récentes [page 89].
7.
Affectez cette URL de service Web à la propriété WebService de l'instance ServerFileReport.
myServerFileReport.WebServiceUrl =
"http://localhost/CrystalReportsWebServices/ServerFileReportService.asmx"
serverFileReport.WebServiceUrl =
"http://localhost/CrystalReportsWebServices/ServerFileReport.asmx";
L'instance ServerFileReport est maintenant configurée et prête à être transmise au contrôle
106
8.
Affectez l'instance de ServerFileReport à la propriété ReportSource du contrôle
myCrystalReportViewer.ReportSource = myServerFileReport
crystalReportViewer.ReportSource = serverFileReport;
1.3.6.4.2.2
Reconfiguration des fichiers serveur pour
désigner un répertoire sécurisé
Dans cette section, vous allez apprendre à reconfigurer le répertoire et l'application cliente pour désigner un
répertoire sécurisé.
Vous allez commencer par désactiver l'accès anonyme au répertoire virtuel des visualiseurs dans IIS (Internet
Information Services).
1.3.6.4.2.2.1
Pour désactiver l'accès anonyme au répertoire
virtuel des visualiseurs dans IIS
Procédure
1.
Dans le Panneau de configuration, cliquez deux fois sur Outils d'administration, puis sur Gestionnaire des
services Internet.
2.
Dans la fenêtre Services Internet (IIS), développez les nœuds supérieurs, puis le nœud Site Web par défaut.
3.
Localisez le répertoire virtuel voulu, cliquez dessus avec le bouton droit de la souris, puis sélectionnez
Propriétés.
4.
Dans la boîte de dialogue Propriétés, dans l'onglet Sécurité de répertoire, cliquez sur Modifier.
5.
Désactivez la case à cocher Accès anonyme, puis cliquez sur OK.
6.
Cliquez sur OK pour fermer la boîte de dialogue Propriétés.
7.
Fermez la fenêtre Services Internet (IIS).
107
Résultats
Vous allez ensuite ajouter une balise <identity> dans le fichier Web.config.
Remarque
Il s'agit du fichier Web.config que vous avez modifié précédemment lors de la procédure de configuration des
fichiers serveur.
1.3.6.4.2.2.2
Web.config
Pour ajouter la balise <identity> au fichier
Procédure
1.
Rouvrez le fichier Web.config dans le répertoire virtuel des visualiseurs.
Remarque
Il existe deux fichiers Web.config, l'un dans le répertoire virtuel des visualiseurs, l'autre dans votre
application Web locale. Vous devez ajouter la balise d'identité au fichier Web.config situé dans le répertoire
virtuel du visualiseur. En effet, cette balise est requise lorsque l'accès anonyme à un répertoire virtuel a été
désactivé.
2.
Dans la balise <system.web>, au début, saisissez la balise <identity> comme indiqué ci-après.
<identity impersonate='true' />
3.
Enregistrez le fichier Web.config.
4.
Si vous avez également désactivé l'accès anonyme au répertoire virtuel de votre projet Web client, ajoutez
également la balise <identity> au fichier Web.config de votre projet Web client.
Étapes suivantes
Vous allez ensuite modifier le projet Web ou Windows client pour accéder au service Web de rapports sécurisé via
l'authentification NT.
108
1.3.6.4.2.2.3
Pour modifier le projet client de sorte qu'il
désigne le répertoire virtuel sécurisé des visualiseurs
Procédure
1.
Ouvrez le projet Web ou Windows client dans Visual Studio.
2.
Cliquez avec le bouton droit de la souris sur le dossier Références, puis sélectionnez Ajouter une référence.
3.
Dans la boîte de dialogue Ajouter une référence, dans l'onglet .NET, cliquez sur les deux assemblys suivants
tout en maintenant la touche CTRL enfoncée pour les sélectionner :
○
CrystalDecisions.ReportSource
○
System.Web.Services
4.
Cliquez sur Sélectionner sur le côté droit de la boîte de dialogue.
5.
Vérifiez que les deux assemblys ont bien été ajoutés dans le panneau Composants sélectionnés, puis cliquez
sur OK.
6.
Dans l'Explorateur de solutions, cliquez avec le bouton droit de la souris sur le nom du projet affiché en gras,
sélectionnez Ajouter, puis cliquez sur Ajouter une classe.
7.
Dans le champ Nom, saisissez le nom de classe "NTServerFileRemoteReportSource", puis cliquez sur
Ajouter.
8.
début de la classe pour les trois espaces de noms suivants.
Imports System.Net
using System.Net;
9.
Modifiez la signature de classe NTServerFileRemoteReportSource pour étendre la classe
RemoteReportSource.
Public Class NTServerFileRemoteReportSource : Inherits RemoteReportSource
End Class
public class NTServerFileRemoteReportSource : RemoteReportSource
{
}
109
La classe de base RemoteReportSource ne contenant aucun constructeur sans argument, vous devez créer
un constructeur avec arguments pour remplacer celui de la classe de base RemoteReportSource.
10. Si vous codez votre projet en C#, supprimez le constructeur par défaut créé dans cette classe.
11. Créez un constructeur qui contient un paramètre de méthode de ServerFileReport, puis appelez le
constructeur de la classe de base en transmettant le paramètre de rapport ainsi que la valeur booléenne
False.
Public Sub New(ByVal report As ServerFileReport)
MyBase.New(report, False)
End Sub
public NTServerFileRemoteReportSource(ServerFileReport report) : base(report,
false)
{
}
12. Dans le constructeur, affectez la propriété statique DefaultCredentials de la classe CredentialCache à la
propriété Credentials de la propriété m_proxy de la classe de base.
MyBase.m_proxy.Credentials = CredentialCache.DefaultCredentials
base.m_proxy.Credentials = CredentialCache.DefaultCredentials;
Résultats
Vous pouvez maintenant modifier la classe code-behind du Web Form ou du Windows Form.
1.3.6.4.2.2.4
Pour modifier la classe code-behind de sorte
qu'elle désigne la source de rapport distant
Procédure
1.
Revenez au Web Form ou Windows Form d'origine.
2.
3.
Dans la méthode ConfigureCrystalReports(), ajoutez une nouvelle ligne entre le paramètre de la
propriété serverFileReport.WebServiceUrl et celui de la propriété ReportSource du contrôle
CrystalReportViewer. Dans cette ligne, déclarez et instanciez la nouvelle classe étendue que vous avez
créée, puis transmettez l'instance ServerFileReport en tant que paramètre de méthode.
Dim myNTServerFileRemoteReportSource As NTServerFileRemoteReportSource = New
NTServerFileRemoteReportSource(myServerFileReport)
110
NTServerFileRemoteReportSource ntServerFileRRS = new
NTServerFileRemoteReportSource(serverFileReport);
4.
Modifiez la dernière ligne de code de cette méthode de la manière suivante : remplacez l'instance
ServerFileReport affectée à la propriété ReportSource du contrôle CrystalReportViewer par la nouvelle
instance NTServerFileRemoteReportSource.
myCrystalReportViewer.ReportSource = myNTServerFileRemoteReportSource
crystalReportViewer.ReportSource = ntServerFileRRS;
Résultats
Vous êtes maintenant prêt à tester l'application cliente qui a été modifiée pour transmettre les références de
connexion nécessaires à partir d'une source de rapport distant. Cette application désigne le service de rapports
des fichiers serveur par l'intermédiaire du répertoire virtuel des visualiseurs, qui nécessite désormais une
authentification NT.
1.3.6.4.2.2.5
Pour tester la source de rapport distant à l'aide
des références de connexion qui désignent le répertoire virtuel
sécurisé des visualiseurs
Procédure
1.
2.
L'application cliente se connecte au répertoire virtuel sécurisé des visualiseurs, et, si la nouvelle instance
NTServerFileRemoteReportSource a été configurée avec les références de connexion correctes, le
rapport s'affiche.
3.
1.3.7
Considérations de sécurité
Les scénarios suivants doivent être pris en compte lors de la conception d'une application sécurisée
111
Stockage des données dans la mémoire cache frontale
Les rapports visualisés dans un navigateur Web peuvent contenir des données sensibles qu'un navigateur Web
est susceptible de mettre en cache. Consultez la documentation Microsoft pour savoir comment désactiver la
mise en cache pour différents navigateurs.
Protection du fichier de rapport
Les fichiers SAP Crystal Reports .rpt doivent contenir des données professionnelles sensibles. Il est recommandé
de protéger l'accès à vos rapports en les gérant avec le serveur de la plateforme SAP BusinessObjects Business
Intelligence, en utilisant la sécurité de fichier ou le cryptage au niveau du système d'exploitation.
Validation d'entrée utilisateur avec champs de paramètre
Les champs de paramètre invitent l'utilisateur à fournir les informations utilisées pour le traitement d'un rapport.
La boîte de dialogue d'invite valide les données mais des étapes supplémentaires permettent de s'assurer que les
valeurs attendues sont fournies :
1.
Utilisez le texte de l'invite pour décrire le type de données attendues.
2.
Indiquez une valeur minimale et une valeur maximale pour limiter la plage de nombres à saisir pour les
données numériques.
3.
Utilisez un masque d'édition pour demander les données dans un format spécifique.
4.
Construisez votre propre boîte de dialogue d'invite. Le SDK de SAP Crystal Reports .NET fournit de
nombreuses API pouvant être utilisées pour construire votre propre boîte de dialogue d'invite. En créant votre
propre boîte de dialogue d'invite, vous contrôlez totalement la manière dont l'utilisateur fournit les champs de
paramètre.
Utilisation du contrôle d'impression ActiveX pour imprimer les rapports depuis
le visualiseur Web Form .NET
Le visualiseur Web Form .NET SAP Crystal Reports vous permet d'imprimer le rapport sous format PDF ou en
utilisant un contrôle d'impression ActiveX. Le format PDF est l'option par défaut recommandée pour l'impression
d'un rapport. Le contrôle d'impression ActiveX est fourni comme solution alternative permettant une impression
en un seul clic. Cette option n'est pas recommandée car elle requiert des droits d'administrateur pour être
installée. Le contrôle d'impression ActiveX est en outre utilisé dans un navigateur Web, le bit d'arrêt n'est donc
pas défini, ce qui est considéré comme étant moins sûr.
112
Construction d'une application pour visualiser les rapports dans la plateforme
SAP BusinessObjects Business Intelligence
Vous pouvez utiliser SAP Crystal Reports, version développeur pour Microsoft Visual Studio pour créer des
applications destinées à visualiser les rapports stockés dans un système de plateforme SAP BusinessObjects
Business Intelligence. Il est nécessaire de prendre en compte les impacts en termes de sécurité lors de la création
d'applications destinées à visualiser les rapports stockés dans un système de plateforme SAP BusinessObjects
Business Intelligence. Pour en savoir plus, voir le Guide d'administration de la plateforme SAP BusinessObjects
Business Intelligence.
Filtrage de données avec des paramètres ou des formules [page 136]
1.4
Utilisation du SDK
Cette section fournit des instructions détaillées sur l'utilisation de fonctionnalités spécifiques du SDK
SAP Crystal Reports .Net.
1.4.1
Impression d'un rapport
Le SDK SAP Crystal Reports .NET permet de créer des applications Windows ou des sites Web pouvant
s'imprimer sur l'imprimante d'un utilisateur final ou sur une imprimante configurée sur votre serveur Web.
La manière la plus simple d'ajouter des fonctionnalités d'impression à votre application SAP Crystal Reports .NET
est d'utiliser le bouton d'impression du contrôle CrystalReportViewer. Lorsque les utilisateurs cliquent sur le
bouton d'impression de la barre d'outils, la boîte de dialogue d'impression standard du système s'affiche. Les
paramètres d'impression personnalisée peuvent être spécifiés par le biais de cette boîte de dialogue.
Le SDK SAP Crystal Reports .NET permet de configurer des options d'impression et d'appeler une imprimante
depuis le code, plutôt que depuis l'interface utilisateur de SAP Crystal Reports. Utilisez la classe PrintOptions
et la méthode PrintToPrinter du modèle d'objet ReportDocument.
Classes utilisées pour l'impression de rapports
●
CrystalDecisions.CrystalReports.Engine.ReportDocument
Représente un rapport et contient les propriétés et les méthodes permettant de définir, mettre en forme,
charger, exporter et imprimer ce rapport.
113
●
CrystalDecisions.CrystalReports.Engine.PrintOptions
Indique les propriétés et les méthodes permettant de définir les options d'impression d'un rapport.
●
CrystalDecisions.Windows.Forms.CrystalReportViewer
Représente le contrôle CrystalReportViewer dans un Windows Form. Le contrôle CrystalReportViewer permet
d'imprimer des rapports via l'interface utilisateur.
●
CrystalDecisions.Web.CrystalReportViewer
Fournit des propriétés, des méthodes et des événements permettant de modifier ou d'extraire les
informations sur la manière dont fonctionne et s'affiche le contrôle CrystalReportViewer. Le contrôle
CrystalReportViewer permet d'imprimer des rapports via l'interface utilisateur.
Exportation d'un rapport [page 123]
1.4.1.1
Impression d'un rapport depuis le contrôle
CrystalReportViewer
La manière la plus simple d'ajouter des fonctionnalités d'impression à votre application SAP Crystal Reports .NET
est d'utiliser le bouton d'impression du contrôle CrystalReportViewer. Le bouton d'impression est activé par
défaut sur la barre d'outils CrystalReportViewer.
Il existe deux contrôles CrystalReportViewer dans le SDK SAP Crystal Reports .NET. Pour un site Web, vous
utiliserez la classe CrystalDecisions.Web.CrystalReportViewer. Pour une application Windows, vous
utiliserez la classe CrystalDecisions.Windows.Forms.CrystalReportViewer.
Impression à l'aide de la classe
Lorsque vous cliquez sur le bouton d'impression de la barre d'outils CrystalReportViewer dans une application
Windows, la boîte de dialogue d'impression Windows standard s'affiche. Vous pouvez invoquer par
programmation la boîte de dialogue d'impression via la méthode CrystalReportViewer.PrintReport.
Le bouton d'impression peut être désactivé dans une application Windows en définissant la propriété
CrystalReportViewer.ShowPrintButton sur False.
Impression à l'aide de la classe CrystalDecisions.Web.CrystalReportViewer
Le contrôle CrystalReportViewer pour les sites Web prend en charge deux méthodes d'impression : PDF et
ActiveX.
114
L'impression PDF est le paramètre par défaut pour un site Web. Lorsque vous cliquez sur le bouton d'impression
de la barre d'outils CrystalReportViewer dans un site Web, la boîte de dialogue Options d'impression s'affiche.
Saisissez une option d'impression personnalisée et cliquez sur OK. SAP Crystal Reports ouvre une nouvelle
fenêtre avec un PDF de votre rapport. Imprimez le PDF sur votre imprimante locale.
Si l'impression ActiveX est activée, la boîte de dialogue d'impression Windows standard s'affiche lorsque vous
cliquez sur le bouton d'impression. L'impression ActiveX requiert une configuration supplémentaire et
éventuellement l'installation du plug-in ActiveX PrintControl.cab sur l'ordinateur client.
Le bouton d'impression peut être désactivé sur un site Web en définissant la propriété
CrystalReportViewer.HasPrintButton sur False.
Impression d'un rapport par programmation [page 118]
1.4.1.1.1
Suppression du bouton d'impression depuis le
contrôle CrystalReportViewer
Contexte
Vous pourrez continuer à utiliser le SDK pour imprimer un rapport, même si le bouton d'impression n'est pas
visible.
Procédure
1.
Ajoutez un contrôle CrystalReportViewer à votre application.
2.
Définissez la propriété qui contrôle la visibilité du bouton d'impression sur False.
○
Pour une application Windows, définissez la propriété CrystalReportViewer.ShowPrintButton sur
False.
○
Pour un site Web, définissez la propriété CrystalReportViewer.HasPrintButton sur False.
Résultats
Lorsque vous exécuterez votre application, le bouton d'impression ne devrait plus apparaître sur le contrôle
115
Exemple
Désactivation du bouton Imprimer dans une application Windows
CrystalReportViewer1.ShowPrintButton = False
End Sub
{
InitializeComponent();
crystalReportViewer1.ShowPrintButton = false;
}
Impression d'un rapport [page 113]
1.4.1.1.2
Impression d'un rapport avec la méthode
CrystalReportViewer.PrintReport
Prérequis
Assurez-vous qu'une imprimante a été configurée sur l'ordinateur client avant d'essayer d'imprimer.
Contexte
Vous pouvez invoquer par programmation la boîte de dialogue d'impression via la méthode
CrystalReportViewer.PrintReport dans une application Windows. Utilisez cette méthode pour imprimer
lorsque la barre d'outils CrystalReportViewer est masquée ou dans une application qui utilise des boutons de
barre d'outils personnalisés.
Procédure
1.
Ajoutez un contrôle CrystalReportViewer à votre Windows Form.
2.
Configurez une source de rapport valide et liez-la au contrôle CrystalReportViewer.
3.
Appelez la méthode PrintReport pour invoquer la boîte de dialogue d'impression par défaut.
116
Exemple
Private Sub PrintReport()
CrystalReportViewer.PrintReport()
End Sub
private void PrintReport()
{
crystalReportViewer.PrintReport();
}
1.4.1.1.3
Web
Activation de l'impression ActiveX dans un site
Contexte
Si l'impression ActiveX est activée, la boîte de dialogue d'impression standard du système s'affiche lorsque
l'utilisateur clique sur le bouton d'impression. L'impression ActiveX requiert une configuration supplémentaire et
éventuellement l'installation du plug-in ActiveX PrintControl.cab sur l'ordinateur client.
Procédure
1.
2.
Définissez la propriété de mode d'impression du contrôle CrystalReportViewer sur ActiveX.
CrystalReportViewer1.PrintMode = PrintMode.ActiveX
CrystalReportViewer1.PrintMode = PrintMode.ActiveX;
3.
Dans votre fichier Web.Config, ajoutez une référence au contrôle ActiveX PrintControl.cab.
<configSections>
<section group name="businessObjects">
</sectionGroup>
</sectionGroup>
</configSections>
<businessObjects>
<crystalReports>
<printControl>
<add key="url" value="http://localhost/PrintControl.cab" />
117
</printControl>
</crystalReports>
</businessObjects>
Remplacez "localhost" par l'adresse de votre serveur Web.
L'élément printControl vous permet d'imprimer le rapport directement sur votre imprimante locale. Par
défaut, ce contrôle n'est pas installé sur votre ordinateur local et doit être téléchargé séparément. Ce
paramètre rend le fichier .cab visible par votre site Web SAP Crystal Reports .NET.
Résultats
Le contrôle CrystalReportViewer doit à présent utiliser la boîte de dialogue d'impression Windows au lieu de
l'impression PDF. La première fois qu'un utilisateur essaie d'imprimer depuis le site Web SAP Crystal Reports, il se
peut qu'il soit invité à installer le plug-in ActiveX PrintControl.cab.
1.4.1.2
Impression d'un rapport par programmation
Vous pouvez configurer des options d'impression et appeler une imprimante par programmation. Pour ce faire,
utilisez la classe PrintOptions et la méthode PrintToPrinter du modèle d'objet ReportDocument.
Si le bouton Imprimer de la barre d'outils du contrôle CrystalReportViewer répond à vos besoins d'impression, il
est inutile d'écrire un code pour configurer des options d'impression supplémentaires.
Toutefois, pour des scénarios particuliers, vous pouvez avoir recours à une solution basée sur du code pour
l'impression des rapports :
●
Vous pouvez contrôler le moment, l'emplacement et la configuration de votre impression. Désactivez le
bouton Imprimerde la barre d'outils du contrôle CrystalReportViewer et gérez toutes les impressions via le
code.
●
Vous pouvez imprimer un rapport en arrière-plan, sans l'afficher. Les paramètres d'impression sont
accessibles via la classe ReportDocument, qui peut être instanciée et configurée sans jamais afficher le
rapport avec un contrôle CrystalReportViewer.
●
Vous pouvez centraliser toutes les impressions sur le serveur Web pour un client Web. Utilisez la méthode
PrintToPrinter() pour envoyer des tâches d'impression à une imprimante connectée au serveur Web
plutôt qu'à une imprimante locale connectée au client Web.
Remarque
L'impression par programmation à l'aide du modèle d'objet ReportDocument est moins complète que la
structure de planification des rapports fournie avec SAP Crystal Reports Server ou la plateforme SAP
BusinessObjects Business Intelligence.
118
Impression par programmation depuis une application Web
Si vous utilisez la méthode ReportDocument.PrintToPrinter dans une application Web, le rapport est
imprimé depuis le serveur Web et non depuis l'ordinateur client. Toute l'impression côté client utilise le contrôle
Impression d'un rapport depuis le contrôle CrystalReportViewer [page 114]
1.4.1.2.1
Définition des options d'impression personnalisée
avec le modèle d'objet ReportDocument
La classe PrintOptions permet de spécifier des paramètres supplémentaires avant l'impression d'un rapport
par programmation. La classe PrintOptions permet d'effectuer les opérations suivantes :
●
Changer la source de papier actuelle.
●
Déterminer la hauteur ou la largeur de la sortie imprimée.
●
Régler les marges de page.
●
Forcer l'impression duplex ou simplex.
●
Changer l'imprimante par défaut.
Pour modifier les options d'impression d'un rapport, vous devez extraire un objet PrintOptions via la propriété
PrintOptions de la classe ReportDocument.
Copie des options d'impression
Les options d'impression peuvent être copiées depuis ou vers les paramètres par défaut de votre système local à
l'aide des méthodes PrintOptions.CopyFrom ou PrintOptions.CopyTo.
Pour en savoir plus sur la classe PrintOptions, voir la Référence de l'API .NET SAP Crystal Reports.
Exemple
Forcer l'impression duplex
Cet exemple définit le mode d'impression par défaut sur Duplex.
Private Sub enableDuplex(ByVal rd As ReportDocument)
rd.PrintOptions.PrinterDuplex = PrinterDuplex.Vertical
End Sub
private void enableDuplex(ReportDocument rd)
119
{
}
rd.PrintOptions.PrinterDuplex = PrinterDuplex.Vertical;
1.4.1.2.2
défaut
Impression d'un rapport sur l'imprimante par
Contexte
La méthode ReportDocument.PrintToPrinter envoie un rapport à l'imprimante par défaut spécifiée dans le
fichier du rapport. Pour envoyer le rapport sur l'imprimante par défaut spécifiée sur l'ordinateur client, vous devez
définir la propriété PrintOptions.PrinterName avant d'imprimer le rapport.
Procédure
1.
Créez une instance de la classe PrintDocument.
L'imprimante par défaut de l'ordinateur client est spécifiée dans la propriété
PrinterSettings.PrinterName de toute nouvelle classe PrintDocument.
Dim localPrinter As System.Drawing.Printing.PrintDocument = New PrintDocument()
System.Drawing.Printing.PrintDocument localPrinter = new PrintDocument();
2.
Définissez la propriété PrinterName de l'objet ReportDocument sur la valeur spécifiée dans
PrinterSettings.PrinterName.
rd.PrintOptions.PrinterName = localPrinter.PrinterSettings.PrinterName
rd.PrintOptions.PrinterName = localPrinter.PrinterSettings.PrinterName;
3.
Appelez la méthode ReportDocument.PrintToPrinter pour imprimer le rapport.
rd.PrintToPrinter(1, False, 0, 0)
rd.PrintToPrinter(1, false, 0, 0);
Cette méthode PrintToPrinter utilise quatre paramètres : le nombre de copies à imprimer, si les pages
doivent être assemblées ou non, la page de début et la page de fin.
120
Conseil
Pour imprimer toutes les pages, définissez les paramètres de page de début et de page de fin sur zéro.
Exemple
Private Sub printReport(ByVal rd As ReportDocument)
Dim localPrinter As System.Drawing.Printing.PrintDocument = New
PrintDocument()
rd.PrintOptions.PrinterName = localPrinter.PrinterSettings.PrinterName
rd.PrintToPrinter(1, False, 0, 0)
End Sub
private void printReport(ReportDocument rd) {
System.Drawing.Printing.PrintDocument localPrinter = new PrintDocument();
rd.PrintOptions.PrinterName = localPrinter.PrinterSettings.PrinterName;
rd.PrintToPrinter(1, false, 0, 0);
}
1.4.1.2.3
Impression d'un rapport sur un fichier
Contexte
Vous pouvez imprimer un rapport sur un fichier de votre système local en modifiant les propriétés
PrinterSettings par défaut et en appelant la méthode ReportDocument.PrintToPrinter. Pour enregistrer
un rapport sur un disque en vue de l'afficher ultérieurement ou pour enregistrer un rapport dans un format
différent, exportez-le au lieu de l'imprimer sur un fichier.
Procédure
1.
Créez une instance des classes PrinterSettings et PageSettings.
Dim printerSettings As New PrinterSettings()
Dim pageSettings As New PageSettings()
PrinterSettings printerSettings = new PrinterSettings();
PageSettings pageSettings = new PageSettings();
2.
Copiez les paramètres de l'objet ReportDocument vers les objets PrinterSettings et PageSettings.
rd.PrintOptions.CopyTo(printerSettings, pageSettings)
121
rd.PrintOptions.CopyTo(printerSettings, pageSettings);
3.
Définissez la propriété PrintToFile de l'objet PrinterSettings sur la valeur True.
printerSettings.PrintToFile = True
printerSettings.PrintToFile = true;
4.
Définissez l'emplacement du fichier de sortie.
printerSettings.PrintFileName = "c:\outputFile.prn"
printerSettings.PrintFileName = "c:\\outputFile.prn";
Remarque
Lors d'une impression sur un fichier, le format du fichier de sortie est déterminé par l'imprimante. Il se peut
que votre imprimante crée des fichiers XPS, PS ou d'un autre format. Consultez le manuel du fabricant
pour plus d'informations.
5.
Appelez la méthode ReportDocument.PrintToPrinter pour imprimer le rapport.
Cette méthode PrintToPrinter utilise trois paramètres : les options d'impression, les paramètres de page
et une valeur booléenne qui indique si le rapport doit être remis en forme pour correspondre aux paramètres
de page.
rd.PrintToPrinter(printerSettings, pageSettings, False)
rd.PrintToPrinter(printerSettings, pageSettings, false);
Exemple
Private Sub printToFile(ByVal rd As ReportDocument)
Dim printerSettings As New PrinterSettings()
Dim pageSettings As New PageSettings()
rd.PrintOptions.CopyTo(printerSettings, pageSettings)
printerSettings.PrintToFile = True
printerSettings.PrintFileName = "c:\outputFile.prn"
rd.PrintToPrinter(printerSettings, pageSettings, False)
End Sub
private void printToFile(ReportDocument rd)
{
PrinterSettings printerSettings = new PrinterSettings();
PageSettings pageSettings = new PageSettings();
rd.PrintOptions.CopyTo(printerSettings, pageSettings);
printerSettings.PrintToFile = true;
printerSettings.PrintFileName = "c:\\outputFile.prn";
122
}
rd.PrintToPrinter(printerSettings, pageSettings, false);
Exportation d'un rapport [page 123]
1.4.1.3
Suppression du pilote de l'imprimante par défaut de
votre rapport
Procédure
1.
Dans l'Explorateur de solutions, cliquez deux fois sur le rapport.
2.
Cliquez avec le bouton droit de la souris sur une zone quelconque du rapport et sélectionnez
Concepteur
Configuration de l'imprimante .
3.
Dans la boîte de dialogue Configuration de l'impression, activez la case à cocher Aucune imprimante, puis
cliquez sur OK.
4.
Cliquez sur
Fichier
Tout enregistrer .
Sélection de l'option Aucune imprimante sous Configuration de l'impression [page 74]
1.4.2
Exportation d'un rapport
SAP Crystal Reports permet d'exporter des rapports vers différents formats. Les formats disponibles dépendent
de la version de SAP Crystal Reports que vous avez installée et de la méthode utilisée pour exporter le rapport.
Un rapport peut être exporté vers un disque, une fenêtre de navigateur ou vers le flux d'entrée/de sortie sous
forme de séquence d'octets.
Classes utilisées pour l'exportation de rapports
●
123
●
CrystalDecisions.Shared
Contient plusieurs classes utilisées pour spécifier les options d'exportation de différents formats de sortie.
●
CrystalDecisions.Shared.ExportOptions
Indique les propriétés permettant d'extraire et de définir des options pour l'exportation de votre rapport.
Impression d'un rapport [page 113]
Boîte de dialogue Exportation [page 908]
1.4.2.1
Formats d'exportation disponibles
Les formats d'exportation pris en charge par SAP Crystal Reports peuvent être classés en deux groupes : les
formats basés sur les pages et les formats basés sur les enregistrements. Les formats d'exportation sont
davantage axés sur la charte graphique et produisent donc généralement un résultat proche de la mise en page et
de la mise en forme de l'original. Les formats d'exportation d'enregistrements sont axés sur la représentation
exacte des données plutôt que sur la mise en page et la mise en forme.
Mise en forme
Description
SAP Crystal Reports (RPT)
L'exportation vers le format SAP Crystal Reports s'apparente
à l'utilisation de la fonctionnalité Enregistrer sous avec
l'option Enregistrer les données avec le rapport sélectionnée.
Ce format exporte (enregistre) le rapport avec les données
en cours sans modifier le rapport d'origine. Si une source de
rapport est un fichier SAP Crystal Reports Read-Only
(RPTR), vous ne pourrez pas l'exporter vers
SAP Crystal Reports (RPT).
SAP Crystal Reports Read-Only (RPTR)
Ce format exporte (enregistre) le rapport avec les données
en cours sans modifier le rapport d'origine. Les rapports
RPTR sont des rapports Crystal qui peuvent être visualisés
avec des applications de visualiseur de rapport, mais qui ne
peuvent pas être modifiés avec le SDK ni ouverts par des
applications de concepteur de rapports. La définition d'un
rapport RPTR ne peut pas être modifiée, ce qui signifie qu'il
n'est pas possible d'utiliser ce SDK pour définir
l'emplacement de la source de données d'un RPTR via le
contrôleur de base de données. Il est toutefois possible
d'actualiser les données d'un rapport RPTR lors de
l'exécution en actualisant le rapport dans un visualiseur.
HTML 4.0
Exporte le rapport au format HTML 4.0. Ce format conserve
la mise en page et la mise en forme du rapport en utilisant le
DHTML.
Microsoft Excel (97-2003)
Ce format convertit le contenu de votre rapport en cellules
Excel page par page. Le contenu de plusieurs pages est
exporté vers la même feuille de calcul Excel. Si une feuille de
calcul est pleine et qu'il reste des données à exporter, le
124
Mise en forme
Description
programme d'exportation crée plusieurs feuilles de calcul
pour intégrer ces données. Si un objet de rapport couvre
plusieurs cellules, le programme d'exportation fusionne les
cellules pour le représenter. Microsoft Excel est limité à
256 colonnes par feuille de calcul ; par conséquent, tout objet
de rapport (ou partie de cet objet) ajouté à des cellules audelà des 256 colonnes ne peut être exporté. Ce format
d'exportation conserve la plupart de la mise en forme, mais
n'exporte pas les objets ligne et objets cadre du rapport.
Microsoft Excel (97-2003) Données uniquement
Comme son nom l'indique, Microsoft Excel - Données
uniquement est un format d'exportation d'enregistrements
axé sur la représentation exacte des données. Toutefois, ce
format exporte également la plupart de la mise en forme.
Contrairement au format Microsoft Excel, Microsoft Excel Données uniquement ne fusionne pas les cellules ; chaque
objet est ajouté à une cellule unique. Ce format exporte aussi
certains types de résumés de rapports Crystal sous forme de
fonctions Excel. Les résumés pris en charge sont SUM,
AVERAGE, COUNT, MIN et MAX.
Microsoft Excel 2007 (XLSX) Données uniquement
Le format XLSX est doté des mêmes propriétés que le format
Microsoft Excel (97-2003) Données uniquement ; toutefois,
le format XLSX prend en charge jusqu'à 16 385 colonnes et
1 048 576 lignes dans un seul classeur.
Microsoft Word (97-2003)
Ce format génère un fichier RTF (Rich Text Format) qui
contient du texte et des objets de dessin pour représenter les
objets de rapport. Ce format d'exportation conserve la
plupart de la mise en forme. Toutefois, les objets texte ne
peuvent pas être placés à l'extérieur du bord gauche de la
page. Les objets texte du rapport placés à l'extérieur du bord
gauche de la zone imprimable sont donc déplacés vers la
droite. (Cela est particulièrement visible dans les rapports
comportant des pages larges.)
Microsoft Word (97-2003) - Modifiable
Le format Microsoft Word - Modifiable diffère du format
Microsoft Word : il s'agit d'un format d'exportation, mais la
mise en page et la mise en forme ne sont pas intégralement
conservées dans le format de sortie. Ce format convertit le
contenu de tous les objets du rapport en lignes de texte.
Contrairement au format Microsoft Word, ce format n'utilise
pas de cadres de texte. La mise en forme du texte est
conservée, mais les attributs tels que couleur d'arrière-plan,
modèle de remplissage, etc. peuvent ne pas être conservés.
Toutes les images du rapport sont alignées sur le contenu
textuel. Par conséquent, les images sont automatiquement
déplacées afin d'intégrer le texte lorsque le document est
édité dans Microsoft Word. Ce format n'exporte pas les
objets ligne et objets cadre du rapport. De même, les champs
spéciaux Numéro de page et Page N sur M ne fonctionnent
pas lorsqu'ils sont exportés dans ce format.
ODBC
ODBC est un format d'échange de données basé sur les
enregistrements. Ce format permet d'exporter les données
125
Mise en forme
Description
de rapport vers n'importe quelle base de données compatible
ODBC.
PDF
Les documents exportés sont destinés à l'impression et à la
redistribution. Le format PDF exporte à la fois la mise en page
et la mise en forme de manière à correspondre à l'apparence
du rapport dans l'onglet Aperçu. Le format PDF intègre les
polices True Type qui apparaissent dans le document. (Les
polices autres que True Type ne sont pas prises en charge.)
Ce format d'exportation ne prend pas en charge la
technologie Font-Linking de Microsoft, utilisée pour des
ensembles de caractères étendus comme le HKCS chinois.
Par conséquent, les polices utilisées dans le rapport doivent
contenir tous les glyphes requis. Les types d'URI suivants
sont pris en charge pour les hyperliens : http, https et mailto.
Style d'enregistrement - Colonnes avec espaces
Exporte les données du rapport sous forme de texte. Ce
format insère des espaces entre les colonnes.
Style d'enregistrement - Colonnes sans espaces
Exporte les données du rapport sous forme de texte. Ce
format n'insère pas d'espaces entre les colonnes.
Définition de rapport
Le format de définition de rapport exporte le rapport dans un
fichier texte qui contient une brève description de la vue de
conception du rapport. Ce format est uniquement géré dans
le cadre d'une compatibilité avec SAP Crystal Reports 5.0.
Rich Text Format (RTF)
Génère un fichier RTF contenant des objets de type texte et
dessin.
Valeurs séparées par des virgules (CSV)
Le format Valeurs délimitées est un format d'échange de
données basé sur les enregistrements. Il exporte le contenu
des objets du rapport sous forme d'ensemble de valeurs
séparées par des séparateurs que vous indiquez. (Lorsqu'une
virgule (,) est utilisée pour séparer des champs, on parle de
Valeurs séparées par des virgules (CSV). Ce format
d'exportation est largement utilisé par les utilisateurs de
Microsoft Excel.)
Texte séparé par des tabulations (TTX)
Conserve la mise en page du rapport à quelques différences
près : les objets texte sur plusieurs lignes sont exportés sur
une seule ligne, toutes les valeurs de type chaîne comportent
des guillemets ("") et les valeurs elles-mêmes sont séparées
par des tabulations. Les fichiers TTX peuvent s'ouvrir dans
Microsoft Excel.
Texte
Génère du texte brut (sans conserver la mise en forme).
XML
Utilisé essentiellement pour l'échange de données. Ce format
génère du code XML à l'aide du schéma XML de
Sélection d'un format d'exportation
Les formats disponibles dépendent de la version de SAP Crystal Reports que vous avez installée et de la méthode
utilisée pour exporter le rapport. Le contrôle CrystalReportViewer propose par défaut la plupart des formats
126
d'exportation. Certains formats sont uniquement disponibles avec le SDK de SAP Crystal Reports .NET ou
l'application autonome SAP Crystal Reports Designer.
Mise en forme
Contrôle
CrystalReportViewer
SDK de
SAP Crystal Reports .NE
T
SAP Crystal Reports Desi
gner
x
x
x
SAP Crystal Reports ReadOnly (RPTR)
x
x
x
x
x
HTML 4.0
x
x
x
Données uniquement
x
x
x
Microsoft Excel 2007 (XLSX)
Données uniquement
x
x
x
x
x
x
Microsoft Word (97-2003) Modifiable
x
x
x
ODBC
PDF
x
x
x
x
Style d'enregistrement Colonnes avec espaces
x
Style d'enregistrement Colonnes sans espaces
x
Définition de rapport
x
x
x
Valeurs séparées par des
virgules (CSV)
x
x
Texte séparé par des
tabulations (TTX)
x
x
Texte
x
x
x
x
XML
x
x
1.4.2.2
Exportation d'un rapport depuis le contrôle
CrystalReportViewer
La manière la plus simple d'ajouter des fonctionnalités d'exportation à votre application SAP Crystal Reports .NET
est d'utiliser le bouton d'exportation du contrôle CrystalReportViewer. Le bouton Exporter est activé par défaut
sur la barre d'outils CrystalReportViewer.
L'utilisateur peut cliquer sur le bouton Exporter pour faire apparaître la boîte de dialogue d'exportation par défaut.
Les options d'exportation disponibles pour votre utilisateur sont déterminées par les pilotes inclus dans votre
déploiement.
127
Désactivation de la fonction d'exportation de rapport depuis le visualiseur
L'exportation est activée par défaut dans toutes les applications SAP Crystal Reports. Vous pouvez limiter
l'exportation de deux façons :
●
Supprimer le bouton Exporter du visualiseur.
Vous pourrez continuer à utiliser le SDK pour exporter un rapport, même si le bouton d'exportation n'est pas
visible.
●
La désactivation de certains pilotes d'exportation dans SAP Crystal Reports fusionne les modules.
Lorsque vous déployez une application SAP Crystal Reports vers un ordinateur cible, vous devez inclure
l'exécution de SAP Crystal Reports sous la forme d'un MSI ou d'un module de fusion. Si vous choisissez
d'utiliser des modules de fusion pour votre déploiement, vous pouvez spécifier les pilotes d'exportation à
inclure ou exclure.
Boîte de dialogue Exportation [page 908]
1.4.2.2.1
Suppression du bouton d'exportation depuis le
Contexte
Vous pourrez continuer à utiliser le SDK pour exporter un rapport, même si le bouton d'exportation n'est pas
visible.
Procédure
1.
2.
Définissez la propriété qui contrôle la visibilité du bouton d'exportation sur False.
○
Pour une application Windows, définissez la propriété CrystalReportViewer.ShowExportButton sur
False.
○
Pour un site Web, définissez la propriété CrystalReportViewer.HasExportButton sur False.
Résultats
Lorsque vous exécuterez votre application, le bouton d'exportation ne devrait plus apparaître sur le contrôle
128
Exemple
Désactivation du bouton Exporter dans une application Web
CrystalReportViewer1.HasExportButton = False
End Sub
{
crystalReportViewer1.HasExportButton = false;
}
1.4.2.3
Exportation d'un rapport par programmation
Le SDK SAP Crystal Reports .NET permet d'exporter par programmation un rapport vers un plus grand nombre
de formats et de destinations que le contrôle CrystalReportViewer.
Si le bouton Exporter de la barre d'outils du contrôle CrystalReportViewer répond à vos besoins d'exportation, il
est inutile d'écrire un code pour configurer des options d'exportation supplémentaires.
Toutefois, pour des scénarios particuliers, vous pouvez avoir recours à une solution basée sur du code pour
l'impression des rapports :
●
Vous pouvez contrôler le moment, l'emplacement et la configuration de votre exportation. Désactivez le
bouton Exporter de la barre d'outils du contrôle CrystalReportViewer et gérez toutes les exportations via le
code.
●
Vous pouvez exporter un rapport en arrière-plan, sans l'afficher.
●
Vous pouvez exporter un rapport vers une réponse HTTP ou vers un flux. Le contrôle CrystalReportViewer
prend uniquement en charge l'exportation d'un rapport vers un disque.
Il existe quatre méthodes pour exporter un rapport. Vous pouvez accéder à toutes ces méthodes via la classe
ReportDocument.
●
ReportDocument.Export
●
ReportDocument.ExportToHTTPResponse
●
ReportDocument.ExportToDisk
●
ReportDocument.ExportToStream
La méthode la plus courante, ReportDocument.Export, permet d'exporter vos rapports vers n'importe quel
format et destination pris en charge par le SDK SAP Crystal Reports .NET. Pour utiliser la méthode
ReportDocument.Export, vous devez d'abord définir plusieurs paramètres via la classe ExportOptions.
Chacune des trois autres méthodes offre un moyen pratique d'exporter un rapport d'une manière spécifique.
L'utilisation des autres méthodes génère en général moins de code, mais offre moins de contrôle sur le fichier qui
en résulte.
129
1.4.2.3.1
Définition des options d'exportation personnalisées
Pour utiliser la méthode ReportDocument.Export, vous devez d'abord définir plusieurs paramètres via la classe
ExportOptions. Ces paramètres contrôlent l'emplacement de l'exportation, le format d'exportation et plusieurs
options de style spécifiques au format de sortie.
Quatre options doivent être définies pour exporter un rapport à l'aide de la méthode ReportDocument.Export.
Option d'exportation
Description
ExportDestinationType
Détermine comment exporter le rapport.
ExportDestinationOptions
Détermine l'emplacement et le nom du fichier qui en résulte.
ExportFormatOptions
Détermine les options de mise en forme spécifiques au
format de sortie.
ExportFormatType
Détermine le type de fichier de destination.
Définition de la propriété ExportDestinationType
La propriété ExportOptions.ExportDestinationType détermine comment exporter le rapport. Les valeurs
disponibles sont stockées dans l'énumération ExportDestinationType.
ExportDestinationType.DiskFile est la valeur la plus courante. D'autres valeurs sont prises en charge,
telles que ExchangeFolder, MicrosoftMail et NoDestination.
Définition de la propriété ExportDestinationOptions
La propriété ExportOptions.ExportDestinationOptions définit les options spécifiques à l'emplacement
cible du fichier de sortie. La valeur de la propriété ExportDestinationOptions dépend de la valeur de la
propriété ExportOptions.ExportDestinationType.
Définit les valeurs suivantes :
DiskFile
Un objet
●
Définit le nom et l'emplacement du
fichier de sortie.
●
Le profil et le mot de passe
utilisateur du serveur Exchange.
●
Le chemin d'accès au dossier
Exchange.
●
Le nom et le mot de passe
utilisateur du compte de courrier
électronique.
●
L'objet et le corps du message
électronique.
DiskFileDestinationOptions
ExchangeFolder
Un objet
ExchangeFolderDestinationOp
tions
MicrosoftMail
Un objet
MicrosoftMailDestinationOpt
ions
130
●
Les destinataires du message
électronique.
Définition de la propriété ExportFormatType
Cette propriété détermine le format du fichier de sortie. Les valeurs disponibles sont stockées dans l'énumération
ExportFormatType. Les options disponibles dépendent de la version de SAP Crystal Reports utilisée.
SAP Crystal Reports, version développeur pour Microsoft Visual Studio prend en charge les options d'exportation
suivantes :
●
●
●
PDF
●
●
●
●
●
Microsoft Excel (2007) Données uniquement
●
HTML 4.0
●
●
Microsoft Word modifiable (RTF)
●
●
Texte
Définition de la propriété ExportFormatOptions
La propriété ExportOptions.ExportFormatOptions définit les options spécifiques au format du fichier de
sortie. La valeur de la propriété ExportFormatOption dépend de la valeur de la propriété
ExportOptions.ExportFormatType.
ExportFormatOptions
Format d'exportation
Un objet ExcelFormatOptions
●
●
●
Microsoft Excel (97-2003) Données
●
uniquement
Un objet HTMLFormatOptions
●
HTML 4.0
La première et la dernière page du
rapport à exporter.
La largeur de colonne par défaut.
●
S'il est nécessaire d'inclure des entêtes de colonne.
●
●
Le nom de la page HTML par
défaut.
131
ExportFormatOptions
Un objet
PdfRtfWordFormatOptions
Format d'exportation
●
PDF
●
●
●
●
Le nom du dossier contenant les
fichiers de prise en charge requis
pour la sortie au format HTML,
comme les images utilisées dans le
rapport.
●
Exemple
Définition des options d'exportation pour Microsoft Excel - Données uniquement
Cet exemple définit les options d'exportation requises pour exporter un rapport au format “Microsoft Excel Données uniquement”.
La méthode instancie une nouvelle classe DiskFileDestinationOptions et affecte à la propriété
DiskFileDestinationOptions.DiskFileName un chemin d'accès au fichier. Pour exporter le fichier vers le
disque, la propriété ExportOptions.ExportDestinationType doit être définie sur
ExportDestinationType.DiskFile et ExportOptions.DestinationOptions doit être définie sur un
objet DiskFileDestinationOptions valide.
Si aucune mise en forme spécifique n'est requise, la propriété ExportOptions.ExportFormatOptions peut
être définie sur null.
Private Function ConfigureExportToExcelRecord(ByVal filepath As String) As
ExportOptions
Dim exOptions As New ExportOptions()
Dim dfDestinationOptions As New DiskFileDestinationOptions()
dfDestinationOptions.DiskFileName = filepath
exOptions.ExportDestinationType = ExportDestinationType.DiskFile
exOptions.DestinationOptions = dfDestinationOptions
exOptions.ExportFormatType = ExportFormatType.ExcelRecord
exOptions.ExportFormatOptions = Nothing
Return exOptions
End Function
private ExportOptions ConfigureExportToExcelRecord(String filepath)
{
ExportOptions exOptions = new ExportOptions();
DiskFileDestinationOptions dfDestinationOptions = new
DiskFileDestinationOptions();
dfDestinationOptions.DiskFileName = filepath;
}
132
exOptions.ExportDestinationType = ExportDestinationType.DiskFile;
exOptions.DestinationOptions = dfDestinationOptions;
exOptions.ExportFormatType = ExportFormatType.ExcelRecord;
exOptions.ExportFormatOptions = null;
return exOptions;
Exemple
Définition des options d'exportation pour le format de sortie HTML 4.0
Cet exemple définit les options d'exportation requises pour exporter un rapport au format “HTML 4.0”.
Il n'est pas nécessaire d'instancier de classe DiskFileDestinationOptions pour les exportations au format
HTML. Ces options sont définies par le biais de la classe HTMLFormatOptions.
Cette méthode instancie une nouvelle classe HTMLFormatOptions et affecte le nom de fichier par défaut à la
propriété HTMLFormatOptions.HTMLFileName et le chemin d'exportation par défaut à la propriété
HTMLFormatOptions.HTMLBaseFolderName. Le dossier de base contient chacune des pages HTML
exportées par le rapport ainsi que toutes les images requises.
Définissez la propriété ExportOptions.ExportFormatOptions sur un objet HTMLFormatOptions valide.
Private Function ConfigureExportToHtml40(ByVal exportpath As String) As
ExportOptions
Dim exOptions As New ExportOptions()
Dim html40FormatOptions As New HTMLFormatOptions()
html40FormatOptions.HTMLBaseFolderName = exportpath
html40FormatOptions.HTMLFileName = "default.html"
html40FormatOptions.HTMLEnableSeparatedPages = True
html40FormatOptions.HTMLHasPageNavigator = True
exOptions.ExportFormatType = ExportFormatType.HTML40
exOptions.ExportFormatOptions = html40FormatOptions
Return exOptions
End Function
private ExportOptions ConfigureExportToHtml40(String exportpath)
{
ExportOptions exOptions = new ExportOptions();
HTMLFormatOptions html40FormatOptions = new HTMLFormatOptions();
html40FormatOptions.HTMLBaseFolderName = exportpath;
html40FormatOptions.HTMLFileName = "default.html";
html40FormatOptions.HTMLEnableSeparatedPages = true;
html40FormatOptions.HTMLHasPageNavigator = true;
exOptions.ExportFormatType = ExportFormatType.HTML40;
exOptions.ExportFormatOptions = html40FormatOptions;
}
return exOptions;
Formats d'exportation disponibles [page 124]
133
1.4.2.3.2
Exportation vers un disque avec des options
d'exportation personnalisée
Contexte
Cet exemple montre comment exporter un rapport Crystal vers le format Microsoft Word. Le SDK de
SAP Crystal Reports 2008 permet d'exporter des rapports vers un format spécifique, tel qu'Excel, PDF ou RTF.
Vous pouvez exporter des rapports vers différents formats en utilisant le modèle d'objet ReportDocument.
Cet exemple définit la propriété ReportDocument.ExportOptions et utilise la méthode
ReportDocument.Export pour exporter le rapport.
Procédure
1.
Créez une méthode qui utilise un objet ReportDocument et un chemin de fichier en tant que paramètres.
2.
Créez une instance de la classe DiskFileDestinationOptions et définissez la valeur de la propriété
DiskFileDestinationOptions.DiskFileName sur le chemin du fichier de sortie.
3.
Créez une instance de la classe ExportOptions et définissez les propriétés requises.
a) Définissez la propriété ExportDestinationType sur ExportDestinationType.DiskFile.
b) Définissez la propriété ExportDestinationOptions sur l'objet DiskFileDestinationOptions.
c) Définissez la propriété ExportFormatType sur ExportFormatType.WordForWindows.
d) Si aucune mise en forme spécifique n'est requise, la propriété ExportOptions.ExportFormatOptions
peut être définie sur null.
Dim wordExportOptions As New ExportOptions()
wordExportOptions.ExportDestinationType = ExportDestinationType.DiskFile
wordExportOptions.ExportDestinationOptions = dfDestinationOptions
wordExportOptions.ExportFormatType = ExportFormatType.WordForWindows
wordExportOptions.ExportFormatOptions = Nothing
ExportOptions wordExportOptions = new ExportOptions();
wordExportOptions.ExportDestinationType = ExportDestinationType.DiskFile;
wordExportOptions.ExportDestinationOptions = dfDestinationOptions;
wordExportOptions.ExportFormatType = ExportFormatType.WordForWindows;
wordExportOptions.ExportFormatOptions = null;
4.
134
Appelez la méthode Export et transmettez l'objet ExportOptions en tant que paramètre.
Exemple
Private Sub ExportToWord_RD(ByVal rd As ReportDocument, ByVal filepath As String)
Dim wordExportOptions As New ExportOptions()
wordExportOptions.ExportDestinationType = ExportDestinationType.DiskFile
wordExportOptions.ExportDestinationOptions = dfDestinationOptions
wordExportOptions.ExportFormatType = ExportFormatType.WordForWindows
wordExportOptions.ExportFormatOptions = Nothing
rd.Export(wordExportOptions)
End Sub
private void ExportToWord_RD(ReportDocument rd, String filepath)
{
ExportOptions wordExportOptions = new ExportOptions();
wordExportOptions.ExportDestinationType = ExportDestinationType.DiskFile;
wordExportOptions.ExportDestinationOptions = dfDestinationOptions;
wordExportOptions.ExportFormatType = ExportFormatType.WordForWindows;
wordExportOptions.ExportFormatOptions = null;
}
rd.Export(wordExportOptions);
1.4.2.3.3
Exportation vers un disque au format PDF à l'aide
de la méthode ReportDocument.ExportToDisk
Contexte
Cet exemple montre comment exporter un rapport Crystal vers le format PDF. Le SDK de
SAP Crystal Reports 2008 permet d'exporter des rapports vers un format spécifique, tel qu'Excel, PDF ou RTF.
Vous pouvez exporter des rapports vers différents formats en utilisant le modèle d'objet ReportDocument.
Procédure
1.
Créez une méthode qui utilise un objet ReportDocument comme paramètre.
2.
Spécifiez un répertoire de sortie et vérifiez qu'il existe. Si le répertoire de sortie n'existe pas, créez-le.
3.
Appelez la méthode ExportToDisk et spécifiez le format de sortie ainsi que le nom du fichier de sortie.
Exemple
Private Shared Sub ExportToPDF_RD(ByVal rd As ReportDocument)
Dim exportPath As String = "C:\\Exported\\"
135
If Not System.IO.Directory.Exists(exportPath) Then
System.IO.Directory.CreateDirectory(exportPath)
End If
rd.ExportToDisk(ExportFormatType.PortableDocFormat, exportPath +
"PortableDoc.pdf")
End Sub
private static void ExportToPDF_RD(ReportDocument rd) {
String exportPath = "C:\\Exported\\";
if (!System.IO.Directory.Exists(exportPath))
{
System.IO.Directory.CreateDirectory(exportPath);
}
rd.ExportToDisk(ExportFormatType.PortableDocFormat, exportPath +
"PortableDoc.pdf");
}
Modèle d'objet ReportDocument [page 37]
1.4.3 Filtrage de données avec des paramètres ou des
formules
SAP Crystal Reports vous permet de personnaliser les données de votre rapport par le biais de paramètres de
rapport ou en changeant la formule de sélection.
Un paramètre est une variable de rapport définie par l'utilisateur et instanciée à l'actualisation du rapport.
Lorsqu'un paramètre est utilisé dans une formule de sélection, il vous permet de modifier les données incluses
dans votre rapport au moment de l'exécution. Les paramètres peuvent également être utilisés pour personnaliser
l'apparence d'un rapport.
Les formules de sélection spécifient et filtrent les enregistrements et les groupes qui apparaissent dans un
rapport. En modifiant la formule de sélection, vous modifiez la requête utilisée lors de l'extraction des données de
la source de données.
Classes utilisées pour la définition de paramètres ou formules
●
CrystalDecisions.CrystalReports.Engine.DataDefinition
Contient toutes les informations relatives à la manipulation des données basées sur la source de données
d'un rapport.
●
CrystalDecisions.CrystalReports.Engine.ParameterFieldDefinition
Représente un champ de paramètre dans le rapport. Cet objet indique les propriétés et les méthodes
permettant d'extraire les informations et de définir les options d'un champ de paramètre dans le rapport.
●
136
CrystalDecisions.Web.Parameter
Fournit des propriétés permettant de modifier ou d'extraire des informations concernant un paramètre dans
un site Web.
1.4.3.1
Paramètres
Un paramètre est une variable de rapport définie par l'utilisateur et instanciée à l'actualisation du rapport. Il existe
de nombreux types de paramètres et la définition par programmation des différents types peut entraîner des
résultats et des expériences différents pour les utilisateurs de votre application.
Possibilités d'optimisation de l'utilisation des paramètres
Afin d'éviter des erreurs de moment d'exécution lors de la définition de paramètres par programmation, notez les
éléments suivants :
●
Les valeurs de paramètres doivent être du même type que le paramètre.
●
Si le paramètre possède un masque d'édition, les valeurs du paramètre doivent respecter ce masque.
●
Lors de la lecture des valeurs de paramètres, assurez-vous de connaître le type de valeurs que vous lisez,
c'est-à-dire, si ces valeurs sont discrètes ou si elles font partie d'une plage.
●
Définissez le type de limite sur une valeur de plage avant de l'ajouter au paramètre.
●
Assurez-vous que la limite supérieure d'une valeur de plage est plus grande que la limite inférieure.
Définition des paramètres [page 699]
Paramètres de données et paramètres non relatifs à des données [page 702]
Conception des champs de paramètre [page 701]
1.4.3.1.1
Propriétés des valeurs de paramètres
Les paramètres prennent en charge de nombreuses fonctions en plus de celles mentionnées ici. Pour obtenir une
liste complète de ces fonctions, voir la classe ParameterField.
Paramètres à valeurs multiples ou uniques
Si un paramètre prend en charge plusieurs valeurs, un utilisateur peut sélectionner plusieurs valeurs pour un
paramètre à l'actualisation du rapport. Si un paramètre prend en charge des valeurs uniques, un utilisateur ne
peut sélectionner qu'une seule valeur pour un paramètre à l'actualisation du rapport. Si un paramètre prend en
charge plusieurs valeurs, il passe d'une variable unique à un tableau contenant de nombreuses valeurs.
137
Valeurs de paramètres discrètes ou faisant partie d'une plage
Les valeurs de paramètres discrètes représentent une valeur unique, telle que 1, "Jill", 3.141 ou True. Les valeurs
de plages représentent une étendue spécifique de valeurs d'un point à un autre, telles que [1..45], (4..6],
["Lundi","Jeudi"]. La valeur de limite inférieure de la plage doit être plus petite que la limite supérieure.
De plus, les paramètres peuvent à la fois être discrets et faire partie d'une plage si le paramètre prend en charge
plusieurs valeurs.
Valeurs par défaut
Vous pouvez spécifier des valeurs par défaut pour un paramètre et forcer l'utilisateur à sélectionner une seule
valeur ou un grand nombre de valeurs. Vous pouvez également fournir des valeurs de paramètres par défaut mais
autoriser l'utilisateur à saisir des valeurs personnalisées. Les valeurs par défaut sont stockées dans la propriété
DefaultValues de l'objet ParameterField. Une fois que l'utilisateur a sélectionné un ensemble de valeurs pour
les paramètres du rapport, ces valeurs sont stockées dans la propriété CurrentValues.
Remarque
Les valeurs par défaut ne peuvent être que discrètes.
Valeurs de paramètres facultatives
Si la valeur d'un paramètre est définie sur "facultative", les utilisateurs ne sont pas obligés de saisir une valeur
lorsqu'une invite s'affiche.
Valeurs de paramètres statiques ou dynamiques
Les valeurs de paramètres statiques sont stockées dans le rapport. Les valeurs de paramètres dynamiques sont
extraites d'une source de données extérieure au rapport.
Valeurs de paramètres de mise en cascade dynamique
Une invite dynamique peut inclure une liste de valeurs mise en cascade qui guide l'utilisateur dans une séquence
d'invites dynamiques pour déterminer une valeur de paramètre finale. Par exemple, les utilisateurs peuvent être
invités à choisir un pays avant qu'un choix de régions apparaisse.
138
Valeurs de paramètres interactives
Les valeurs de paramètres peuvent être manipulées au moment de l'exécution à l'aide de la propriété
CrystalReportViewer.ViewTimeSelectionFormula. La formule de sélection du moment de visualisation
est prise en compte après application des résultats des formules de sélection enregistrés avec le rapport.
Types de valeurs de paramètres
Un champ de paramètre doit contenir un ParameterType spécifique.
Une valeur de paramètre doit être de l'un des types de paramètres suivants :
●
ReportParameter
●
StoredProcedureParameter
●
QueryParameter
1.4.3.1.2
Panneau des paramètres
Mettez en forme et filtrez les données de rapport de manière interactive en utilisant le panneau des paramètres.
Le nouveau panneau des paramètres de SAP Crystal Reports 2008 permet aux utilisateurs de définir des
paramètres statiques et dynamiques et d'actualiser le rapport. Les utilisateurs peuvent également mettre en
forme et filtrer les données du rapport de manière interactive. Le panneau des paramètres est accessible depuis
le volet des outils. Vous pouvez accéder au panneau des paramètres en cliquant sur le bouton Paramètres de la
barre d'outils ou par programmation en utilisant le code suivant :
myCrystalReportViewer.ToolPanelView = ToolPanelViewType.ParameterPanel
crystalReportViewer.ToolPanelView = ToolPanelViewType.ParameterPanel;
Vous pouvez masquer le bouton Paramètres par programmation en utilisant le code suivant :
myCrystalReportViewer.ShowParameterPanelButton = False
crystalReportViewer.ShowParameterPanelButton = false;
Le panneau affiche tous les paramètres qui ont été définis sur Modifiable ou Lecture seule. Si un paramètre est
défini sur Modifiable, vous pouvez ajouter, supprimer ou modifier les valeurs du paramètre en cliquant sur le
bouton Afficher la boîte de dialogue Paramètres avancés. Si les valeurs du paramètre sont modifiées mais pas
appliquées, un astérisque apparaît en regard du champ de paramètre pour indiquer que les valeurs n'ont pas été
appliquées au rapport.
Remarque
Si le paramètre accepte les valeurs personnalisées, vous pouvez directement modifier la valeur du paramètre
dans le champ de texte du panneau des paramètres.
139
Une icône de base de données apparaît à côté des paramètres de données. Lorsque vous modifiez la valeur d'un
paramètre de données, le rapport actualise la base de données et y accède pour effectuer les modifications
correspondantes. Lorsque vous modifiez la valeur d'un paramètre non relatif à des données, le rapport est mis en
forme ou filtré en fonction des données enregistrées dans le rapport. Le rapport n'accède pas à la base de
données.
Filtrage des données à l'aide des formules de sélection [page 148]
1.4.3.1.3
Définition de paramètres dans la page ASPX
Lorsque vous créez un rapport Crystal, la sélection des données de ce rapport est gérée par le critère "where". La
valeur de ce critère peut être codée en dur, mais lorsqu'elle doit être dynamique, un paramètre est créé et la
clause "where" lui est affectée. Les paramètres ne sont pas gérés de la même manière selon que vous utilisez un
modèle de programmation allégée ou classique.
Lorsque vous développez un projet à l'aide d'un modèle de programmation classique, SAP Crystal Reports,
version développeur pour Microsoft Visual Studio accède aux paramètres et interagit avec eux par le biais d'un
groupe de classes associées aux paramètres dans le SDK de SAP Crystal Reports.
Lorsque vous utilisez un modèle de programmation allégée (le modèle de développement d'applications avec
balises), le contrôle CrystalReportSourceaccède aux paramètres et interagit avec eux par le biais de la
structure Parameters. La structure Parameters est une nouveauté de ASP.NET version 2.0, qui permet d'affecter
des paramètres à n'importe quel contrôle DataSource (dans le cas présent, un contrôle
CrystalReportSource). Ces paramètres peuvent être affectés au rapport principal comme aux sous-rapports,
si nécessaire.
Il est possible d'affecter un paramètre à partir de tous les types de paramètre suivants :
●
ControlParameter
●
QueryStringParameter
●
SessionParameter
●
FormParameter
●
CookieParameter
Cette affectation permet alors de créer une solution de programmation allégée dans laquelle les paramètres d'un
rapport peuvent être définis à partir de sélections effectuées dans les contrôles DropDownList (ou d'autres types
de contrôle), de valeurs contenues dans une chaîne de requête URL, de valeurs extraites d'un objet Session, de
valeurs provenant de champs de formulaires ou d'un cookie.
140
Configuration des propriétés Parameters directement dans le fichier XML
Dans un fichier XML, la balise <Parameters> est imbriquée dans la balise <CrystalReportSource>. Dans la
balise imbriquée <Parameters>, il est possible de configurer des liens à un paramètre par défaut ou à un
paramètre à partir d'un contrôle.
Exemple
Configuration d'un paramètre dans XML
Cet exemple définit la valeur par défaut du paramètre City sur Tokyo.
<CR:CrystalReportSource ID="CrystalReportSource1"
runat="server">
<Report FileName="SalesReport.rpt">
<Parameters>
<CR:Parameter ConvertEmptyStringToNull="False"
DefaultValue="Tokyo" Name="City" ReportName="" />
</Parameters>
</Report>
</CR:CrystalReportSource>
Exemple
Liaison d'un paramètre à un contrôle
Vous pouvez lier la valeur d'un paramètre à un autre contrôle au sein du Web Form. Cet exemple définit la
valeur d'un paramètre nommé City sur la valeur d'un contrôle de zone de texte nommé Location.
<CR:CrystalReportSource ID="CrystalReportSource1"
runat="server">
<Report FileName="SalesReport.rpt">
<Parameters>
<CR:ControlParameter ControlID="Location"
ConvertEmptyStringToNull="False"
Name="city" PropertyName="Text" ReportName="" />
</Parameters>
</Report>
Définition des paramètres [page 699]
141
1.4.3.1.3.1
Accès à la boîte de dialogue Editeur de
collections de paramètres
Contexte
Les paramètres sont configurés dans la boîte de dialogue Editeur de collections de paramètres.
Procédure
1.
Sélectionnez le contrôle CrystalReportSource.
2.
Dans Propriétés, développez Report.
3.
Dans la propriété Report, cliquez sur le bouton de sélection (...) tout à fait à droite de Parameters (Collection).
4.
Dans la boîte de dialogue Editeur de collections de paramètres, saisissez un ou plusieurs paramètres pour le
rapport principal ainsi que pour tous les sous-rapports.
1.4.3.1.4
Définition de paramètres discrets dans un rapport
Cet exemple définit les paramètres sur des valeurs spécifiques utilisées par l'exemple de rapport.
Prérequis
Vous devez disposer d'un rapport avec un champ de paramètre déjà spécifié.
Contexte
En utilisant le modèle d'objet ReportDocument, vous pouvez définir les valeurs des paramètres existants dans un
rapport. Les paramètres sont accessibles par nom ou valeur d'index numérique. Pour ajouter un nouveau
paramètre à un rapport, vous devez utiliser le modèle d'objet ReportClientDocument.
Procédure
1.
Crée une constante de chaîne PARAMETER_FIELD_NAME et définit sa valeur sur le nom d'un paramètre
existant.
2.
142
Créez une instance de la classe ArrayList.
3.
Pour chaque valeur que vous souhaitez affecter au paramètre, ajoutez une valeur à l'instance ArrayList.
4.
Appelez la méthode ReportDocument.SetParameterValue et transmettez le nom de paramètre et la liste
de valeurs.
La méthode ReportDocument.SetParameterValue définit la valeur actuelle d'un champ de paramètre.
Cette valeur peut être une valeur primaire, ParameterValue, un tableau d'un type ou l'autre ou une
collection ParameterValues.
Exemple
Définition de paramètres discrets dans un rapport
Private Sub SettingParameters_RD(ByVal TestReport As ReportDocument)
Dim PARAMETER_FIELD_NAME As String = "Country"
Dim countries As New ArrayList()
countries.Add("Canada")
countries.Add("USA")
TestReport.SetParameterValue(PARAMETER_FIELD_NAME, countries.ToArray())
crystalReportViewer.ReportSource = TestReport
End Sub
private void SettingParameters_RD(ReportDocument TestReport)
{
string PARAMETER_FIELD_NAME = "Country";
ArrayList countries = new ArrayList();
countries.Add("Canada");
countries.Add("USA");
TestReport.SetParameterValue(PARAMETER_FIELD_NAME, countries.ToArray());
crystalReportViewer.ReportSource = TestReport;
}
Étapes suivantes
Un site Web SAP Crystal Reports peut requérir un code supplémentaire pour gérer l'état de la session entre les
affichages de page.
Tutoriel : Lecture et définition des paramètres discrets [page 389]
Dans ce tutoriel, vous allez apprendre à créer un rapport dont les données peuvent être filtrées en fonction d'un
paramètre discret.
143
1.4.3.1.5
rapport
Définition de paramètres discrets dans un sous-
Cet exemple attribue à un paramètre de sous-rapport une valeur spécifique.
Prérequis
Contexte
Pour définir une valeur discrète dans un rapport, vous devez appeler la méthode
ReportDocument.SetParameterValue avec le nom du paramètre et la valeur du paramètre. Cette méthode
n'est pas prise en charge pour les sous-rapports. Dans ce cas, vous devez accéder au paramètre du sous-rapport
via la collection ParameterFields du rapport principal et le définir sur un nouvel objet
ParameterDiscreteValue.
Procédure
1.
Créez une instance de la classe ParameterDiscreteValue.
Conseil
Utilisez la classe ParameterRangeValue pour les paramètres limités.
2.
Définissez la propriété ParameterDiscreteValue.Value sur la nouvelle valeur du paramètre.
Dim dv As New ParameterDiscreteValue()
dv.Value = parameterValue
ParameterDiscreteValue dv = new ParameterDiscreteValue();
dv.Value = parameterValue;
3.
Créez une instance de la collection ParameterFields et affectez-lui la valeur de la propriété
ReportDocument.ParameterFields du rapport principal.
Dim parameterFields As ParameterFields = testReport.ParameterFields
ParameterFields parameterFields = testReport.ParameterFields;
144
4.
Accédez au paramètre du sous-rapport via un index nommé de l'instance ParameterFields.
Dim parameterField As ParameterField = parameterFields(parameterFieldName,
subreportName)
ParameterField parameterField = parameterFields[parameterFieldName,
subreportName];
La collection ParameterFields requiert deux index, l'un pour le nom du paramètre et l'autre pour le nom du
sous-rapport.
5.
Effacez la valeur existante dans le champ de paramètre et ajoutez l'objet ParameterDiscreteValue que vous
avez créé préalablement.
parameterField.CurrentValues.Clear()
parameterField.CurrentValues.Add(dv)
parameterField.CurrentValues.Clear();
parameterField.CurrentValues.Add(dv);
6.
Liez le rapport à un contrôle CrystalReportViewer.
Remarque
ParameterFields doit être défini avant la propriété ReportSource du contrôle CrystalReportViewer ; sinon,
le contrôle vous invite à saisir les informations de paramètres.
Exemple
Définition de paramètres discrets dans un sous-rapport
Private Sub SubreportSettingParameters_RD(ByVal testReport As ReportDocument,
ByVal subreportName As String, ByVal parameterFieldName As String, ByVal
parameterValue As String)
Dim dv As New ParameterDiscreteValue()
dv.Value = parameterValue
Dim parameterFields As ParameterFields = testReport.ParameterFields
Dim parameterField As ParameterField = parameterFields(parameterFieldName,
subreportName)
parameterField.CurrentValues.Clear()
parameterField.CurrentValues.Add(dv)
crystalReportViewer1.ReportSource = TestReport
End Sub
private void SubreportSettingParameters_RD(ReportDocument testReport,
String subreportName, String parameterFieldName, String
parameterValue)
{
ParameterDiscreteValue dv = new ParameterDiscreteValue();
dv.Value = parameterValue;
ParameterFields parameterFields = testReport.ParameterFields;
ParameterField parameterField = parameterFields[parameterFieldName,
subreportName];
145
}
parameterField.CurrentValues.Add(dv);
crystalReportViewer1.ReportSource = TestReport;
Étapes suivantes
affichages de page.
Tutoriel : Lecture et définition des paramètres de plage d'un sous-rapport [page 277]
Dans ce tutoriel, vous allez traiter un problème supplémentaire : que faire si un rapport contient un sousrapport nécessitant des paramètres différents ?
1.4.3.1.6
Définition de paramètres limités dans un rapport
Prérequis
Contexte
En utilisant le modèle d'objet ReportDocument, vous pouvez définir les valeurs des paramètres existants dans un
rapport. Les paramètres sont accessibles par nom ou valeur d'index numérique. Pour ajouter un nouveau
paramètre à un rapport, vous devez utiliser le modèle d'objet ReportClientDocument.
Pour définir un paramètre limité, vous devez créer une instance de la classe ParameterRangeValue et la
transmettre à la méthode ReportDocument.SetParameterValue.
146
Procédure
1.
Crée une constante de chaîne PARAMETER_FIELD_NAME et définit sa valeur sur le nom d'un paramètre
existant.
2.
Créez une instance de la classe ParameterRangeValue.
Dim dateRange As New ParameterRangeValue()
ParameterRangeValue dateRange = new ParameterRangeValue();
3.
Définissez les valeurs de début et de fin pour l'objet ParameterRangeValue.
dateRange.StartValue = startDate
dateRange.EndValue = endDate
dateRange.StartValue = startDate;
dateRange.EndValue = endDate;
4.
Définissez les limites supérieure et inférieure de la plage.
Option
Description
RangeBoundType.BoundExclusive
Les valeurs supérieures et inférieures ne sont pas incluses dans la plage.
RangeBoundType.BoundInclusive
Les valeurs supérieures et inférieures sont incluses dans la plage.
RangeBoundType.NoBound
Aucune plage n'est sélectionnée.
dateRange.LowerBoundType = RangeBoundType.BoundInclusive
dateRange.UpperBoundType = RangeBoundType.BoundInclusive
dateRange.LowerBoundType = RangeBoundType.BoundInclusive;
dateRange.UpperBoundType = RangeBoundType.BoundInclusive;
5.
Appelez la méthode ReportDocument.SetParameterValue et transmettez le nom du paramètre et l'objet
ParameterRangeValue.
La méthode ReportDocument.SetParameterValue définit la valeur actuelle d'un champ de paramètre.
Cette valeur peut être une valeur primaire, ParameterValue, un tableau d'un type ou l'autre ou une
collection ParameterValues.
Exemple
Private Sub SettingParameters_RD(ByVal testReport As ReportDocument, ByVal
startDate As String, ByVal endDate As String)
Dim PARAMETER_FIELD_NAME As String = "SalesDates"
Dim dateRange As New ParameterRangeValue()
dateRange.StartValue = startDate
dateRange.EndValue = endDate
dateRange.LowerBoundType = RangeBoundType.BoundInclusive
147
dateRange.UpperBoundType = RangeBoundType.BoundInclusive
testReport.SetParameterValue(PARAMETER_FIELD_NAME, dateRange)
crystalReportViewer1.ReportSource = testReport
End Sub
private void SettingParameters_RD(ReportDocument testReport, String startDate,
String endDate)
{
string PARAMETER_FIELD_NAME = "SalesDates";
ParameterRangeValue dateRange = new ParameterRangeValue();
dateRange.StartValue = startDate;
dateRange.EndValue = endDate;
dateRange.LowerBoundType = RangeBoundType.BoundInclusive;
dateRange.UpperBoundType = RangeBoundType.BoundInclusive;
}
testReport.SetParameterValue(PARAMETER_FIELD_NAME, dateRange);
crystalReportViewer1.ReportSource = testReport;
Étapes suivantes
affichages de page.
1.4.3.2
Filtrage des données à l'aide des formules de
sélection
Les formules de sélection spécifient et filtrent les enregistrements et les groupes qui apparaissent dans un
rapport. Les trois formules de sélection suivantes permettent de filtrer les données :
●
Formule de sélection d'enregistrement
●
Formule de sélection des données enregistrées
●
Formule de sélection de groupe
Le tableau suivant montre les types de champs autorisés dans différents filtres de rapports :
148
Formule de sélection
d'enregistrement
Formule de sélection des
données enregistrées
Formule de sélection de
groupe
Paramètres
X
X
X
Résumés
-
-
X
Formules d'heure d'im
pression/totaux cumulés
-
-
-
Le tableau suivant montre les différents comportements associés aux différents filtres de rapports :
Formule de sélection
d'enregistrement
Formule de sélection des
données enregistrées
Formule de sélection de
groupe
Peut-on se référer au ré
sumé ?
Non.
Oui.
Oui.
Quand la formule est-elle
évaluée ?
Pendant la lecture des en
registrements.
Si un résumé est utilisé, à
l'heure d'impression ; si
non, pendant la lecture
des enregistrements.
A l'heure d'impression.
Quand le rapport est-il ac
tualisé ?
Si le résultat de l'évalua
tion est faux, lorsque les
enregistrements sont
abandonnés.
Si les enregistrements
sont lus, lors de l'évalua
tion. Si le résultat de l'éva
luation est faux, lorsque
les enregistrements sont
abandonnés.
N/A
Le calcul du résumé est-il
affecté ?
Oui, les enregistrements
Si le filtre est évalué pen
Non, les enregistrements
filtrés ne sont pas compta dant la lecture des enre
sont comptabilisés même
bilisés.
gistrements, alors non ; si lorsqu'ils sont filtrés.
non, oui.
Vous pouvez appliquer la formule de sélection des données enregistrées au résultat de la formule de sélection
d'enregistrement. Le diagramme suivant décrit le flux d'utilisation des formules de sélection d'enregistrement et
de sélection des données enregistrées :
Formule de sélection d'enregistrement
La formule de sélection d'enregistrement spécifie les enregistrements qui formeront les données enregistrées du
rapport. Cette formule de sélection autorise deux niveaux de filtrage :
●
filtrage par la base de données ;
●
filtrage par le moteur de traitement du rapport.
149
Formule de sélection des données enregistrées
SavedDataFilter permet aux utilisateurs de visualiser un sous-ensemble des données enregistrées dans un
rapport. En cas de modification de SavedDataFilter, les données enregistrées dans le rapport ne sont pas ignorées
et la base de données n'est pas sollicitée.
Formule de sélection de groupe
La formule de sélection de groupe spécifie les enregistrements qui seront pris en compte lors du rendu des pages
du rapport. Cette formule utilise généralement les valeurs produites à des étapes antérieures de traitement du
rapport, comme les résumés.
Remarque
La formule de sélection de groupe filtre les enregistrements et pas les groupes.
1.4.3.2.1
sélection
Filtrage de données à l'aide de formules de
Contexte
Cet exemple applique un filtre à l'un des paramètres de la base de données qui sont utilisés par l'exemple de
rapport. Le filtre permet aux utilisateurs de personnaliser les valeurs qui apparaissent dans un rapport.
Procédure
1.
Créez une méthode qui utilise un objet ReportDocument et une chaîne contenant une formule de sélection.
Le SDK SAP Crystal Reports .NET utilise la même syntaxe pour une formule de sélection que le concepteur
incorporé de SAP Crystal Reports.
2.
Affectez la formule de sélection à la propriété DataDefinition.RecordSelectionFormula de l'objet
ReportDocument en cours.
La classe DataDefinition contient toutes les informations relatives à la manipulation des données basées sur
la source de données d'un rapport. La classe DataDefinition de chaque rapport est accessible via la propriété
ReportDocument.DataDefinition.
3.
150
Liez la propriété ReportSource du contrôle CrystalReportViewer à l'instance ReportDocument.
Résultats
Le rapport sera actualisé avec les nouveaux résultats en fonction de la formule de sélection spécifiée.
Exemple
Cet exemple accepte un objet ReportDocument et un paramètre d'entier. Le paramètre d'entier est concaténé
avec une chaîne existante pour créer une formule de sélection complète. La formule de sélection est appliquée
au rapport avant la liaison du contrôle CrystalReportViewer à l'objet ReportDocument.
Private Sub FilterData_RD(ByVal TestReport As ReportDocument, ByVal sales As
Integer)
Dim selectFormula As String = "{Customer.Last Year's Sales} > " + sales
TestReport.DataDefinition.RecordSelectionFormula = selectionFormula
crystalReportViewer.ReportSource = TestReport
End Sub
private void FilterData_RD(ReportDocument TestReport, int sales)
{
string selectFormula = "{Customer.Last Year's Sales} > " + sales;
TestReport.DataDefinition.RecordSelectionFormula = selectionFormula;
crystalReportViewer.ReportSource = TestReport;
}
Étapes suivantes
affichages de page.
Incorporation des paramètres dans des formules [page 705]
1.4.4
Définition de la source de données
SAP Crystal Reports permet de créer des rapports à partir de n'importe quelle source de données, notamment les
sources persistantes telles que les bases de données et les fichiers XML, et les sources exécutables telles que les
ensembles d'objets.
Le modèle d'objet ReportDocument permet d'accéder par programmation aux informations de connexion à ces
sources de données et de les modifier pour le fichier de rapport au moment de l'exécution.
151
Une source de données peut être définie de différentes manières :
●
En utilisant la méthode ReportDocument.DatasourceConnections[0].SetConnection.
Cette méthode permet de se connecter à un rapport ou à un sous-rapport.
●
En mettant à jour la propriété ReportDocument.Table.LogOnInfo et en appelant la méthode
ReportDocument.Table.ApplyLogOnInfo.
Cette méthode permet de se connecter à un rapport ou à un sous-rapport. Cette méthode permet également
de spécifier un emplacement de tableau entièrement qualifié.
●
En utilisant la méthode CrystalReportViewer.LogOnInfo.
Cette méthode permet de se connecter à un rapport, mais ne permet pas de définir l'emplacement de la base
de données.
Classes utilisées pour la définition de la source de données
●
CrystalDecisions.Shared.ConnectionInfo
Indique les propriétés permettant d'extraire et de définir des options de connexion aux serveurs de bases de
données ou aux sources de données ODBC.
●
CrystalDecisions.CrystalReports.Engine.Table
Représente une table de base de données à laquelle accède le rapport. Cette classe indique les propriétés et
les méthodes permettant d'extraire les informations sur la table et de définir les informations de connexion de
la table.
●
Représente un rapport et contient les propriétés et les méthodes permettant de spécifier une source de
données au moment de l'exécution.
Sources de données prises en charge [page 666]
Accès aux données et ajout des données [page 666]
1.4.4.1
Connexion à une base de données
La source de données la plus courante pour un rapport Crystal est une base de données. Vous pouvez accéder à
une base de données à partir de l'une des sources suivantes :
●
152
Directement à partir du fichier de rapport, à l'aide des informations de connectivité de la base de données
stockées dans ce fichier.
Les informations de connectivité à la base de données sont configurées à l'aide du concepteur
SAP Crystal Report incorporé lorsque le rapport est créé ou modifié. Ces informations sont automatiquement
transmises à la base de données par le moteur de rapport chaque fois qu'un rapport est affiché.
Les références de connexion peuvent être enregistrées avec le rapport ou transmises au moment de
l'exécution.
●
A partir du code de l'API .NET de SAP Crystal Reports.
Les informations de connectivité à la base de données peuvent être reconfigurées avec un code qui interagit
avec le rapport par programmation au moment de l'exécution.
Le scénario le plus courant pour la création d'une connexion à une base de données consiste à définir les
paramètres de connexion à la base de données dans le concepteur SAP Crystal Reports, puis à fournir les
informations de connexion par programmation au moment de l'exécution.
Accès aux données et ajout des données [page 666]
1.4.4.1.1
Optimisation de la sécurité lors d'une connexion à
une base de données SQL Server
Quelle que soit la source des rapports, le problème de sécurité reste le même : comment protéger la base de
données des attaques malveillantes ?
utiliser l'authentification Windows avec la sécurité intégrée
Pour une sécurité optimale, Microsoft recommande l'utilisation de l'authentification Windows avec la sécurité
intégrée. Avec cette configuration, aucun ID utilisateur ni mot de passe n'est nécessaire dans l'application.
utiliser l'authentification SQL Server avec un compte de base de données à
accès limité
Pour utiliser l'authentification SQL Server avec votre base de données, vous devez prendre des mesures
supplémentaires pour parvenir à une sécurité optimale.
N'utilisez jamais l'ID et le mot de passe de l'administrateur système dans votre code. Ceci représentant une
menace considérable pour la sécurité. Procédez plutôt de la manière suivante :
●
Créez un compte de base de données à accès limité.
●
Configurez ce compte pour autoriser uniquement l'accès aux tables requises de la base de données.
●
Pour chaque table accessible, autorisez uniquement l'exécution de l'instruction SELECT.
Microsoft recommande également de crypter votre ID utilisateur et votre mot de passe. Pour en savoir plus sur le
cryptage de l'ID utilisateur et du mot de passe, consultez les informations sur la sécurité dans MSDN.
153
1.4.4.1.2
Connexion à une base de données SQL Server
sécurisée avec un sous-rapport
Prérequis
Pour exécuter cet exemple, vous devez disposer d'un rapport contenant un sous-rapport qui requiert une
authentification SQL sécurisée. Le nom d'utilisateur et le mot de passe pour se connecter à la base de données
SQL Server doivent être fournis.
Contexte
Cet exemple permet d'activer la base de données d'un sous-rapport par programmation.
Procédure
1.
Extrayez l'instance DataSourceConnections de la propriété DataSourceConnections des instances de
rapport et sous-rapport.
2.
Extrayez l'élément IConnectionInfo au niveau de l'index 0 de l'instance DataSourceConnections.
3.
Appelez la méthode SetConnection avec votre nom de serveur, de base de données, d'utilisateur et votre
mot de passe.
4.
Appelez la méthode SetLogon avec votre nom d'utilisateur et de votre mot de passe.
Exemple
Private Function SubreportLogon_RD(ByVal TestReport As ReportDocument) As
ReportDocument
Dim dataSourceConnections As DataSourceConnections =
TestReport.DataSourceConnections
Dim connectInfo As IConnectionInfo = dataSourceConnections(0)
connectInfo.SetConnection("ServerName", "DatabaseName", "UserName",
"Password")
Dim TestSubreport As ReportDocument = TestReport.Subreports("Subreport1")
Dim subreportDataSourceConnections As DataSourceConnections =
TestSubreport.DataSourceConnections
Dim connectInfo As IConnectionInfo = subreportDataSourceConnections(0)
connectInfo.SetLogon("UserName", "Password")
End Function
private ReportDocument SubreportLogon_RD(ReportDocument TestReport)
{
DataSourceConnections dataSourceConnections =
TestReport.DataSourceConnections;
IConnectionInfo connectInfo = dataSourceConnections[0];
connectInfo.SetConnection("ServerName", "DatabaseName", "UserName",
"Password");
154
ReportDocument TestSubreport = TestReport.Subreports["Subreport1"];
DataSourceConnections subreportDataSourceConnections =
TestSubreport.DataSourceConnections;
IConnectionInfo connectInfo = subreportDataSourceConnections[0];
connectInfo.SetLogon("UserName", "Password");
}
1.4.4.1.3
sécurisée avec le modèle d'objet ReportDocument
Cet exemple montre comme se connecter à une base de données en utilisant une authentification SQL sécurisée.
Prérequis
Avant de commencer, vous devez disposer d'un rapport requérant une authentification SQL sécurisée.
Contexte
Pour mettre à jour les informations de connexion pour un rapport en utilisant le modèle d'objet ReportDocument,
vous devez mettre à jour la propriété ConnectionInfo pour chaque objet Table de la collection
ReportDocument.Database.Tables. Une fois chaque propriété mise à jour, appelez la méthode
Table.ApplyLogOnInfo pour valider les modifications.
Procédure
1.
Créez un objet ConnectionInfo.
2.
Définissez les propriétés DatabaseName, UserID et Password de l'objet ConnectionInfo sur les valeurs
requises pour la connexion.
Remarque
Si vous définissez uniquement les propriétés DatabaseName, UserID et Password, vous êtes connecté au
serveur par défaut de la base de données spécifiée dans le rapport. Toutefois, si vous affectez une autre
propriété ServerName, vous pouvez rediriger le rapport vers un serveur différent au moment de
l'exécution.
3.
Extrayez l'instance Tables de la propriété Database de la classe ReportDocument.
Remarque
Tables est une classe indexée contenant des instances de la classe Table.
155
4.
Pour chaque objet Table de la collection :
a) Extrayez l'instance TableLogOnInfode la propriété LogOnInfo de la classe Table.
b) Mettez à jour la propriété ConnectionInfo de l'objet TableLogOnInfo.
c) Appelez la méthode ApplyLogOnInfo pour valider la modification.
Exemple
Private Sub setDatabaseLogon(ByVal rd As ReportDocument, ByVal databaseName As
String, ByVal userName As String, ByVal password As String)
Dim myConnectionInfo As New ConnectionInfo()
myConnectionInfo.DatabaseName = databaseName
myConnectionInfo.UserID = userName
myConnectionInfo.Password = password
Dim myTables As Tables = rd.Database.Tables
For Each myTable As Table In myTables
Dim newLogonInfo As TableLogOnInfo = myTable.LogOnInfo
newLogonInfo.ConnectionInfo = myConnectionInfo
myTable.ApplyLogOnInfo(newLogonInfo)
Next
End Sub
private void setDatabaseLogon(ReportDocument rd, String databaseName, String
userName, String password)
{
ConnectionInfo connectionInfo = new ConnectionInfo();
connectionInfo.DatabaseName = databaseName;
connectionInfo.UserID = userName;
connectionInfo.Password = password;
}
Tables tables = rd.Database.Tables;
foreach (Table table in tables)
{
TableLogOnInfo newLogonInfo = table.LogOnInfo;
newLogonInfo.ConnectionInfo = connectionInfo;
table.ApplyLogOnInfo(newLogonInfo);
}
Étapes suivantes
Une fois les informations de connexion à la base de données définies pour l'instance ReportDocument, mettez à
jour la propriété ReportSource de l'objet CrystalReportViewer.
156
1.4.4.1.4
sécurisée avec le contrôle CrystalReportViewer
Contexte
Lorsque vous utilisez le modèle d'objet CrystalReportViewer pour vous connecter à une base de données SQL
Server sécurisée, vous devez utiliser les classes de l'espace de noms CrystalDecisions.Shared.
Les propriétés de la classe ConnectionInfo permettent la connexion au serveur de base de données ou aux
sources de données ODBC.
Procédure
1.
Créez un objet ConnectionInfo.
2.
Définissez les propriétés DatabaseName, UserID et Password de l'objet ConnectionInfo sur les valeurs
requises pour la connexion.
Remarque
Si vous définissez uniquement les propriétés DatabaseName, UserID et Password, vous êtes connecté au
serveur par défaut de la base de données spécifiée dans le rapport. Toutefois, si vous affectez une autre
propriété ServerName, vous pouvez rediriger le rapport vers un serveur différent au moment de
l'exécution.
3.
Extrayez l'instance TableLogOnInfosde la propriété LogOnInfo de la classe CrystalReportViewer.
Remarque
TableLogOnInfos est une classe indexée contenant des instances de la classe TableLogOnInfo.
4.
Pour chaque objet TableLogOnInfo de la collection, définissez la ConnectionInfo propriété
d'TableLogOnInfoobjet sur l'ConnectionInfo objet.
Exemple
Private
String,
Dim
Dim
For
Sub setDatabaseLogon(ByVal databaseName As String, ByVal userName As
ByVal password As String)
myCconnectionInfo As New ConnectionInfo()
logOnInfos As TableLogOnInfos = crystalReportViewer.LogOnInfo
Each logOnInfo As TableLogOnInfo In logOnInfos
logOnInfo.ConnectionInfo = myCconnectionInfo
Next
myCconnectionInfo.DatabaseName = databaseName
myCconnectionInfo.UserID = userName
myCconnectionInfo.Password = password
End Sub
private void setDatabaseLogon(String databaseName, String userName, String
157
password){
TableLogOnInfos logOnInfos = crystalReportViewer.LogOnInfo;
foreach(TableLogOnInfo logOnInfo in logOnInfos) {
logOnInfo.ConnectionInfo = connectionInfo;
}
connectionInfo.DatabaseName = databaseName;
connectionInfo.UserID = userName;
connectionInfo.Password = password;
}
1.4.4.2
Connexion aux IDataReader
De nombreux projets .NET utilisent les DataReader, plutôt que les DataSets, pour extraire des données. Par
exemple, le moyen le plus courant de lier un contrôle (tel que le contrôle GridView) aux données consiste à créer
une méthode qui extrait les données par le biais d'un DataReader, puis de renvoyer ces données à partir de la
méthode via une interface IDataReader.
Le concepteur de rapports SAP Crystal incorporé peut accéder à l'interface IDataReader si certaines conditions
sont remplies :
●
Les données doivent être renvoyées à partir d'une méthode, par le biais de l'interface IDataReader.
●
Le fournisseur de données utilisé dans la méthode doit être le fournisseur de données OleDb .NET.
Remarque
Les classes de ce fournisseur de données se trouvent dans l'espace de noms System.Data.OleDb.
●
La méthode doit être partagée [Visual Basic] ou statique [C#].
●
La classe contenant cette méthode doit faire partie d'un projet de bibliothèque de classes et être compilée
dans un assembly.
Pour créer un rapport Crystal utilisant une instance d'IDataReader comme source de données, vous devez créer
une bibliothèque de classes à l'aide d'une méthode statique qui renvoie un objet IDataReader. Après avoir
compilé cette bibliothèque de classes, l'assemblage qui en résulte fait office de source de données pour votre
rapport.
Remarque
Vous ne serez pas en mesure de définir la source de données de votre rapport sur IDataReader tant que vous
n'aurez pas créé et compilé la bibliothèque de classes.
Tutoriel : Connexion aux IDataReader [page 563]
Dans ce tutoriel sur la connectivité des données, vous allez apprendre à vous connecter à une instance
d'IDataReader.
158
1.4.4.3
Connexion aux DataSets ADO.NET
Un objet DataSet ADO.NET est une collection de classes de DataSets créées en mémoire. Vous pouvez créer un
DataSet ADO.NET à partir de diverses sources de données (y compris à partir de bases de données Access,
Oracle et SQL Server) à l'aide du concepteur de DataSets ADO.NET de Visual Studio. Le concepteur de DataSets
ADO.NET affiche une vue graphique de la base de données avec ses tables, ses champs et les types
correspondants. Vous pouvez faire glisser des tables de l'Explorateur de serveurs vers un fichier de schéma dans
l'onglet Schéma du concepteur.
Pour créer un rapport Crystal utilisant un ensemble de données ADO.Net comme source de données, vous devez
créer une bibliothèque de classes à l'aide d'une méthode statique ou d'une propriété qui renvoie un objet
DataSet. Après avoir compilé cette bibliothèque de classes, l'assemblage qui en résulte fait office de source de
données pour votre rapport.
Remarque
Vous ne pourrez pas définir la source de données de votre rapport sur le DataSet tant que vous n'aurez pas
créé et compilé la bibliothèque de classes.
Dans quels cas utiliser un DataSet
Les DataSets sont utiles lorsque :
●
Les données du DataSet doivent être modifiées après l'exécution de la requête.
●
Les données de plusieurs sources de données doivent être mises en relation.
Remarque
Les DataSets sont une représentation XML des données qui proviennent généralement d'une base de
données. Un DataSet correspond non pas à une seule table mais à un groupe de tables dans une base de
données. Cela peut présenter un problème d'évolutivité au niveau des rapports. Si un rapport extrait
plusieurs tables dans un DataSet et qu'une jointure est requise entre ces tables, c'est au rapport
d'effectuer la jointure lorsqu'il interagit séparément avec chaque table. Ce processus n'est pas efficace. Il
est toujours plus judicieux de placer les instructions de jointure dans la requête que vous utilisez pour
remplir le DataSet. Cela génère une "pseudo-table" unique de données pré-jointes dans votre DataSet, qui
"libère" ainsi le rapport et lui permet de se consacrer à l'affichage des données.
Eviter d'utiliser des DataSets pour des requêtes simples [page 68]
En cas d'utilisation des DataSets, les mettre en mémoire cache [page 69]
Tutoriel : Connexion aux DataSets ADO.NET [page 549]
159
1.4.4.4
Connexion aux ensembles d'objets
SAP Crystal Reports 2008 a la capacité de créer des rapports à partir de données d'objet. Les données d'objet
peuvent être simples, telles que des données de chaîne ou d'entier. ou peuvent être complexes, telles qu'une
classe ou une collection. Les collections doivent être un simple tableau ou un objet IEnumerable. SAP Crystal
Reports peut accéder à ces collections d'objets comme à une source de données normale, fournissant une source
de données polyvalente pour vos rapports Crystal.
Une collection d'objets permet d'écrire une classe personnalisée qui remplit un objet avec des données par
programmation ou de façon dynamique. Vous pouvez également rédiger vos propres objets d'accès aux données
en augmentant le nombre de sources de données fournies avec une installation par défaut SAP Crystal Reports,
version développeur pour Microsoft Visual Studio.
Pour utiliser une collection d'objets comme source de données, vous devez créer une classe qui fournit au moins
une propriété publique. Si la propriété renvoie des données simples, telles que des valeurs de chaîne ou d'entier,
SAP Crystal Reports traite ces données en tant que champ d'une base de données. Si la propriété renvoie des
données complexes, telles qu'un objet ArrayList, chaque objet de la collection d'objets fournit une ligne de détails
dans le rapport.
Accès aux données au sein des objets
Les versions antérieures de SAP Crystal Reports permettent d'accéder à des propriétés qui renvoient uniquement
des types de données simples. Par exemple, si un objet contient une propriété qui renvoie une chaîne, cette
chaîne est fournie en tant que champ normal au moment de la conception. Mais si l'objet contient une propriété
qui renvoie un objet, les données au sein de l'objet renvoyé ne sont pas fournies, même s'il contient des données
simples.
SAP Crystal Reports 2008 et les versions ultérieures permettent d'accéder aux données contenues dans des
types de données complexes grâce à une expansion des types complexes. Au moment de la conception, l'objet
renvoyé apparaît en tant que source de données hiérarchique. Les données complexes peuvent être étendues
pour révéler tout type de données simples qu'elles fournissent et qui peuvent ensuite être ajoutées au rapport.
Pour activer l'expansion des types complexes, ajoutez l'attribut CrystalComplexTypeExpansionLevels à la
propriété qui renvoie l'objet que vous souhaitez étendre. Vous devez définir l'attribut
CrystalComplexTypeExpansionLevels sur une valeur supérieure à 1 pour explorer en avant les données de
classe. Si vous ne définissez pas l'attribut CrystalComplexTypeExpansionLevels, SAP Crystal Reports ne
pourra pas accéder aux données de champ au sein de la classe.
Exemple
Exposition de données simples
Cet exemple comporte deux objets : Employee et Person. Lorsque l'objet Employee est ajouté au rapport
comme source de données, la propriété Employee.EmployeeID est fournie en tant que champ valide ;
toutefois, la propriété Employee.Person n'est pas visible, car elle renvoie un type de données complexes.
Class Employee
Private _employeeID As Integer
Private _person As New Person()
160
Public Property EmployeeID() As Integer
Get
Return _employeeID
End Get
Set(ByVal value As Integer)
_employeeID = value
End Set
End Property
Public ReadOnly Property Person() As Person
Get
Return _person
End Get
End Property
End Class
Class Person
Private _name As String
Public Property Name() As String
Get
Return _name
End Get
Set(ByVal value As String)
_name = value
End Set
End Property
End Class
class Employee
{
int _employeeID;
Person _person = new Person();
public int EmployeeID
{
get { return _employeeID; }
set { _employeeID = value; }
}
}
public Person Person
{
get { return _person; }
}
class Person
{
private String _name;
}
public String Name
{
get { return _name; }
set { _name = value; }
}
Exemple
Autorisation d'expansion de types complexes
Dans l'exemple précédent, la propriété Employee.Person n'est pas visible, car elle renvoie un type de
données complexes.
161
Dans cet exemple, l'attribut CrystalComplexTypeExpansionLevels a été ajouté à la propriété
Employee.Person, ce qui permet au concepteur du rapport d'afficher un nouveau champ dans l'Explorateur
de champs : Person-Name.
Class Employee
Private _employeeID As Integer
Private _person As New Person()
Public Property EmployeeID() As Integer
Get
Return _employeeID
End Get
Set(ByVal value As Integer)
_employeeID = value
End Set
End Property
_
<CrystalDecisions.CrystalReports.Engine.CrystalComplexTypeExpansionLevels(1)>
Public ReadOnly Property Person() As Person
Get
Return _person
End Get
End Property
End Class
Class Person
Private _name As String
Public Property Name() As String
Get
Return _name
End Get
Set(ByVal value As String)
_name = value
End Set
End Property
End Class
class Employee
{
int _employeeID;
Person _person = new Person();
public int EmployeeID
{
get { return _employeeID; }
set { _employeeID = value; }
}
}
[CrystalDecisions.CrystalReports.Engine.CrystalComplexTypeExpansionLevels(1)]
public Person Person
{
get { return _person; }
}
class Person
{
private String _name;
public String Name
{
get { return _name; }
162
}
}
set { _name = value; }
Tutoriels : Connexion aux collections d'objets [page 574]
Dans ce tutoriel sur la connectivité des données, vous allez apprendre à utiliser une collection d'objets comme
source de données d'un rapport Crystal.
1.4.4.5 Activation de la mise en cache des rapports dans un
site Web SAP Crystal Reports
Prérequis
Ces étapes font appel aux tâches guidées. Cette fonctionnalité est disponible dans Visual Studio 2005 et versions
ultérieures.
Contexte
Les projets Windows qui utilisent Crystal Reports, version développeur pour Microsoft Visual Studio font appel à
la même structure de mise en cache que celle utilisée dans Visual Studio .NET 2003. A savoir, lorsqu'un rapport
est ajouté à un projet, deux classes de rapport wrapper sont générées : une classe de rapport standard et une
classe de rapport mis en cache.
Si aucune classe wrapper de rapport n'est généré pour un rapport, la mise en cache est contrôlée via la propriété
EnableCaching du contrôle CrystalReportSource.
Procédure
1.
Créer un site Web Crystal Reports, version développeur pour Microsoft Visual Studio.
2.
Dans la page Default.aspx, sélectionnez le mode Source.
3.
Localisez la balise XML du contrôle CrystalReportSource.
4.
Modifiez la valeur de la propriété EnableCaching en la faisant passer de False à True.
163
Remarque
Pour en savoir plus sur la mise en cache des rapports, sur la version mise en cache de la classe de rapport
wrapper et sur l'opportunité de faire ou non appel à la mise en cache, voir Cache et persistance du modèle
d'objet ReportDocument [page 59].
Exemple
<CR:CrystalReportSource ID="myCrystalReportSource" runat="server"
EnableCaching="True">
<Report FileName="CrystalReport1.rpt">
</Report>
1.4.4.6
Utilisation de LINQ
LINQ (Language Integrated Query) est un composant Microsoft Framework permettant d'effectuer des requêtes
sur tout type de source de données.
SAP Crystal Reports peut créer des rapports sur une collection d'objets personnalisés. Cela permet de mieux
contrôler l'affichage des informations dans un rapport. Toutefois, la constitution d'une collection d'objets peut se
révéler compliquée si cette collection contient des données d'agrégat issues de plusieurs sources de données.
L'utilisation de LINQ simplifie le processus de reporting sur une collection d'objets et permet d'exécuter des
requêtes de type SQL sur des objets personnalisés. Par exemple, supposons que vous ayez une base de données
SQL, un fichier XML et un fichier Microsoft Access contenant des données commerciales. LINQ permet
d'effectuer une requête à partir des trois sources de données et d'afficher les données dans un rapport unique.
LINQ permet d'effectuer les opérations suivantes :
●
Constituer une collection d'objets à partir de plusieurs sources de données.
●
Lier deux collections d'objets.
●
Regrouper des éléments au sein d'une collection.
Vous devez installer les logiciels suivants pour utiliser LINQ avec SAP Crystal Reports :
●
Visual Studio 2008 ou une version plus récente
●
Microsoft .NET Framework version 3.5
●
SAP Crystal Reports Basic pour Visual Studio 2008 ou une version plus récente
Définition de la source de données [page 151]
164
1.4.5
Visualisation d'un rapport
Le contrôle CrystalReportViewer permet de visualiser des rapports Crystal. Il existe deux contrôles
CrystalReportViewer dans le SDK SAP Crystal Reports .NET. Pour un site Web, utilisez la classe
CrystalDecisions.Web.CrystalReportViewer. Pour une application Windows, utilisez la classe
CrystalDecisions.Windows.Forms.CrystalReportViewer.
Pour visualiser un rapport, vous devez d'abord ajouter un contrôle CrystalReportViewer à votre application, puis
affecter la propriété ReportSource de ce contrôle à un rapport. Le processus d'affectation d'un rapport à un
contrôle CrystalReportViewer est appelé liaison de rapports.
Il existe différentes manières de lier un contrôle CrystalReportViewer à un rapport. Cette section détaille chaque
scénario de liaison de rapports, ainsi que les considérations générales concernant la visualisation de rapport.
Classes utilisées pour la visualisation de rapports
●
informations sur la manière dont fonctionne et s'affiche le contrôle CrystalReportViewer.
●
●
Contrôle CrystalReportViewer [page 43]
Scénarios de liaison de rapports [page 170]
1.4.5.1
Comparaison des rapports incorporés et non
incorporés
Différence entre un rapport incorporé et un rapport non incorporé
Un rapport incorporé est un rapport qui a été importé ou créé dans un projet Visual Studio. Lorsqu'un rapport est
incorporé dans un projet, une classe wrapper est automatiquement générée pour ce rapport. Cela permet
d'accéder au rapport par son nom, plutôt que par le biais d'une instance ReportDocument distincte.
165
Un rapport non incorporé est un rapport externe au projet Visual Studio. Il existe de nombreuses manières
d'accéder au rapport et de le charger dans un modèle d'objet (afin de pouvoir interagir avec lui par
programmation), mais ce rapport restera toujours externe au projet.
Fonctionnement d'un rapport incorporé
Lorsqu'un rapport est importé ou créé dans un projet, une classe wrapper (du même nom que le rapport) est
générée. Cette classe wrapper inclut ou représente le rapport dans le projet. Une fois cette opération terminée,
tout le code du projet interagit avec la classe créée pour représenter le rapport plutôt qu'avec le rapport luimême.
Lorsque le projet est compilé, le rapport et sa classe wrapper sont incorporés dans l'assembly, comme pour
n'importe quelle autre ressource du projet.
Remarque
Avec .Net Framework, la taille des fichiers DLL est limitée. Cela signifie que la compilation du projet peut
échouer s'il contient des rapports incorporés volumineux. Pour les projets utilisant des rapports volumineux,
désactivez les données enregistrées dans le rapport ou modifiez votre projet de sorte à utiliser des rapports
non incorporés. La taille limite varie selon les versions de .Net Framework. Pour en savoir plus, reportez-vous à
la documentation de .Net Framework.
La classe wrapper d'un rapport s'étend à partir de la classe de base commune ReportDocument. Elle hérite de
toutes les propriétés et méthodes de ReportDocument.
La classe ReportDocument est la classe racine du modèle d'objet ReportDocument.
Fonctionnement d'un rapport non incorporé
L'accès à un rapport non incorporé se fait toujours depuis l'extérieur et le SDK peut y accéder de diverses
manières :
●
Le rapport peut être situé sur le disque dur avec un chemin d'accès au répertoire de fichiers.
●
Le rapport peut être exposé en tant que service Web de rapports.
●
Le rapport peut faire partie d'un groupe de rapports exposés via les services Crystal.
Les rapports non incorporés ne sont jamais importés dans un projet, et par conséquent, aucune classe wrapper
n'est créée (contrairement aux rapports incorporés). A la place, le rapport non incorporé est chargé dans un des
modèles d'objet au moment de l'exécution, de l'une des manières suivantes :
●
Le rapport est chargé par et dans le modèle d'objet ReportDocument à l'aide de la méthode
ReportDocument.Load().
●
Le modèle d'objet CrystalReportViewer utilise la propriété CrystalReportViewer.ReportSource pour lier
directement le rapport au contrôle.
166
Comment choisir entre un rapport incorporé ou non incorporé
Si vous souhaitez simplifier le déploiement de votre projet, utilisez des rapports incorporés. Vous aurez moins de
fichiers à gérer et aucun risque de placement incorrect des rapports suite à un chemin d'accès erroné. Cette
solution est également plus sûre dans la mesure où les rapports ne sont pas exposés pour les modifications.
S'ils garantissent simplicité et sécurité, les rapports incorporés impliquent une charge de travail plus importante.
Ils ne peuvent pas être modifiés sans recompiler le projet dans son intégralité. Si des rapports doivent être
modifiés régulièrement, ne les incorporez pas. Leur accès et leur modification seront ainsi facilités et vous n'aurez
pas à recompiler les assemblys à chaque fois. En outre, la taille des rapports incorporés est limitée. Les rapports
très volumineux ne peuvent pas être compilés en tant que ressources incorporées.
Les scénarios de liaison de rapports vous indiqueront de nombreuses manières de lier des rapports incorporés et
non incorporés. Vous verrez également comment utiliser ReportDocument en tant que classe générique pour l'un
comme pour l'autre type de rapport. Cela permet de limiter au maximum les modifications de code, si vous
décidez de passer d'une solution à une autre.
Incorporation de rapports dans un projet Web
La prise en charge des rapports incorporés est activée par le biais d'un Build Provider qui compile les rapports
sous la forme d'un fichier DLL. Pour incorporer un rapport dans un fichier DLL lors de la compilation, vous devez
attribuer au paramètre embedRptInResourc de votre fichier web.config la valeur True. Pour accéder à la classe
du wrapper via Intellisense, vous devez placer le rapport dans le dossier App_Code/Global de votre solution.
Remarque
Si le rapport est situé dans le répertoire App_Code/Global et que le paramètre embedRptInResource est
défini sur False, le fichier du rapport ne sera pas copié dans l'emplacement cible au moment de la publication
du site Web. Pour contourner ce problème, copiez votre site Web dans l'emplacement cible.
embedRptInResour
ce
Emplacement du
rapport
Intellisense
disponible
Publier pour
déployer
Copier pour
déployer
True
App_Code/Global
X
X
X
True
En dehors de
X
X
X
X
App_Code/Global,
mais dans le projet
False
App_Code/Global
False
En dehors de
X
X
App_Code/Global,
mais dans le projet
167
1.4.5.2
Définition de la source du rapport
Le contrôle CrystalReportViewer n'affiche qu'un rapport à la fois. Pour indiquer au contrôle le rapport qu'il doit
afficher, vous devez lier sa propriété ReportSource à un rapport particulier. Au moment de l'exécution, le contrôle
charge le rapport lié à la propriété ReportSource et l'affiche.
Un contrôle CrystalReportViewer peut être lié à un fichier sur un disque, à un objet ReportDocument ou à un objet
ReportClientDocument. La liaison à un objet fournit des fonctionnalités supplémentaires par le biais des modèles
d'objet ReportDocument et ReportClientDocument. Il s'agit de la manière la plus simple de définir la propriété
ReportSource.
Dans sa forme la plus simple, l'affectation se présente de la manière suivante :
crystalReportViewer1.ReportSource = "C:\WorldSalesReport.rpt"
crystalReportViewer1.ReportSource = "C:\\WorldSalesReport.rpt";
Dans cet exemple, le rapport est lié au contrôle directement à partir de son chemin d'accès au répertoire de
fichiers.
Contrôle CrystalReportSource
Le contrôle CrystalReportSource est un élément du modèle de développement d'applications avec balises fourni
avec ASP.NET version 2.0.
Remarque
Le contrôle CrystalReportSource n'est disponible que pour les sites Web.
Dans la structure de contrôle DataSource, les contrôles .NET visuels se connectent aux contrôles DataSource non
visuels (contrôles qui ne gèrent pas les informations d'affichage). Cette nouvelle structure DataSource encapsule
les informations de connectivité des données écrites sous forme de lignes de code dans les contrôles .NET insérés
dans le Web Form.
168
1.4.5.2.1
fichier sur disque
Contexte
l'application.
Procédure
1.
2.
3.
4.
○
○
1.4.5.2.2
Liaison du contrôle CrystalReportViewer à un objet
ReportDocument
Contexte
Ce scénario de liaison de rapports permet d'utiliser ReportDocument, le modèle d'objet le plus puissant, avec des
rapports non incorporés (externes à votre projet).
Au lieu de lier directement les chemins d'accès des répertoires au visualiseur, vous les transmettez à la méthode
ReportDocument.Load(). Vous liez ensuite le contrôle CrystalReportViewer à l'objet ReportDocument.
169
Procédure
1.
2.
3.
4.
Instanciez un nouvel objet ReportDocument et chargez un rapport depuis le disque à l'aide de la méthode
ReportDocument.Load.
Dim rd As ReportDocument = New ReportDocument()
rd.Load(reportPath)
ReportDocument rd = new ReportDocument();
rd.Load(reportPath);
5.
Définissez la propriété ReportSource sur l'objet ReportDocument.
○
myCrystalReportViewer.ReportSource = rd
crystalReportViewer.ReportSource = rd;
○
myCrystalReportViewer.ViewerCore.ReportSource = rd
crystalReportViewer.ViewerCore.ReportSource = rd;
1.4.5.3
Scénarios de liaison de rapports
SAP Crystal Reports, version développeur pour Microsoft Visual Studio, propose plusieurs méthodes pour
associer un contrôle CrystalReportViewer à un rapport. Afin de vous aider à choisir le scénario de liaison de
rapports le mieux adapté à votre application, cette section récapitule les avantages et les inconvénients des
scénarios recommandés et explique pourquoi certains sont plus utilisés que d'autres.
Remarque
La plupart des sites Web ou des projets Windows peuvent reposer sur les deux scénarios de liaison les plus
simples : la liaison à un rapport incorporé ou non incorporé.
Après avoir lu cette section, vous pouvez consulter la liste détaillée de tous les scénarios afin d'examiner en détail
toutes les options disponibles dans le SDK.
170
Scénarios de liaison recommandés pour SAP Crystal Reports
Les scénarios qui lient les rapports à l'aide du modèle d'objet ReportDocument sont généralement plus utilisés
que ceux qui font appel au modèle d'objet CrystalReportViewer. Cela tient au fait que le modèle d'objet
ReportDocument fournit une interface API plus complète pour programmer l'interaction avec le rapport.
La plupart des utilisateurs préfèrent le scénario Liaison à une classe de rapport incorporé [page 200]. S'il n'est pas
le plus à même d'optimiser les performances, ce scénario est le plus simple d'utilisation : vous ajoutez un rapport
au projet pour créer une classe wrapper de rapport, vous instanciez cette classe wrapper, puis vous la
transmettez au contrôle CrystalReportViewer. Etant donné que la classe wrapper du rapport hérite des
caractéristiques de la classe de base ReportDocument, vous avez accès à toutes les fonctionnalités du modèle
d'objet ReportDocument.
Une autre méthode courante de liaison des rapports est décrite dans Liaison à un rapport non incorporé chargé
dans la classe ReportDocument [page 202]. Ce scénario offre également un accès à toutes les fonctionnalités du
modèle d'objet ReportDocument avec en plus l'avantage des rapports non incorporés qui peuvent être modifiés
sans avoir à recompiler l'application dans son intégralité.
Scénarios de liaison recommandés pour le Report Application Server
Avec le serveur RAS et selon la manière dont vous configurez votre projet, vous pouvez utiliser des scénarios
supplémentaires de liaison de rapports.
●
Si vous utilisez SAP Crystal Reports 10 avec le RAS 10, vous pouvez transférer des projets créés à l'origine
dans SAP Crystal Reports (en utilisant des rapports incorporés) vers le serveur RAS et le modèle d'objet
ReportClientDocument, en ajoutant uniquement deux lignes de code par rapport.
●
Pour optimiser le scénario ci-dessus, faites des copies de vos rapports incorporés sur le serveur RAS et
dirigez ce dernier de manière à ce qu'il utilise ces copies.
Scénarios de liaison recommandés pour SAP Crystal Reports Server ou la
plateforme SAP BusinessObjects Business Intelligence
Si vous avez procédé à une mise à niveau vers SAP Crystal Reports Server ou la plateforme SAP BusinessObjects
Business Intelligence, vous avez le choix entre quatre scénarios de liaison de rapports recommandés. Votre choix
dépendra de vos attentes en matière de modification des rapports et d'évolutivité :
●
Vous pouvez afficher un rapport qui ne nécessite aucun modification par programmation avec une vitesse et
des performances optimales.
●
Vous pouvez modifier l'affichage de votre rapport par programmation en accédant au modèle d'objet
ReportClientDocument.
●
Si vous utilisez SAP Crystal Reports, version développeur pour Microsoft Visual Studio avec
SAP Crystal Reports Server ou la plateforme SAP BusinessObjects Business Intelligence, vous pouvez
transférer des projets initialement créés dans SAP Crystal Reports (en utilisant des rapports incorporés) vers
SAP Crystal Reports Server ou la plateforme SAP BusinessObjects Business Intelligence, tout en conservant
le code de rapport existant, en publiant des copies des rapports incorporés dans SAP Crystal Reports Server
ou dans la plateforme SAP BusinessObjects Business Intelligence.
171
●
Vous pouvez accéder à votre rapport en tant qu'instance d'InfoObject dans la structure de plateforme, ce
qui vous permet de planifier ce rapport et d'en modifier les paramètres.
Contrôles du visualiseur de rapports [page 35]
1.4.5.3.1
Liaison de rapports à l'aide du modèle d'objet
CrystalReportViewer
Le modèle d'objet CrystalReportViewer est le modèle d'objet le plus simple. Etant donné la portée limitée de ses
fonctionnalités, son utilisation est généralement déconseillée au profit du modèle d'objet plus complet
ReportDocument.
Modèle d'objet CrystalReportViewer [page 37]
Liaison au chemin d'accès d'un répertoire de fichiers par code [page 172]
1.4.5.3.1.1
Liaison au chemin d'accès d'un répertoire de
fichiers par code
Modèle d'objet
Ce scénario de liaison de rapports utilise le modèle d'objet CrystalReportViewer.
Emplacement des rapports
Les rapports se trouvent dans un répertoire de fichiers.
Description
Il s'agit du scénario de liaison de rapports le plus simple : vous liez un rapport situé dans le répertoire de fichiers
au contrôle CrystalReportViewer par le biais de son chemin d'accès.
172
Avantages
●
Peu de maintenance : les rapports sont ajoutés, supprimés ou modifiés sans avoir à recompiler l'application.
●
Implémentation simplifiée : il est inutile de déclarer et d'instancier les classes. Ce scénario contourne
l'utilisation du modèle d'objet ReportDocument en transférant directement un rapport au contrôle
Inconvénients
●
Distribution limitée : les rapports restent généralement stockés sur le même ordinateur que l'application, en
raison des complications générées par l'octroi au compte utilisateur ASPNET de droits d'accès à un autre
ordinateur du réseau.
●
Modèle d'objet limité : ce scénario de liaison n'offre qu'un modèle d'objet limité qui fait partie du contrôle
Liaison au chemin d'accès d'un répertoire de fichiers via la fenêtre Propriétés [page 174]
1.4.5.3.1.1.1
fichier sur disque
Contexte
l'application.
Procédure
1.
2.
3.
4.
173
○
○
1.4.5.3.1.2
Liaison au chemin d'accès d'un répertoire de
fichiers via la fenêtre Propriétés
Modèle d'objet
Description
Ce scénario constitue une alternative au scénario de liaison de rapports le plus simple : Liaison au chemin d'accès
d'un répertoire de fichiers par code [page 172]. Vous liez un rapport situé dans un répertoire de fichiers au contrôle
CrystalReportViewer par le biais de son chemin d'accès, mais définissez cette affectation dans la fenêtre
Propriétés, directement à l'aide de la propriété DataBindings>ReportSource ou de la propriété
ReportSource.
Dans un projet Web, le chemin d'accès au rapport est inséré directement dans le code HTML de la page ASPX
plutôt que dans le code de la classe code-behind.
Avantages
●
174
Aperçu au moment de la conception : vous pouvez afficher un aperçu du rapport au moment de sa
conception, dans le Web Form ou le Windows Form.
Remarque
L'aperçu au moment de la conception est une fonctionnalité dont les projets Web bénéficiaient déjà, mais
qui est nouvelle pour les projets Windows.
●
●
Implémentation simplifiée : il est inutile de déclarer et d'instancier les classes. Ce scénario contourne
l'utilisation du modèle d'objet ReportDocument en transférant directement un rapport au contrôle
Inconvénients
●
Pour les applications Web, étant donné que la liaison se fait au niveau de la page HTML, vous devez appeler la
méthode DataBind() du contrôle CrystalReportViewer dans la classe code-behind.
Remarque
Cette restriction a été supprimée dans SAP Crystal Reports pour Visual Studio 2005.
●
●
Liaison à un contrôle CrystalReportSource (sites Web dans Visual Studio) [page 176]
1.4.5.3.1.2.1
Pour lier un rapport par l'intermédiaire du
chemin d'accès à son répertoire de fichiers à l'aide de la
fenêtre Propriétés
Procédure
1.
Créez un projet Web ou Windows.
2.
Dans la boîte à outils, faites glisser un contrôle CrystalReportViewer dans un Web Form ou un
Windows Form.
3.
Cliquez sur le contrôle CrystalReportViewer pour le sélectionner.
4.
Dans la fenêtre Propriétés, affectez à la propriété ReportSource le chemin d'accès à un répertoire de
fichiers.
175
Remarque
Le chemin d'accès au répertoire de fichiers pointe sur les exemples de rapports de Visual Studio 2005.
En raison de la fonctionnalité d'aperçu au moment de la conception, le rapport s'affiche en mode Aperçu.
C:\Program Files\Microsoft Visual Studio 8.0\Crystal Reports\Samples\fr\Reports
\Feature Examples\Hierarchical Grouping.rpt
5.
Pour visualiser le rapport, générez et exécutez votre projet.
1.4.5.3.1.3
Liaison à un contrôle CrystalReportSource (sites
Web dans Visual Studio)
Modèle d'objet
Description
Ce scénario constitue une alternative au scénario de liaison de rapports le plus simple : Liaison au chemin d'accès
d'un répertoire de fichiers par code [page 172]. Dans ce scénario, vous liez un rapport à l'aide du nouveau modèle
de développement d'applications avec balises et programmation allégée d'ASP.NET version 2.0.
Remarque
Ce scénario de liaison de rapports n'est disponible que pour les sites Web.
Dans ce scénario, vous utilisez des tâches guidées pour créer un contrôle CrystalReportSource. Vous
sélectionnez ensuite un rapport pour le contrôle CrystalReportSource.
Au lieu d'écrire manuellement du code pour interagir avec le rapport et permettre son accès au modèle d'objet
CrystalReportViewer, vous effectuez des sélections dans le panneau des tâches guidées (mode Design) ou vous
saisissez directement des déclarations XML (mode Source).
Avec les déclarations XML, vous pouvez associer les balises <Parameters> et <DataSources>, imbriquées dans la
balise <Report>, à un ensemble de contrôles non visuels accessibles à partir des structures Parameter et
DataSource.
176
Remarque
Les structures Parameter et DataSource sont de nouvelles fonctionnalités d'ASP.NET 2.0. Elles incluent des
contrôles tels que ControlParameter ou QueryStringParameter et SqlDataSource ou JetDataSource.
Le modèle de développement d'applications avec balises est un moyen simple et rapide d'interagir de manière
limitée avec le rapport sans avoir à écrire du code.
Avantages
●
Aperçu au moment de la conception : vous pouvez afficher un aperçu du rapport au moment de sa
conception, dans le Web Form ou le Windows Form.
●
Interaction simplifiée avec le rapport : le modèle de développement d'applications avec balises, plus simple et
allégé en programmation, peut être utilisé pour interagir avec le rapport.
●
Avantages identiques à ceux répertoriés dans le scénario Liaison au chemin d'accès d'un répertoire de fichiers
par code [page 172].
Inconvénients
●
●
1.4.5.3.1.3.1
Liaison à un contrôle CrystalReportSource à
l'aide du modèle de programmation allégée
Procédure
1.
Faites glisser un contrôle CrystalReportViewer sur le Web Form.
2.
Dans l'angle supérieur droit du contrôle CrystalReportViewer, cliquez sur le petit bouton triangulaire.
Le panneau des tâches guidées Tâches CrystalReportViewer s'affiche. Dans la liste Sélectionner la source du
rapport, la valeur <Aucune> s'affiche.
3.
Cliquez sur la liste Sélectionner la source du rapport, puis sélectionnez <Source du nouveau rapport…>.
La boîte de dialogue Créer la source du rapport s'ouvre.
4.
Dans la zone Indiquer le nom du contrôle CrystalReportSource, laissez l'entrée par défaut
CrystalReportSource1.
5.
Cliquez sur la liste Spécifier un rapport pour le contrôle CrystalReportSource, puis sélectionnez <Parcourir...>.
L'autre sélection possible est <Nouveau rapport>. Cette option permet de créer un rapport Crystal.
177
6.
Sélectionnez un rapport à afficher dans le contrôle CrystalReportViewer et cliquez sur OK.
7.
Cliquez à nouveau sur OK pour fermer la boîte de dialogue Créer la source du rapport.
Tutoriel : Configuration par programmation allégée d'un site Web avec SAP Crystal Reports à l'aide du panneau des
tâches guidées [page 508]
Dans ce tutoriel, vous allez apprendre à utiliser le nouveau modèle de développement d'applications avec
balises dans Visual Studio. Vous allez suivre un modèle de développement par programmation allégée pour
configurer un site Web avec SAP Crystal Reports, à l'aide des tâches guidées.
1.4.5.3.1.4
Liaison à l'URL d'un service Web de rapports
Modèle d'objet
Les rapports, situés à l'emplacement d'un service Web de rapports, sont hébergés sur un serveur Web (en général
distant).
Description
Un rapport, stocké sur un autre serveur et traité comme un service Web de rapports, est lié par le biais de son
URL au contrôle CrystalReportViewer.
Avantages
●
Large distribution : les rapports peuvent exister n'importe où sur Internet.
●
Distribution facile : les services Web de rapports se trouvent sur le port 80, ce qui les rend accessibles même
par le biais de pare-feu.
178
Inconvénients
●
Implémentation
Remarque
Cette procédure fonctionne uniquement avec un projet créé à partir de la procédure Configuration d'un projet
[page 15]. La section Configuration d'un projet contient une configuration de références d'espaces de noms et
de code spécifique nécessaire à cette procédure. Il est impossible de suivre cette procédure sans cette
configuration.
●
Dans la méthode ConfigureCrystalReports() (que vous avez créée dans la section Configuration d'un
projet [page 15]), affectez l'URL d'un service Web de rapports à la propriété ReportSource de la classe
Cette opération lie le rapport directement au contrôle. Toutes les interactions par programmation avec le
rapport doivent être effectuées dans le modèle d'objet limité CrystalReportViewer.
myCrystalReportViewer.ReportSource = _
"http://localhost/TestProject/World_Sales_ReportService.asmx"
"http://localhost/TestProject/World_Sales_ReportService.asmx";
Remarque
Pour utiliser ce scénario de liaison, créez un projet de services Web de rapports dans Visual Studio.
179
1.4.5.3.1.5
Scénarios de liaison CrystalReportViewer avec les
services Crystal
Utilisation des services Crystal dans Visual Studio
SAP Crystal Reports, version développeur pour Microsoft Visual Studio permet d'accéder par programmation aux
fichiers serveur via Crystal Services.
Utilisation des services Crystal dans Visual Studio 2003
Dans Visual Studio 2003, vous pouvez accéder aux rapports Crystal via le nœud Services Crystal dans
l'Explorateur de serveurs. Une fois SAP Crystal Reports et les services Crystal installés, Services Crystal apparaît
sous la forme d'un sous-nœud sous chaque serveur de l'Explorateur de serveurs.
Le nœud Services Crystal peut être développé pour afficher des listes de rapports situés à divers emplacements :
●
Répertoire de fichiers local sur votre disque dur
●
●
Crystal Enterprise
Vous pouvez placer n'importe quel rapport répertorié dans ces listes dans un Web Form ou un Windows Form à
l'aide d'une opération glisser-déplacer.
Selon la version de SAP Crystal Reports que vous avez installée et les licences supplémentaires que vous avez
éventuellement acquises pour le RAS (Report Application Server) ou Crystal Enterprise, les services Crystal
exposent généralement deux nœuds qui peuvent être développés. Le tableau situé dans la section suivante décrit
les conditions requises pour accéder à un nœud particulier.
Classes wrapper
Lorsque vous faites glisser un rapport depuis les services Crystal vers un Web Form ou un Windows Form, cela
crée une instance de la classe wrapper qui référence le rapport dans la région du code de la classe code-behind
généré par le Concepteur Web Form ou Windows Form.
Remarque
Le type de classe wrapper varie selon les versions de SAP Crystal Reports. Voir le tableau ci-dessous.
180
Les services Crystal répertoriés dans le tableau ci-dessous exposent des types de classes wrapper qui ne
contiennent pas de modèle d'objet et dépendent du modèle d'objet limité fourni par le contrôle
La table indique les services Crystal inclus dans SAP Crystal Reports pour Visual Studio 2003. Ces services
exposent des groupes de rapports, soit à partir du répertoire de fichiers local, soit à partir du WCS
(Web Component Server) de Crystal Enterprise. Les rapports sont contenus dans deux classes wrapper
différentes : ServerFileReport pour les rapports situés dans le répertoire de fichiers local, et EnterpriseReport
pour les rapports situés sur le WCS de Crystal Enterprise.
Classe wrapper ex Nom du nœud sous
posée par le biais
les services Crystal
des services Crystal
Versions de
SAP Crystal Re
ports
Description
Conditions requises
pour accéder au
nœud
ServerFileReport
SAP Crystal Reports
pour Visual Stu
dio .NET 2003
Expose les rapports
situés dans le réper
toire de fichiers local
par le biais d'un ser
vice Web commun,
ServerFileReport
Service. Pour en sa
voir plus, voir Liaison
aux fichiers serveur
(VS .NET 2003)
[page 181].
Configurez les auto
risations pour les uti
lisateurs ASPNET.
(Voir Liaison aux fi
chiers serveur
(VS .NET 2003)
[page 181].)
Accède aux services
Web de rapports ex
posés par le serveur
WCS de Crystal En
Û²?à%`Cłã
prise 8, 8.5, 9 ou 10
par le biais d'un ser
vice Web commun,
EnterpriseReport
Service. Pour en sa
voir plus, voir Liaison
à Crystal Enterprise
(VS .NET 2003)
[page 186].
Vous devez pouvoir
accéder à Crys
tal Enterprise (qui
expose les rapports
Enterprise par le bi
ais de son WCS).
Fichiers serveur
(le nœud est rem
placé lorsque
SAP Crystal Re
ports 9 ou 10 est in
stallé)
EnterpriseReport
Crystal Enterprise
SAP Crystal Reports
pour Visual Stu
dio .NET 2003
(le nœud est rem
placé lorsque
SAP Crystal Re
ports 9 ou 10 est in
stallé)
1.4.5.3.1.5.1
Liaison aux fichiers serveur (VS .NET 2003)
Modèle d'objet
Ce scénario de liaison de rapports utilise CrystalReportViewer.
181
Les rapports se trouvent dans un dossier situé dans le répertoire de fichiers local. Ces rapports sont exposés en
tant que services Web de rapports.
Présentation des services Crystal
Ce scénario de liaison de rapports s'applique aux rapports accessibles depuis le nœud du serveur de services
Crystal dans l'Explorateur de serveurs.
Cette section présente le sous-nœud Fichiers serveur des services Crystal dans Visual Studio .NET 2003.
[NOMSERVEUR]
●
Services Crystal
○
Fichiers serveur
Description
Le sous-nœud Fichiers serveur accède aux rapports qui ont été exposés comme services Web de rapports à partir
du répertoire de fichiers local, puis les affiche. Ces rapports sont exposés à l'aide du protocole des services Web
de rapports. Dans Visual Studio .NET 2003, cliquez sur le nœud Fichiers serveur situé sous Services Crystal pour
accéder aux fichiers serveur.
Avantages
●
Accès centralisé aux rapports : offre un point d'accès unique à tous les rapports situés dans votre répertoire
d'exemples de rapports, ce qui crée un référentiel de rapports efficace sur votre disque dur local.
Inconvénients
●
Remplacé dans SAP Crystal Reports 9 et 10 par un nœud Services Crystal de serveur RAS non géré. Pour en
savoir plus, voir la section Description ci-dessus.
●
182
Les fichiers serveur sont fournis en tant que nœud de Services Crystal dans SAP Crystal Reports pour Visual
Studio 2003. Lorsque SAP Crystal Reports 9 ou 10 (les versions complètes) est installé par-dessus la version
incluse avec Visual Studio 2003, le nœud des fichiers serveur n'est plus visible.
Chaque édition de SAP Crystal Reports Developer continue à prendre en charge les fichiers serveur dans le SDK.
Toutefois, une programmation manuelle est nécessaire pour utiliser les fichiers serveur dans cette version.
Liaison à Crystal Enterprise (VS .NET 2003) [page 186]
1.4.5.3.1.5.1.1
Pour installer les services Crystal
Prérequis
SAP Crystal Reports pour Visual Studio 2003 doit être installé.
Contexte
Les services Crystal ne sont pas installés par défaut lors de l'installation de Visual Studio .NET 2003. Dans cette
procédure, vous allez installer les Services Crystal à partir du CD d'installation de Visual Studio .NET 2003.
Procédure
1.
Sur le CD d'installation de Microsoft Visual Studio .NET, localisez Crystal Reports.
2.
Sélectionnez les services Web Crystal.
3.
Cliquez sur le bouton Mettre à jour.
183
1.4.5.3.1.5.1.2
Pour utiliser le nœud Services
Crystal > Fichiers serveur
Prérequis
●
SAP Crystal Reports pour Visual Studio 2003 est installé et fonctionnel.
●
Ou SAP Crystal Reports 9 ou versions ultérieures est installé et fonctionnel.
Remarque
Dans SAP Crystal Reports 9 et 10, les fichiers serveur sont remplacés (ils ne s'affichent plus en tant que
nœud sous Services Crystal). Il est toutefois toujours possible de les coder manuellement.
Remarque
configuration.
Procédure
1.
Dans le menu Affichage, cliquez sur Autres fenêtres, puis sur Explorateur de serveurs.
2.
Développez le nœud Services Crystal, puis Fichiers serveur.
3.
Sélectionnez un rapport dans l'arborescence Fichiers serveur, puis faites-le glisser dans votre formulaire.
Remarque
Lorsqu'un rapport Fichiers serveur est placé dans votre formulaire, une instance de la classe
ServerFileReport est ajoutée à la région du code généré par le concepteur de votre formulaire.
Lorsqu'une classe qui hérite de System.ComponentModel.Component (telle que ServerFileReport)
est instanciée et configurée dans la région du code généré par le concepteur, une icône correspondant à
cette classe instanciée s'affiche au bas du formulaire en mode Design.
En mode Design, un objet serverFileReport1 s'affiche au bas du formulaire.
4.
Passez en mode code et ouvrez la région du code généré par le Concepteur Web Form ou Windows Form.
Une classe ServerFileReport a été instanciée et configurée dans cette région.
5.
projet), affectez l'instance de ServerFileReport à la propriété ReportSource du contrôle
myCrystalReportViewer.ReportSource = serverFileReport1
crystalReportViewer.ReportSource = serverFileReport1;
184
Étapes suivantes
1.4.5.3.1.5.1.3
Pour coder manuellement les fichiers serveur
Prérequis
●
SAP Crystal Reports pour Visual Studio 2003 est installé et fonctionnel.
●
Ou SAP Crystal Reports 9 ou versions ultérieures est installé et fonctionnel.
Remarque
Dans SAP Crystal Reports 9 et 10, les fichiers serveur sont remplacés (ils ne s'affichent plus en tant que
nœud sous Services Crystal). Il est toutefois toujours possible de les coder manuellement.
Remarque
configuration.
Procédure
1.
projet), déclarez une instance deServerFileReport.
Dim myServerFileReport As CrystalDecisions.Shared.ServerFileReport = _
New CrystalDecisions.Shared.ServerFileReport()
CrystalDecisions.Shared.ServerFileReport serverFileReport = new
CrystalDecisions.Shared.ServerFileReport();
2.
Attribuez à la propriété ObjectType de ServerFileReport la valeur REPORT.
myServerFileReport.ObjectType = CrystalDecisions.
[Shared].EnumServerFileType.REPORT
serverFileReport.ObjectType = CrystalDecisions.Shared.EnumServerFileType.REPORT;
3.
Attribuez à la propriété ReportPath de ServerFileReport le rapport et son sous-répertoire.
myServerFileReport.ReportPath = "\General Business\World Sales Report.rpt"
185
serverFileReport.ReportPath = "\\General Business\\World Sales Report.rpt";
4.
Définissez la propriété WebServiceURL de ServerFileReport sur le répertoire virtuel du visualiseur de
votre version installée de SAP Crystal Reports.
Remarque
Dans cet exemple de code, le répertoire virtuel des visualiseurs est configuré pour SAP Crystal Reports 10.
myServerFileReport.WebServiceUrl = "http://localhost/crystalreportviewers10/
ServerFileReportService.asmx"
serverFileReport.WebServiceUrl = "http://localhost/crystalreportviewers10/
ServerFileReportService.asmx";
5.
Attribuez à la propriété ReportSource du contrôle CrystalReportViewer l'instance ServerFileReport.
1.4.5.3.1.5.2
Liaison à Crystal Enterprise (VS .NET 2003)
Il fait référence à une ancienne technologie et s'adresse aux utilisateurs équipés d'une version de
Crystal Enterprise. Crystal Enterprise a été remplacé par SAP Crystal Reports Server et la plateforme SAP
Modèle d'objet
Ce scénario de liaison de rapports utilise le modèle d'objet CrystalReportViewer (voir Liaison de rapports à l'aide
du modèle d'objet CrystalReportViewer [page 172]).
Les rapports sont situés sur le WCS (Web Component Server) de Crystal Enterprise 8, 8.5, 9 ou 10. Les rapports
issus du serveur WCS sont exposés comme services Web de rapports par le biais du service Web
EnterpriseReportService.asmx. Ce service Web se trouve dans le répertoire virtuel des visualiseurs du WCS.
186
Cette section présente le sous-nœud Crystal Enterprise des services Crystal dans Visual Studio .NET 2003.
[NOMSERVEUR]
●
Services Crystal
○
Crystal Enterprise
Description
Le sous-nœud Crystal Enterprise accède aux rapports qui ont été exposés comme services Web de rapports à
partir d'un serveur WCS, puis les affiche.
Pour que le sous-nœud Crystal Enterprise accède à une liste de rapports depuis le serveur WCS
Crystal Enterprise et les affiche correctement, les conditions suivantes doivent être remplies :
●
Le serveur que vous visualisez actuellement dans l'Explorateur de serveurs exécute
Crystal Enterprise 8 ou 8.5.
Remarque
Vous devez mettre à niveau SAP Crystal Reports pour Visual Studio 2003 vers
SAP Crystal Reports Developer (version 9 ou ultérieure) pour pouvoir vous connecter à
Crystal Enterprise 9 ou version ultérieure.
●
Le serveur WCS de Crystal Enterprise est installé sur le serveur Crystal Enterprise.
Remarque
Le serveur WCS est installé par défaut dans Crystal Enterprise 9 et 10. Dans Crystal Enterprise 8 et 8.5, le
serveur WCS doit être installé séparément.
●
Pour configurer des services Web de rapports sur le serveur Crystal Enterprise 10, vous devez installer
Visual Studio .NET 2003 sur le serveur Crystal Enterprise, puis exécuter une installation personnalisée pour
ajouter spécifiquement les services Crystal.
Si l'administrateur de Crystal Enterprise ne souhaite pas installer une version complète de
Visual Studio .NET 2003 sur le serveur Crystal Enterprise, il peut procéder comme suit :
○
Installer le module de fusion managed.msm.
○
Rechercher le répertoire virtuel des visualiseurs installé sur l'ordinateur de développement et copier le
fichier EnterpriseReportService.asmx de ce répertoire vers le répertoire virtuel des visualiseurs de
l'ordinateur serveur.
Une fois les rapports affichés dans les services Crystal, choisissez-en un et faites-le glisser dans le Web Form ou le
Windows Form. Une fois dans le formulaire, le rapport est ajouté à une classe wrapper de rapport, puis affiché
sous forme d'instance dans la barre d'état des composants.
Remarque
Il existe plusieurs types de classes wrapper de rapport, en fonction de la source du rapport sur le serveur et du
protocole de connexion. Ceux-ci varient en fonction des versions de SAP Crystal Reports.
187
Installation des services Crystal
Les services Crystal ne sont pas installés par défaut lors de l'installation de Visual Studio .NET 2003. Pour ajouter
les services Crystal, chargez le CD d'installation de Microsoft Visual Studio .NET, localisez Crystal Reports,
sélectionnez les services Web Crystal, puis cliquez sur le bouton Mettre à jour.
Avantages
●
Les rapports Crystal Enterprise sont facilement accessibles à partir d'une application Web ou Windows.
Inconvénients
●
Remarque
Dans SAP Crystal Reports 9 et 10, les services Crystal sont mis à niveau vers une classe wrapper et un
protocole de connexion différents.
Liaison aux fichiers serveur (Visual Studio 2005 et versions ultérieures) [page 190]
1.4.5.3.1.5.2.1
Pour accéder à Services
Crystal > Crystal Enterprise dans l'Explorateur de serveurs
Procédure
1.
Dans le menu Affichage, cliquez sur Autres fenêtres, puis sur Explorateur de serveurs.
2.
Si votre serveur Crystal Enterprise ne se trouve pas sur votre ordinateur local (recommandé) :
a) Cliquez avec le bouton droit de la souris sur Serveurs, puis cliquez sur Ajouter un serveur.
b) Dans le champ Ordinateur de la boîte de dialogue Ajouter un serveur, saisissez le nom réseau du serveur
Crystal Enterprise, puis cliquez sur OK.
c) Dans le nœud Serveurs, développez le sous-nœud du serveur ajouté, puis développez le sous-nœud
Services Crystal de celui-ci.
188
d) Dans la boîte de dialogue Ouverture d'une session Enterprise, saisissez les valeurs dans les champs Nom
d'utilisateur et Mot de passe, puis cliquez sur OK.
3.
Si votre serveur Crystal Enterprise est installé sur votre ordinateur local :
a) Dans le nœud Serveurs, développez le sous-nœud correspondant à votre ordinateur local, puis
développez le sous-nœud Services Crystal de celui-ci.
b) Dans la boîte de dialogue Ouverture d'une session Enterprise, saisissez les valeurs dans les champs Nom
d'utilisateur et Mot de passe, puis cliquez sur OK.
Résultats
Vous pouvez maintenant configurer Services Crystal > Crystal Enterprise dans votre projet Web ou Windows.
1.4.5.3.1.5.2.2
Pour configurer un rapport Services
Crystal > Crystal Enterprise
Prérequis
[page 15]. La section Configuration d'un projet contient une configuration de références d'espaces de noms et de
code spécifique nécessaire à cette procédure. Il est impossible de suivre cette procédure sans cette
configuration.
Procédure
1.
Sélectionnez un rapport dans le sous-nœud Crystal Enterprise, puis faites-le glisser dans votre Web Form ou
votre Windows Form.
Au bas du formulaire, dans la barre d'état des composants, un objet enterpriseReport1 s'affiche.
2.
Remarque
Une classe EnterpriseReport a été instanciée et configurée dans cette région.
3.
projet [page 15]), affectez l'instance d'EnterpriseReport à la propriété ReportSource du contrôle
myCrystalReportViewer.ReportSource = enterpriseReport1
crystalReportViewer.ReportSource = enterpriseReport1;
189
4.
1.4.5.3.1.5.3
Liaison aux fichiers serveur (Visual Studio 2005
et versions ultérieures)
Modèle d'objet
Les rapports se trouvent dans un dossier situé dans le répertoire de fichiers local. Ces rapports sont exposés en
tant que services Web de rapports.
Présentation générale des fichiers serveur
Ce scénario de liaison s'applique aux rapports accessibles en tant que fichiers serveur par l'intermédiaire d'un
service Web.
Description
Le service Web Fichiers serveur accède aux rapports qui ont été exposés comme services Web de rapports à
partir du répertoire de fichiers local, puis les affiche. Dans Visual Studio 2005 et versions ultérieures, les fichiers
serveur sont accessibles par programmation.
Avantages
●
Accès centralisé aux rapports : offre un point d'accès unique à tous les rapports situés dans votre répertoire
d'exemples de rapports, ce qui crée un référentiel de rapports efficace sur votre disque dur local.
Inconvénients
●
190
Dans SAP Crystal Reports, version développeur pour Microsoft Visual Studio, les fichiers serveur sont accessibles
par programmation. Chaque édition de SAP Crystal Reports Developer continue à prendre en charge par
programmation les fichiers serveur dans le SDK.
1.4.5.3.1.5.3.1
Pour coder manuellement les fichiers serveur
Prérequis
●
Un service Web de rapports permettant d'accéder par programmation aux fichiers serveur doit être
configuré.
●
Ou SAP Crystal Reports Developer est installé et en cours de fonctionnement.
Remarque
configuration.
Procédure
1.
projet [page 15]), déclarez une instance de ServerFileReport.
Dim myServerFileReport As CrystalDecisions.Shared.ServerFileReport = _New
CrystalDecisions.Shared.ServerFileReport()
CrystalDecisions.Shared.ServerFileReport serverFileReport = new
CrystalDecisions.Shared.ServerFileReport();
2.
Attribuez à la propriété ObjectType de ServerFileReport la valeur REPORT.
myServerFileReport.ObjectType = CrystalDecisions.
[Shared].EnumServerFileType.REPORT
191
serverFileReport.ObjectType = CrystalDecisions.Shared.EnumServerFileType.REPORT;
3.
Définissez la propriété ReportPath de la classe ServerFileReport sur le rapport et son sous-répertoire.
myServerFileReport.ReportPath = "\General Business\World Sales
Report.rpt"
serverFileReport.ReportPath = "\\General Business\\World Sales
Report.rpt";
4.
Définissez la propriété WebServiceURL de ServerFileReport sur l'emplacement du service Web de rapports.
Si vous disposez de SAP Crystal Reports Developer, cet emplacement correspond au répertoire virtuel du
visualiseur de la version installée de SAP Crystal Reports (voir Répertoire des visualiseurs [page 14]). Si vous
ne disposez pas de SAP Crystal Reports Developer, il s'agit de l'URL du service Web de rapports que vous
avez créé dans Configuration des fichiers serveur dans Visual Studio 2005 et les versions plus récentes [page
89].
Remarque
Dans le code ci-dessous, le répertoire virtuel des visualiseurs est configuré pour SAP Crystal Reports pour
Visual Studio 2005.
myServerFileReport.WebServiceUrl =
"http://localhost/CrystalReportsWebServices2005/ServerFileReportService.asmx"
serverFileReport.WebServiceUrl =
"http://localhost/CrystalReportsWebServices2005/ServerFileReportService.asmx";
5.
Attribuez à la propriété ReportSource du contrôle CrystalReportViewer l'instance ServerFileReport.
1.4.5.3.1.5.4
Liaison à SAP Crystal Reports Server ou à la
plateforme SAP BusinessObjects Business Intelligence
(Visual Studio)
Modèle d'objet
Ce scénario de liaison de rapports utilise le modèle d'objet CrystalReportViewer (voir Liaison de rapports à l'aide
du modèle d'objet CrystalReportViewer [page 172]).
192
Les rapports sont situés sur le WCS (Web Component Server) de SAP Crystal Reports Server ou de la plateforme
SAP BusinessObjects Business Intelligence. Les rapports issus du serveur WCS sont exposés comme services
Web de rapports par le biais du service Web EnterpriseReportService.asmx. Ce service Web se trouve dans le
répertoire virtuel des visualiseurs du WCS.
Cette section présente le sous-nœud Services SAP Crystal Reports des services Crystal dans Visual Studio.
[NOMSERVEUR]
●
Services SAP Crystal Reports
○
Rapports du serveur
Description
Le sous-nœud de la plateforme SAP BusinessObjects Business Intelligence accède aux rapports qui ont été
fournis en tant que services Web de rapports à partir d'un serveur WCS de plateforme SAP BusinessObjects
Business Intelligence, puis les affiche.
Pour que le sous-nœud de la plateforme SAP BusinessObjects Business Intelligence accède à une liste de
rapports depuis le serveur WCS de la plateforme SAP BusinessObjects Business Intelligence et les affiche
correctement, les conditions suivantes doivent être remplies :
●
Le serveur que vous visualisez actuellement dans l'Explorateur de serveurs exécute la plateforme SAP
●
Pour configurer les services Web de rapports dans la plateforme SAP BusinessObjects Business Intelligence,
vous devez installer Visual Studio sur le serveur de la plateforme SAP BusinessObjects Business Intelligence,
puis exécuter une installation personnalisée pour ajouter spécifiquement les services Crystal.
Remarque
L'installation de Visual Studio sur le serveur de la plateforme SAP BusinessObjects Business Intelligence et
l'installation personnalisée des services Crystal sont nécessaires pour que le fichier
EnterpriseReportService.asmx soit correctement installé et configuré dans le répertoire virtuel des
visualiseurs.
Si l'administrateur de Crystal Enterprise ne souhaite pas installer une version complète de Visual Studio sur le
serveur de la plateforme SAP BusinessObjects Business Intelligence, il peut procéder comme suit :
○
Installer le module de fusion managed.msm.
193
○
Rechercher le répertoire virtuel des visualiseurs installé sur l'ordinateur de développement et copier le
fichier EnterpriseReportService.asmx de ce répertoire vers le répertoire virtuel des visualiseurs de
l'ordinateur serveur.
Une fois que les rapports s'affichent dans les services SAP BusinessObjects, vous pouvez lier un contrôle
CrystalReportsViewer à n'importe quel rapport répertorié. Pour en savoir plus, voir la documentation relative
à la plateforme SAP BusinessObjects Business Intelligence.
Avantages
●
Les rapports de la plateforme SAP BusinessObjects Business Intelligence sont facilement accessibles depuis
une application Web ou Windows.
Inconvénients
●
Remarque
Dans SAP Crystal Reports 9 et 10, les services Crystal sont mis à niveau vers une classe wrapper et un
protocole de connexion différents.
1.4.5.3.1.5.4.1
Pour lier un rapport par l'intermédiaire du
chemin d'accès à son répertoire de fichiers à l'aide de la
fenêtre Propriétés
Procédure
1.
Créez un projet Web ou Windows.
2.
Dans la boîte à outils, faites glisser un contrôle CrystalReportViewer dans un Web Form ou un
Windows Form.
194
3.
4.
Dans la fenêtre Propriétés, affectez à la propriété ReportSource le chemin d'accès à un répertoire de
fichiers.
Remarque
Le chemin d'accès au répertoire de fichiers pointe sur les exemples de rapports de Visual Studio 2005.
En raison de la fonctionnalité d'aperçu au moment de la conception, le rapport s'affiche en mode Aperçu.
C:\Program Files\Microsoft Visual Studio 8.0\Crystal Reports\Samples\fr\Reports
\Feature Examples\Hierarchical Grouping.rpt
5.
1.4.5.3.1.6
Liaison à ReportSource
(SAP Crystal Reports Server ou
SAP BusinessObjects Enterprise 11)
Remarque
Les fonctionnalités décrites dans cette page ne sont pas disponibles dans SAP Crystal Reports, version
développeur pour Microsoft Visual Studio mais le sont dans l'une des versions mises à niveau.
Modèle d'objet
Les rapports sont accessibles depuis le Page Server de la plateforme SAP BusinessObjects Business Intelligence.
Description
SAP Crystal Reports Server ou la plateforme SAP BusinessObjects Business Intelligence permet de distribuer des
rapports à partir de serveurs au sein d'une structure Enterprise. Un rapport stocké dans
SAP Crystal Reports Server ou dans la plateforme SAP BusinessObjects Business Intelligence peut être affiché
par différents serveurs à différents moments, selon vos besoins. Dans SAP Crystal Reports Server ou la
plateforme SAP BusinessObjects Business Intelligence, si vous voulez afficher un rapport avec les meilleures
195
performances possibles et que vous ne souhaitez pas lui apporter de modifications importantes par
programmation, affichez-le directement depuis le Page Server avec la classe ReportSource.
La classe ReportSource n'est associée à aucun modèle d'objet. Si vous souhaitez modifier des paramètres ou
des informations de connexion à la base de données, vous pouvez utiliser le modèle d'objet limité fourni par le
contrôle CrystalReportViewer. Toutefois, pour une interaction par programmation plus complexe avec le
rapport, utilisez l'un des autres scénarios de liaison de rapports SAP Crystal Reports Server ou de plateforme SAP
Remarque
Pour une comparaison de plusieurs scénarios utilisant des serveurs différents dans
SAP Crystal Reports Server ou la plateforme SAP BusinessObjects Business Intelligence, voir les scénarios de
liaison recommandés pour SAP Crystal Reports Server ou la plateforme SAP BusinessObjects Business
Intelligence à la section Scénarios de liaison de rapports [page 170].
Avantages
●
Scénario le plus rapide : offre les meilleures performances d'affichage d'un rapport dans
SAP Crystal Reports Server ou la plateforme SAP BusinessObjects Business Intelligence.
Inconvénients
●
Modèle d'objet limité : les modifications par programmation qui peuvent être apportées aux paramètres ou
aux informations de connexion à la base de données sont limitées au modèle d'objet
●
Disponibilité limitée : ce scénario est uniquement disponible dans Crystal Enterprise version 10,
SAP Crystal Reports Server ou SAP BusinessObjects Enterprise XI.
Liaison de rapports à l'aide du modèle d'objet ReportDocument [page 200]
196
1.4.5.3.1.6.1
rapport pris en charge en dehors du Page Server de
SAP Crystal Reports Server ou de la plateforme SAP
BusinessObjects Business Intelligence
Prérequis
●
SAP Crystal Reports Server ou la plateforme SAP BusinessObjects Business Intelligence doit être installé et
en cours de fonctionnement.
●
Le SDK SAP Crystal Reports Server ou de la plateforme SAP BusinessObjects Business Intelligence (y
compris les assemblys .NET) doit être installé et en cours de fonctionnement.
Remarque
Si vous avez installé SAP Crystal Reports Server ou la plateforme SAP BusinessObjects Business
Intelligence sur votre ordinateur de développement, le SDK est inclus dans cette installation.
Procédure
1.
Localisez et notez le nom d'un serveur SAP Crystal Reports Server ou de plateforme SAP BusinessObjects
Business Intelligence. Pour cet exemple, le nom du serveur est "BOE01".
a) Pour rechercher le nom du serveur, cliquez avec le bouton droit de la souris sur l'icône Poste de travail,
puis sélectionnez Propriétés.
b) Dans la boîte de dialogue Propriétés système, cliquez sur l'onglet Identification réseau.
c) Le nom de l'ordinateur apparaît dans le champ "Nom complet de l'ordinateur".
2.
Utilisez l'Assistant de publication pour publier le rapport Chart.rpt sur le serveur SAP Crystal Reports Server
ou de plateforme SAP BusinessObjects Business Intelligence.
Remarque
Pour savoir comment utiliser l'Assistant de publication, consultez la documentation utilisateur de
3.
4.
Ajoutez les références d'assembly suivantes à votre projet :
○
CrystalDecisions.Enterprise.Framework
○
CrystalDecisions.Enterprise.InfoStore
○
CrystalDecisions.Enterprise.Viewing.ReportSource
○
CrystalDecisions.ReportAppServer.Controllers
Dans le menu Affichage, cliquez sur Code pour afficher la classe code-behind du Web Form ou du Windows
Form. Au-dessus de la classe, ajoutez une instruction "Imports" [Visual Basic] ou "using" [C#] pour
l'espace de noms CrystalDecisions.Enterprise.
Imports CrystalDecisions.Enterprise
197
Imports CrystalDecisions.Enterprise.Viewing
Imports CrystalDecisions.ReportAppServer.Controllers
using CrystalDecisions.Enterprise;
using CrystalDecisions.Enterprise.Viewing;
using CrystalDecisions.ReportAppServer.Controllers;
1.4.5.3.1.6.2
Connexion à SAP Crystal Reports Server ou
SAP BusinessObjects Enterprise
Procédure
1.
Dans la méthode ConfigureCrystalReports() (que vous avez créée dans Configuration d'un projet [page
15]), déclarez une variable de chaîne serverName et attribuez-lui le nom du serveur
SAP Crystal Reports Server ou du serveur SAP BusinessObjects Enterprise.
Dim serverName As String = "BOE01"
string serverName = "BOE01";
2.
Déclarez et instanciez la classe SessionMgr.
Dim mySessionMgr As SessionMgr = New SessionMgr()
SessionMgr sessionMgr = new SessionMgr();
3.
Transmettez le nom de l'utilisateur (Administrator), le mot de passe (vide), la variable serverName et le type
de connexion (secEnterprise) à la méthode de connexion de l'instance de SessionMgr, puis extrayez-la
comme une instance d'EnterpriseSession.
Dim myEnterpriseSession As EnterpriseSession = mySessionMgr.Logon( _
"Administrator", "", serverName, "secEnterprise")
EnterpriseSession enterpriseSession = sessionMgr.Logon(
"Administrator", "", serverName, "secEnterprise");
4.
Extrayez le service InfoStore (en tant que EnterpriseService), de la méthode GetService
d'EnterpriseSession.
Dim myEnterpriseService As EnterpriseService = _
myEnterpriseSession.GetService("InfoStore")
EnterpriseService enterpriseService = enterpriseSession.GetService("InfoStore");
198
5.
Déclarez et instanciez InfoStore, puis transmettez à InfoStore le service EnterpriseService extrait
comme un paramètre.
Dim myInfoStore As InfoStore = New InfoStore(myEnterpriseService)
InfoStore infoStore = new InfoStore(enterpriseService);
1.4.5.3.1.6.3
Extraction du rapport Hierarchical Grouping de
SAP Crystal Reports Server ou de
SAP BusinessObjects Enterprise
Procédure
1.
Pour réattribuer la valeur de l'instance d'EnterpriseService au service de référence de rapport du Page Server,
transmettez la chaîne "PSReportFactory" à la méthode GetService() d'EnterpriseService.
myEnterpriseService = myEnterpriseSession.GetService("PSReportFactory")
enterpriseService = enterpriseSession.GetService("PSReportFactory");
2.
Renvoyez la propriété Interface de l'instance EnterpriseService en tant que variable objet.
Dim psrfObject As Object = myEnterpriseService.Interface
Object psrfObject = enterpriseService.Interface;
3.
Effectuez un cast de la variable objet en une instance de PSReportFactory.
Dim myPSReportFactory As PSReportFactory = CType(psrfObject, PSReportFactory)
PSReportFactory psReportFactory = (PSReportFactory)psrfObject;
4.
Saisissez la chaîne de requête suivante pour interroger SAP Crystal Reports Server ou
SAP BusinessObjects Enterprise sur le rapport.
Dim queryString As String = "Select SI_ID, SI_NAME, SI_PARENTID From
CI_INFOOBJECTS " _
& "Where SI_PROGID='CrystalEnterprise.Report' " _
& "And SI_NAME Like 'Chart'"
string queryString = "Select SI_ID, SI_NAME, SI_PARENTID From CI_INFOOBJECTS "
+ "Where SI_PROGID='CrystalEnterprise.Report' "
+ "And SI_NAME Like 'Chart'";
5.
Transmettez la chaîne de requête à la méthode Query d'InfoStore pour extraire une classe indexée
InfoObjects qui contient le résultat de la requête.
Dim myInfoObjects As InfoObjects = myInfoStore.Query(queryString)
199
InfoObjects infoObjects = infoStore.Query(queryString);
6.
Extrayez l'InfoObject de la première colonne de la classe indexée InfoObjects.
Dim myInfoObject As InfoObject = myInfoObjects(1)
InfoObject infoObject = infoObjects[1];
7.
Déclarez et remplissez une instance de ReportSource à partir de la méthode OpenReportSource() de
l'instance de PSReportFactory en transmettant la propriété ID d'InfoObject.
Dim myReportSource As ReportSource =
myPSReportFactory.OpenReportSource(myInfoObject.ID)
ReportSource reportSource = psReportFactory.OpenReportSource(infoObject.ID);
8.
Liez l'instance ReportSource à la propriété ReportSource du contrôle CrystalReportViewer.
myCrystalReportViewer.ReportSource = myReportSource
crystalReportViewer.ReportSource = reportSource;
9.
Le rapport s'affiche désormais depuis le Page Server de SAP Crystal Reports Server ou de
SAP BusinessObjects Enterprise en fonction de son ID. Si vous utilisez une autre méthode pour accéder à
reportID (en sélectionnant l'ID dans une liste de rapports dans un contrôle DropDownList par exemple),
vous n'aurez pas à rechercher InfoStore ni à générer une classe InfoObject pour extraire reportID.
1.4.5.3.2
Liaison de rapports à l'aide du modèle d'objet
ReportDocument
Le modèle d'objet ReportDocument est le plus puissant et le plus complet des modèles d'objet fournis avec
SAP Crystal Reports, version développeur pour Microsoft Visual Studio. Il s'agit du modèle d'objet privilégié pour
développer un projet avec SAP Crystal Reports, version développeur pour Microsoft Visual Studio.
1.4.5.3.2.1
Liaison à une classe de rapport incorporé
Modèle d'objet
Ce scénario de liaison de rapports utilise le modèle d'objet ReportDocument.
Les rapports sont incorporés dans le projet.
200
Remarque
Dans les précédentes versions de cette documentation, les rapports incorporés étaient appelés "rapports
fortement typés". Le principal terme désormais utilisé pour faire référence à un rapport qui a été ajouté ou
importé dans un projet Visual Studio est "incorporé".
Description
Dans ce scénario, un rapport est incorporé dans un projet. Pour incorporer un rapport, vous pouvez soit créer un
rapport à l'aide du SAP Crystal Reports Designer incorporé (inclus dans Visual Studio), soit importer un rapport
existant dans le projet. Une fois le rapport créé ou importé, une classe wrapper représentant ce rapport est
automatiquement générée. Cette classe wrapper porte le même nom que le rapport. Dérivée de la classe de base
ReportDocument, elle hérite naturellement de toutes les propriétés et méthodes de la classe ReportDocument qui
fait partie du modèle d'objet ReportDocument.
Avantages
●
Sécurité renforcée : les rapports sont incorporés et donc distribués en tant que partie de l'application.
●
Interaction par programmation étendue : fournit un accès au puissant modèle d'objet ReportDocument.
●
Sécurité renforcée : offre le contrôle le plus complet sur l'accès aux sources des rapports.
●
Utilisation la plus courante : la plupart des développeurs considèrent que ce scénario offre le plus grand
nombre d'avantages.
Inconvénients
●
Maintenance supplémentaire : toute modification apportée aux rapports nécessite la recompilation et la
redistribution de l'application.
1.4.5.3.2.1.1
Pour lier à une classe de rapport incorporé
Contexte
Une fois un rapport créé ou importé, une classe wrapper représentant ce rapport est automatiquement générée.
Cette classe wrapper porte le même nom que le rapport. Dérivée de la classe de base ReportDocument, elle hérite
naturellement de toutes les propriétés et méthodes de la classe ReportDocument qui fait partie du modèle d'objet
ReportDocument.
201
Procédure
1.
Ajoutez un contrôle CrystalReportViewer à un Windows Form.
Remarque
Toutes les versions de SAP Crystal Reports prennent en charge la liaison à une classe de rapport
incorporée pour les applications Windows. Certaines configurations fournissent une prise en charge de ce
scénario de liaison pour les sites Web grâce à un fournisseur intégré amélioré.
2.
Ajoutez un rapport au projet. Cela génère automatiquement une classe wrapper ayant le même nom que le
rapport.
3.
Instanciez la classe wrapper du rapport.
Dim myReport As New QuarterlySalesReport()
QuarterlySalesReport myReport = new QuarterlySalesReport();
4.
Affectez-la à la propriété ReportSource du contrôle CrystalReportViewer.
myCrystalReportViewer.ReportSource = myReport
crystalReportViewer.ReportSource = myReport;
1.4.5.3.2.2
Liaison à un rapport non incorporé chargé dans la
classe ReportDocument
Modèle d'objet
Les rapports se trouvent dans le répertoire de fichiers.
Description
Ce scénario de liaison de rapports permet d'utiliser ReportDocument, le modèle d'objet le plus puissant, avec des
rapports non incorporés (externes à votre projet).
202
Dans le scénario Liaison au chemin d'accès d'un répertoire de fichiers par code [page 172], vous liez les rapports
par l'intermédiaire de leur chemin d'accès à un répertoire de fichiers, mais au lieu de les lier directement au
visualiseur, vous les transmettez à la méthode ReportDocument.Load(). Cela vous permet d'utiliser le modèle
d'objet ReportDocument.
Par ailleurs, chaque rapport externe étant chargé dans la classe ReportDocument commune, vous pouvez
développer un processus de sélection de rapports qui permet le partage du code de liaison avec tous les rapports.
Avantages
●
●
Interaction par programmation étendue : fournit un accès au puissant modèle d'objet ReportDocument.
●
Moins de codage grâce au partage de code : les rapports peuvent partager le même code, car ils sont tous
chargés dans la classe ReportDocument commune.
Inconvénients
●
Distribution limitée : les rapports doivent se trouver sur le même ordinateur que l'application. (L'accès à
d'autres serveurs du réseau à partir du compte utilisateur ASPNET du serveur Web est généralement limité.)
●
Effort de déploiement accru : les rapports doivent être distribués avec l'application en utilisant le chemin
relatif correct.
●
Source des rapports moins sécurisée : les rapports peuvent être déplacés ou supprimés sur l'ordinateur de
déploiement au moment de l'exécution.
1.4.5.3.2.2.1
Pour lier à une classe de rapport non incorporé
à l'aide du modèle d'objet ReportDocument
Prérequis
Remarque
configuration.
203
Procédure
1.
Ajoutez une instruction "Imports" [Visual Basic] ou "using" [C#] au début de la classe pour
l'espace de noms CrystalDecisions.CrystalReports.Engine.
Remarque
Vous devez déclarer cet espace de noms pour pouvoir accéder à la classe ReportDocument sans préfixe
d'espace de noms.
2.
Recherchez le fichier World Sales Report.rpt dans le sous-répertoire General Business de votre version
3.
Copiez dans le Presse-papiers le chemin d'accès complet au répertoire de fichiers en incluant World Sales
Report.rpt.
4.
projet [page 15]), déclarez une variable chaîne reportPath et affectez-lui une chaîne contenant le chemin
d'accès au fichier World Sales Report copié lors de l'étape précédente.
Dim reportPath As String = _
"C:\Program Files\Microsoft Visual Studio 9.0\" _ & "Crystal Reports\Samples
\fr\Reports\General Business\" _ & "World Sales Report.rpt"
string reportPath =
"C:\\Program Files\\Microsoft Visual Studio 9.0\\" + "Crystal Reports\\Samples
\\fr\\Reports\\General Business\\" + "World Sales Report.rpt";
5.
Sous la chaîne déclarée, déclarez une instance de ReportDocument.
Dim myReportDocument As ReportDocument = New ReportDocument()
ReportDocument reportDocument = new ReportDocument();
6.
Chargez la variable chaîne liée à la classe de rapport non incorporé et contenant le chemin d'accès au
répertoire de fichiers dans ReportDocument.
myReportDocument.Load(reportPath)
reportDocument.Load(reportPath);
204
7.
Affectez l'instance de ReportDocument (qui contient maintenant la classe de rapport non incorporé
chargée) à la propriété ReportSource du contrôle CrystalReportViewer.
myCrystalReportViewer.ReportSource = myReportDocument
crystalReportViewer.ReportSource = reportDocument;
8.
1.4.5.3.2.3
en cache
Liaison à une classe de rapport incorporé et mis
Modèle d'objet
Les rapports sont incorporés dans le projet.
Description
Lorsqu'un rapport est incorporé dans un projet Visual Studio, une classe wrapper, qui représente le rapport dans
le projet, est automatiquement générée. Parallèlement, une classe utilitaire de gestion du cache pour ce rapport
est également créée.
Dans ce scénario, vous liez le contrôle CrystalReportViewer à la classe utilitaire de gestion du cache de manière à
ce que la mise en mémoire cache des rapports dans l'objet Cache ASP.NET soit gérée automatiquement.
Utilisation de la mise en cache
La mise en cache doit être utilisée dans des cas particuliers et limités car elle peut "surconsommer" des
ressources système lorsqu'elle n'est pas gérée avec précaution.
205
Mise en cache des rapports non incorporés
Si vous souhaitez gérer la mise en cache de rapports non incorporés, vous devez créer votre propre classe
utilitaire de gestion du cache. Pour en savoir plus, voir Liaison à un rapport non incorporé chargé dans une classe
utilitaire de gestion du cache [page 207].
Avantages
●
Conçu pour le partage : idéal pour stocker les rapports qui présentent un fort potentiel de partage et peu de
modifications à apporter aux paramètres ou aux informations de connexion.
●
Accès aux données optimisé : si les rapports à fort potentiel de partage sont très volumineux ou s'ils
contiennent une requête tellement complexe que l'extraction prend plusieurs minutes, la classe utilitaire de
gestion du cache permet d'accéder plus rapidement aux données.
Inconvénients
●
Charge du serveur : les rapports stockés dans l'objet Cache ASP.NET peuvent "surcharger" les ressources
mémoire sur le serveur.
●
Problèmes de persistance : le cache possède certaines dépendances qui permettent la vérification des
modifications apportées à l'instance d'un rapport et la remise en cache de cette instance. Toutefois, si la base
de données est modifiée, l'instance du rapport stockée dans l'objet Cache n'est pas actualisée en
conséquence.
●
Consommation de ressources : un rapport dont les paramètres sont appelés fréquemment à l'aide de
différentes chaînes de paramètre(particulièrement si l'un de ces paramètres correspond à l'ID utilisateur)
implique à chaque fois la mise en cache d'un nouveau rapport. Ce processus consomme des ressources
système. Si le rapport ne présente pas un fort potentiel de partage, affectez son instance à un objet Session.
Utilisation de rapports standard ou mis en cache ? [page 221]
206
1.4.5.3.2.3.1
cache
Pour lier à une classe utilitaire de gestion du
Prérequis
Remarque
configuration.
Procédure
1.
projet [page 15]), supprimez les lignes de code existantes pour remplacer la classe wrapper par la classe
utilitaire de gestion du cache.
2.
Instanciez la classe utilitaire de gestion du cache associée au rapport Hierarchical Grouping.rpt.
Dim cachedHierarchicalGroupingReport As CachedHierarchical_Grouping
= New CachedHierarchical_Grouping()
CachedHierarchical_Grouping cachedHierarchicalGroupingReport = new
CachedHierarchical_Grouping();
3.
Transmettez l'instance de la classe utilitaire de gestion du cache au contrôle CrystalReportViewer.
myCrystalReportViewer.ReportSource = cachedHierarchicalGroupingReport
crystalReportViewer.ReportSource = cachedHierarchicalGroupingReport;
4.
1.4.5.3.2.4
Liaison à un rapport non incorporé chargé dans
une classe utilitaire de gestion du cache
Modèle d'objet
207
Description
Ce scénario de liaison de rapports est semblable au scénario Liaison à une classe de rapport incorporé et mis en
cache [page 205]. La différence tient au fait que dans ce scénario les rapports ne sont pas incorporés. Pour en
savoir plus sur les rapports incorporés, voir Utilisation de rapports incorporés ou non incorporés ?Comparaison
des rapports incorporés et non incorporés [page 165]
SAP Crystal Reports, version développeur pour Microsoft Visual Studio est fourni avec deux fonctionnalités d'aide
à la mise en cache des rapports avec l'objet Cache ASP.NET :
●
Une structure intégrée de gestion de la mise en cache des rapports qui détecte des rapports identiques
possédant des paramètres ou des informations de connexion uniques qui nécessitent une clé unique pour
chaque instance mise en cache.
●
Une interface, ICachedReport, qui identifie les classes utilitaire de gestion du cache auprès de la structure
de gestion de la mise en cache des rapports.
Dans Liaison à une classe de rapport incorporé et mis en cache [page 205], vous en avez appris davantage sur la
classe Cached[NomRapport] qui est automatiquement générée lorsqu'un rapport est incorporé dans un projet.
Vous pouvez toutefois créer manuellement une classe utilitaire de gestion du cache pour gérer les rapports non
incorporés. Pour obtenir un exemple de code, voir la section Implémentation ci-dessous.
Utilisation de la mise en cache
La mise en cache doit être utilisée dans des cas particuliers et limités car elle peut "surconsommer" des
ressources système lorsqu'elle n'est pas gérée avec précaution.
Avantages
●
Conçu pour le partage : idéal pour stocker les rapports qui présentent un fort potentiel de partage et peu de
modifications à apporter aux paramètres ou aux informations de connexion.
●
Accès aux données optimisé : si les rapports à fort potentiel de partage sont très volumineux ou s'ils
contiennent une requête tellement complexe que l'extraction prend plusieurs minutes, la classe utilitaire de
gestion du cache permet d'accéder plus rapidement aux données.
208
Inconvénients
●
Charge du serveur : les rapports stockés dans l'objet Cache ASP.NET peuvent "surcharger" les ressources
mémoire sur le serveur.
●
Problèmes de persistance : le cache possède certaines dépendances qui permettent la vérification des
modifications apportées à l'instance d'un rapport et la remise en cache de cette instance. Toutefois, si la base
de données est modifiée, l'instance du rapport stockée dans l'objet Cache n'est pas actualisée en
conséquence.
●
Consommation de ressources : un rapport dont les paramètres sont appelés fréquemment à l'aide de
différentes chaînes de paramètre(particulièrement si l'un de ces paramètres correspond à l'ID utilisateur)
implique à chaque fois la mise en cache d'un nouveau rapport. Ce processus consomme des ressources
système. Si le rapport ne présente pas un fort potentiel de partage, affectez son instance à un objet Session.
Liaison avec le composant ReportDocument [page 214]
1.4.5.3.2.4.1
Pour mettre en cache une classe de rapport non
incorporé, puis la lier au contrôle CrystalReportViewer
Prérequis
Remarque
configuration.
Procédure
1.
Recherchez le fichier World Sales Report.rpt dans le sous-répertoire General Business.
2.
Copiez dans le Presse-papiers le chemin d'accès complet au répertoire de fichiers en incluant World Sales
Report.rpt.
209
3.
projet [page 15]), déclarez une variable chaîne reportPath et affectez-lui une chaîne contenant le chemin
d'accès au fichier World Sales Report copié lors de l'étape précédente.
Dim reportPath As String = _
"C:\Program Files\Microsoft Visual Studio 9.0\" _
& "Crystal Reports\Samples\En\Reports\General Business\" _
& "World Sales Report.rpt"
string reportPath =
"C:\\Program Files\\Microsoft Visual Studio 9.0\\"
+ "Crystal Reports\\Samples\\En\\Reports\\General Business\\"
+ "World Sales Report.rpt";
4.
Déclarez et instanciez la classe NonEmbeddedReportCacher, puis transmettez-lui la variable chaîne
reportFile.
Remarque
Pour apprendre à créer la classe NonEmbeddedReportCacher, voir la procédure décrite juste après cette
procédure.
Dim myNonEmbeddedReportCacher As NonEmbeddedReportCacher = _New
NonEmbeddedReportCacher(reportFile)
NonEmbeddedReportCacher nonEmbeddedReportCacher = new
NonEmbeddedReportCacher(reportFile);
5.
Affectez l'instance de la classe utilitaire de gestion du cache à la propriété ReportSource du contrôle
myCrystalReportViewer.ReportSource = myNonEmbeddedReportCacher
crystalReportViewer.ReportSource = nonEmbeddedReportCacher;
1.4.5.3.2.4.2
Pour créer la classe utilitaire de gestion du
cache NonEmbeddedReportCacher
Procédure
1.
Créez dans votre projet une classe nommée NonEmbeddedReportCacher.
Public Class NonEmbeddedReportCacher
End Class
210
using System;
namespace MyWebApplication
{
public class NonEmbeddedReportCacher
{
public NonEmbeddedReportCacher()
{
}
}
}
2.
Ajoutez l'interface ICachedReport à la signature de la classe.
Public Class NonEmbeddedReportCacher
Implements ICachedReport
public class NonEmbeddedReportCacher : ICachedReport
3.
Ajoutez trois instructions "Imports" [Visual Basic] ou "using" [C#] au début de la classe.
4.
Dans la classe, déclarez deux instances de niveau classe : une instance chaîne nommée reportFileName et
une instance de ReportDocument nommée nonEmbeddedReportDocument.
Private reportFileName As String
Private nonEmbeddedReportDocument As ReportDocument
private string reportFileName;
private ReportDocument nonEmbeddedReportDocument;
5.
Configurez le constructeur de manière à ce qu'il accepte une chaîne reportFileName et dans le constructeur,
attribuez cette chaîne à la variable de classe reportFileName.
Public Sub New(ByVal reportFileName As String)
Me.reportFileName = reportFileName
End Sub
public NonEmbeddedReportCacher(string reportFileName)
{
this.reportFileName = reportFileName;
}
Les étapes suivantes implémentent les propriétés et les méthodes requises par l'interface :
○
IsCacheable
211
6.
○
ShareDBLogonInfo
○
CacheTimeOut
○
CreateReport()
○
GetCustomizedCacheKey(requête RequestContext)
Créez la propriété IsCacheable qui renvoie la valeur True.
Public Overridable Property IsCacheable() As Boolean Implements
ICachedReport.IsCacheable
Get
Return True
End Get
Set(ByVal Value As Boolean)
End Set
End Property
public virtual Boolean IsCacheable
{
get
{
return true;
}
set
{
}
}
7.
Créez la propriété ShareDBLogonInfo qui renvoie la valeur False.
Public Overridable Property ShareDBLogonInfo() As Boolean Implements
ICachedReport.ShareDBLogonInfo
Get
Return False
End Get
Set(ByVal Value As Boolean)
End Set
End Property
public virtual Boolean ShareDBLogonInfo
{
get
{
return false;
}
set
{
}
}
8.
Créez la propriété CacheTimeOut qui renvoie une valeur de constante depuis la classe
CachedReportConstants.
Public Overridable Property CacheTimeOut() As TimeSpan Implements
ICachedReport.CacheTimeOut
Get
Return CachedReportConstants.DEFAULT_TIMEOUT
End Get
Set(ByVal Value As TimeSpan)
212
End Set
End Property
public virtual TimeSpan CacheTimeOut
{
get
{
return CachedReportConstants.DEFAULT_TIMEOUT;
}
set
{
}
}
9.
Créez la méthode CreateReport(), qui renvoie un rapport non incorporé chargé dans l'instance de niveau
classe ReportDocument.
Public Overridable Function CreateReport() As ReportDocument Implements
ICachedReport.CreateReport
nonEmbeddedReportDocument = New ReportDocument()
nonEmbeddedReportDocument.Load(reportFileName)
Return nonEmbeddedReportDocument
End Function
public virtual ReportDocument CreateReport()
{
nonEmbeddedReportDocument = new ReportDocument();
nonEmbeddedReportDocument.Load(reportFileName);
return nonEmbeddedReportDocument;
}
10. Créez la méthode GetCustomizedCacheKey() qui renvoie une valeur nulle.
Remarque
Le fait que cette méthode renvoie une valeur nulle indique au SDK de SAP Crystal Reports .NET qu'il doit
gérer la clé de recherche du cache lui-même. Vous avez également la possibilité de créer et d'ajouter ici
votre propre méthode de clé de cache.
Public Overridable Function GetCustomizedCacheKey(ByVal request As
RequestContext) As String Implements ICachedReport.GetCustomizedCacheKey
Return Nothing
End Function
public virtual String GetCustomizedCacheKey(RequestContext request)
{
return null;
}
11. Pour visualiser le rapport, générez et exécutez votre projet.
213
1.4.5.3.2.5
Liaison avec le composant ReportDocument
Modèle d'objet
Description
Le composant ReportDocument se trouve dans la boîte à outils et fournit une méthode basée sur une interface
utilisateur graphique pour générer un code d'instanciation de classe du rapport dans la classe code-behind. Vous
pouvez spécifier un rapport non incorporé, un rapport incorporé ou un rapport incorporé mis en cache.
Remarque
La boîte de dialogue utilise les anciens termes "rapport non typé" pour désigner un rapport non incorporé et
"rapport fortement typé" pour désigner un rapport incorporé.
En utilisant cette boîte de dialogue pour ajouter ReportDocument en tant que composant, la classe
ReportDocument (ou la classe wrapper du rapport incorporé) est instanciée dans la région générée
automatiquement de la classe code-behind. En même temps, une icône apparaît dans la barre d'état des
composants de l'environnement de développement intégré pour représenter visuellement la classe de rapport
instanciée.
Remarque
Il est inutile d'ajouter un composant ReportDocument à votre projet pour instancier le rapport dans la classe
code-behind. Pour mieux contrôler votre code, il est recommandé d'ajouter le code d'instanciation de classe
manuellement.
214
1.4.5.3.2.6
Scénarios de liaison ReportDocument utilisant
les services Crystal (VS .NET 2003)
Les services Crystal offrent un accès pratique aux rapports dans Visual Studio 2003. Cette fonctionnalité n'est
pas disponible dans Visual Studio 2005 ou Visual Studio 2008. Une fois SAP Crystal Reports et les services
Crystal installés, Services Crystal apparaît sous la forme d'un sous-nœud situé sous chaque serveur du nœud
Serveurs de l'Explorateur de serveurs. Le nœud Services Crystal peut être développé pour afficher des listes de
rapports situés à divers emplacements :
●
Répertoire de fichiers local sur votre disque dur
●
●
Plateforme SAP BusinessObjects Business Intelligence (BIP)
Vous pouvez placer n'importe quel rapport répertorié dans ces listes dans un Web Form ou un Windows Form à
l'aide d'une opération glisser-déplacer.
Selon la version de SAP Crystal Reports que vous avez installée et les licences supplémentaires que vous avez
éventuellement acquises pour le RAS (Report Application Server) ou la plateforme SAP BusinessObjects Business
Intelligence, les services Crystal fournissent généralement deux nœuds qui peuvent être développés. Le tableau
situé dans la section suivante décrit les conditions requises pour accéder à un nœud particulier.
Remarque
Certaines versions de la plateforme SAP BusinessObjects Business Intelligence ne comprennent pas la prise en
charge des services Crystal. Pour en savoir plus, consultez la documentation relative à la plateforme SAP
Classes wrapper
Lorsque vous faites glisser un rapport depuis les services Crystal vers un Web Form ou un Windows Form, cela
crée une instance de classe wrapper qui référence le rapport dans la région du code de la classe code-behind
généré par le Web Form ou Windows Form.
Remarque
Le type de classe wrapper varie selon les versions de SAP Crystal Reports. Voir le tableau ci-dessous.
Les services Crystal répertoriés dans le tableau ci-dessous exposent les types de la classe wrapper
ReportDocument.
Ces deux services Crystal sont fournis avec SAP Crystal Reports 10. Ils fournissent des groupes de rapports pris
en charge depuis un serveur RAS géré ou non géré. ReportDocument correspond désormais à la classe wrapper
(depuis SAP Crystal Reports 9).
215
Classe wrapper ex Nom du nœud sous
posée par le biais
les services Crystal
des services Crystal
Versions de
SAP Crystal Re
ports
Description
Conditions requises
pour accéder au
nœud
ReportDocument
Report Application
Server
SAP Crystal Re
ports 10
Expose les rapports Installez un serveur
situés sur un serveur RAS non géré.
RAS chargé dans Re
portDocument. Pour
en savoir plus, voir
Liaison au Report
Application Server
(SAP Crystal Re
ports 10 et versions
ultérieures) [page
216].
ReportDocument
Crystal Enterprise
SAP Crystal Re
ports 10
Expose les rapports Installez Crystal En
situés sur le serveur terprise.
RAS géré chargé
dans ReportDocu
ment. Pour en savoir
plus, voir Liaison à
Crystal Enterprise
(SAP Crystal Re
ports 10 et versions
ultérieures) [page
219].
Les précédentes versions des services Crystal exposent des types de classes wrapper qui n'utilisent pas le
modèle d'objet ReportDocument. Elles dépendent donc du modèle d'objet limité fourni par le contrôle
CrystalReportViewer. Pour en savoir plus, voir Scénarios de liaison CrystalReportViewer avec les services Crystal
[page 180].
1.4.5.3.2.6.1
Liaison au Report Application Server
(SAP Crystal Reports 10 et versions ultérieures)
Remarque
Modèle d'objet
216
Les rapports se trouvent sur le serveur RAS non géré. Ils sont inclus dans la classe ReportDocument.
Cette section présente le sous-nœud Report Application Server des services Crystal dans
SAP Crystal Reports Developer.
[NOMSERVEUR]
●
Services Crystal
○
Report Application Server
Description
Le sous-nœud Report Application Server accède aux rapports qui ont été exposés par un serveur RAS non géré,
puis les affiche. Le nœud RAS fonctionne uniquement lorsque le serveur RAS non géré a été installé sur votre
ordinateur de développement.
Lorsque vous déplacez un rapport par glisser-déposer depuis le nœud Services Crystal > Plateforme SAP
BusinessObjects Business Intelligence vers un Web Form ou un Windows Form, une instance de ReportDocument
est générée. La classe ReportDocument fonctionne comme une classe wrapper. Son rôle consiste à représenter le
rapport transmis depuis le serveur RAS non géré.
Avantages
●
Accès simple : les rapports situés sur le serveur RAS non géré peuvent être facilement visualisés dans une
arborescence et déplacés à l'aide d'une simple opération glisser dans un Web Form.
●
Interaction par programmation étendue : fournit un accès au puissant modèle d'objet ReportDocument. La
classe wrapper dans cette version est ReportDocument. Il s'agit de la première version des Services Crystal
donnant accès au modèle d'objet ReportDocument.
Inconvénients
●
Codage moins direct : le codage des rapports RAS est moins direct que lorsqu'il est effectué à l'aide du
modèle d'objet ReportClientDocument.
217
Liaison à Crystal Enterprise (SAP Crystal Reports 10 et versions ultérieures) [page 219]
1.4.5.3.2.6.1.1
Pour utiliser les services Crystal > Report
Application Server
Prérequis
●
SAP Crystal Reports 10 ou une version ultérieure doit être installée et en cours de fonctionnement.
●
Le serveur RAS non géré doit être installé et en cours de fonctionnement.
Remarque
configuration.
Procédure
1.
Dans Visual Studio, ouvrez l'Explorateur de serveurs.
2.
Développez le nœud Services Crystal, puis le nœud Report Application Server.
3.
Sélectionnez un rapport dans l'arborescence Report Application Server, puis faites-le glisser dans votre
Web Form ou votre Windows Form.
En mode Design, un objet reportDocument1 s'affiche au bas du formulaire.
Remarque
Lorsqu'un rapport Report Application Server est placé dans votre formulaire, une instance de la classe
ReportDocument est ajoutée à la zone Code généré par le concepteur de votre formulaire.
Lorsqu'une classe qui hérite de System.ComponentModel.Component (telle que ReportDocument) est
instanciée et configurée dans la région du code généré par le Concepteur, une icône correspondant à cette
classe instanciée s'affiche au bas du formulaire en mode Design.
4.
Remarque
Une classe ReportDocument a été instanciée et configurée dans cette région.
218
5.
projet [page 15]), affectez l'instance de ReportDocument à la propriété ReportSource du contrôle
myCrystalReportViewer.ReportSource = reportDocument1
crystalReportViewer.ReportSource = reportDocument1;
6.
1.4.5.3.2.6.2
Liaison à Crystal Enterprise
(SAP Crystal Reports 10 et versions ultérieures)
Remarque
Modèle d'objet
Les rapports se trouvent sur le serveur RAS géré. Ils sont inclus dans la classe ReportDocument.
Cette section présente le sous-nœud de la plateforme SAP BusinessObjects Business Intelligence des services
Crystal dans SAP Crystal Reports Developer.
[NOMSERVEUR]
●
Services Crystal
○
Crystal Enterprise
219
Description
Le sous-nœud de la plateforme SAP BusinessObjects Business Intelligence accède aux rapports qui ont été
fournis par un serveur RAS géré dans la plateforme SAP BusinessObjects Business Intelligence, puis les affiche.
Le nœud Services Crystal > Plateforme SAP BusinessObjects Business Intelligence fournit les rapports de Crystal
Enterprise via le serveur RAS géré. Le nœud de la plateforme SAP BusinessObjects Business Intelligence
fonctionne, mais si la plateforme SAP BusinessObjects Business Intelligence n'a pas été installée sur l'ordinateur
de développement, accédez aux propriétés de ce nœud et définissez le nom du serveur de la plateforme SAP
BusinessObjects Business Intelligence sur le réseau.
Lorsque vous déplacez un rapport par glisser-déposer depuis le nœud Services Crystal > Plateforme SAP
BusinessObjects Business Intelligence vers un Web Form ou un Windows Form, une instance de ReportDocument
est générée. La classe ReportDocument fonctionne comme une classe wrapper. Son rôle consiste à représenter le
rapport transmis depuis le serveur RAS dans Crystal Enterprise.
Avantages
●
Accès facile : les rapports situés sur le serveur RAS dans Crystal Enterprise sont facilement accessibles à
partir d'une application Web.
●
Interaction par programmation étendue : fournit un accès au puissant modèle d'objet ReportDocument. La
classe wrapper dans cette version est ReportDocument. C'est la première version des services Crystal qui
donne accès au modèle d'objet ReportDocument.
Inconvénients
●
Codage moins direct : le codage des rapports RAS est moins direct que lorsqu'il est effectué à l'aide du
modèle d'objet ReportClientDocument.
1.4.5.3.2.6.2.1
Pour utiliser les Services
Crystal > Crystal Enterprise
Prérequis
●
220
SAP Crystal Reports 10 ou XI doit être installé et en cours de fonctionnement.
Remarque
configuration.
Procédure
1.
Dans Visual Studio, ouvrez l'Explorateur de serveurs.
2.
Développez le nœud Services Crystal, puis le nœud Crystal Enterprise.
3.
Sélectionnez un rapport dans l'arborescence Crystal Enterprise, puis faites-le glisser dans votre formulaire.
En mode Design, un objet reportDocument1 s'affiche au bas du formulaire.
Remarque
Lorsqu'un rapport Crystal Enterprise est placé dans votre formulaire, une instance de la classe
ReportDocument est ajoutée à la région du code généré par le Concepteur de votre formulaire.
Lorsqu'une classe qui hérite de System.ComponentModel.Component (telle que ReportDocument) est
instanciée et configurée dans la région du code généré par le Concepteur, une icône correspondant à cette
classe instanciée s'affiche au bas du formulaire en mode Design.
4.
Une classe ReportDocument a été instanciée et configurée dans cette région.
5.
projet [page 15]), affectez l'instance ReportDocument de à la propriété ReportSource du contrôle
myCrystalReportViewer.ReportSource = reportDocument1
crystalReportViewer.ReportSource = reportDocument1;
6.
Générez puis exécutez votre projet Web pour visualiser le rapport.
1.4.5.4
Utilisation de rapports standard ou mis en cache ?
Lorsque vous envisagez de générer une application à l'aide du SDK de SAP Crystal Reports, l'un des points les
plus importants à déterminer concerne l'utilisation de rapports standard ou de rapports mis en cache. Connaître
les principes fondamentaux du SDK qui influencent la mise en cache des rapports vous aidera à choisir la
structure la mieux adaptée à votre projet SAP Crystal Reports, version développeur pour Microsoft Visual Studio.
221
Qu'est-ce qu'un rapport mis en cache ?
Un rapport mis en cache est un objet de rapport qui a été stocké dans l'objet Cache ASP.NET dans le but
d'augmenter les performances et l'évolutivité. SAP Crystal Reports fournit une structure particulière pour la mise
en cache des instances de ReportDocument. Cette structure met automatiquement en cache tout rapport qui
implémente l'interface ICachedReport.
Qu'est ce que l'objet Cache ASP.NET ?
Dans ASP comme dans ASP.NET, les objets de rapport sont placés dans Session ou dans Application sur le
serveur Web pour deux raisons :
1.
Pour garantir la persistance des objets de rapport au fur et à mesure que les pages sont rechargées.
2.
Pour accroître l'évolutivité et les performances en plaçant les rapports volumineux ou lents à se charger dans
la mémoire du serveur.
Dans ASP.NET, une version plus avancée de l'objet Application, appelée Cache, a été introduite. Tout comme
l'objet Application, l'objet Cache rend les instances uniques d'un objet de rapport persistantes. Cache permet en
outre de rechercher des dépendances basées sur des fichiers, des clés ou des délais. Ces dépendances peuvent
arriver à expiration automatiquement et actualiser les objets de rapport stockés dans le cache afin que le contenu
de ce dernier soit toujours actuel.
Les rapports stockés dans Cache sont propres à l'utilisateur et à la session.
Remarque
Les termes "objet Cache" et "Cache", tout comme les termes "objet Session" et "Session" ou "objet
Application" et "Application" sont utilisés de manière interchangeable et signifient la même chose. Le terme
"objet" souligne le fait qu'il s'agit d'objets qui garantissent la persistance et s'exécutent dans l'espace mémoire
du .NET Framework sur le serveur Web.
Comment les objets de rapport sont-ils placés dans l'objet Cache ASP.NET ?
Il existe deux manières de placer les objets de rapport dans l'objet Cache ASP.NET :
●
En affectant les objets de rapport à l'objet Cache à l'aide de la même syntaxe que celle utilisée pour une
affectation à l'objet Session ou Application (affectation explicite).
●
En instanciant une version du rapport qui implémente l'interface ICachedReport. Le moteur de rapport
recherche alors tous les objets de rapport qui implémentent cette interface et place automatiquement ces
objets dans l'objet Cache (affectation implicite).
Qu'est-ce que l'interface ICachedReport ?
L'interface ICachedReport marque d'un indicateur toutes les classes de rapport qui lui permettent de fonctionner
avec la structure de mise en mémoire cache de SAP Crystal Reports. Cette structure personnalisée fournit une
222
couche sur l'objet Cache ASP.NET afin de répondre à des besoins spécifiques de mise en mémoire cache des
rapports.
L'interface ICachedReport comporte des signatures de méthodes qui, lorsqu'elles sont implémentées dans la
classe de rapport, indiquent à la structure comment mettre en cache cette classe.
Quelles sont les fonctionnalités de mise en mémoire cache fournies lors de
l'incorporation d'un rapport dans un projet Visual Studio ?
Lorsque vous créez ou importez un rapport dans un projet Visual Studio, ce rapport est incorporé dans le projet et
deux classes sont automatiquement générées :
●
Une classe wrapper (du même nom que le rapport).
Cette classe wrapper représente le rapport dans le projet et hérite de toutes les propriétés et méthodes de
ReportDocument. Pour en savoir plus, voir Comparaison des rapports incorporés et non incorporés [page
165].
●
Une classe utilitaire de gestion du cache (nommée classe Cached[NomRapport]).
Cette classe gère la mise en cache du rapport incorporé à l'aide de l'objet Cache ASP.NET et de la structure
de mise en mémoire cache construite dans le SDK de SAP Crystal Reports.
La table suivante présente les éléments générés lors de l'ajout du rapport de regroupement hiérarchique :
Nom des éléments
Correspond
Hierarchical Grouping.rpt
au rapport
Classe Hierarchical_Grouping
à la classe wrapper du rapport
Classe CachedHierarchical_Grouping
à la classe utilitaire de gestion du cache servant à gérer
la mise en mémoire cache de la classe wrapper du rap
port
La classe wrapper de rapport et la classe utilitaire de gestion du cache ont des rôles distincts :
●
La classe wrapper de rapport hérite de ReportDocument et, par conséquent, a accès au modèle d'objet
ReportDocument dans son intégralité. Il s'agit de la classe principale que vous programmez pour interagir
avec le rapport.
●
La classe utilitaire de gestion du cache gère et stocke les instances de la classe wrapper de rapport dans
l'objet Cache ASP.NET. Elle identifie les différentes instances de la classe wrapper et évite qu'elles ne
s'écrasent mutuellement dans le Cache. Par exemple, elle distingue les différences générées lorsque les
paramètres et les informations de connexion sont modifiés. Pour cela, elle affecte une clé unique à chaque
instance de la classe wrapper de rapport.
●
Pour s'identifier auprès de la fonction de mise en cache du .NET Framework de SAP Crystal Reports, la classe
utilitaire de gestion du cache implémente l'interface ICachedReport.
La classe wrapper de rapport et la classe utilitaire de gestion du cache sont toutes deux générées dans le même
fichier de classe. Pour les visualiser, cliquez avec le bouton droit de la souris sur le fichier de classe dans
l'Explorateur de solutions, puis sélectionnez Afficher le code. Dans le fichier ouvert, le code correspondant à la
classe wrapper est affiché dans le haut du fichier et le code relatif à la classe utilitaire de gestion du cache est
affiché plus bas, à mi-fichier.
223
Remarque
Pour apprendre à lier le contrôle CrystalReportViewer à la classe utilitaire de gestion du cache, voir Liaison à
une classe de rapport incorporé et mis en cache [page 205]. Pour créer votre propre classe utilitaire de gestion
du cache afin de la lier à des rapports non incorporés, voir Liaison à un rapport non incorporé chargé dans une
classe utilitaire de gestion du cache [page 207].
Quand mettre les rapports en cache ?
Ne placez qu'un nombre restreint d'objets de rapport dans l'objet Cache ASP.NET. La plupart des objets de
rapport présentent un faible potentiel de partage (en d'autres termes, ils ne sont pas utilisés en tant que
ressources partagées avec d'autres objets). Ils viendraient en quelque sorte "encombrer" le Cache. S'ils doivent
être rendus persistants, placez plutôt les objets de rapport dans l'objet Session de l'utilisateur.
Placez l'objet de rapport dans Cache ASP.NET uniquement si le rapport doit être affiché à de nombreuses
reprises par le même utilisateur au cours d'une session donnée. Ceci est particulièrement important si un objet de
rapport est très volumineux ou s'il contient une requête si complexe que l'extraction de ses données prend
plusieurs minutes.
Liaison à une classe de rapport incorporé et mis en cache [page 205]
1.4.5.5
Affichage d'un rapport au moment de la conception
SAP Crystal Reports vous permet d'afficher l'aperçu d'un rapport au moment de la conception dans Visual Studio.
Lorsqu'un rapport est affecté à la propriété ReportSource dans la fenêtre Propriétés, il s'affiche sous forme
d'aperçu dans le Windows Form ou la page ASPX.
Les données statiques, telles que les dates, images ou champs de texte, s'affichent comme au moment de
l'exécution. Les données dynamiques, telles que les données provenant d'une base de données, peuvent utiliser
des valeurs artificielles à la place des données de votre source de données. Si votre rapport contient des donnée
enregistrées, celles-ci apparaissent dans l'aperçu lors de la conception.
Le SAP Crystal Reports Designer incorporé fournit des fonctionnalités d'affichage supplémentaires via l'onglet
Aperçu. Lorsque vous affichez votre rapport dans l'onglet Aperçu, SAP Crystal Reports tente d'extraire les
nouvelles données de la source de données spécifiée. L'aperçu au moment de la conception ne tente pas
d'extraire de données. Il affiche les données actuellement enregistrées dans le rapport.
Remarque
L'onglet Aperçu n'est pas disponible dans le SAP Crystal Reports Designer pour Visual Studio .NET 2003
incorporé.
224
Onglet Aperçu [page 658]
1.4.6
Personnalisation du contrôle CrystalReportViewer
Le contrôle CrystalReportViewer permet de lier et d'afficher des rapports dans le .NET Framework. Le contrôle
CrystalReportViewer par défaut inclut des éléments d'interface utilisateur pour vous aider à afficher, enregistrer
et parcourir un rapport.
En fonction de votre application, vous pouvez modifier certains éléments du contrôle par défaut.
SAP Crystal Reports vous permet de personnaliser l'aspect et la convivialité du visualiseur dans votre application
de différentes manières, notamment :
●
La barre d'outils CrystalReportViewer peut être supprimée du visualiseur.
●
Les boutons de la barre d'outils CrystalReportViewer peuvent être ajoutés ou supprimés par programmation.
●
Le contrôle CrystalReportViewer prend en charge la personnalisation via CSS ou Thèmes.
Cette section explique comment modifier le contrôle du visualiseur pour votre application.
Classes utilisées pour la visualisation de rapports
●
●
1.4.6.1
Indicateur de traitement de rapport
L'indicateur de traitement de rapport fournit une indication visuelle du temps de traitement sur votre site Web
SAP Crystal Reports. Lorsque le temps de traitement du rapport dépasse un seuil spécifié, une boîte de dialogue
apparaît pour fournir une indication sur le progrès de l'action en cours.
Le texte de la boîte de dialogue et le délai préalable à l'apparition de la boîte de dialogue peuvent être spécifiés
dans le fichier Web.Config de votre site Web.
225
Le texte par défaut est : Veuillez patienter pendant le traitement du document.
Le délai par défaut préalable à l'apparition de l'indicateur de traitement de rapport est de 200 ms.
1.4.6.1.1
Personnalisation du texte de l'indicateur de
traitement de rapport
Contexte
Le texte du message de l'indicateur de traitement de rapport est configuré dans le fichier Web.Config de votre
site Web.
Procédure
1.
2.
Ouvrez votre fichier Web.config.
Si vous ne disposez pas de fichier Web.Config, cliquez sur
Déboguer
Démarrer le débogage
pour
déboguer votre application. Visual Studio vous invite à créer un fichier Web.Config. Cliquez sur OK pour créer
le fichier.
3.
Dans votre fichier Web.Config, ajoutez le paramètre NameValueSectionHandler en tant que premier
enfant de l'élément de configuration.
<configSections>
</sectionGroup>
</sectionGroup>
</configSections>
L'élément configSections doit être l'unique premier enfant de l'élément configuration. Si vous disposez
déjà d'un élément configSections pour SAP Crystal Reports, ajoutez l'élément section de
CrystalReportViewer au nœud configSections existant.
4.
Ajoutez le paramètre processingIndicatorText directement après l'élément configSections.
<businessObjects>
<crystalReports>
226
<add key="processingIndicatorText" value="Thank you for waiting"/>
</crystalReports>
</businessObjects>
5.
Remplacez le texte de l'attribut value par le message à afficher dans l'indicateur de traitement de rapport.
L'élément processingIndicatorText contrôle le texte affiché dans l'indicateur de traitement de rapport.
Le texte par défaut est : Veuillez patienter pendant le traitement du document.
Résultats
Le contrôle CrystalReportViewer doit à présent utiliser le message personnalisé dans l'indicateur de traitement de
rapport.
Exemple
Cet exemple réduit le délai de l'indicateur de traitement de rapport à 20 ms et remplace le message affiché par
“Merci d'avoir patienté”.
<configuration>
<configSections>
</sectionGroup>
</sectionGroup>
</configSections>
<businessObjects>
<crystalReports>
</crystalReports>
</businessObjects>
<appSettings>
</appSettings>
<system.web>
<assemblies>
<add assembly="CrystalDecisions.Shared, Version=12.0.2000.0,
<add assembly="CrystalDecisions.ReportSource, Version=12.0.2000.0,
Version=12.0.2000.0, Culture=neutral, PublicKeyToken=692FBEA5521E1304"/>
</assemblies>
</compilation>
<httpHandlers>
227
</httpHandlers>
</system.web>
</configuration>
1.4.6.1.2
Modification du délai préalable à l'apparition de
l'indicateur de traitement de rapport
Contexte
Le délai préalable à l'apparition de l'indicateur de traitement de rapport est configuré dans le fichier Web.Config
de votre site Web. L'élément processingIndicatorDelay contrôle le délai préalable à l'apparition de
l'indicateur de traitement de rapport.
Procédure
1.
2.
Ouvrez votre fichier Web.config.
Si vous ne disposez pas de fichier Web.Config, cliquez sur
Déboguer
Démarrer le débogage
pour
déboguer votre application. Visual Studio vous invite à créer un fichier Web.Config. Cliquez sur OK pour créer
le fichier.
3.
Dans votre fichier Web.Config, ajoutez le paramètre NameValueSectionHandler en tant que premier
enfant de l'élément de configuration.
<configSections>
</sectionGroup>
</sectionGroup>
</configSections>
L'élément configSections doit être l'unique premier enfant de l'élément configuration. Si vous disposez
déjà d'un élément configSections pour SAP Crystal Reports, ajoutez l'élément section de
CrystalReportViewer au nœud configSections existant.
4.
Ajoutez le paramètre processingIndicatorDelay directement après l'élément configSections.
<businessObjects>
<crystalReports>
228
</crystalReports>
</businessObjects>
5.
Remplacez le texte de l'attribut value par la durée qui doit s'écouler avant l'apparition de l'indicateur de
traitement de rapport.
La valeur est spécifiée en millisecondes. Le fait de définir cette valeur sur 0 désactive l'indicateur de
traitement de rapport. La valeur par défaut est de 200 ms.
Exemple
Cet exemple réduit le délai de l'indicateur de traitement de rapport à 20 ms et remplace le message affiché par
“Merci d'avoir patienté”.
<configuration>
<configSections>
</sectionGroup>
</sectionGroup>
</configSections>
<businessObjects>
<crystalReports>
</crystalReports>
</businessObjects>
<appSettings>
</appSettings>
<system.web>
<assemblies>
<add assembly="CrystalDecisions.Shared, Version=12.0.2000.0,
<add assembly="CrystalDecisions.ReportSource, Version=12.0.2000.0,
Version=12.0.2000.0, Culture=neutral, PublicKeyToken=692FBEA5521E1304"/>
</assemblies>
</compilation>
<httpHandlers>
</httpHandlers>
</system.web>
</configuration>
229
1.4.6.2 Prise en charge de plusieurs langues avec le contrôle
CrystalReportViewer
SAP Crystal Reports, version développeur pour Microsoft Visual Studio inclut la prise en charge des clients Web et
Windows multilingues via une localisation dynamique.
La localisation dynamique permet aux utilisateurs d'afficher des info-bulles ainsi que d'autres contenus du
contrôle CrystalReportViewer dans la langue de leur choix. Pour activer la localisation dynamique, vous devez
rendre disponible les fichiers de ressources de langue dans la langue souhaitée.
Tutoriel : Configuration de la prise en charge de client multilingue [page 590]
Dans ce tutoriel, vous allez apprendre à configurer la prise en charge de client multilingue dans un site Web ou
un projet Windows.
1.4.6.2.1
Fichiers de ressources de langue
Les fichiers de ressources de langue contiennent une série de paires clés/valeurs qui fournissent le texte affiché
dans l'application. Pour chaque élément de texte qui apparaît dans une application de rapport Crystal, il existe une
valeur correspondante dans le fichier de ressources de langue qui spécifie la manière dont doit apparaître le texte
dans chaque langue.
Fichiers de ressources de langue
Sur le serveur Web ou le client Windows, vous pouvez accéder aux ressources de langue du contrôle
CrystalReportViewer à partir de deux sources différentes :
●
●
230
Les fichiers DLL de ressources de langue par défaut, comprenant les langues suivantes :
○
Anglais (en)
○
Français (fr)
○
Allemand (de)
○
Espagnol (es)
○
Italien (it)
○
Japonais (jp)
○
Coréen (ko)
○
Chinois simplifié (zh-chs)
○
Chinois traditionnel (zh-cht)
Les fichiers de ressources de langue personnalisées, qui sont créés sous forme de chaînes de texte, puis
compilés en tant que fichiers DLL de ressources de langue personnalisées.
Ressources neutres et non neutres
Les ressources de langue comprennent des ressources neutres et non neutres.
Les ressources neutres représentent un paramètre de langue général, tel que en (pour l'anglais), fr (pour le
français) et jp (pour le japonais).
Les ressources non neutres représentent une version de la langue qualifiée par des critères supplémentaires, tels
que la région : par exemple, de-AT pour Allemand (Autriche).
Ressources globales et locales
Les ressources de langue par défaut sont installées dans le GAC et sont donc toujours disponibles de manière
globale, mais les ressources de langue personnalisée sont accessibles de manière globale ou locale.
Le dossier des ressources de langue peut être stocké dans un emplacement central et partagé à partir de cet
emplacement ou bien il peut être copié dans un répertoire local de l'application Web ou Windows.
Lorsque les ressources de langue sont stockées dans un emplacement central, on les appelle des ressources
globales. Dans ce scénario, l'application Web ou Windows doit être informée de leur emplacement grâce aux
paramètres d'un fichier de configuration XML. Pour que le chargement d'une ressource globale s'effectue
correctement, le nom du dossier contenant les fichiers de la ressource doit correspondre aux paramètres
régionaux de la langue.
Si les ressources de langue sont copiées dans le répertoire local, on les appelle des ressources locales. Dans ce
scénario, aucun fichier de configuration n'est nécessaire. Pour que le chargement d'une ressource locale
s'effectue correctement, la culture des fichiers de ressource et le nom du dossier contenant les fichiers de
ressource doivent correspondre aux paramètres régionaux de langue.
Choix entre ressources globales et ressources locales
Choisissez de préférence les ressources globales lorsque les ressources doivent être partagées avec plusieurs
applications. Par exemple, l'utilisation des ressources globales est plus adaptée à un serveur Web contenant
plusieurs sites Web requérant le partage d'un ensemble de ressources de langues à travers tous les sites Web.
Choisissez de préférence les ressources locales lorsque les ressources sont utilisées par une seule application,
dont la large distribution requiert une configuration simple. Par exemple, l'utilisation des ressources locales est
plus adaptée à une application Windows composée d'un seul dossier d'application destiné à une large distribution.
La plupart du temps, les applications Web sont plus adaptées aux ressources globales et les applications
Windows sont plus adaptées aux ressources locales.
231
Quelle ressource est chargée en premier ?
Si vous configurez des ressources globales et locales pour une application particulière, les ressources locales sont
prioritaires (elles sont chargées en premier). Si vous souhaitez garantir l'utilisation des ressources globales,
vérifiez que votre fichier de configuration est correct et supprimez le dossier de ressources locales.
Les ressources neutres et non neutres sont également influencées par l'ordre de chargement des ressources. Si
vous avez configuré des ressources neutres et non neutres pour une langue donnée (telles que "allemand
(Autriche)" et "allemand"), les ressources non neutres sont vérifiées en premier.
Dans les deux cas, le spécifique prévaut sur le général.
Affichage côté client
Les facteurs suivants déterminent la langue affichée par l'application cliente au moment de l'exécution :
Dans une application Windows :
●
les paramètres régionaux de l'ordinateur de chaque utilisateur.
Dans un site Web :
●
les paramètres régionaux du serveur Web ;
●
les paramètres de langue du navigateur client ;
●
la propriété Culture que vous définissez sur une autre page ASPX.
1.4.6.2.2
Prise en charge des standards de codage de
caractères Unicode et GB18030
SAP Crystal Reports, version développeur pour Microsoft Visual Studio inclut la prise en charge des caractères
internationaux selon les standards de codage de caractères suivants :
●
Unicode
●
GB18030
Pour comprendre comment SAP Crystal Reports prend en charge le codage de caractères Unicode et GB18030,
vous devez connaître les trois différentes vues de caractères (répertoire de caractères, caractères sous forme de
points de code, caractères sous forme de données codées). Vous devez également connaître la relation entre les
points de code (terme plus précis désignant les caractères codés) et les unités de code.
1.4.6.2.2.1
Vues des caractères
Pour comprendre les standards de codage de caractères, vous devez faire la distinction entre trois vues de
caractères :
232
●
Le répertoire de caractères (la liste résumée des caractères).
●
Les caractères sous forme de points de code avec valeurs scalaires.
●
Les caractères sous forme de données codées.
Répertoire de caractères (liste résumée des caractères)
Le répertoire de caractères est une liste résumée de plus d'un million de caractères que l'on retrouve dans une
grande diversité de scripts, notamment le latin, le cyrillique, le chinois, le coréen, le japonais, l'hébreu et
l'araméen. D'autres symboles tels que des notes de musique sont également inclus dans le répertoire de
caractères.
Les standards de codage de caractères Unicode et GB18030 possèdent tous deux un répertoire de caractères.
Lorsque de nouveaux caractères sont ajoutés à un standard, l'autre standard ajoute également ces caractères
pour maintenir la parité.
Caractères sous forme de points de code avec valeurs scalaires
Remarque
Cette seconde vue des caractères s'applique uniquement au format Unicode, et non à GB18030.
Chaque caractère du répertoire de caractères est affecté à un point de code. Chaque point de code a une valeur
numérique spécifique que l'on appelle valeur scalaire. La valeur scalaire est souvent exprimée en hexadécimaux.
Les points de code se situent dans un espace de code. Cet espace de code contient différentes valeurs scalaires
qui se répartissent sur deux plans :
●
Le plan BMP (Basic Multilingual Plane) (taille : 64k).
Dans le standard Unicode, l'expression en hexadécimaux des valeurs de ce plan inférieur se situe entre U
+0000 et U+FFFF.
●
Plan SMP (Supplemental Multilingual Plane) (16 sections supplémentaires d'une taille de 64k).
Dans le standard Unicode, l'expression en hexadécimaux des valeurs de ce plan supérieur se situe entre U
+10000 to U+10FFFF.
L'espace de code complet pour toutes les valeurs scalaires possibles est égal à une taille de 17 * 64k
(1 088 000 valeurs possibles).
Caractères sous forme de données codées
Chaque format de codage convertit des caractères du répertoire de caractères en données codées.
Dans le format GB18030, les données codées sont directement dérivées du répertoire de caractères : le concept
d'une valeur scalaire jouant le rôle d'intermédiaire entre le répertoire de caractères et les données codées
s'applique uniquement à Unicode.
233
Dans le format Unicode, les données codées sont obtenues en appliquant un algorithme à la valeur scalaire.
Unicode définit trois formats de codage de caractères :
●
UTF-8
●
UTF-16
●
UTF-32
1.4.6.2.2.2
code
Relation entre les points de code et les unités de
Pour comprendre comment SAP Crystal Reports, version développeur pour Visual Studio</nom_produit> prend
en charge GB18030 et Unicode, il est important de comprendre la relation entre les points de code et les unités de
code.
Points de code et unités de code
Dans chaque format de codage, les points de code sont mis en correspondance avec une ou plusieurs unités de
code.
Une unité de code est une unité unique au sein de chaque format de codage. La taille de l'unité de code est
équivalente à la valeur en bits du format de codage concerné :
●
Une unité de code UTF-8 est égale à 8 bits.
●
●
●
Avec GB18030, une unité de code est égale à 8 bits.
Nombre d'unités de code dans chaque point de code
Le nombre d'unités de code devant être mises en correspondance avec un point de code varie en fonction des
formats de codage :
●
UTF-8
Le codage UTF-8 comporte souvent plusieurs unités de code par point de code, car les unités de code sont
plus petites. Les points de code sont mis en correspondance avec une, deux, trois ou quatre unités de code.
●
UTF-16
Les unités de code UTF-16 sont deux fois plus volumineuses que les unités de code 8 bits. Par conséquent, un
point de code dont la valeur scalaire est inférieure à U+10000 est codé avec une seule unité de code.
Pour les points de code dont la valeur scalaire est supérieure ou égale à U+10000, deux unités de code sont
nécessaires par point de code. Ces paires d'unités de code sont désignées par un terme unique en codage
UTF-16 : "paires de substitution Unicode".
234
Remarque
La prise en charge des paires de substitution est abordée ci-dessous.
●
UTF-32
L'unité de code 32 bits utilisée dans le codage UTF-32 est suffisamment volumineuse pour que chaque point
de code soit codé avec une seule unité de code.
●
GB18030
Le codage GB18030 comporte souvent plusieurs unités de code par point de code, car les unités de code sont
plus petites. Les points de code sont mis en correspondance avec une, deux ou quatre unités de code.
Prise en charge des paires de substitution Unicode
Certains scripts pris en charge par le standard Unicode contiennent des caractères dont les points de code ont
une valeur scalaire supérieure ou égale à U+10000. Dans le codage UTF-16, ces points de code sont codés à l'aide
de paires de substitution.
Il est important que les paires de substitution Unicode soient manipulées correctement. Par exemple, lorsque
vous travaillez sur un texte dans une application utilisant le codage UTF-16, le curseur doit se déplacer sur chaque
point de code comme s'il s'agissait d'un caractère texte unique lors de l'ajout, de la suppression ou de la sélection
de caractères à couper, copier ou coller.
1.4.6.2.2.3
Prise en charge de GB18030 via Unicode par
SAP Crystal Reports
SAP Crystal Reports, version développeur pour Microsoft Visual Studio</nom_produit> ne prend pas
directement en charge le codage GB18030. Il accède au standard GB18030 par le biais de valeurs qui ont déjà été
converties dans l'un des formats de codage Unicode.
Les conversions sont effectuées par différentes sources, notamment le .NET Framework, certains pilotes de
bases de données et le système d'exploitation Windows. Le texte est généralement stocké sur le disque dur au
format UTF-8, puis chargé en mémoire au format UTF-16. SAP Crystal Reports prend en charge les paires de
substitution Unicode en UTF-16.
Exemples de prise en charge du format GB18030 via Unicode
Les principaux cas de figure de prise en charge du format GB18030 via la conversion en Unicode sont les
suivants :
●
Bases de données contenant des données codées en GB18030
Les données codées en GB18030 sont prises en charge uniquement lorsque le pilote de la base de données
convertit les données en UTF-16 au moment de leur extraction.
235
Remarque
Microsoft SQL Server 2005 convertit les données GB18030 en UTF-16 au moment de leur extraction. Pour
les autres serveurs, consultez le fournisseur de votre base de données.
●
DataSets exposant les données issues d'une source GB18030
Quelle que soit la source d'origine, les DataSets sont formatés en XML, lequel est encodé en UTF-8.
●
Services Web qui exposent des données issues d'une source GB18030
Le texte envoyé ou reçu via un service Web est déjà converti en Unicode.
Scénarios GB18030 non pris en charge
SAP Crystal Reports ne permet pas d'accéder aux fichiers texte codés au format GB18030, ni de les importer.
Le fichier texte codé au format GB18030 doit d'abord être converti au format Unicode par un tiers afin que
SAP Crystal Reports puisse ensuite interagir avec le fichier texte codé au format Unicode.
1.4.6.3
Gestion des événements Error
Dans les précédentes versions de SAP Crystal Reports, version développeur pour Microsoft Visual Studio, chaque
fois que vous utilisiez le contrôle CrystalReportViewer, vous deviez intercepter toutes les éventuelles
exceptions renvoyées. Toute exception non interceptée interrompait le traitement des pages et générait un
message d'erreur.
Afin d'éviter les interruptions et les erreurs, un nouvel événement à été ajouté au contrôle
CrystalReportViewer : l'événement Error. Lorsque cet événement est utilisé, des messages d'exception
s'affichent au début du contrôle CrystalReportViewer sans entraîner d'interruption.
1.4.6.3.1
Pour supprimer la page d'erreur à l'aide de la
méthode d'événement Error
Contexte
Pour supprimer l'exception renvoyée, vous devez appeler la méthode d'événement Error et définir
ErrorEventArgs.Handled sur True dans le gestionnaire d'événements.
Procédure
1.
236
Ajoutez la méthode d'événement Error à votre classe code-behind.
2.
Définissez ErrorEventArgs.Handled sur True dans le gestionnaire d'événements.
Exemple
Sub myCrystalReportViewer_Error(ByVal source As Object, ByVal e As
CrystalDecisions.Web.ErrorEventArgs)
e.Handled = True
End Sub
void crystalReportViewer_Error(object source,
CrystalDecisions.Web.ErrorEventArgs e)
{
e.Handled = true;
}
1.4.6.4 Personnalisation du contrôle CrystalReportViewer
avec la CSS
L'apparence visuelle du contrôle CrystalReportViewer est créée grâce à des graphiques et des feuilles de style en
cascade (CSS).
La feuille de style, nommée default.css, est stockée dans un sous-répertoire du répertoire virtuel du
visualiseur nommé css.
Remarque
Dans Visual Studio 2005 et versions ultérieures (ainsi que dans ASP.NET version 2.0), l'aspect des contrôles
visuels peut être géré par un nouvel outil appelé Thèmes. Les thèmes peuvent être appliqués au contrôle
CrystalReportViewer afin de garantir la cohérence de l'aspect des contrôles au sein d'une même page ou dans
l'intégralité d'un site Web.
Personnalisation du contrôle CrystalReportViewer avec Thèmes [page 238]
Boîte de dialogue Définir la classe CSS [page 953]
Mise en forme de rapports à l'aide de feuilles de style en cascade [page 743]
237
1.4.6.4.1
Personnalisation de la CSS pour le contrôle
CrystalReportViewer
Contexte
Cette feuille de style est accessible via la propriété CssFileName du contrôle CrystalReportViewer et peut
être visualisée dans la fenêtre Propriétés lorsque leCrystalReportViewer contrôle est sélectionné en mode
Design.
Procédure
1.
Créez un site Web contenant un contrôle CrystalReportViewer et un rapport Crystal.
2.
Compilez et exécutez le projet au moins une fois pour visualiser le contrôle CrystalReportViewer avec ses
paramètres de style par défaut, puis quittez le mode débogage.
3.
Ouvrez la page Default.aspx en mode Design.
4.
Cliquez une fois sur le contrôle CrystalReportViewer pour le sélectionner.
5.
Dans la fenêtre Propriétés, localisez le chemin d'accès au répertoire du fichier default.css dans la propriété
CssFileName.
6.
Dans l'Explorateur Windows, localisez ce fichier et copiez-le dans le répertoire de votre site Web.
7.
Renommez le fichier en custom.css.
8.
Modifiez la propriété CssFileName de sorte qu'elle pointe sur le répertoire du site Web et sur le fichier
custom.css.
9.
Recompilez votre projet et assurez-vous que le contrôle CrystalReportViewer voit le fichier custom.css dans le
répertoire de votre site Web local.
10. Quittez le mode débogage.
11. Ouvrez le fichier custom.css, puis modifiez la feuille de style.
12. Recompilez le projet et vérifiez que vos modifications ont été appliquées au contrôle CrystalReportViewer.
1.4.6.5 Personnalisation du contrôle CrystalReportViewer
avec Thèmes
Thèmes est un outil qui permet de donner un aspect et une convivialité identique à tous les contrôles visuels d'une
page (ou de tout un site Web).
Pour gérer l'aspect des contrôles visuels au niveau de la page, affectez le nom d'un thème à la propriété Theme
d'un contrôle visuel. Ce thème sera alors appliqué à tous les contrôles visuels de la page.
Le contrôle CrystalReportViewer est compatible avec les thèmes ASP.NET 2.0. Toute modification apportée à un
thème est répercutée sur le contrôle CrystalReportViewer ainsi que sur tous les autres contrôles de la page.
Pour en savoir plus sur la configuration et la personnalisation des thèmes dans ASP.NET 2.0, voir la
documentation de .NET Framework version 2.0.
238
Personnalisation du contrôle CrystalReportViewer avec la CSS [page 237]
1.4.6.6 Personnalisation de la barre d'outils
CrystalReportViewer
La barre d'outils CrystalReportViewer contient des boutons contrôlant les fonctions courantes du contrôle
CrystalReportViewer, telles que l'impression, l'exportation ou le changement de la page en cours d'affichage.
Personnalisation des boutons de la barre d'outils
La barre d'outils CrystalReportViewer contient des boutons contrôlant les fonctions courantes du contrôle
CrystalReportViewer, telles que l'impression, l'exportation ou le changement de la page en cours d'affichage.
La visibilité de chaque bouton sur le contrôle CrystalReportViewer est contrôlée via une propriété correspondante
de la classe CrystalReportViewer. Les noms des propriétés diffèrent entre les versions Windows et Web du
Sur un site Web, l'apparence de la barre d'outils peut être contrôlée via la CSS ou via Thèmes ASP .Net. Vous
pouvez modifier l'apparence des icônes de boutons par défaut en modifiant les images dans le répertoire virtuel
du visualiseur.
Suppression de la barre d'outils
Vous pouvez supprimer la barre d'outils du contrôle CrystalReportViewer par programmation ou via le panneau
Tâches guidées. Vous pouvez créer des contrôles personnalisés pour répliquer le comportement de nombreux
boutons de la barre d'outils CrystalReportViewer.
Personnalisation du contrôle CrystalReportViewer avec la CSS [page 237]
Personnalisation du contrôle CrystalReportViewer avec Thèmes [page 238]
239
1.4.6.6.1
Contrôle des boutons apparaissant sur la barre
d'outils CrystalReportViewer
Chacun des boutons de la barre d'outils CrystalReportViewer peut être activé ou désactivé individuellement.
La visibilité de chaque bouton sur le contrôle CrystalReportViewer est contrôlée via une propriété correspondante
de la classe CrystalReportViewer. Il existe deux contrôles CrystalReportViewer dans le SDK
SAP Crystal Reports .NET. Pour un site Web, utilisez la classe
CrystalDecisions.Web.CrystalReportViewer. Pour une application Windows, utilisez la classe
CrystalDecisions.Windows.Forms.CrystalReportViewer.
Le nom de la propriété qui contrôle la visibilité d'un bouton de la barre d'outils diffère selon la version du contrôle
CrystalReportViewer que vous utilisez. Pour la classe CrystalDecisions.Web.CrystalReportViewer,
chaque propriété commence par “Has”, comme HasExportButton, HasPrintButton ou HasSearchButton.
En ce qui concerne la classe CrystalDecisions.Windows.Forms.CrystalReportViewer, chaque propriété
commence par “Show”, comme ShowExportButton, ShowPrintButton ou ShowSearchButton.
Pour en savoir plus sur la classe CrystalDecisions.Web.CrystalReportViewer ou la classe
CrystalDecisions.Windows.Forms.CrystalReportViewer, voir la Référence de l'API .NET
Remarque
La suppression d'un bouton de la barre d'outils ne désactive pas le comportement correspondant.
Exemple
Cet exemple montre comment supprimer plusieurs boutons de la barre d'outils CrystalReportViewer dans un
site Web.
CrystalReportViewer1.HasPrintButton = False
CrystalReportViewer1.HasExportButton = False
CrystalReportViewer1.HasSearchButton = False
End Sub
{
crystalReportViewer1.HasPrintButton = false;
crystalReportViewer1.HasExportButton = false;
crystalReportViewer1.HasSearchButton = false;
}
Suppression du bouton d'impression depuis le contrôle CrystalReportViewer [page 115]
Suppression du bouton d'exportation depuis le contrôle CrystalReportViewer [page 128]
240
1.4.6.6.2 Suppression de la barre d'outils
CrystalReportViewer
Contexte
Conseil
La barre d'outils peut être supprimée de votre application par programmation ou en décochant la case Afficher
la barre d'outils dans le panneau Tâches guidées des Tâches CrystalReportViewer.
Procédure
1.
2.
Définissez la propriété CrystalReportViewer.DisplayToolbar sur False.
Résultats
Lorsque vous exécuterez votre application, la barre d'outils ne devrait plus apparaître sur le contrôle
Exemple
CrystalReportViewer1.DisplayToolbar = False
End Sub
{
crystalReportViewer1.DisplayToolbar = false;
}
241
1.4.6.6.3 Modification des boutons de la barre d'outils par
défaut dans le visualiseur Web
Contexte
La barre d'outils CrystalReportViewer se compose de différents graphiques qui représentent la plupart des
propriétés disponibles. Les graphiques sont stockés dans le répertoire virtuel du visualiseur de votre version de
Pour un site Web, la barre d'outils utilise des graphiques qui représentent les propriétés suivantes :
●
Arborescence des groupes
●
Exporter
●
Imprimer
●
Explorer en amont
●
Navigation : première page, dernière page, page précédente et page suivante
●
Aller à la page
●
Rechercher
●
Logo SAP BusinessObjects
Il est possible de remplacer ces boutons par votre propre jeu d'icônes personnalisées.
Procédure
1.
Naviguez jusqu'au répertoire virtuel du visualiseur.
2.
Cliquez deux fois sur le dossier images.
3.
Cliquez deux fois sur le dossier toolbar.
Dans le dossier "toolbar", vous trouverez toutes les images utilisées pour la barre d'outils
4.
Remplacez les images par d'autres images de votre choix ou ouvrez les images dans un éditeur de graphiques
pour les modifier. Le nom de l'image doit toutefois rester le même.
Résultats
Les images de la barre d'outils CrystalReportViewer sont remplacées pour toutes les applications Web
utilisant le répertoire virtuel du visualiseur.
242
1.4.7
Utilisation des rapports SAP Crystal Reports Read-Only
(RPTR)
Les rapports SAP Crystal Reports Read-Only (RPTR) sont des rapports Crystal qui peuvent être visualisés avec
des applications de visualiseur de rapport, mais qui ne peuvent pas être modifiés avec le SDK ni ouverts par des
applications de concepteur de rapports. Cela vous permet de protéger votre propriété intellectuelle en empêchant
les utilisateurs de modifier le rapport ou d'obtenir les informations en lien avec votre logique métier stockées dans
la définition du rapport.
Les rapports au format SAP Crystal Reports Read-Only utilisent l'extension de fichier RPTR à la place de
l'extension de fichier RPT utilisée par les rapports Crystal. Vous pouvez créer un rapport RPTR en exportant un
rapport RPT au format RPTR. Cependant, la conversion d'un rapport RPTR en rapport RPT n'est pas prise en
charge.
La définition d'un rapport RPTR ne pouvant pas être modifiée, il n'est pas possible d'utiliser ce SDK pour définir
l'emplacement de la source de données d'un rapport RPTR via le contrôleur de base de données. Il est en
revanche possible d'actualiser les données d'un rapport RPTR au moment de l'exécution.
Vous pouvez utiliser ce SDK pour exécuter les tâches suivantes :
●
Créer un rapport RPTR en exportant un rapport Crystal (RPT) au format RPTR.
Remarque
Seuls les rapports créés par SAP Crystal Reports 2011 peuvent être exportés au format RPTR.
●
Afficher un rapport RPTR en obtenant la source du rapport et en la transmettant au visualiseur.
●
Actualiser les données d'un rapport RPTR au moment de l'exécution.
●
Ouvrir un rapport RPTR et l'exporter sous d'autres formats que RPT.
Vous ne pouvez en revanche pas utiliser ce SDK pour exécuter les tâches suivantes :
●
Modifier la définition du rapport d'un rapport RPTR.
●
Définir l'emplacement de la source de données du rapport.
●
Extraire les informations relatives à la définition d'un rapport RPTR, notamment les formules, les champs, les
sections et les objets du rapport.
●
Exporter un rapport RPTR au format RPT.
●
Ajouter un rapport RPTR en tant que sous-rapport d'un rapport RPT.
1.5
1.5.1
Tutoriels
Tutoriels du modèle d'objet CrystalReportViewer
Les tutoriels présentés dans cette section utilisent des méthodes et des propriétés de la classe
CrystalReportViewer et les classes de l'espace de noms CrystalDecisions.Shared.
Les tutoriels présentés dans cette section utilisent des méthodes et des propriétés de la classe
CrystalReportViewer et les classes de l'espace de noms CrystalDecisions.Shared.
243
1.5.1.1
Tutoriel : Connexion à une base de données SQL
Server sécurisée
Dans ce tutoriel, vous allez apprendre à ajouter un code de connexion afin d'afficher un rapport contenant des
informations provenant d'une base de données SQL Server sécurisée.
Introduction
Lorsque vous utilisez le modèle d'objet CrystalReportViewer pour vous connecter à une base de données SQL
Server sécurisée, vous devez utiliser les classes de l'espace de noms CrystalDecisions.Shared.
Les propriétés de la classe ConnectionInfo permettent la connexion au serveur de base de données ou aux
sources de données ODBC. Dans ce tutoriel, vous allez définir les propriétés ServerName, DatabaseName, UserID
et Password. Si vous définissez uniquement les propriétés DatabaseName, UserID et Password, vous êtes
connecté au serveur par défaut de la base de données spécifiée dans le rapport. Toutefois, si vous affectez une
autre propriété ServerName, vous pouvez rediriger le rapport vers un serveur différent au moment de l'exécution.
Vous extrayez l'instance TableLogOnInfos de la propriété LogOnInfo du contrôle CrystalReportViewer. Vous
affectez ensuite l'instance ConnectionInfo à chaque objet TableLogOnInfo de l'instance TableLogOnInfos.
Le code de connexion de ce tutoriel s'applique également aux sous-rapports insérés dans le rapport principal.
Pour le modèle d'objet ReportDocument, vous devez modifier le code pour l'adapter aux sous-rapports (voir
Tutoriel : Connexion à une base de données SQL Server sécurisée avec un sous-rapport [page 382]).
Pour créer ce tutoriel à l'aide du modèle d'objet ReportDocument, voir Tutoriel : Connexion à une base de données
SQL Server sécurisée [page 244] utilisant le modèle d'objet ReportDocument. Il est recommandé d'utiliser le
modèle d'objet ReportDocument plutôt que le modèle d'objet CrystalReportViewer.
Exemple de code
Chaque tutoriel fournit des exemples de code Visual Basic et C# qui illustrent la version terminée du projet. Suivez
les instructions de ce tutoriel pour créer un projet ou ouvrez le projet d'exemple de code pour travailler à partir
d'une version terminée.
Les exemples de code sont stockés dans des dossiers classés par langue et par type de projet. Les noms des
dossiers de chaque version d'exemple de code sont les suivants :
●
Site Web C# : CS_Web_CRVObjMod_DBLogon
●
Projet Windows C# : CS_Win_CRVObjMod_DBLogon
●
Site Web Visual Basic : VB_Web_CRVObjMod_DBLogon
●
Projet Windows Visual Basic : VB_Win_CRVObjMod_DBLogon
244
Répertoire d'exemples de rapports [page 15]
1.5.1.1.1
Création d'un rapport connecté à une base de
données SQL Server sécurisée
Prérequis
●
Configuration de SQL Server :
○
Si vous disposez de SQL Server (ou de la version OEM, MSDE), il doit être configuré de manière à exiger
une authentification SQL Server.
○
Si vous ne disposez pas de SQL Server (ou de la version OEM, MSDE), vous devez installer MSDE en
attribuant à l'authentification SQL Server la valeur True.
●
La base de données Northwind fournie avec SQL Server doit être installée et vous devez vérifier que
l'authentification SQL Server est bien requise.
●
Vous devez créer un compte à accès limité qui sera utilisé au sein du site Web.
Contexte
Après avoir configuré SQL Server et la base de données Northwind conformément aux instructions des sections
ci-dessus, vous êtes prêt à créer un rapport dont les informations proviennent, de façon sécurisée, de la base de
données Northwind.
Remarque
configuration.
Procédure
1.
pointez sur Ajouter, puis cliquez sur Nouvel élément.
2.
Dans la boîte de dialogue Ajouter un nouvel élément, dans la vue Modèles, sélectionnez le modèle Rapport
Crystal.
3.
Dans le champ Nom, saisissez le nom "NorthwindCustomers.rpt", puis cliquez sur Ouvrir.
4.
Dans le panneau Créer un document de rapport Crystal de la boîte de dialogue Galerie de rapports Crystal,
sélectionnez en utilisant l' Assistant de création de rapports.
5.
Dans le panneau Choisir un expert, sélectionnez Standard, puis cliquez sur OK.
La fenêtre Assistant de création de rapports standard s'affiche.
245
6.
Dans le panneau Sources de données disponibles, développez le dossier Créer une nouvelle connexion.
7.
Dans le sous-dossier qui s'ouvre, développez le dossier OLE DB (ADO).
La fenêtre OLE DB (ADO) s'affiche.
8.
Sélectionnez Microsoft OLE DB Provider for SQL Server, puis cliquez sur Suivant.
9.
Saisissez les valeurs correspondant à votre serveur de base de données, l'ID utilisateur et le mot de passe
dans les champs Serveur, ID utilisateur et Mot de passe.
10. Dans la liste déroulante Base de données, sélectionnez "Northwind".
Laissez la case à cocher Sécurité intégrée désactivée, car vous utilisez l'authentification SQL Server au lieu de
11. Cliquez sur Terminer.
Le dossier OLE DB est maintenant développé, affichant votre serveur de base de données et, à l'intérieur de
celui-ci, la base de données Northwind.
12. Développez les nœuds Northwind, dbo et Tables, puis sélectionnez la table Customers.
13. Cliquez sur le bouton > pour déplacer la table dans le panneau Tables sélectionnées, puis cliquez sur Suivant.
14. Développez la table Customers, maintenez la touche Ctrl enfoncée et cliquez sur CompanyName,
ContactName et City.
15. Cliquez sur le bouton > pour déplacer ces champs dans le panneau Champs à afficher, puis cliquez sur
Suivant.
16. Dans le panneau Champs disponibles, sous Champs du rapport, sélectionnez Customer.City, cliquez sur le
bouton > pour déplacer le champ dans le panneau Regrouper par, puis cliquez sur Terminer.
Le rapport NorthwindCustomers est créé et chargé dans la fenêtre principale de Visual Studio.
1.5.1.1.2
Liaison du rapport sans code de connexion
Durant la procédure Configuration d'un projet [page 15], vous avez placé un contrôle CrystalReportViewer dans un
Web Form ou un Windows Form. Lors de l'étape précédente, vous avez ajouté un rapport NorthwindCustomers au
projet.
Dans cette section, vous allez lier le chemin d'accès au répertoire du rapport NorthwindCustomers au contrôle
CrystalReportViewer. Vous allez ensuite vérifier si le rapport s'affiche correctement lorsque le code de connexion
à la base de données n'a pas été défini.
1.5.1.1.2.1
Pour lier le chemin d'accès au répertoire du
rapport NorthwindCustomers au contrôle CrystalReportViewer.
Procédure
1.
2.
246
3.
Localisez la méthode ConfigureCrystalReports() (que vous avez créée dans la section Configuration
d'un projet [page 15]).
4.
Déclarez une variable chaîne, nommez-la reportPath et affectez-lui un chemin d'accès au rapport local au
moment de l'exécution. Ce chemin est déterminé différemment selon qu'il s'agit d'un site Web ou d'un projet
Windows :
○
Pour un site Web, transmettez le nom du fichier de rapport local sous forme de paramètre de type chaîne
dans la méthode Server.MapPath(). Ceci permet d'associer le rapport local au chemin d'accès du
répertoire de fichiers du disque dur au moment de l'exécution.
Dim reportPath As String = Server.MapPath("NorthwindCustomers.rpt")
string reportPath = Server.MapPath("NorthwindCustomers.rpt");
○
Pour un projet Windows, concaténez la propriété Application.StartupPath avec une barre oblique
inverse et le nom du fichier de rapport local. Ceci permet d'associer le rapport au même répertoire que
celui du fichier exécutable Windows.
Remarque
Au moment de la compilation, vous copierez le rapport dans le répertoire contenant le fichier
exécutable.
Dim reportPath As String = Application.StartupPath & "\" &
"NorthwindCustomers.rpt"
string reportPath = Application.StartupPath + "\\" + "NorthwindCustomers.rpt";
5.
Affectez le chemin d'accès au répertoire du fichier du rapport NorthwindCustomers à la propriété
ReportSource du contrôle CrystalReportViewer.
myCrystalReportViewer.ReportSource = reportPath
crystalReportViewer.ReportSource = reportPath;
1.5.1.1.2.2
Pour tester le chargement du rapport
NorthwindCustomers
Contexte
Vous êtes maintenant prêt à générer et exécuter votre projet. Dans la mesure où le code permettant de se
connecter à la base de données n'a pas encore été écrit, le chargement du rapport doit échouer.
247
Procédure
1.
2.
3.
Si vous utilisez un rapport non incorporé dans un projet Windows, recherchez l'exécutable Windows compilé
dans le sous-répertoire \bin\debug\, puis copiez le rapport dans ce sous-répertoire.
Remarque
Pour que le rapport non incorporé soit chargé par l'exécutable Windows au moment de l'exécution, le
rapport doit être stocké dans le même répertoire que l'exécutable Windows.
4.
Le rapport NorthwindCustomers ne s'affiche pas. Il s'affiche après que vous avez ajouté le code de connexion
à la base de données.
Remarque
Les résultats peuvent varier selon la version de SAP Crystal Reports utilisée. Par exemple, si vous utilisez
SAP Crystal Reports 10 ou une version ultérieure, vous êtes invité à saisir les informations de connexion à
la base de données pour le rapport. Si vous exécutez une version antérieure de SAP Crystal Reports, une
exception est renvoyée. Dans les deux cas, vous devez effectuer la procédure suivante pour créer une
application entièrement fonctionnelle.
5.
1.5.1.1.3
Ajout du code de connexion au rapport
Vous êtes maintenant prêt à ajouter le code de connexion à la classe code-behind. Vous commencez par créer
une méthode d'assistance privée nommée SetDBLogonForReport().
1.5.1.1.3.1
Pour créer et coder la méthode
SetDBLogonForReport()
Procédure
1.
Revenez à la classe code-behind de ce Web Form ou Windows Form.
2.
Dans la partie inférieure de la classe, créez une méthode privée nommée SetDBLogonForReport() avec la
variable ConnectionInfo dans la signature de la méthode.
Private Sub SetDBLogonForReport(ByVal myConnectionInfo As ConnectionInfo)
End Sub
248
private void SetDBLogonForReport(ConnectionInfo connectionInfo)
{
}
3.
Dans cette méthode, extrayez l'instance TableLogOnInfos de la propriété LogOnInfo de la classe
Remarque
TableLogOnInfos est une classe indexée contenant des instances de la classe TableLogOnInfo.
Dim myTableLogOnInfos As TableLogOnInfos = myCrystalReportViewer.LogOnInfo
TableLogOnInfos tableLogOnInfos = crystalReportViewer.LogOnInfo;
4.
Créez une boucle foreach qui effectue une boucle sur chaque instance TableLogOnInfode l'instance de
classe indexée TableLogOnInfos.
For Each myTableLogOnInfo As TableLogOnInfo In myTableLogOnInfos
Next
foreach(TableLogOnInfo tableLogOnInfo in tableLogOnInfos)
{
}
5.
Dans la boucle foreach, affectez à la propriété ConnectionInfo de TableLogOnInfo le paramètre
ConnectionInfo.
myTableLogOnInfo.ConnectionInfo = myConnectionInfo
tableLogOnInfo.ConnectionInfo = connectionInfo;
1.5.1.1.3.2
Pour modifier la méthode
ConfigureCrystalReports() selon le code de connexion à la base
de données
Contexte
Cette procédure a créé une méthode permettant de définir les informations de connexion à la base de données.
Toutefois, vous devez modifier la méthode ConfigureCrystalReports() pour désigner cette méthode afin que
le rapport sache qu'il dispose des informations de connexion à la base de données.
La modification de la méthode ConfigureCrystalReports() se déroule en deux étapes :
249
●
Configurer l'instance ConnectionInfo.
●
Appeler la méthode SetDBLogonForReport().
Procédure
1.
Dans la méthode ConfigureCrystalReports(), déclarez et instanciez la classe ConnectionInfo endessous du code qui lie le rapport au contrôle CrystalReportViewer.
Dim myConnectionInfo As ConnectionInfo = New ConnectionInfo()
2.
Sur la ligne suivante, appelez la méthode SetDBLogonForReport() en transmettant l'instance
ConnectionInfo.
SetDBLogonForReport(myConnectionInfo)
SetDBLogonForReport(connectionInfo);
3.
Définissez les propriétés DatabaseName, UserIDet Password de l'instance ConnectionInfo.
Remarque
Pour des raisons de sécurité, il est important que vous utilisiez un compte de base de données à accès
limité.
Dans votre propre code, remplacez l'exemple de mot de passe 1234 (indiqué ci-dessous) par votre propre
mot de passe.
myConnectionInfo.DatabaseName = "Northwind"
myConnectionInfo.UserID = "limitedPermissionAccount"
myConnectionInfo.Password = "1234"
connectionInfo.DatabaseName = "Northwind";
connectionInfo.UserID = "limitedPermissionAccount";
connectionInfo.Password = "1234";
250
1.5.1.1.3.3
NorthwindCustomers
Contexte
Vous êtes maintenant prêt à générer et exécuter votre projet. Le rapport doit se charger correctement, car vous
avez ajouté le code de connexion à la base de données.
Procédure
1.
2.
3.
Le rapport NorthwindCustomers s'affiche correctement.
4.
1.5.1.1.4
Ajout de la possibilité de modifier l'emplacement
de la base de données au moment de l'exécution
Dans cette section, vous allez apprendre à modifier l'emplacement de la base de données au moment de
l'exécution. Cette opération nécessite simplement une légère modification de l'instance ConnectionInfo.
Remarque
Dans ce tutoriel, vous allez changer le nom du serveur de base de données, et non le nom de la base de
données. Il est impossible de changer le nom de la base de données avec le contrôle CrystalReportViewer.
1.5.1.1.4.1
Pour modifier l'emplacement de la base de
données au moment de l'exécution
Procédure
1.
Dans la méthode ConfigureCrystalReports(), créez plusieurs sauts de ligne dans le code après la ligne
qui appelle la méthode SetDBLogonForReport().
2.
Dans les sauts de ligne, définissez la propriété ServerName de l'instance ConnectionInfo.
251
Remarque
Dans le code que vous écrivez, remplacez l'exemple de nom de serveur DevDatabaseServer (indiqué cidessous) par votre propre nom de serveur.
myConnectionInfo.ServerName = "DevDatabaseServer"
connectionInfo.ServerName = "DevDatabaseServer";
1.5.1.1.4.2
Pour vérifier si un autre serveur de base de
données peut être redéfini pour le rapport au moment de
l'exécution
Contexte
Vous êtes maintenant prêt à générer et exécuter votre projet. Le rapport devrait se rediriger vers l'autre serveur
de base de données au moment de l'exécution.
Procédure
1.
2.
3.
4.
1.5.1.2
Tutoriel : Lecture et définition des paramètres
discrets
paramètre discret.
Introduction
Un paramètre discret est une valeur unique alors qu'un paramètre de plage fait référence à une plage de valeurs.
Les éléments textuels (tels que les villes) sont généralement accessibles via des paramètres discrets. Les
252
éléments numériques (tels que les salaires des employés) sont généralement accessibles via des paramètres de
plage.
Dans ce tutoriel, vous allez définir une valeur de paramètre discret afin d'afficher un rapport sur les clients basé
sur un champ. Ce rapport affiche uniquement les clients vivant dans les villes sélectionnées dans une liste de
villes. Cette liste provient des valeurs par défaut du paramètre Ville. Les valeurs par défaut du paramètre Ville sont
encapsulées dans le rapport.
Créez tout d'abord un rapport sur les clients avec un paramètre de ville. Les données du rapport proviennent de
l'exemple de base de données fourni avec SAP Crystal Reports, version développeur pour Microsoft Visual Studio.
Lorsque vous instanciez le rapport dans le code, vous créez une instance ArrayList contenant des noms de ville
(Paris, Tokyo), puis transmettez cette instance à une méthode d'assistance qui définit ces noms de ville comme
les valeurs actuelles du paramètre Ville. Vous liez ensuite le rapport au contrôle CrystalReportViewer et seuls les
clients vivant à Paris ou à Tokyo sont affichés dans ce rapport.
Dans la partie suivante du tutoriel, vous allez effectuer les opérations suivantes :
●
Créer une méthode qui extrait toutes les valeurs par défaut et les renvoie dans une instance ArrayList.
●
Ajouter un contrôle ListBox au formulaire et le remplir avec les valeurs provenant de l'ArrayList.
●
Ajouter un contrôle Button pour réafficher le rapport en fonction des sélections ListBox.
Dans la dernière partie du tutoriel, vous coderez l'événement de clic pour extraire les éléments sélectionnés à
partir du contrôle ListBox et définir les valeurs actuelles du paramètre Ville. Le rapport est réaffiché, indiquant
uniquement les clients qui vivent dans les villes sélectionnées dans le contrôle ListBox.
Exemple de code
Ce tutoriel fournit des exemples de code Visual Basic et C# qui illustrent la version terminée du projet. Suivez les
instructions de ce tutoriel pour créer un projet ou ouvrez le projet d'exemple de code pour travailler à partir d'une
version terminée.
●
Site Web C# : CS_Web_CRVObjMod_Parameters
●
Projet Windows C# : CS_Win_CRVObjMod_Parameters
●
Site Web Visual Basic : VB_Web_CRVObjMod_Parameters
●
Projet Windows Visual Basic : VB_Win_CRVObjMod_Parameters
Base de données Xtreme
La base de données Xtreme est utilisée par certains tutoriels. Elle figure dans le package d'exemples de code qui
peut être téléchargé à l'adresse suivante : http://www.sdn.sap.com/irj/boc/sdklibrary
manuellement une connexion ODBC à la base de données.
. Vous devez créer
253
1.5.1.2.1
Création d'un rapport avec des paramètres
Commencez par créer un rapport à partir des informations de la base de données Xtreme.
1.5.1.2.1.1
Pour créer un rapport avec des paramètres
Procédure
1.
2.
Crystal.
3.
Dans le champ Nom, saisissez le nom CustomersByCity.rpt, puis cliquez sur Ajouter.
4.
5.
6.
Dans le panneau Sources de données disponibles de la fenêtre Assistant de création de rapports standard,
développez le dossier Créer une nouvelle connexion.
7.
Dans le sous-dossier qui s'ouvre, développez le dossier ODBC (RDO).
8.
Dans la fenêtre ODBC (RDO), sélectionnez l'entrée DSN ODBC correspondant à la base de données Xtreme,
puis cliquez sur Terminer.
9.
Développez le nœud Tables, cliquez deux fois sur la table Clients pour la déplacer dans le panneau Tables
sélectionnées, puis cliquez sur Suivant.
10. Développez la table Clients, puis utilisez la combinaison de touches CTRL-clic pour sélectionner les champs
Nom du client, Titre, Adresse 1, Nom du contact et Ville.
11. Cliquez sur le bouton > pour déplacer ces champs dans le panneau Champs à afficher, puis cliquez sur le
bouton Suivant.
12. Dans le panneau Champs disponibles, sous Champs du rapport, cliquez deux fois sur Clients.Ville pour
déplacer le champ dans le panneau Regrouper par, puis cliquez sur Terminer.
Le rapport CustomersByCity est créé et chargé dans la fenêtre principale de Visual Studio.
254
1.5.1.2.1.2
Pour ajouter un paramètre Ville
Contexte
Vous êtes maintenant prêt à ajouter un paramètre appelé Ville et à le remplir avec des valeurs par défaut.
L'Explorateur de champs doit être visible, car il permet d'accéder à plusieurs fonctions du rapport, notamment
aux paramètres. Pour rendre l'Explorateur de champs visible, dans le menu Crystal Reports, cliquez sur
Explorateur de champs.
Procédure
1.
Si l'Explorateur de champs n'est pas visible, cliquez sur Activer/Désactiver l'affichage du champ dans la barre
d'outils Crystal Reports.
Conseil
Vous pouvez également afficher l'Explorateur de champs en ouvrant le menu Crystal Reports, puis en
cliquant sur Explorateur de champs.
2.
Dans l'Explorateur de champs, cliquez avec le bouton droit de la souris sur Champs de paramètre, puis
sélectionnez Nouveau.
3.
Dans la boîte de dialogue Créer un champ de paramètre :
a) Attribuez à Nom la valeur Ville.
b) Attribuez à Type la valeur Chaîne. Attribuez à Texte de l'invite la valeur Sélectionnez une ou
plusieurs villes.
c) Attribuez à Champ de valeur la valeur Ville.
d) Cliquez sur Actions, puis sélectionnez Ajouter toutes les valeurs de la base de données. La liste complète
des villes apparaît dans le volet du milieu.
e) Dans le volet Options de valeur, attribuez à Texte de l'invite la valeur Sélectionnez une ou
plusieurs villes.
f)
Dans ce même volet, attribuez à Autoriser plusieurs valeurs la valeur True.
g) Attribuez à Autoriser les valeurs discrètes la valeur True.
4.
Cliquez sur OK pour fermer la boîte de dialogue Créer un champ de paramètre.
1.5.1.2.1.3
Pour connecter le paramètre Ville à la colonne
Ville de la base de données
Contexte
Vous venez de définir les valeurs par défaut de sorte qu'elles contiennent une liste importante de villes. Plus loin
dans ce tutoriel, vous accéderez par programmation à cette même liste de valeurs par défaut, via la propriété
ParameterFieldInfo de la classe CrystalReportViewer.
255
Vous devez maintenant utiliser l'Expert Sélection pour définir une formule permettant de connecter la colonne
Ville de la base de données au champ de paramètre Ville que vous venez de créer.
Procédure
1.
Dans la barre d'outils Crystal Reports, cliquez sur Expert Sélection.
2.
Dans la boîte de dialogue Choisir un champ, sous Champs du rapport, sélectionnez Clients.Ville, puis cliquez
sur OK.
3.
Dans la boîte de dialogue Select Expert, dans l'onglet Customer.City, choisissez "est égal à" dans la liste
déroulante.
4.
Dans la nouvelle liste déroulante qui s'affiche à droite, sélectionnez le premier élément de la liste, {?Ville}, puis
cliquez sur OK.
Remarque
Cette sélection, {?City}, correspond au paramètre Ville que vous avez créé précédemment.
5.
Dans le menu Fichier, sélectionnez Enregistrer tout.
Résultats
Vous êtes maintenant prêt à lier le rapport au contrôle CrystalReportViewer et à définir le paramètre Ville avec
deux valeurs d'origine, Paris et Tokyo.
1.5.1.2.2
Liaison du rapport
Lorsque vous avez sélectionné les instructions de la procédure Configuration d'un projet [page 15] en préparation
de ce tutoriel, vous avez placé un contrôle CrystalReportViewer sur le Web Form ou le Windows Form. Au cours
des étapes précédentes, vous avez ajouté un rapport CustomersByCity au projet.
Dans cette section, vous allez lier le chemin d'accès au répertoire du rapport CustomersByCity au contrôle
CrystalReportViewer. Vous allez ensuite vérifier si le rapport s'affiche correctement lorsque les valeurs
actuelles n'ont pas été définies pour ce paramètre.
256
1.5.1.2.2.1
rapport CustomersByCity au contrôle CrystalReportViewer.
Procédure
1.
2.
Form.
3.
4.
Windows :
○
Dim reportPath As String = Server.MapPath("CustomersByCity.rpt")
string reportPath = Server.MapPath("CustomersByCity.rpt");
○
Remarque
exécutable.
"CustomersByCity.rpt"
string reportPath = Application.StartupPath + "\\" + "CustomersByCity.rpt";
5.
Affectez le chemin d'accès au répertoire du fichier du rapport CustomersByCity à la propriété ReportSource
du contrôle CrystalReportViewer.
257
1.5.1.2.2.2
CustomersByCity
Contexte
Vous êtes maintenant prêt à générer et exécuter votre projet. Le chargement du rapport doit échouer, car le code
permettant de définir une valeur pour le champ de paramètre Ville n'a pas encore été écrit.
Procédure
1.
2.
3.
dans le sous-répertoire \bin\ [Visual Basic] ou \bin\debug\ [C#], puis copiez le rapport dans ce
sous-répertoire.
Remarque
4.
Le rapport CustomersByCity ne s'affiche pas. Il s'affiche après que vous avez ajouté une valeur au paramètre
Ville plus loin dans ce tutoriel.
Remarque
Les résultats peuvent varier selon la version de SAP Crystal Reports utilisée. Dans les versions plus
récentes, un formulaire s'affiche vous demandant de fournir des valeurs de paramètre pour ce rapport.
Dans les versions antérieures, une exception "Valeur actuelle du champ de paramètre introuvable" est
renvoyée. Dans les deux cas, vous devez ajouter du code supplémentaire pour créer une application
entièrement fonctionnelle.
5.
1.5.1.2.3
Définition manuelle des paramètres dans le code
Vous êtes maintenant prêt à créer deux valeurs ("Paris" et "Tokyo") dans le champ de paramètre Ville du rapport
CustomersByCity.
Cette opération nécessite un code qui peut être décomposé selon les processus suivants :
●
Une constante PARAMETER_FIELD_NAME est nécessaire pour contenir le champ de paramètre "Ville".
●
Le code permettant d'ajouter les valeurs actuelles au paramètre Ville étant utilisé dans différents
emplacements dans ce tutoriel, il est préférable de créer ce code en tant que méthode d'assistance distincte.
258
●
Dans la méthode ConfigureCrystalReports(), vous devez ajouter les paramètres "Paris" et "Tokyo" à
une instance ArrayList, puis transmettre le rapport et l'instance à la méthode d'assistance pour le traitement.
1.5.1.2.3.1
Pour créer une constante
PARAMETER_FIELD_NAME
Procédure
1.
2.
Au niveau de la classe, créez une constante chaîne, PARAMETER_FIELD_NAME, et attribuez-lui la valeur "Ville."
Private Const PARAMETER_FIELD_NAME As String = "City"
private const string PARAMETER_FIELD_NAME = "City";
1.5.1.2.3.2
Pour créer une méthode d'assistance permettant
d'ajouter les valeurs actuelles au paramètre dans le rapport
Contexte
Vous êtes maintenant prêt à créer la méthode d'assistance qui permet d'ajouter les valeurs actuelles au
paramètre dans le rapport.
Procédure
1.
2.
Au-dessus de la signature de classe, ajoutez une déclaration "Imports" [Visual Basic] ou "using"
[C#] au début de la classe de l'espace de noms System.Collections (si cet espace de noms n'a pas déjà été
déclaré).
Remarque
Cette déclaration est nécessaire pour accéder à la classe ArrayList.
Imports System.Collections
using System.Collections;
259
3.
Dans la partie inférieure de la classe, créez une méthode privée nommée
SetCurrentValuesForParameterField() avec deux variables dans la signature de la méthode :
ParameterFields et ArrayList.
Private Sub SetCurrentValuesForParameterField(ByVal myParameterFields As
ParameterFields, ByVal myArrayList As
ArrayList)
End Sub
private void SetCurrentValuesForParameterField(ParameterFields parameterFields,
ArrayList arrayList)
{
}
4.
Dans cette méthode, déclarez et instanciez la classeParameterValues en tant que variable
currentParameterValues.
Remarque
Pour que la classe ParameterValues soit accessible, vous devez avoir inclus une déclaration "Imports"
[Visual Basic] ou "using" [C#] dans la partie supérieure de la classe code-behind pour l'espace de
noms CrystalDecisions.Shared. (Vous avez ajouté cette déclaration dans la procédure Configuration d'un
projet [page 15].)
Dim currentParameterValues As ParameterValues = New ParameterValues()
ParameterValues currentParameterValues = new ParameterValues();
5.
Créez une boucle foreach pour extraire toutes les valeurs envoyées (comme type Object) de l'instance
ArrayList.
Remarque
Dans cette méthode, vous extrayez les valeurs d'ArrayList. Par la suite, vous écrirez du code permettant
d'ajouter des valeurs à l'ArrayList.
For Each submittedValue As Object In myArrayList
Next
foreach(object submittedValue in arrayList)
{
}
6.
Dans la boucle foreach, déclarez et instanciez la classe ParameterDiscreteValue.
Dim myParameterDiscreteValue As ParameterDiscreteValue = New
ParameterDiscreteValue()
260
ParameterDiscreteValue parameterDiscreteValue = new ParameterDiscreteValue();
7.
Dans la boucle foreach, convertissez la submittedValue en chaîne et transmettez-la à la propriété Value
de l'instance ParameterDiscreteValue.
myParameterDiscreteValue.Value = submittedValue.ToString()
parameterDiscreteValue.Value = submittedValue.ToString();
8.
Dans la boucle foreach, ajoutez l'instance ParameterDiscreteValue dans la classe indexée
L'écriture de code dans la boucle foreach est à présent terminée. Vous placez le code restant (à l'aide des
étapes suivantes) après la boucle foreach.
currentParameterValues.Add(myParameterDiscreteValue)
currentParameterValues.Add(parameterDiscreteValue);
9.
En dehors de la boucle foreach, extrayez l'instance ParameterField de la classe indexée
ParameterFields, qui se base sur l'entrée d'index de la constante PARAMETER_FIELD_NAME.
Dim myParameterField As ParameterField = myParameterFields(PARAMETER_FIELD_NAME)
ParameterField parameterField = parameterFields[PARAMETER_FIELD_NAME];
10. Transmettez l'instance currentParameterValues à la propriété CurrentValues de l'instance
ParameterField.
myParameterField.CurrentValues = currentParameterValues
parameterField.CurrentValues = currentParameterValues;
1.5.1.2.3.3
Pour appeler la méthode
SetCurrentValuesForParameterField () avant la liaison du
rapport au contrôle CrystalReportViewer
Contexte
Cette procédure a permis de créer une méthode qui extrait les valeurs envoyées d'une instance ArrayList et les
place comme valeurs actuelles dans une instance ParameterField. Vous devez maintenant appeler cette
261
méthode avant que votre rapport ne soit lié au contrôle CrystalReportViewer afin que le rapport sache qu'il
dispose de paramètres.
Procédure
1.
Dans la méthode ConfigureCrystalReports(), déclarez et instanciez une ArrayList au-dessus de la ligne
qui lie le rapport au contrôle CrystalReportViewer.
Dim myArrayList As ArrayList = New ArrayList()
ArrayList arrayList = new ArrayList();
2.
Ajoutez les noms de ville "Paris" et "Tokyo" comme chaînes à l'instance ArrayList.
myArrayList.Add("Paris")
myArrayList.Add("Tokyo")
arrayList.Add("Paris");
arrayList.Add("Tokyo");
3.
Sous le code qui lie le contrôle CrystalReportViewer, extrayez l'instance ParameterFields de la
propriété ParameterFieldInfo du contrôle CrystalReportViewer.
Dim myParameterFields As ParameterFields =
myCrystalReportViewer.ParameterFieldInfo
ParameterFields parameterFields = crystalReportViewer.ParameterFieldInfo;
4.
Appelez la méthode SetCurrentValuesForParameterField(), puis transmettez l'instance
ParameterFields et l'instance ArrayList.
SetCurrentValuesForParameterField(myParameterFields, myArrayList)
SetCurrentValuesForParameterField(parameterFields, arrayList);
262
1.5.1.2.3.4
CustomersByCity
Contexte
Vous êtes maintenant prêt à générer et exécuter votre projet. Le rapport doit s'afficher correctement, car le code
définissant les valeurs actuelles dans le champ de paramètre est désormais écrit.
Procédure
1.
2.
3.
4.
Résultats
Dans la section suivante, vous allez apprendre à extraire les valeurs par défaut du champ de paramètre et à définir
ces valeurs dans un contrôle ListBox. Ces valeurs seront utilisées à la fin du tutoriel pour sélectionner de façon
dynamique de nouvelles villes et filtrer le rapport en fonction des nouvelles villes sélectionnées.
1.5.1.2.4
Création d'un contrôle ListBox qui affiche les
paramètres par défaut
Le reste du tutoriel concerne l'affichage de la liste complète des valeurs par défaut du champ de paramètre dans
un contrôle ListBox et le refiltrage du contenu du rapport en fonction des sélections effectuées à partir du
contrôle ListBox.
Dans cette section, vous allez apprendre à remplir le contrôle ListBox à partir des valeurs par défaut du champ
de paramètre.
Remarque
N'oubliez pas que vous avez défini les valeurs par défaut, une liste importante de villes, lors de la création du
rapport au début de ce tutoriel.
Pour ce faire, vous devez ajouter et configurer un contrôle ListBox, puis créer une méthode d'assistance pour
remplir ce contrôle ListBox.
263
1.5.1.2.4.1
Pour créer et configurer un contrôle ListBox sur
le formulaire
Procédure
1.
2.
3.
Si vous développez un site Web, procédez comme suit :
a) Cliquez sur le contrôle CrystalReportViewer pour le sélectionner.
b) Appuyez sur la FLECHE GAUCHE du clavier afin de faire apparaître un curseur clignotant, puis appuyez
sur ENTREE.
4.
Si vous développez un projet Windows, procédez comme suit :
b) Dans la fenêtre Propriétés, attribuez à la propriété Dock la valeur "Bottom".
c) Redimensionnez le contrôle CrystalReportViewer pour laisser assez d'espace au-dessus afin d'ajouter un
contrôle ListBox.
d) Dans la fenêtre Propriétés, attribuez à la propriété Anchor la valeur "Top, Bottom, Left, Right".
5.
Dans la boîte à outils, faites glisser un contrôle ListBox au-dessus du contrôle CrystalReportViewer.
6.
Cliquez sur le contrôle ListBox pour le sélectionner.
7.
Dans la fenêtre Propriétés, procédez comme suit :
a) Attribuez à ID ou Name la valeur "defaultParameterValuesList".
b) Attribuez à SelectionMode la valeur "Multiple" (ou "MultiExtended" dans un projet Windows).
8.
1.5.1.2.4.2
Pour créer une méthode d'assistance qui extrait
les valeurs par défaut du champ de paramètre
Contexte
Vous êtes maintenant prêt à créer une méthode d'assistance qui extrait les valeurs par défaut du champ de
paramètre.
Procédure
1.
2.
264
3.
GetDefaultValuesFromParameterField() qui renvoie une instance ArrayList, en transmettant
ParameterFields dans la signature de la méthode.
Private Function GetDefaultValuesFromParameterField(ByVal
myParameterFields As ParameterFields) As ArrayList
End Function
private ArrayList
GetDefaultValuesFromParameterField(ParameterFields parameterFields)
{
}
4.
Extrayez l'instance ParameterField de la classe indexée ParameterFields, basée sur l'entrée d'index de
la constante PARAMETER_FIELD_NAME.
Dim myParameterField As ParameterField =
myParameterFields(PARAMETER_FIELD_NAME)
ParameterField parameterField =
parameterFields[PARAMETER_FIELD_NAME];
5.
Extrayez une classe indexée ParameterValues (en tant que variable defaultParameterValues) de la
propriété DefaultValues de l'instance ParameterField.
Dim defaultParameterValues As ParameterValues =
myParameterField.DefaultValues
ParameterValues defaultParameterValues =
parameterField.DefaultValues;
6.
Déclarez et instanciez une ArrayList.
7.
Créez une boucle foreach pour extraire chaque instance ParameterValue de la variable
defaultParameterValues.
Dans la boucle foreach, créez maintenant un bloc conditionnel imbriqué qui recherche des valeurs de
paramètre discret (par opposition aux valeurs de paramètre de plage). Il existe deux versions de ce bloc
conditionnel, car l'API a subi de légères modifications au cours de l'évolution des versions de
SAP Crystal Reports, version développeur pour Microsoft Visual Studio. Vérifiez votre API (à l'aide
d'IntelliSense) pour connaître la propriété disponible sous ParameterValue :
For Each myParameterValue As ParameterValue In
defaultParameterValues
265
Next
foreach(ParameterValue parameterValue in defaultParameterValues)
{
}
8.
Si la propriété disponible est IsRange, saisissez le code suivant dans la boucle foreach :
If (Not myParameterValue.IsRange) Then
End If
if(!parameterValue.IsRange)
{
}
9.
Ou, si la propriété disponible est Kind (DiscreteOrRangeKind, une énumération comportant trois valeurs :
DiscreteValue, RangeValue, DiscreteAndRangeValue), saisissez le code suivant dans la boucle
foreach :
If (myParameterValue.Kind = DiscreteOrRangeKind.DiscreteValue) Then
End If
if(parameterValue.Kind == DiscreteOrRangeKind.DiscreteValue)
{
}
10. Dans le bloc conditionnel imbriqué, effectuez un cast de l'instance ParameterValue en sa classe étendue
DiscreteParameterValue.
Dim myParameterDiscreteValue As ParameterDiscreteValue =
CType(myParameterValue, ParameterDiscreteValue)
ParameterDiscreteValue parameterDiscreteValue =
(ParameterDiscreteValue)parameterValue;
11. Dans le bloc conditionnel imbriqué, ajoutez la propriété Value de l'instance ParameterDiscreteValue
(convertie en chaîne) dans l'instance ArrayList.
myArrayList.Add(myParameterDiscreteValue.Value.ToString())
arrayList.Add(parameterDiscreteValue.Value.ToString());
12. En dehors du bloc conditionnel et de la boucle foreach, en fin de méthode, renvoyez l'instance ArrayList
depuis la méthode.
Return myArrayList
266
return arrayList;
1.5.1.2.4.3
Pour lier l'ArrayList renvoyée de la méthode au
contrôle ListBox dans un projet Web
Contexte
Vous avez extrait les valeurs par défaut du champ de paramètre et les avez renvoyées de la méthode sous la
forme d'une ArrayList. Vous allez maintenant lier cette ArrayList au contrôle ListBox
defaultParameterValuesList.
Le code varie légèrement selon que vous utilisez un projet Web ou un projet Windows ; en conséquence, vous ne
devez effectuer que l'une des procédures Web ou Windows ci-après.
Procédure
1.
Dans la méthode ConfigureCrystalReports(), créez plusieurs sauts de ligne dans le code,
immédiatement après la ligne de code qui extrait l'instance ParameterFields.
2.
Dans les sauts de ligne, créez un bloc conditionnel Not IsPostBack.
Remarque
Le bloc conditionnel Not IsPostBack est utilisé pour encapsuler du code devant être exécuté
uniquement lors du premier chargement de la page. Les contrôles sont généralement liés aux valeurs de
données dans des blocs conditionnels Not IsPostBack afin que leurs valeurs de données (et tout
événement de contrôle suivant) ne soient pas redéfinies lorsque les pages sont rechargées.
If Not IsPostBack Then
End If
if(!IsPostBack)
{
}
3.
Dans le bloc conditionnel Not IsPostBack, attribuez à la propriété DataSource du contrôle ListBox
defaultParameterValuesList la méthode d'assistance GetDefaultValuesFromParameterField(),
en transmettant l'instance ParameterFields en tant que paramètre de méthode.
defaultParameterValuesList.DataSource =
GetDefaultValuesFromParameterField(myParameterFields)
267
GetDefaultValuesFromParameterField(parameterFields);
4.
Toujours dans le bloc conditionnel Not IsPostBack, appelez la méthode DataBind() du contrôle ListBox
defaultParameterValuesList.DataBind()
defaultParameterValuesList.DataBind();
1.5.1.2.4.4
contrôle ListBox dans un projet Windows
Procédure
1.
Dans la méthode ConfigureCrystalReports(), créez plusieurs sauts de ligne dans le code,
immédiatement après la ligne de code qui extrait l'instance ParameterFields.
Dans ces sauts de ligne, vous pouvez à présent saisir un code supplémentaire définissant la source de
données du contrôle ListBox defaultParameterValuesList lors du premier chargement de la page.
2.
Dans les sauts de lignes, attribuez à la propriété DataSource du contrôle ListBox defaultParameterValuesList
la méthode d'assistance GetDefaultValuesFromParameterField(), en transmettant l'instance
ParameterFields en tant que paramètre de méthode.
1.5.1.2.4.5
Pour vérifier si le contrôle ListBox
defaultParameterValuesList est rempli
Contexte
Vous êtes maintenant prêt à créer et exécuter le projet pour vérifier si la zone de texte
defaultParameterValuesList est renseignée.
268
Procédure
1.
2.
3.
Le contrôle ListBox ListBox defaultParameterValuesList affiche la liste complète des valeurs par
défaut (dans ce tutoriel, il s'agit de villes).
4.
1.5.1.2.5
ListBox
Définition des paramètres à partir des sélections
Dans cette section, vous allez ajouter un bouton pour réafficher le rapport en fonction des sélections du contrôle
ListBox defaultParameterValuesList. Dans la méthode d'événement de ce bouton, vous appellerez la
même méthode que celle appelée lors du premier chargement de la page :
SetCurrentValuesForParameterField(). Mais cette fois, au lieu de transmettre des valeurs arbitraires
(Paris et Tokyo), vous transmettrez les valeurs sélectionnées depuis le contrôle ListBox
1.5.1.2.5.1
Pour créer et configurer un contrôle Button de
réaffichage sur le formulaire
Procédure
1.
2.
3.
Dans la boîte à outils, faites glisser un contrôle Button à droite du contrôle ListBox.
4.
Cliquez sur le contrôle Button pour le sélectionner.
5.
Dans la fenêtre Propriétés, procédez comme suit :
a) Attribuez à ID ou Name la valeur "redisplay".
b) Attribuez à Text la valeur "Réafficher le rapport".
269
1.5.1.2.5.2
Pour créer la méthode d'événement de clic du
contrôle Button de réaffichage dans un projet Web
Contexte
Vous êtes maintenant prêt à créer une méthode d'événement de clic qui recherche des éléments sélectionnés
dans le contrôle ListBox et les transmet à la méthode SetCurrentValuesForParameterField().
Le code varie légèrement pour un projet Web ou un projet Windows ; en conséquence, vous ne devez effectuer
que l'une des procédures Web ou Windows ci-après.
Procédure
1.
Cliquez deux fois sur le bouton Réafficher le rapport.
Cette opération affiche la classe code-behind dans laquelle une méthode d'événement redisplay_Click()
a été générée automatiquement.
2.
[C#] au début de la classe de l'espace de noms System.Web.UI.WebControls (si cet espace de noms n'a pas
déjà été déclaré).
Imports System.Web.UI.WebControls
using System.Web.UI.WebControls;
3.
Dans la méthode d'événement redisplay_Click() qui vient d'être automatiquement générée, déclarez et
instanciez une ArrayList.
4.
Créez une boucle foreach pour extraire chaque instance ListItem de la propriété Items du contrôle
ListBox defaultParameterValuesList.
For Each item As ListItem In defaultParameterValuesList.Items
Next
foreach(ListItem item in defaultParameterValuesList.Items)
{
}
270
5.
Dans la boucle foreach, créez un bloc conditionnel imbriqué qui vérifie si la propriété Selected de l'instance
actuelle Item a pour valeur True.
If item.Selected Then
End If
if(item.Selected)
{
}
6.
Dans le bloc conditionnel, ajoutez la propriété Value de l'instance Item à l'instance ArrayList.
myArrayList.Add(item.Value)
arrayList.Add(item.Value);
7.
En dehors du bloc conditionnel et de la boucle foreach, liez à nouveau le chemin d'accès au répertoire du
rapport CustomersByCity à la propriété ReportSource de la classe CrystalReportViewer.
Remarque
Le chemin d'accès au fichier indiqué ci-dessous s'applique à un projet Visual Studio. "NomProjet" est
remplacé par le nom de votre site Web. "NomUtilisateur" est remplacé par votre nom de connexion.
Le chemin par défaut d'un projet de site Web est le suivant :
myCrystalReportViewer.ReportSource = "C:\WebSites\NomProjet\CustomersByCity.rpt"
crystalReportViewer.ReportSource = "C:\\WebSites\\ NomProjet\
\CustomersByCity.rpt";
8.
Extrayez l'instance ParameterFields de la propriété ParameterFieldInfo du contrôle
ParameterFields parameterFields =
crystalReportViewer.ParameterFieldInfo;
9.
Transmettez l'instance ParameterFields et l'instance ArrayList à la méthode
SetCurrentValuesForParameterField().
271
1.5.1.2.5.3
contrôle Button de réaffichage dans un projet Windows
Procédure
1.
Cliquez deux fois sur le contrôle Button de réaffichage.
2.
3.
Créez une boucle foreach pour extraire chaque élément (sous forme de chaîne) de la propriété
SelectedItems du contrôle ListBox defaultParameterValuesList.
For Each item As String In defaultParameterValuesList.SelectedItems
Next
foreach(string item in defaultParameterValuesList.SelectedItems)
{
}
4.
Dans la boucle foreach, ajoutez l'instance chaîne item à l'instance ArrayList.
myArrayList.Add(item)
arrayList.Add(item);
5.
En dehors de la boucle foreach, liez à nouveau le chemin d'accès au répertoire du rapport CustomersByCity à
la propriété ReportSource de la classe CrystalReportViewer.
Remarque
Le chemin d'accès au fichier indiqué ci-dessous s'applique à un projet Visual Studio. "NomProjet" est
remplacé par le nom de votre projet Windows. "NomUtilisateur" est remplacé par votre nom de connexion.
Le chemin par défaut d'un projet Windows est le suivant :
myCrystalReportViewer.ReportSource = "C:\Documents and Settings\NomUtilisateur
\Mes Documents\Visual Studio\Projects\NomProjet\CustomersByCity.rpt"
272
crystalReportViewer.ReportSource = "C:\\Documents and Settings\\NomUtilisateur\
\Mes Documents\\Visual Studio\\Projects\\NomProjet\\CustomersByCity.rpt";
6.
Extrayez l'instance ParameterFields de la propriété ParameterFieldInfo du contrôle
ParameterFields parameterFields =
crystalReportViewer.ParameterFieldInfo;
7.
Transmettez l'instance ParameterFields et l'instance ArrayList à la méthode
1.5.1.2.5.4
Contexte
Les valeurs sélectionnées du contrôle ListBox ayant été appliquées comme valeurs actuelles du champ de
paramètre, vous êtes maintenant prêt à réafficher le rapport.
Vous êtes maintenant prêt à générer et exécuter le projet pour vérifier si le champ de paramètre a bien été
correctement redéfini.
Procédure
1.
2.
3.
4.
Dans le contrôle ListBox, cliquez sur des villes différentes dans la liste en maintenant la touche Ctrl enfoncée.
5.
Cliquez sur le bouton Réafficher le rapport.
La page est rechargée, affichant les enregistrements des clients qui vivent dans les villes sélectionnées dans
la liste.
6.
273
1.5.1.2.6
Configuration de la persistance des paramètres
Dans cette section, vous allez configurer la persistance (dans un tutoriel via le Web) des sélections des champs de
paramètre effectuées à partir du contrôle ListBox.
1.5.1.2.6.1
Pour ajouter un code de persistance à la méthode
Contexte
Vous devez ajouter un code de persistance à votre application afin que les modifications apportées soient rendues
persistantes lorsque les pages Web sont rechargées.
Pour commencer, vous allez ajouter un code de persistance à la méthode ConfigureCrystalReports() en
ajoutant un bloc Else au bloc conditionnel If Not IsPostBack. Vous allez ensuite définir des valeurs uniques
pour l'instance ArrayList pour l'une des deux conditions du bloc conditionnel. A l'ouverture de la page, vous
allez définir les valeurs par défaut ("Paris" et "Tokyo") dans l'instance ArrayList. Au rechargement de la page,
vous allez extraire l'instance ArrayList stockée dans Session.
Procédure
1.
Dans la méthode ConfigureCrystalReports(), coupez et collez au bas du bloc conditionnel Not
IsPostBack les deux lignes de code permettant d'ajouter Paris et Tokyo à l'instance ArrayList.
Lorsque vous avez terminé, le bloc conditionnel doit ressembler à ceci :
End If
if (!IsPostBack)
{
}
2.
274
Ajoutez une ligne de code finale au bloc conditionnel qui affecte l'instance ArrayList à Session.
Remarque
Vous pouvez utiliser le nom de variable comme identificateur de chaîne pour la Session ajoutée.
Session("myArrayList") = myArrayList
Session["arrayList"] = arrayList;
3.
Ajoutez une condition Else au bloc conditionnel Not IsPostBack.
4.
Dans le bloc Else, extrayez l'instance ArrayList de Session, puis effectuez un cast de celle-ci en instance
ArrayList.
myArrayList = Ctype(Session("myArrayList"), ArrayList)
arrayList = (ArrayList)Session["arrayList"];
Résultats
Else
End If
if (!IsPostBack)
{
}
else
{
}
Ces modifications apportées à la méthode ConfigureCrystalReports() permettent de garantir que l'instance
actuelle ArrayList est toujours disponible pour être transmise à la méthode
275
Dans la section suivante, vous allez apporter deux modifications au code dans l'événement de clic :
●
Sélectionner l'instance ArrayList créée et l'affecter à Session.
●
Remplacer les deux dernières lignes de code (qui configurent et affichent le rapport) par un appel à la
méthode ConfigureCrystalReports() afin d'exécuter cette fonctionnalité sur un bloc de code commun.
1.5.1.2.6.2
Pour modifier le code de la méthode d'événement
de clic selon la persistance Session
Procédure
1.
Supprimez les trois dernières lignes de code dans la méthode d'événement de clic.
○
La première ligne de code à supprimer représente le code qui lie le chemin d'accès au répertoire de
fichiers du rapport à la propriété ReportSource du contrôle CrystalReportViewer.
○
La deuxième ligne de code à supprimer représente le code qui extrait l'instance ParameterFields de la
propriété ParameterFieldInfo du contrôle CrystalReportViewer.
○
La troisième ligne de code à supprimer représente l'appel à la méthode
Dans l'étape suivante, vous allez ajouter deux nouvelles lignes de code pour remplacer le code supprimé.
2.
Dans la méthode d'événement de clic, immédiatement en dehors de la boucle foreach, ajoutez une ligne de
code qui affecte l'instance ArrayList à Session.
Remarque
3.
Appeler la méthode ConfigureCrystalReports().
Cette méthode extrait l'instance ArrayList, l'applique au rapport, puis lie le rapport au contrôle
276
1.5.1.2.6.3
Contexte
Procédure
1.
2.
3.
4.
Dans le contrôle ListBox, utilisez la combinaison de touches MAJ-clic pour sélectionner toutes les villes dans
la liste.
5.
Cliquez sur Réafficher le rapport.
La page se recharge et affiche les enregistrements clients de tous les clients dans toutes les villes. Il s'agit
d'un rapport volumineux contenant de nombreuses pages.
6.
Dans la barre d'outils CrystalReportViewer, cliquez sur Page suivante.
7.
La liste des villes sélectionnées est désormais rendue persistante. La page 2 du rapport s'affiche.
8.
1.5.1.3
Tutoriel : Lecture et définition des paramètres de
plage d'un sous-rapport
Dans ce tutoriel, vous allez traiter un problème supplémentaire : que faire si un rapport contient un sous-rapport
nécessitant des paramètres différents ?
Introduction
Dans le tutoriel précédent, Tutoriel : Lecture et définition des paramètres discrets [page 252], vous avez appris à
créer un rapport avec un paramètre discret et à créer un code permettant de définir ce paramètre au moment de
l'exécution, en utilisant chaque fois des valeurs de paramètres codées en dur et des valeurs de paramètres
transmises à partir d'un contrôle ListBox ou TextBox.
Dans ce tutoriel, vous allez apprendre à ajouter des paramètres de plage à un sous-rapport.
Vous devez apporter quatre modifications au projet que vous avez précédemment créé :
277
●
Vous ajoutez un sous-rapport au rapport d'origine.
Ce sous-rapport désigne la table Commandes de la base de données Xtreme. La table Commandes est liée à
la table Clients utilisée dans le tutoriel précédent par la clé externe ID client.
●
Vous ajoutez un paramètre de plage au sous-rapport qui effectue un filtrage selon une plage de dates de
commande.
●
Vous ajoutez deux contrôles Text au formulaire : orderStartDate et orderEndDate afin de définir la plage des
dates de commande au moment de l'exécution.
●
Vous modifiez la méthode SetCurrentValuesForParameter() que vous avez créée lors du tutoriel précédent.
Cette méthode crée une instance ParameterRangeValue contenant les valeurs startDate et endDate, puis
transmet cette instance ParameterRangeValue au paramètre de plage dans le sous-rapport.
Une fois le tutoriel terminé, vous pouvez filtrer les valeurs affichées dans le rapport au moment de l'exécution. Le
code que vous ajoutez limite le nombre de villes affichées dans le rapport principal ainsi que la plage de dates de
commande qui apparaîtront dans le sous-rapport.
Ce tutoriel peut également être effectué avec des classes du modèle d'objet ReportDocument ; voir Tutoriel :
Lecture et définition des paramètres avec un sous-rapport [page 418] utilisant le modèle d'objet
ReportDocument.
Exemple de code
version terminée.
●
Site Web C# : CS_Web_CRVObjMod_ParametersSubrpt
●
Projet Windows C# : CS_Win_CRVObjMod_ParametersSubrpt
●
Site Web Visual Basic : VB_Web_CRVObjMod_ParametersSubrpt
●
Projet Windows Visual Basic : VB_Win_CRVObjMod_ParametersSubrpt
1.5.1.3.1
Ajout d'un sous-rapport au rapport d'origine
Pour commencer, vous ajoutez un sous-rapport au rapport d'origine.
278
1.5.1.3.1.1
Pour ajouter un sous-rapport
Procédure
1.
Ouvrez le projet que vous avez créé dans le tutoriel précédent Tutoriel : Lecture et définition des paramètres
discrets [page 252].
2.
Dans l'Explorateur de solutions, cliquez deux fois sur le rapport CustomersByCity pour l'ouvrir.
3.
Cliquez avec le bouton droit de la souris sur la barre grise Détails et sélectionnez Insérer une section en
dessous.
4.
Cliquez avec le bouton droit de la souris sur la nouvelle section Détails b que vous avez créée, sélectionnez
Insérer, puis cliquez sur Sous-rapport.
Un carré gris encadre le curseur de la souris.
5.
Faites glisser le rectangle gris sur la nouvelle section Détails b, puis relâchez le bouton de la souris.
6.
Dans l'onglet Sous-rapport de la boîte de dialogue Insérer un sous-rapport, sélectionnez Créer un sous-rapport
à l'aide de l'Assistant de création de rapports.
Remarque
La boîte de dialogue Insérer un sous-rapport inclut d'autres options permettant de sélectionner un rapport
existant et des sous-rapports à la demande. Pour en savoir plus sur ces fonctionnalités, voir Onglet Sousrapport (boîte de dialogue Insérer un sous-rapport) [page 939].
7.
Dans le champ Nom du nouveau rapport, saisissez "CustomerOrders".
8.
Cliquez sur Assistant de création de rapports...
9.
10. Dans le sous-dossier qui s'ouvre, développez le dossier ODBC (RDO).
11. Dans la fenêtre ODBC (RDO), sélectionnez l'entrée DSN ODBC correspondant à la base de données Xtreme,
Le dossier ODBC (RDO) se développe pour afficher la base de données Xtreme.
12. Sélectionnez la table Commandes et cliquez sur le bouton > pour la déplacer dans le panneau Tables
13. Dans le panneau Champs disponibles, sélectionnez ID commande, Date de commande, Date d'expédition et
Transporteur.
Terminer.
15. Dans la boîte de dialogue Insérer un sous-rapport, sélectionnez l'onglet Mise en relation.
16. Dans la liste Champs disponibles du panneau Champs du rapport principal à mettre en relation, développez la
table Clients, sélectionnez ID client, puis cliquez sur le bouton >.
17. Dans le panneau Mise en relation du champ Clients.ID client qui s'affiche, laissez les sélections par défaut.
Ces sélections de paramètres et de données génèrent automatiquement une relation entre le rapport
principal et le sous-rapport.
18. Cliquez sur OK.
Le nouveau sous-rapport, CustomerOrders, s'affiche dans la section Détails b du rapport principal.
279
Remarque
Lorsque vous ajoutez un sous-rapport à la section Détails, le sous-rapport s'affiche pour chaque ligne, ce
qui influe sur les performances du rapport. Si vous ne souhaitez pas obtenir des informations aussi
détaillées, placez le sous-rapport dans une section Groupe plutôt qu'une section Détails.
1.5.1.3.1.2
Pour vérifier les paramètres du sous-rapport
Procédure
1.
Dans la section Détails du rapport, cliquez deux fois sur le sous-rapport CustomerOrders pour l'afficher.
Des boutons de navigation apparaissent au bas de la fenêtre du concepteur à la fois pour le rapport principal
et le sous-rapport CustomerOrders.
2.
Remarque
3.
Dans l'Explorateur de champs, développez Champs de paramètre.
4.
Vérifiez que le champ de paramètre Pm-Clients.ID Client a été automatiquement généré lorsque le
sous-rapport a été relié.
5.
6.
Dans la boîte de dialogue Expert Sélection, vérifiez que le critère Commandes.ID Client est égal à
{Pm-Clients.ID Client} est défini, puis cliquez sur OK.
7.
Résultats
Vous avez réussi à ajouter un sous-rapport CustomerOrders au rapport CustomersByCity.
280
1.5.1.3.1.3
Pour ajouter un paramètre OrderDateRange au
sous-rapport
Procédure
1.
Dans l'Explorateur de champs, cliquez avec le bouton droit de la souris sur Champs de paramètre et
2.
a) Attribuez à Nom la valeur "OrderDateRange".
b) Attribuez à Texte de l'invite la valeur "Spécifiez une plage de dates des commandes à afficher".
c) Attribuez à Type de valeur la valeur "Date".
d) Attribuez au paramètre Options une seule sélection, "Valeur(s) de plage".
3.
Cliquez sur OK.
4.
5.
Cliquez sur l'onglet Nouveau.
6.
Dans la boîte de dialogue Choisir un champ, développez la table Commandes, sélectionnez Date de
commande, puis cliquez sur OK.
7.
Dans le nouvel onglet Commandes.date de commande, sélectionnez formule dans la liste déroulante des
critères : {Commandes.date de commande} in {?OrderDateRange}
8.
Cliquez sur OK.
9.
Vous avez réussi à ajouter un paramètre OrderDateRange au sous-rapport et à l'associer à la colonne
Commandes.Date de commande. Dans la section suivante, vous allez ajouter un code afin de désigner le
paramètre OrderDateRange dans le sous-rapport.
1.5.1.3.2
Ajout du code de paramètre au sous-rapport
Contexte
Vous allez à présent ajouter le code de paramètre du sous-rapport à la classe code-behind. Vous commencez par
créer une méthode d'assistance privée SetDateRangeForOrders().
Procédure
1.
2.
281
3.
Au début de la classe, ajoutez deux nouvelles constantes sous la constante PARAMETER_FIELD_NAME
existante définie dans le tutoriel précédent.
Private Const SUBREPORT_PARAMETER_FIELD_NAME As String =
"OrderDateRange"
Private Const SUBREPORT_NAME As String = "CustomerOrders"
private const string SUBREPORT_PARAMETER_FIELD_NAME =
"OrderDateRange";
private const string SUBREPORT_NAME = "CustomerOrders";
4.
Dans la partie inférieure de la classe, créez une méthode privée nommée SetDateRangeForOrders() avec
les trois paramètres suivants : ParameterFields, une chaîne startDate et une chaîne endDate.
Private Sub SetDateRangeForOrders(ByVal myParameterFields As
ParameterFields, ByVal startDate As String, ByVal endDate As
String)
End Sub
private void SetDateRangeForOrders(ParameterFields parameterFields,
string startDate, string endDate)
{
}
5.
Dans cette méthode, déclarez et instanciez la classe ParameterRangeValue.
Remarque
Pour que la classe ParameterRangeValue soit accessible, vous devez inclure une instruction "Imports"
noms CrystalDecisions.Shared. (Vous avez ajouté cette déclaration dans la procédure Configuration
d'un projet [page 15].)
Dim myParameterRangeValue As ParameterRangeValue = New
ParameterRangeValue()
ParameterRangeValue parameterRangeValue = new
ParameterRangeValue();
6.
Attribuez à la propriété StartValue de l'instance ParameterRangeValue le paramètre de méthode
startDate.
Remarque
Les propriétés StartValue et EndValue de la classe ParameterRangeValue acceptent les valeurs de
type Object. Ce type générique permet de transmettre la valeur de plage sous plusieurs formes, y compris
texte, nombre, date, devise ou heure.
myParameterRangeValue.StartValue = startDate
282
parameterRangeValue.StartValue = startDate;
7.
Attribuez à la propriété EndValue de l'instance ParameterRangeValue le paramètre de méthode endDate.
myParameterRangeValue.EndValue = endDate
parameterRangeValue.EndValue = endDate;
8.
Définissez les limites inférieures et supérieures afin de les inclure.
Remarque
Pour le paramètre BoundInclusive, les valeurs de plage supérieures et inférieures sont incluses dans la
plage.
myParameterRangeValue.LowerBoundType =
myParameterRangeValue.UpperBoundType =
parameterRangeValue.LowerBoundType = RangeBoundType.BoundInclusive;
parameterRangeValue.UpperBoundType = RangeBoundType.BoundInclusive;
Vous allez à présent affecter l'instance ParameterRangeValue au paramètre du sous-rapport.
9.
Extrayez l'instance ParameterField de la classe indexée ParameterFields, basée sur les deux valeurs
indexées suivantes : le nom du champ de paramètre du sous-rapport et le nom du sous-rapport. Transmettez
les deux valeurs de constante que vous avez déclarées au début de la classe.
myParameterFields(SUBREPORT_PARAMETER_FIELD_NAME, SUBREPORT_NAME)
ParameterField parameterField =
parameterFields[SUBREPORT_PARAMETER_FIELD_NAME, SUBREPORT_NAME];
10. Appelez la méthode Clear() de la propriété CurrentValues de l'instance ParameterField afin de supprimer
les éventuelles valeurs existantes de la propriété CurrentValues.
myParameterField.CurrentValues.Clear()
11. Ajoutez l'instance ParameterRangeValue que vous venez de créer à la propriété CurrentValues de
l'instance ParameterField.
myParameterField.CurrentValues.Add(myParameterRangeValue)
283
parameterField.CurrentValues.Add(parameterRangeValue);
Résultats
Cette procédure a défini des valeurs de date de début et de fin dans une instance ParameterRangeValue et les a
transmises au paramètre OrderDateRange du sous-rapport CustomerOrders.
1.5.1.3.3
Ajout de contrôles TextBox pour contenir les
valeurs de paramètres de plage
Dans cette section, vous allez ajouter deux contrôles TextBox pour transmettre au paramètre de plage
OrderDateRange des valeurs de date de début et de date de fin au moment de l'exécution dans le sous-rapport
CustomerOrders.
Remarque
Si vous implémentez ce tutoriel dans un site Web, la persistance des valeurs de date que les utilisateurs
saisissent dans les zones de texte est conservée par ViewState.
1.5.1.3.3.1
Procédure
1.
2.
3.
a) Cliquez entre le contrôle ListBox et le contrôle Button.
b) Appuyez trois fois sur ENTREE pour insérer deux lignes entre le contrôle ListBox et le contrôle Button.
c) Sur la première ligne créée sous le contrôle ListBox, saisissez Date de début de la commande.
d) Sur la seconde ligne créée sous le contrôle ListBox, saisissez Date de fin de la commande.
4.
a) Dans la boîte à outils, faites glisser deux contrôles Label à droite du contrôle ListBox. Placez une
étiquette sur l'autre, en positionnant les deux étiquettes au-dessus du contrôle Button.
b) Sélectionnez le premier contrôle Label, puis attribuez à la propriété Text la valeur Date de début de
la commande dans la fenêtre Propriétés.
c) Sélectionnez le second contrôle Label, puis attribuez à la propriété Text la valeur Date de fin de la
commande dans la fenêtre Propriétés.
284
5.
Dans la boîte à outils, faites glisser un contrôle à droite de "Date de début de la commande."
6.
Cliquez sur le contrôle TextBox pour le sélectionner.
7.
Dans la fenêtre Propriétés, attribuez à ID (ou Name) la valeur orderStartDate.
8.
Dans la boîte à outils, faites glisser un contrôle TextBox à droite de "Date de fin de la commande."
9.
10. Dans la fenêtre Propriétés, attribuez à ID (ou Name) la valeur orderEndDate.
11. Dans le menu Fichier, sélectionnez Enregistrer tout.
1.5.1.3.4
Modification des méthodes d'appel du sous-rapport
Vous devez à présent modifier la méthode ConfigureCrystalReports() et la méthode d'événement
redisplay_Click() pour recevoir des informations de ces contrôles TextBox, les appliquer à la méthode
SetDateRangeForOrders() et traiter les informations de paramètre pour les sous-rapports.
Dans le tutoriel précédent, Tutoriel : Lecture et définition des paramètres discrets [page 252], vous avez conçu ces
méthodes de deux façons différentes si vous avez inclus la persistance Session.
Remarque
Les projets Windows ne nécessitent aucune persistance Session. Les sites Web nécessitent généralement la
persistance Session.
Choisissez l'une des deux (mais pas les deux) procédures ci-dessous. Modifiez les méthodes qui excluent la
persistance Session ou les méthodes qui incluent la persistance Session :
1.5.1.3.4.1
Modification des méthodes qui excluent la
persistance Session
Si vous avez créé le tutoriel précédent Tutoriel : Lecture et définition des paramètres discrets [page 252] et exclu
la persistance Session, effectuez les procédures suivantes. Sinon, effectuez la procédure Modification des
méthodes qui incluent la persistance Session [page 287].
1.5.1.3.4.1.1
ConfigureCrystalReports() excluant la persistance Session
Procédure
1.
Dans la méthode ConfigureCrystalReports(), créez plusieurs sauts de ligne dans le code après les lignes
qui affectent "Paris" et "Tokyo" comme variables ArrayList.
285
2.
Dans les sauts de ligne, déclarez et définissez des valeurs en code dur pour les deux variables chaîne,
startDate et endDate.
Dim startDate As String = "1/8/1997"
Dim endDate As String = "31/8/1997"
string startDate = "1/8/1997";
string endDate = "31/8/1997";
3.
Sous le code qui appelle la méthode SetCurrentValuesForParameterField(), appelez la méthode
SetDateRangeForOrders() et transmettez l'instance ParameterFields et les variables startDate et
endDate.
SetDateRangeForOrders(myParameterFields, startDate, endDate)
SetDateRangeForOrders(parameterFields, startDate, endDate);
4.
1.5.1.3.4.1.2
Pour modifier la méthode redisplay_Click()
excluant la persistance Session
Procédure
1.
Dans la méthode d'événement redisplay_Click(), créez plusieurs sauts de ligne dans le code au-dessus
de la ligne qui lie le rapport au contrôle CrystalReportViewer.
2.
Dans les sauts de ligne, déclarez et définissez les valeurs des deux variables chaîne startDate et endDate à
partir des contrôles TextBox que vous avez ajoutés au Web Form ou Windows Form.
Dim startDate As String = orderStartDate.Text
Dim endDate As String = orderEndDate.Text
string startDate = orderStartDate.Text;
string endDate = orderEndDate.Text;
3.
endDate.
286
4.
1.5.1.3.4.2
Modification des méthodes qui incluent la
persistance Session
Si vous avez créé le tutoriel précédent Tutoriel : Lecture et définition des paramètres discrets [page 252] et inclus
méthodes qui excluent la persistance Session [page 285].
1.5.1.3.4.2.1
ConfigureCrystalReports() incluant la persistance Session
Procédure
1.
qui déclare et instancie ArrayList.
2.
Dans les sauts de ligne, déclarez deux variables chaîne, startDate et endDate.
Dim startDate As String
Dim endDate As String
string startDate;
string endDate;
3.
Dans le bloc conditionnel Not IsPostBack, saisissez des valeurs par défaut pour les variables startDate et
endDate.
startDate = "1/8/1997"
endDate = "31/8/1997"
startDate = "1/8/1997";
endDate = "31/8/1997";
4.
Dans le bloc conditionnel Not IsPostBack, affectez les variables startDate et endDate à Session.
Session("startDate") = startDate
Session("endDate") = endDate
Session["startDate"] = startDate;
Session["endDate"] = endDate;
287
5.
Dans le bloc Else, après l'extraction de l'instance ArrayList de Session, extrayez les variables startDate et
endDate de Session.
startDate = Session("startDate").ToString()
endDate = Session("endDate").ToString()
startDate = Session["startDate"].ToString();
endDate = Session["endDate"].ToString();
Cette approche permet d'atteindre la fin du bloc avec les variables de date affectées dans les deux cas. Cette
méthode suit la logique parallèle de l'affectation de la variable ArrayList que vous avez configurée dans le
tutoriel précédent.
6.
endDate.
7.
1.5.1.3.4.2.2
incluant la persistance Session
Contexte
Modifiez à présent la méthode d'événement redisplay_Click.
Procédure
1.
Dans la méthode d'événement redisplay_Click(), créez plusieurs sauts de ligne dans le code après la
ligne qui affecte l'instance ArrayList à Session.
2.
Dans les sauts de ligne, affectez la propriété Text des contrôles TextBox orderStartDate et orderEndDate aux
variables Session.
Session("startDate") = orderStartDate.Text
Session("endDate") = orderEndDate.Text
Session["startDate"] = orderStartDate.Text;
Session["endDate"] = orderEndDate.Text;
288
3.
Résultats
Ces valeurs Session startDate et endDate sont à présent extraites et appliquées lors de l'appel de la méthode
Vous êtes maintenant prêt à générer et exécuter le projet pour vérifier que les valeurs TextBox redéfinissent le
paramètre de plage dans le sous-rapport.
1.5.1.3.5
Vérification du paramètre du sous-rapport
Contexte
Vous allez à présent vérifier le paramètre du sous-rapport à partir des valeurs TextBox.
Procédure
1.
2.
3.
4.
Dans le contrôle ListBox, cliquez sur au moins quatre villes différentes dans la liste en maintenant la touche
Ctrl enfoncée.
5.
Dans le contrôle TextBox orderStartDate, saisissez 1/1/1997.
6.
Dans le contrôle TextBox orderEndDate, saisissez 8/31/1997.
7.
La page se recharge et affiche les enregistrements des clients qui vivent dans les villes que vous venez de
sélectionner dans la liste, ainsi qu'un sous-rapport indiquant les commandes correspondant à la plage de
dates spécifiées ci-dessus.
8.
Dans le contrôle CrystalReportViewer, augmentez le facteur de zoom à 125 %.
La page se recharge avec un facteur de zoom de 125 %. Les valeurs sélectionnées à la fois pour les villes et la
plage des dates de commande sont rendues persistantes.
9.
289
1.5.1.4
Tutoriel : Filtrage des données à l'aide des formules
de sélection
Dans ce tutoriel, vous allez apprendre à utiliser des formules de sélection afin de filtrer les enregistrements à
afficher dans un rapport Crystal.
Introduction
Les formules de sélection servent à filtrer les enregistrements à afficher dans un rapport Crystal. Pour écrire des
formules de sélection, vous pouvez utiliser la syntaxe Basic et la syntaxe Crystal.
Dans ce tutoriel, vous allez créer une formule de sélection afin de filtrer les enregistrements clients dans lesquels
le champ Ventes de l'année dernière est supérieur à une valeur spécifique et le champ Nom du client est comparé
à une autre chaîne. Un contrôle ListBox sert à sélectionner un opérateur de comparaison pour le champ Nom du
client. Vous pouvez choisir d'afficher les noms de client qui sont égaux, inférieurs, supérieurs, inférieurs ou égaux,
supérieurs ou égaux, ou pas égaux à la valeur de chaîne que vous avez spécifiée.
La formule est transmise sous forme de variable chaîne à la propriété SelectionFormula de la classe
CrystalReportViewer. Une fois la propriété définie, le rapport Crystal lié au contrôle CrystalReportViewer est filtré
avant d'être affiché.
Exemple de code
version terminée.
●
Site Web C# : CS_Web_CRVObjMod_FilteringData
●
Projet Windows C# : CS_Win_CRVObjMod_FilteringData
●
Site Web Visual Basic : VB_Web_CRVObjMod_FilteringData
●
Projet Windows Visual Basic : VB_Win_CRVObjMod_FilteringData
Formules - Référence [page 786]
290
1.5.1.4.1
sélection
Création d'un rapport avec une formule de
Dans cette section, vous créez un rapport à partir des informations de la base de données Xtreme.
1.5.1.4.1.1
Pour créer un rapport avec des données
sécurisées de la base de données Xtreme
Procédure
1.
2.
Crystal.
3.
Dans le champ Nom, saisissez le nom CustomersBySalesName.rpt, puis cliquez sur Ajouter.
4.
5.
6.
7.
8.
Dans la fenêtre ODBC (RDO), sélectionnez l'entrée DSN ODBC correspondant à l'exemple de base de données
Xtreme, puis cliquez sur Terminer.
9.
Développez le nœud Tables, cliquez deux fois sur la table Clients pour la déplacer dans le panneau Tables
10. Développez la table Clients, puis utilisez la combinaison de touches Ctrl-clic pour sélectionner les champs
Nom du client et Ventes de l'année dernière.
Suivant.
12. Dans le panneau Champs disponibles, sous Champs du rapport, cliquez deux fois sur Clients.Noms du client
pour déplacer le champ dans le panneau Regrouper par, puis cliquez sur Terminer.
Le rapport CustomersBySalesName est créé et chargé dans la fenêtre principale de Visual Studio.
291
1.5.1.4.1.2
Pour créer une formule de sélection en fonction
du champ Ventes de l'année dernière
Contexte
Vous allez ensuite créer une formule de sélection pour filtrer les données en fonction du champ Ventes de l'année
dernière.
Procédure
1.
2.
Form.
3.
Pour un site Web, dans la méthode ConfigureCrystalReports() (que vous avez créée dans la section
Configuration d'un projet [page 15]), créez un bloc conditionnel Not IsPostBack.
Remarque
Le bloc conditionnel Not IsPostBack encapsule du code devant être exécuté uniquement lors du premier
chargement de la page.
End If
if(!IsPostBack)
{
}
4.
Pour un site Web, ajoutez les lignes de code suivantes dans le bloc conditionnel Not IsPostBack. Pour un
projet Windows, ajoutez le code à la méthode ConfigureCrystalReports(), sans le bloc conditionnel Not
IsPostBack.
a) Saisissez la formule afin de sélectionner uniquement les enregistrements Ventes de l'année dernière
supérieurs à 11 000 $ et les clients dont le nom commence par la lettre "A".
Dim mySelectFormula As String = "{Customer.Last Year's Sales} >
11000.00 " _
& "AND Mid({Customer.Customer Name}, 1, 1) = ""A"" "
string selectFormula = "{Customer.Last Year's Sales} > 11000.00
"
+ "AND Mid({Customer.Customer Name}, 1, 1) = \"A\"";
292
b) Affectez la chaîne de formule de sélection à la propriété SelectionFormula du contrôle
myCrystalReportViewer.SelectionFormula = mySelectFormula
crystalReportViewer.SelectionFormula = selectFormula;
1.5.1.4.2
Liaison du rapport
Lorsque vous avez suivi les instructions de la procédure Configuration d'un projet [page 15] en préparation de ce
tutoriel, vous avez placé un contrôle CrystalReportViewer sur le Web Form ou le Windows Form. Aux étapes
précédentes, vous avez ajouté un rapport CustomersBySalesName et une formule de sélection au projet.
Dans cette section, vous allez lier le chemin d'accès au répertoire du rapport CustomersBySalesName au
contrôle CrystalReportViewer. Vous allez ensuite vérifier si le rapport s'affiche correctement avec les rapports
filtrés selon la formule de sélection.
1.5.1.4.2.1
rapport CustomersBySalesName au contrôle
Procédure
1.
2.
Form.
3.
4.
Windows :
○
Dim reportPath As String =
Server.MapPath("CustomersBySalesName.rpt")
string reportPath = Server.MapPath("CustomersBySalesName.rpt");
293
○
Remarque
exécutable.
"CustomersBySalesName.rpt"
string reportPath = Application.StartupPath + "\\" +
"CustomersBySalesName.rpt";
5.
Affectez le chemin d'accès au répertoire du fichier du rapport NorthwindCustomers à la propriété
1.5.1.4.2.2
Pour vérifier la formule de sélection du rapport
CustomersBySalesName
Procédure
1.
Dans le menu Générer, cliquez sur Générer la solution.
2.
3.
sous-répertoire.
Remarque
4.
Le rapport Crystal affiche quatre enregistrements clients : Alley Cat Cycles, Ankara Bicycle Company,
Arsenault et Maurier ainsi que Athens Bicycle Co.
5.
294
1.5.1.4.3
Ajout de contrôles dans la formule de sélection
Contexte
Dans cette section, vous allez ajouter des contrôles pour modifier de façon dynamique les valeurs utilisées dans la
formule de sélection. Pour le champ Ventes de l'année dernière, vous ajoutez une zone de texte pour spécifier la
valeur minimale des ventes à afficher dans le rapport Crystal. Pour le champ Nom du client, vous ajoutez des
contrôles DropDownList et TextBox pour spécifier les noms de client à afficher.
Procédure
1.
2.
3.
trois fois sur ENTREE.
Le contrôle CrystalReportViewer descend de trois lignes.
4.
c) Redimensionnez le contrôle CrystalReportViewer afin d'afficher environ trois lignes au-dessus.
5.
Si vous développez un site Web, saisissez dans la première ligne Saisissez la valeur minimale des
ventes de l'année dernière : $.
6.
a) Dans la Boîte à outils, faites glisser un contrôle Label en haut du formulaire.
b) Dans la fenêtre Propriétés, attribuez à la propriété Text la valeur Saisissez la valeur minimale
des ventes de l'année dernière : $.
7.
Dans la Boîte à outils, faites glisser un contrôle TextBox à droite du texte.
8.
Sélectionnez le contrôle TextBox, puis effectuez les opérations suivantes dans la fenêtre Propriétés :
a) Attribuez à ID (ou Name) la valeur lastYearsSales.
b) Attribuez à Text la valeur 11000.00.
9.
Si vous développez un site Web, saisissez dans la deuxième ligne Afficher les noms des clients.
10. Si vous développez un projet Windows, procédez comme suit :
a) Dans la Boîte à outils, faites glisser un contrôle Label sur la deuxième ligne du formulaire.
b) Dans la fenêtre Propriétés, attribuez à la propriété Text la valeur "Afficher les noms des clients".
11. Dans la Boîte à outils, faites glisser un contrôle DropDownList (ComboBox dans un projet Windows) à droite
du texte.
12. Sélectionnez le contrôle DropDownList (ComboBox), puis attribuez à ID (ou Name) la valeur
"selectOperatorList" dans la fenêtre Propriétés.
295
13. Dans la Boîte à outils, faites glisser un contrôle TextBox à droite du contrôle DropDownList.
14. Sélectionnez le contrôle TextBox, puis effectuez les opérations suivantes dans la fenêtre Propriétés :
a) Attribuez à ID (ou Name) la valeur customerName.
b) Attribuez à Text la valeur A.
15. Dans la Boîte à outils, faites glisser un contrôle Button sur la troisième ligne du formulaire et au-dessus du
16. Sélectionnez le contrôle Button, puis effectuez les opérations suivantes dans la fenêtre Propriétés :
a) Attribuez à ID (ou Name) la valeur redisplay.
b) Attribuez à Text la valeur Réafficher le rapport.
1.5.1.4.4
le code
Définition manuelle de la formule de sélection dans
Vous allez à présent ajouter un code pour modifier la formule de sélection dans la classe code-behind.
1.5.1.4.4.1
Pour coder la formule de sélection
Procédure
1.
2.
Dans le menu Affichage, sélectionnez Concepteur.
3.
Cliquez deux fois sur Réafficher le rapport.
La classe code-behind du rapport s'affiche et indique qu'une méthode d'événement redisplay_Click() a
été automatiquement générée.
4.
Pour la formule de sélection, créez une variable chaîne dont les valeurs proviennent des contrôles TextBox.
La formule de sélection est similaire au texte que vous avez saisi dans la méthode
ConfigureCrystalReports(). Au lieu de spécifier une valeur minimale de ventes de 11 000 $, vous utilisez
la valeur provenant du contrôle TextBox lastYearsSales. Pour le champ Nom du client, vous utilisez la
valeur provenant du contrôle TextBox customerName.
" & lastYearsSales.Text _
& " AND Mid({Customer.Customer Name}, 1, 1) > """ &
customerName.Text & """"
string selectFormula = "{Customer.Last Year's Sales} > " +
lastYearsSales.Text
+ " AND Mid({Customer.Customer Name}, 1, 1) > \"" +
customerName.Text + "\"";
296
5.
Affectez la variable chaîne à la propriété SelectionFormula du contrôle CrystalReportViewer.
myCrystalReportViewer.SelectionFormula = mySelectFormula
crystalReportViewer.SelectionFormula = selectFormula;
6.
Liez à nouveau le rapport CustomerBySalesName à la propriété ReportSource du contrôle
Remarque
Le chemin d'accès au fichier indiqué ici s'applique à un projet Visual Studio. NomProjet est remplacé par le
nom de votre projet Web ou Windows. NomUtilisateur est remplacé par votre nom de connexion.
○
Le chemin par défaut d'un projet de site Web est le suivant :
myCrystalReportViewer.ReportSource = "C:\WebSites\ NomProjet
\CustomersBySalesName.rpt"
crystalReportViewer.ReportSource = "C:\\WebSites\\ NomProjet\
\CustomersBySalesName.rpt";
○
Le chemin par défaut d'un projet de site Windows est le suivant :
myCrystalReportViewer.ReportSource = "C:\Documents and Settings\
NomUtilisateur\Mes documents\Visual Studio\Projects\ NomProjet
\CustomersBySalesName.rpt"
crystalReportViewer.ReportSource = "C:\\Documents and Settings\\
NomUtilisateur\\Mes documents\\Visual Studio\\Projects\\ NomProjet\
\CustomersBySalesName.rpt";
Résultats
Vous venez de créer une formule de sélection que vous pouvez modifier au moment de l'exécution.
1.5.1.4.4.2
Pour vérifier la formule de sélection
Procédure
1.
2.
297
3.
4.
Dans le contrôle TextBox lastYearsSales, saisissez200000.
5.
Dans le contrôle TextBox customerName, saisissez SAB.
6.
Le rapport Crystal affiche trois enregistrements clients : SAB Mountain, Tek Bikes et Tienda de Bicicletas El
Pardo.
Seuls les enregistrements clients dont le nom vient après les lettres "SAB" et dont les ventes annuelles de
l'année dernière sont supérieures à la valeur "200000" s'affichent.
7.
1.5.1.4.5
Utilisation d'un contrôle DropDownList pour
modifier la formule de sélection
Dans cette section, vous allez remplir le contrôle DropDownList avec des opérateurs de comparaison. Vous
créez une énumération contenant les opérateurs de comparaison.
Le contrôle DropDownList permet de choisir d'afficher les noms de client qui sont égaux, inférieurs, supérieurs,
inférieurs ou égaux, supérieurs ou égaux, ou pas égaux au texte que vous avez saisi dans le contrôle TextBox.
Dans la méthode d'événement redisplay_Click(), vous modifiez la chaîne actuellement affectée à la propriété
SelectionFormula du contrôle CrystalReportViewer.
1.5.1.4.5.1
Pour créer une énumération
CeComparisonOperator
Procédure
1.
2.
Dans la boîte de dialogue Ajouter un nouvel élément, sélectionnez Classe dans la vue Modèles.
3.
Dans le champ Nom, saisissez CeComparisonOperator, puis cliquez sur Ajouter.
Remarque
Vous pouvez être invité à placer cette classe dans un répertoire Code. Cliquez sur le bouton Oui.
4.
Dans la signature de classe, remplacez le mot class par enum pour convertir la classe en énumération.
Dans un projet Windows C# pour Visual Studio, vous devez également remplacer l'espace de noms par le
nom de votre projet.
298
Remarque
Dans Visual Basic, n'oubliez pas de remplacer les signatures d'ouverture et de fermeture de la classe par
enum.
5.
Les énumérations ne comportant aucun constructeur, supprimez la méthode constructeur par défaut qui est
fournie dans la version C# du code.
6.
Dans l'énumération, saisissez les valeurs suivantes :
EqualTo
LessThan
GreaterThan
LessThan_or_EqualTo
GreaterThan_or_EqualTo
Not_EqualTo
EqualTo,
LessThan,
GreaterThan,
LessThan_or_EqualTo,
GreaterThan_or_EqualTo,
Not_EqualTo
1.5.1.4.5.2
Pour remplir le contrôle DropDownList à l'aide de
l'énumération CeComparisonOperator pour un site Web
Contexte
Les procédures suivantes indiquent comment lier l'énumération CeComparisonOperator au contrôle
DropDownList pour un site Web ou un projet Windows. Suivez les instructions de l'une des procédures ci-dessous.
Procédure
1.
Ouvrez le Web Form.
2.
3.
Dans le bloc conditionnel Not IsPostBack de la méthode ConfigureCrystalReports(), avant la
déclaration de chaîne de la formule de sélection, définissez la propriété DataSource du contrôle
DropDownList selon les valeurs de l'énumération CeComparisonOperator.
selectOperatorList.DataSource =
System.Enum.GetValues(GetType(CeComparisonOperator))
System.Enum.GetValues(typeof(CeComparisonOperator));
299
4.
Appelez à présent la méthode DataBind() du contrôle DropDownList selectOperatorList pour lier les valeurs
au contrôle.
selectOperatorList.DataBind()
selectOperatorList.DataBind();
1.5.1.4.5.3
l'énumération CeComparisonOperator pour un projet Windows
Procédure
1.
Ouvrez le Windows Form.
2.
3.
Dans la méthode ConfigureCrystalReports(), avant la déclaration de chaîne de la formule de sélection,
définissez la propriété DataSource du contrôle ComboBox selectOperatorList selon les valeurs de
l'énumération CeComparisonOperator.
1.5.1.4.5.4
Pour créer la méthode d'assistance
GetSelectedCompareOperator()
Contexte
Créez ensuite la méthode d'assistance GetSelectedCompareOperator() pour renvoyer l'index sélectionné
sous la forme d'une chaîne représentant un signe d'opérateur de comparaison.
Procédure
1.
A la fin de la classe, créez une méthode d'assistance privée intitulée GetSelectedCompareOperator() qui
renvoie une variable chaîne.
Private Function GetSelectedCompareOperator() As String
300
End Function
private string GetSelectedCompareOperator()
{
}
2.
Dans la méthode, créez une instruction "Select Case" [Visual Basic] ou "switch" [C#] qui
référence les membres de l'énumération CeComparisonOperator et renvoie le signe d'opérateur de
comparaison sous la forme d'une variable chaîne.
Select Case selectOperatorList.SelectedIndex
Case CeComparisonOperator.EqualTo
return "="
Case CeComparisonOperator.LessThan
return "<"
Case CeComparisonOperator.GreaterThan
return ">"
Case CeComparisonOperator.LessThan_or_EqualTo
return "<="
Case CeComparisonOperator.GreaterThan_or_EqualTo
return ">="
Case CeComparisonOperator.Not_EqualTo
return "<>"
Case Else
return "="
End Select
switch ((CeComparisonOperator)selectOperatorList.SelectedIndex)
{
case CeComparisonOperator.EqualTo:
return "=";
case CeComparisonOperator.LessThan:
return "<";
case CeComparisonOperator.GreaterThan:
return ">";
case CeComparisonOperator.LessThan_or_EqualTo:
return "<=";
case CeComparisonOperator.GreaterThan_or_EqualTo:
return ">=";
case CeComparisonOperator.Not_EqualTo:
return "<>";
default:
return "=";
}
1.5.1.4.5.5
Pour modifier l'opérateur de comparaison du
paramètre Nom du client affecté à la propriété
SelectionFormula
Contexte
Dans la méthode d'événement redisplay_Click(), un signe "supérieur à" (">") est actuellement utilisé pour la
sélection du champ Nom du client. Vous allez ensuite apprendre à remplacer le signe par l'opérateur de
301
comparaison que vous avez sélectionné à partir du contrôle DropDownList. Le signe sélectionné est renvoyé
sous la forme d'une chaîne lorsque vous appelez la méthode d'assistance GetSelectedCompareOperator().
Procédure
1.
Au début de la méthode d'événement redisplay_Click(), appelez la méthode d'assistance
GetSelectedCompareOperator(), puis affectez le résultat à une variable chaîne.
Dim mySelectedOperator As String = GetSelectedCompareOperator()
string selectedOperator = GetSelectedCompareOperator();
2.
Pour la variable chaîne de la formule de sélection, remplacez le signe "supérieur à" (">") par la chaîne de
l'opérateur sélectionnée.
" & lastYearsSales.Text _
& " AND Mid({Customer.Customer Name}, 1, 1) " &
mySelectedOperator & " """ & customerName.Text & """"
string selectFormula = "{Customer.Last Year's Sales} > " +
lastYearsSales.Text
+ " AND Mid({Customer.Customer Name}, 1, 1) " + selectedOperator + "
\"" + customerName.Text + "\"";
1.5.1.4.5.6
Pour vérifier la formule de sélection du rapport
CustomersBySalesName
Contexte
Vous avez créé une formule de sélection qui dépend des valeurs saisies dans le champ Ventes de l'année dernière
et le champ Nom du client.
Vous pouvez à présent créer et vérifier la formule de sélection.
Procédure
1.
2.
3.
302
a) Dans le contrôle TextBox lastYearsSales, saisissez 40000.
b) Dans le contrôle TextBox customerName, saisissez Athens Bicycle Co.
c) Dans le contrôle DropDownList, sélectionnez LessThan.
d) Cliquez sur Réafficher le rapport.
Le rapport Crystal affiche deux enregistrements clients : Alley Cat Cycles et Ankara Bicycle Company.
4.
1.5.1.5
Tutoriel : Personnalisation du contrôle
CrystalReportViewer
Dans ce tutoriel, vous allez apprendre à personnaliser l'affichage du contrôle CrystalReportViewer.
Introduction
Dans ce tutoriel, vous allez apprendre à personnaliser l'apparence du contrôle CrystalReportViewer en utilisant
les propriétés de sa classe sous-jacente.
Vous allez également apprendre à utiliser les méthodes de sélection de la page, de zoom, de recherche et
d'impression.
Pour commencer, vous allez apprendre à personnaliser la barre d'outils CrystalReportViewer. Vous avez besoin
d'un contrôle ListBox qui stocke les propriétés disponibles dans la barre d'outils. Seules les propriétés
sélectionnées dans le contrôle ListBox s'affichent dans la barre d'outils CrystalReportViewer.
Vous allez ensuite ajouter un second contrôle ListBox pour stocker les éléments du rapport. Pour un site Web,
vous pouvez également choisir d'afficher toutes les pages du rapport sous forme d'une page unique ou de pages
séparées.
Vous allez apprendre à personnaliser la couleur d'arrière-plan à l'aide d'un contrôle DropDownList.
Vous allez apprendre ensuite à sélectionner la page de rapport que vous souhaitez visualiser. Vous avez besoin
d'un contrôle TextBox pour saisir le numéro de page et d'un contrôle Button pour recharger le rapport à la page
sélectionnée. Vous avez également besoin d'un contrôle TextBox et d'un contrôle Button pour modifier le facteur
de zoom et rechercher un texte dans votre rapport.
Pour un site Web, vous disposez de propriétés du contrôle CrystalReportViewer qui ne sont pas disponibles pour
un projet Windows : une propriété permettant de choisir le mode d'impression et d'autres propriétés permettant
de changer la largeur, le style e
Exemple de code
version terminée.
303
●
Site Web C# : CS_Web_CRVObjMod_CustomizeViewer
●
Projet Windows C# : CS_Win_CRVObjMod_CustomizeViewer
●
Site Web Visual Basic : VB_Web_CRVObjMod_CustomizeViewer
●
Projet Windows Visual Basic : VB_Win_CRVObjMod_CustomizeViewer
1.5.1.5.1
Création d'un tableau de paramètres personnalisés
Dans cette section, vous allez créer et configurer un tableau (dans un site Web) ou un contrôle TableLayoutPanel
(dans un projet Windows) contenant les différents contrôles qui constituent votre tableau de paramètres
personnalisés.
Les sites Web et les projets Windows utilisant des types de tableau différents, choisissez la procédure
correspondant à votre site Web ou votre projet Windows.
1.5.1.5.1.1
Pour créer un tableau de paramètres
personnalisés pour un site Web
Procédure
1.
Ouvrez la page Default.aspx (le Web Form) en mode Design.
2.
3.
Cliquez sur la flèche orientée vers la gauche pour déplacer le curseur à gauche du contrôle
CrystalReportViewer, puis appuyez sur Entrée.
4.
Cliquez sur la flèche orientée vers le haut pour déplacer le curseur vers la ligne vide au-dessus du contrôle
5.
Dans le menu Disposition, cliquez sur Insérer un tableau.
6.
Dans la boîte de dialogue Insérer un tableau, sélectionnez l'option Personnalisé.
7.
Dans le panneau Disposition, cochez la case Largeur et conservez la valeur 100 %.
8.
Configurez pour Lignes le nombre 6 et pour Colonnes le nombre 4.
9.
Dans le panneau Attributs, cochez la case Bordure et attribuez-lui la valeur 1.
10. Cliquez sur le bouton Propriétés de la cellule.
11. Dans la boîte de dialogue Propriétés de la cellule du panneau Disposition, dans la liste déroulante Alignement
vertical, sélectionnez Top.
304
12. Cochez la case Pas de retour automatique à la ligne, puis cliquez sur OK.
13. Cliquez à nouveau sur OK pour fermer la boîte de dialogue Insérer un tableau.
Résultats
Vous pouvez maintenant ajouter des contrôles personnalisés pour votre site Web dans ce tableau.
Effectuez maintenant la procédure Eléments du rapport et de la barre d'outils du contrôle CrystalReportViewer
[page 306].
1.5.1.5.1.2
Pour créer un tableau de paramètres
personnalisés pour un projet Windows
Contexte
Remarque
configuration.
Procédure
1.
Ouvrez le Windows Form en mode Design.
2.
Cliquez sur la barre de titre du Windows Form pour le sélectionner entièrement, puis faites glisser le coin
inférieur droit du formulaire pour l'agrandir jusqu'à ce qu'il remplisse la zone principale.
3.
4.
Dans la fenêtre Propriétés, attribuez à la propriété Dock la valeur "Bottom".
5.
Dans la fenêtre Propriétés, attribuez à la propriété Anchor la valeur "Top, Bottom, Left, Right".
6.
Dans la Boîte à outils, faites glisser un contrôle TableLayoutPanel en haut à gauche du Windows Form.
Un contrôle TableLayoutPanel apparaît affichant deux colonnes et deux lignes.
7.
Si le panneau des tâches guidées n'est pas ouvert, cliquez sur le bouton triangulaire dans le coin supérieur
droit du contrôle TableLayoutPanel.
Le panneau des tâches guidées "Tâches TableLayoutPanel" s'affiche.
8.
Dans le panneau Tâches TableLayoutPanel, cliquez sur le lien Modifier les lignes et les colonnes.
9.
Dans la boîte de dialogue Styles de ligne et de colonne, dans la liste déroulante Type de membre, sélectionnez
Colonnes.
305
10. Cliquez sur Ajouter jusqu'à ce que vous atteigniez quatre colonnes.
11. Pour chaque colonne, procédez de la manière suivante :
a) Sélectionnez la colonne.
b) Dans le panneau Type de taille, sélectionnez Pourcentage.
c) Définissez 25 % pour chaque valeur.
12. Dans la liste déroulante Type de membre, sélectionnez Lignes.
13. Cliquez sur Ajouter jusqu'à ce que vous atteigniez cinq lignes.
Remarque
Le tableau du projet Windows nécessite une ligne de moins que le tableau d'un site Web parce qu'il y a un
peu moins d'options configurables sur le contrôle CrystalReportViewer d'un projet Windows.
14. Pour chaque ligne, procédez de la manière suivante :
a) Sélectionnez la ligne.
b) Dans le panneau Type de taille, sélectionnez Pourcentage.
c) Définissez 40 % pour la valeur de la première ligne, puis 15 % pour chaque ligne suivante.
Remarque
(1 x 40 %) et (4 x 15 %) = 100 % de l'espace disponible.
15. Cliquez sur OK.
16. Fermez le panneau des tâches TableLayoutPanel.
17. Faites glisser le coin inférieur droit du contrôle TableLayoutPanel pour agrandir le tableau jusqu'à ce qu'il
remplisse l'espace que vous avez créé au-dessus du contrôle CrystalReportViewer.
Résultats
Vous pouvez maintenant ajouter des contrôles personnalisés pour votre projet Windows dans ce tableau.
1.5.1.5.2
Eléments du rapport et de la barre d'outils du
Dans ce tutoriel, vous allez manipuler les différents éléments du rapport et de la barre d'outils du contrôle
Eléments du visualiseur
Les éléments par défaut du contrôle CrystalReportViewer varient légèrement en fonction des sites Web et des
projets Windows :
306
●
Pour les sites Web et les projets Windows :
○
Barre d'outils : affiche une barre d'outils au-dessus de la zone principale du rapport. Chaque élément de la
barre d'outils est contrôlé séparément.
Remarque
Pour en savoir plus, voir la section sur les éléments de la barre d'outils ci-dessous.
○
●
●
Arborescence des groupes : affiche les titres de chaque groupe du rapport, de la même façon qu'une
arborescence de répertoires ; elle s'affiche dans le panneau de la colonne gauche du rapport.
Pour les sites Web uniquement :
○
Page principale : affiche le rapport dans la zone principale de la page.
○
Activer les pages séparées : détermine si le rapport doit être affiché sur une seule page Web ou sous la
forme de pages séparées mises en forme.
Pour les projets Windows uniquement :
○
Barre d'état : affiche le numéro de page en cours et d'autres informations sur le rapport au bas de la zone
du rapport.
Eléments de la barre d'outils
Les éléments par défaut de la barre d'outils varient légèrement en fonction des sites Web et des projets Windows :
●
●
●
Pour les sites Web et les projets Windows :
○
Bouton d'arborescence des groupes : affiche ou masque la section Arborescence des groupes du rapport.
○
Exporter : enregistre le rapport Crystal sous un autre format de fichier tel que RPT, PDF, DOC, XLS ou
RTF.
○
Imprimer : imprime le rapport Crystal dans un fichier PDF ou appelle la boîte de dialogue d'impression.
○
Navigation : permet de sélectionner la page suivante, la page précédente, la dernière page ou la première
page à afficher.
○
Aller à la page : permet de saisir le numéro de la page à afficher.
○
Rechercher : permet de saisir une chaîne à rechercher dans le rapport.
○
Facteur de zoom : permet de sélectionner le facteur de zoom du rapport.
Pour les sites Web uniquement :
○
Vue Liste (uniquement pour un site Web) : permet de choisir la vue du rapport à afficher (par exemple
sous-rapports, etc.).
○
Explorer en amont : ouvre une page fournissant des informations plus détaillées que la rubrique actuelle.
○
Logo Crystal : affiche le logo du produit SAP Crystal Reports.
Pour les projets Windows uniquement :
○
Actualiser : réaffiche le rapport.
○
Fermer la vue : ferme la vue actuelle du rapport si plusieurs vues sont ouvertes.
307
1.5.1.5.3
Ajout d'un mécanisme d'affichage et de masquage
des éléments du rapport et de la barre d'outils
Contexte
Dans cette section, vous allez apprendre à ajouter un mécanisme d'affichage/masquage pour déterminer quels
éléments doivent être affichés dans la barre d'outils CrystalReportViewer.
Vous allez commencer par ajouter les contrôles ListBox et Button dans le tableau sur le Web Form ou le Windows
Form.
Vous allez ensuite créer deux énumérations qui répertorient les éléments du rapport et les éléments de la barre
d'outils, puis vous allez remplir chaque contrôle ListBox avec les valeurs de l'une des énumérations.
Vous allez ensuite coder la méthode d'événement de clic du contrôle Button pour mettre à jour les éléments du
rapport et de la barre d'outils.
Au sein du gestionnaire d'événements, les propriétés de la classe CrystalReportViewer sont définies en fonction
des sélections effectuées dans les deux contrôles ListBox. Si un élément du contrôle ListBox est sélectionné, la
propriété de la barre d'outils a la valeur True.
Plus loin dans ce tutoriel, vous utiliserez le contrôle Button pour mettre à jour d'autres sélections.
Au moment de l'exécution, vous pourrez choisir quels éléments du rapport et de la barre d'outils vous souhaitez
afficher.
Commencez par ajouter les contrôles dans le tableau au bas du Web Form ou du Windows Form.
Procédure
1.
Ouvrez le Web Form ou le Windows Form en mode Design.
2.
Dans la Boîte à outils, faites glisser un contrôle Label vers la première ligne de la première colonne du tableau.
3.
Sélectionnez le contrôle Label, puis dans la fenêtre Propriétés, attribuez à la propriété Text la valeur
Sélectionner les éléments du rapport à afficher.
4.
Dans la Boîte à outils, faites glisser un contrôle ListBox vers la première ligne de la deuxième colonne du
tableau.
5.
Sélectionnez le contrôle ListBox, puis effectuez les opérations suivantes dans la fenêtre Propriétés :
a) Attribuez à ID la valeur listCRVReport.
b) Attribuez à SelectionMode la valeur Multiple (ou MultiExtended dans un projet Windows).
6.
Dans la Boîte à outils, faites glisser un second contrôle Label vers la première ligne de la troisième colonne du
tableau.
7.
Sélectionner les éléments de la barre d'outils à afficher.
8.
Dans la Boîte à outils, faites glisser un contrôle Button vers la troisième ligne de la première colonne du
tableau.
9.
308
10. Dans la fenêtre Propriétés :
a) Attribuez à ID la valeur "redisplay".
b) Attribuez à Text la valeur "Réafficher le rapport".
11. Dans un projet Windows, redimensionnez le contrôle Button pour afficher la totalité du texte qu'il contient.
Résultats
La prochaine procédure varie selon que vous créez un site Web ou un projet Windows. Choisissez l'une des
procédures suivantes :
●
Configuration des contrôles ListBox pour un site Web [page 309]
●
Configuration des contrôles ListBox pour un projet Windows [page 315]
1.5.1.5.4
Web
Configuration des contrôles ListBox pour un site
Cette section explique comment configurer les contrôles ListBox d'un site Web. Si vous créez un projet Windows,
voir Configuration des contrôles ListBox pour un projet Windows [page 315].
Vous allez maintenant pouvoir créer le gestionnaire d'événements de clic du contrôle Button, puis ajouter du code
à ce gestionnaire d'événements. Le gestionnaire d'événements définit différentes valeurs booléennes pour les
propriétés de la barre d'outils de la classe CrystalReportViewer en fonction des sélections effectuées par
l'utilisateur dans le contrôle ListBox.
Avant de créer ce gestionnaire d'événements, vous devez créer deux énumérations : CeWebCRVReportOptions
et CeWebCRVToolbarOptions.
Ces énumérations fournissent une liste d'éléments du rapport et d'éléments de la barre d'outils pouvant être
sélectionnés.
1.5.1.5.4.1
Pour créer l'énumération
CeWebCRVReportOptions
Procédure
1.
Dans l'Explorateur de solutions, cliquez avec le bouton droit de la souris sur le nom du site Web, pointez sur
Ajouter, puis cliquez sur Nouvel élément.
2.
3.
Dans le champ Nom, saisissez "CeWebCRVReportOptions", puis cliquez sur Ajouter.
Remarque
Vous pouvez être invité à placer cette classe dans un répertoire App_Code. Cliquez sur le bouton Oui.
309
4.
Dans la signature de classe, remplacez le mot class par "enum" pour convertir la classe en énumération.
Remarque
enum.
5.
6.
Toolbar
Group_Tree
Main_Page
Enable_Separate_Pages
Toolbar,
Group_Tree,
Main_Page,
Enable_Separate_Pages
7.
1.5.1.5.4.2
CeWebCRVToolbarOptions
Procédure
1.
Dans l'Explorateur de solutions, cliquez avec le bouton droit de la souris sur le nom du site Web, pointez sur
Ajouter, puis cliquez sur Nouvel élément.
2.
3.
Dans le champ Nom, saisissez CeWebCRVToolbarOptions, puis cliquez sur Ajouter.
Remarque
4.
Remarque
enum.
5.
6.
Group_Tree_Button
310
Export_Button
Print_Button
View_List_Button
Drill_Up_Button
Page_Navigation_Button
Go_to_Page_Button
Search_Button
Zoom_Button
Crystal_Logo
Group_Tree_Button,
Export_Button,
Print_Button,
View_List_Button,
Drill_Up_Button,
Page_Navigation_Button,
Go_to_Page_Button,
Search_Button,
Zoom_Button,
Crystal_Logo
7.
1.5.1.5.4.3
Pour remplir les contrôles ListBox à partir des
énumérations
Contexte
Vous remplissez à présent les contrôles ListBox avec les valeurs d'énumération qui représentent les propriétés
disponibles pour la barre d'outils CrystalReportViewer.
Procédure
1.
Ouvrez le Web Form.
2.
3.
Dans la méthode ConfigureCrystalReports(), ajoutez un bloc conditionnel Not IsPostBack.
Remarque
Vous avez créé la méthode ConfigureCrystalReports() dans la section Configuration d'un projet
[page 15] au début de ce tutoriel.
End If
if (!IsPostBack)
311
{
}
4.
Dans le bloc conditionnel, attribuez à la propriété DataSource du contrôle ListBox listCRVReport les
valeurs de l'énumération CeWebCRVReportOptions.
listCRVReport.DataSource = System.Enum.GetValues(GetType(CeWebCRVReportOptions))
listCRVReport.DataSource = System.Enum.GetValues(typeof(CeWebCRVReportOptions));
5.
Appelez la méthode DataBind() du contrôle ListBox listCRVReport pour lier les valeurs au contrôle.
listCRVReport.DataBind()
listCRVReport.DataBind();
6.
Attribuez ensuite à la propriété DataSource du contrôle ListBox listCRVToolbar les valeurs de
l'énumération CeWebCRVToolbarOptions.
listCRVToolbar.DataSource =
System.Enum.GetValues(GetType(CeWebCRVToolbarOptions))
System.Enum.GetValues(typeof(CeWebCRVToolbarOptions));
7.
Appelez à présent la méthode DataBind() du contrôle ListBox listCRVToolbar pour lier les valeurs au
contrôle.
listCRVToolbar.DataBind()
listCRVToolbar.DataBind();
8.
En dehors du bloc conditionnel Not IsPostBack, liez le fichier Chart.rpt à la propriété ReportSource du
Pour en savoir plus sur les exemples de rapports, voir Répertoire d'exemples de rapports [page 15].
myCrystalReportViewer.ReportSource = "C:\Program Files\Microsoft Visual Studio
9,0\Crystal Reports\Samples\fr\Reports\Feature Examples\Chart.rpt"
crystalReportViewer.ReportSource = "C:\\Program Files\\Microsoft Visual Studio
9.0\\Crystal Reports\\Samples\\fr\\Reports\\Feature Examples\\Chart.rpt";
312
1.5.1.5.4.4
Pour coder le contrôle Button de réaffichage pour
un site Web
Contexte
Vous pouvez à présent ajouter le code à l'événement de clic du contrôle Button. La méthode de clic doit définir
des valeurs booléennes pour les éléments du rapport et de la barre d'outils de la classe CrystalReportViewer.
Si un élément est sélectionné, la valeur booléenne est True et l'élément du rapport ou de la barre d'outils s'affiche.
Si aucune propriété n'est sélectionnée, la valeur booléenne est False et l'élément du rapport ou de la barre d'outils
ne s'affiche pas.
Procédure
1.
Ouvrez le Web Form.
2.
3.
4.
Dans la méthode d'événement redisplay_Click(), appelez la propriété Selected de chaque élément des
contrôles ListBox listCRVReport et listCRVToolbar.
La propriété Selected renvoie une valeur booléenne afin de définir les propriétés de la barre d'outils
Remarque
Les éléments du rapport et de la barre d'outils CrystalReportViewer sont définis sur leurs valeurs
correspondantes dans les énumérations CeWebCRVReportOptions et CeWebCRVToolbarOptions. Les
valeurs de la classe enum renvoient une chaîne que vous devez convertir en nombre entier.
myCrystalReportViewer.HasToggleGroupTreeButton =
listCRVToolbar.Items(Convert.ToInt32(CeWebCRVToolbarOptions.Group_Tree_Button)).S
elected
myCrystalReportViewer.HasExportButton =
listCRVToolbar.Items(Convert.ToInt32(CeWebCRVToolbarOptions.Export_Button)).Selec
ted
myCrystalReportViewer.HasPrintButton =
listCRVToolbar.Items(Convert.ToInt32(CeWebCRVToolbarOptions.Print_Button)).Select
ed
myCrystalReportViewer.HasViewList =
listCRVToolbar.Items(Convert.ToInt32(CeWebCRVToolbarOptions.View_List_Button)).Se
lected
myCrystalReportViewer.HasDrillUpButton =
listCRVToolbar.Items(Convert.ToInt32(CeWebCRVToolbarOptions.Drill_Up_Button)).Sel
ected
myCrystalReportViewer.HasPageNavigationButtons =
listCRVToolbar.Items(Convert.ToInt32(CeWebCRVToolbarOptions.Page_Navigation_Butto
n)).Selected
myCrystalReportViewer.HasGotoPageButton =
313
listCRVToolbar.Items(Convert.ToInt32(CeWebCRVToolbarOptions.Go_to_Page_Button)).S
elected
myCrystalReportViewer.HasSearchButton =
listCRVToolbar.Items(Convert.ToInt32(CeWebCRVToolbarOptions.Search_Button)).Selec
ted
myCrystalReportViewer.HasZoomFactorList =
listCRVToolbar.Items(Convert.ToInt32(CeWebCRVToolbarOptions.Zoom_Button)).Selecte
d
myCrystalReportViewer.HasCrystalLogo =
listCRVToolbar.Items(Convert.ToInt32(CeWebCRVToolbarOptions.Crystal_Logo)).Select
ed
myCrystalReportViewer.DisplayToolbar =
listCRVReport.Items(Convert.ToInt32(CeWebCRVReportOptions.Toolbar)).Selected
myCrystalReportViewer.DisplayGroupTree =
listCRVReport.Items(Convert.ToInt32(CeWebCRVReportOptions.Group_Tree)).Selected
myCrystalReportViewer.DisplayPage =
listCRVReport.Items(Convert.ToInt32(CeWebCRVReportOptions.Main_Page)).Selected
myCrystalReportViewer.SeparatePages =
listCRVReport.Items(Convert.ToInt32(CeWebCRVReportOptions.Enable_Separate_Pages))
.Selected
crystalReportViewer.HasToggleGroupTreeButton =
listCRVToolbar.Items[Convert.ToInt32(CeWebCRVToolbarOptions.Group_Tree_Button)].S
elected;
crystalReportViewer.HasExportButton =
listCRVToolbar.Items[Convert.ToInt32(CeWebCRVToolbarOptions.Export_Button)].Selec
ted;
crystalReportViewer.HasPrintButton =
listCRVToolbar.Items[Convert.ToInt32(CeWebCRVToolbarOptions.Print_Button)].Select
ed;
crystalReportViewer.HasViewList =
listCRVToolbar.Items[Convert.ToInt32(CeWebCRVToolbarOptions.View_List_Button)].Se
lected;
crystalReportViewer.HasDrillUpButton =
listCRVToolbar.Items[Convert.ToInt32(CeWebCRVToolbarOptions.Drill_Up_Button)].Sel
ected;
crystalReportViewer.HasPageNavigationButtons =
listCRVToolbar.Items[Convert.ToInt32(CeWebCRVToolbarOptions.Page_Navigation_Butto
n)].Selected;
crystalReportViewer.HasGotoPageButton =
listCRVToolbar.Items[Convert.ToInt32(CeWebCRVToolbarOptions.Go_to_Page_Button)].S
elected;
crystalReportViewer.HasSearchButton =
listCRVToolbar.Items[Convert.ToInt32(CeWebCRVToolbarOptions.Search_Button)].Selec
ted;
crystalReportViewer.HasZoomFactorList =
listCRVToolbar.Items[Convert.ToInt32(CeWebCRVToolbarOptions.Zoom_Button)].Selecte
d;
crystalReportViewer.HasCrystalLogo =
listCRVToolbar.Items[Convert.ToInt32(CeWebCRVToolbarOptions.Crystal_Logo)].Select
ed;
crystalReportViewer.DisplayToolbar =
listCRVReport.Items[Convert.ToInt32(CeWebCRVReportOptions.Toolbar)].Selected;
crystalReportViewer.DisplayGroupTree =
listCRVReport.Items[Convert.ToInt32(CeWebCRVReportOptions.Group_Tree)].Selected;
crystalReportViewer.DisplayPage =
listCRVReport.Items[Convert.ToInt32(CeWebCRVReportOptions.Main_Page)].Selected;
crystalReportViewer.SeparatePages =
listCRVReport.Items[Convert.ToInt32(CeWebCRVReportOptions.Enable_Separate_Pages)]
.Selected;
314
1.5.1.5.4.5
Pour vérifier le contrôle Button de réaffichage
Contexte
Vous êtes maintenant prêt à générer et exécuter le projet afin de personnaliser la barre d'outils
Procédure
1.
2.
3.
Les contrôles ListBox listCRVReport et listCRVToolbar affichent une liste complète des options du
rapport et de la barre d'outils CrystalReportViewer.
4.
Dans la liste des options de la barre d'outils, sélectionnez "Page_Navigation_Button", "Print_Button" et
"Export_Button".
5.
Dans la liste des options du rapport, sélectionnez "Toolbar", "Group_Tree" et "Main_Page".
6.
La page se recharge et affiche un contrôle CrystalReportViewer avec une barre d'outils, une arborescence
des groupes et une page principale visibles. Dans la barre d'outils, seuls les boutons Navigation, Imprimer et
Exporter sont visibles.
7.
1.5.1.5.5
Windows
Configuration des contrôles ListBox pour un projet
Cette section explique comment configurer les contrôles ListBox d'un projet Windows. Si vous créez un site Web,
voir Configuration des contrôles ListBox pour un site Web [page 309].
Vous allez maintenant pouvoir créer le gestionnaire d'événements de clic du contrôle Button, puis ajouter du code
à ce gestionnaire d'événements. Le gestionnaire d'événements définit différentes valeurs booléennes pour les
propriétés de la barre d'outils de la classe CrystalReportViewer en fonction des sélections effectuées par
l'utilisateur dans le contrôle ListBox.
Avant de créer ce gestionnaire d'événements, vous devez créer deux énumérations : CeWinCRVReportOptions
et CeWinCRVToolbarOptions.
Ces énumérations fournissent une liste d'éléments du rapport et d'éléments de la barre d'outils pouvant être
sélectionnés.
315
1.5.1.5.5.1
CeWinCRVReportOptions
Procédure
1.
pointez sur Ajouter, puis cliquez sur Classe.
2.
Dans le champ Nom de la boîte de dialogue Ajouter un nouvel élément, saisissez CeWinCRVReportOptions,
puis cliquez sur Ajouter.
Remarque
Dans Visual Studio, vous pouvez être invité à placer cette classe dans un répertoire App_Code. Cliquez sur
le bouton Oui.
3.
Remarque
enum.
4.
5.
Toolbar
Group_Tree
Status_Bar
Toolbar,
Group_Tree,
Status_Bar
6.
1.5.1.5.5.2
CeWinCRVToolbarOptions
Procédure
1.
pointez sur Ajouter, puis cliquez sur Classe.
2.
Dans le champ Nom de la boîte de dialogue Ajouter un nouvel élément, saisissez "CeWinCRVToolbarOptions",
puis cliquez sur Ajouter.
316
Remarque
3.
Remarque
enum.
4.
5.
Page_Navigation_Button
Go_to_Page_Button
Close_View_Button
Print_Button
Refresh_Button
Export_Button
Group_Tree_Button
Zoom_Button
Search_Button
Page_Navigation_Button,
Go_to_Page_Button,
Close_View_Button,
Print_Button,
Refresh_Button,
Export_Button,
Group_Tree_Button,
Zoom_Button,
Search_Button
6.
1.5.1.5.5.3
Pour remplir les contrôles ListBox à partir des
énumérations
Contexte
Vous remplissez à présent les contrôles ListBox avec les valeurs d'énumération qui représentent les propriétés
disponibles pour la barre d'outils CrystalReportViewer.
317
Procédure
1.
2.
3.
Dans la méthode ConfigureCrystalReports(), attribuez à la propriété DataSource du contrôle ListBox
listCRVReport les valeurs de l'énumération CeWinCRVReportOptions.
Remarque
Vous avez créé la méthode ConfigureCrystalReports() dans la section Configuration d'un projet
[page 15] au début de ce tutoriel.
listCRVReport.DataSource =
System.Enum.GetValues(GetType(CeWinCRVReportOptions))
listCRVReport.DataSource =
System.Enum.GetValues(typeof(CeWinCRVReportOptions));
4.
Attribuez à la propriété DataSource du contrôle ListBox listCRVToolbar les valeurs de l'énumération
CeWinCRVToolbarOptions.
System.Enum.GetValues(GetType(CeWinCRVToolbarOptions))
System.Enum.GetValues(typeof(CeWinCRVToolbarOptions));
5.
Liez le fichier Chart.rpt à la propriété ReportSource du contrôle CrystalReportViewercontrol.
Pour en savoir plus sur les exemples de rapports, voir Répertoire d'exemples de rapports [page 15].
myCrystalReportViewer.ReportSource = "C:\Program Files\Microsoft Visual Studio
9,0\Crystal Reports\Samples\fr\Reports\Feature Examples\Chart.rpt"
crystalReportViewer.ReportSource = "C:\\Program Files\\Microsoft Visual Studio
9.0\\Crystal Reports\\Samples\\fr\\Reports\\Feature Examples\\Chart.rpt";
1.5.1.5.5.4
Pour coder le contrôle Button de réaffichage pour
un projet Windows
Contexte
Vous pouvez à présent ajouter le code à l'événement de clic du contrôle Button. La méthode de clic doit définir
des valeurs booléennes pour les éléments du rapport et de la barre d'outils de la classe CrystalReportViewer.
318
Si un élément est sélectionné, la valeur booléenne est True et l'élément du rapport ou de la barre d'outils s'affiche.
Si aucune propriété n'est sélectionnée, la valeur booléenne est False et l'élément du rapport ou de la barre
d'outils ne s'affiche pas.
Procédure
1.
2.
3.
4.
Dans la méthode d'événement redisplay_Click(), appelez la méthode GetSelected(), puis transmettez
chaque élément du contrôle ListBox.
La méthode GetSelected() renvoie une valeur booléenne afin de définir les propriétés du rapport et de la
barre d'outils CrystalReportViewer.
Remarque
Les éléments du rapport et de la barre d'outils CrystalReportViewer sont définis sur leurs valeurs
correspondantes dans les énumérations CeWinCRVReportOptions et CeWinCRVToolbarOptions.
myCrystalReportViewer.ShowPageNavigateButtons =
listCRVToolbar.GetSelected(CeWinCRVToolbarOptions.Page_Navigation_Button)
myCrystalReportViewer.ShowGotoPageButton =
listCRVToolbar.GetSelected(CeWinCRVToolbarOptions.Go_to_Page_Button)
myCrystalReportViewer.ShowCloseButton = listCRVToolbar.
GetSelected(CeWinCRVToolbarOptions.Close_View_Button)
myCrystalReportViewer.ShowPrintButton =
listCRVToolbar.GetSelected(CeWinCRVToolbarOptions.Print_Button)
myCrystalReportViewer.ShowRefreshButton =
listCRVToolbar.GetSelected(CeWinCRVToolbarOptions.Refresh_Button)
myCrystalReportViewer.ShowExportButton =
listCRVToolbar.GetSelected(CeWinCRVToolbarOptions.Export_Button)
myCrystalReportViewer.ShowGroupTreeButton =
listCRVToolbar.GetSelected(CeWinCRVToolbarOptions.Group_Tree_Button)
myCrystalReportViewer.ShowZoomButton =
listCRVToolbar.GetSelected(CeWinCRVToolbarOptions.Zoom_Button)
myCrystalReportViewer.ShowTextSearchButton =
listCRVToolbar.GetSelected(CeWinCRVToolbarOptions.Search_Button)
myCrystalReportViewer.DisplayToolbar =
listCRVReport.GetSelected(CeWinCRVReportOptions.Toolbar)
myCrystalReportViewer.DisplayGroupTree =
listCRVReport.GetSelected(CeWinCRVReportOptions.Group_Tree)
myCrystalReportViewer.DisplayStatusBar =
listCRVReport.GetSelected(CeWinCRVReportOptions.Status_Bar)
crystalReportViewer.ShowPageNavigateButtons =
listCRVToolbar.GetSelected(Convert.ToInt32(CeWinCRVToolbarOptions.Page_Navigation
_Button));
crystalReportViewer.ShowGotoPageButton =
listCRVToolbar.GetSelected(Convert.ToInt32(CeWinCRVToolbarOptions.Go_to_Page_Butt
319
on));
crystalReportViewer.ShowCloseButton = listCRVToolbar.
GetSelected(Convert.ToInt32(CeWinCRVToolbarOptions.Close_View_Button));
crystalReportViewer.ShowPrintButton =
listCRVToolbar.GetSelected(Convert.ToInt32(CeWinCRVToolbarOptions.Print_Button));
crystalReportViewer.ShowRefreshButton =
listCRVToolbar.GetSelected(Convert.ToInt32(CeWinCRVToolbarOptions.Refresh_Button)
);
crystalReportViewer.ShowExportButton =
listCRVToolbar.GetSelected(Convert.ToInt32(CeWinCRVToolbarOptions.Export_Button))
;
crystalReportViewer.ShowGroupTreeButton =
listCRVToolbar.GetSelected(Convert.ToInt32(CeWinCRVToolbarOptions.Group_Tree_Butt
on));
crystalReportViewer.ShowZoomButton =
listCRVToolbar.GetSelected(Convert.ToInt32(CeWinCRVToolbarOptions.Zoom_Button));
crystalReportViewer.ShowTextSearchButton =
listCRVToolbar.GetSelected(Convert.ToInt32(CeWinCRVToolbarOptions.Search_Button))
;
crystalReportViewer.DisplayToolbar =
listCRVReport.GetSelected(Convert.ToInt32(CeWinCRVReportOptions.Toolbar));
crystalReportViewer.DisplayGroupTree =
listCRVReport.GetSelected(Convert.ToInt32(CeWinCRVReportOptions.Group_Tree));
crystalReportViewer.DisplayStatusBar =
listCRVReport.GetSelected(Convert.ToInt32(CeWinCRVReportOptions.Status_Bar));
1.5.1.5.5.5
Contexte
Vous êtes maintenant prêt à générer et exécuter le projet afin de personnaliser la barre d'outils
Procédure
1.
2.
3.
Les contrôles ListBox listCRVReportet listCRVToolbar affichent une liste complète des options de
CrystalReportViewer rapport et barre d'outils.
4.
Dans la liste des options de la barre d'outils, sélectionnez "Page_Navigation_Button", "Print_Button" et
"Export_Button".
5.
Dans la liste des options du rapport, sélectionnez "Toolbar", "Group_Tree" et "Main_Page".
6.
La page se recharge et affiche un contrôle CrystalReportViewer avec une barre d'outils, une arborescence
des groupes et une page principale visibles. Dans la barre d'outils, seuls les boutons Navigation, Imprimer et
Exporter sont visibles.
320
7.
1.5.1.5.6
Modification de la couleur d'arrière-plan du rapport
Dans cette section, vous allez apprendre à modifier la couleur d'arrière-plan du rapport.
Vous allez commencer par ajouter un contrôle DropDownList pour sélectionner la couleur d'arrière-plan.
1.5.1.5.6.1
Pour ajouter des contrôles pour modifier la
couleur d'arrière-plan
Procédure
1.
2.
3.
Dans la Boîte à outils, faites glisser un contrôle Label vers la seconde ligne de la première colonne du tableau.
4.
Sélectionnez la couleur d'arrière-plan.
5.
Dans la Boîte à outils, faites glisser un contrôle DropDownList (pour les sites Web) ou ComboBox (pour les
projets Windows) vers la seconde ligne de la deuxième colonne du tableau.
6.
Sélectionnez le contrôle DropDownList/ComboBox, puis dans la fenêtre Propriétés, attribuez à ID/Name la
valeur "selectBackColor".
1.5.1.5.6.2
Pour définir les valeurs par défaut des contrôles
Contexte
Vous devez à présent ajouter du code à la méthode ConfigureCrystalReports() afin de définir les valeurs par
défaut de la liste des couleurs d'arrière-plan et des cases à cocher des composants du rapport.
Procédure
1.
2.
Dans la méthode ConfigureCrystalReports(), vous ajoutez ensuite du code pour définir les valeurs par
défaut des contrôles.
321
Remarque
Si vous créez un site Web, placez ces lignes de code dans le bloc conditionnel Not IsPostBack. Si vous
créez un projet Windows, placez ces lignes de code dans la zone principale de la méthode
3.
Affectez l'énumération KnownColor à la propriété DataSource du contrôle DropDownList
selectBackColor.
selectBackColor.DataSource = System.Enum.GetValues(GetType(KnownColor))
selectBackColor.DataSource = System.Enum.GetValues(typeof(KnownColor));
4.
Dans un site Web, liez la source de données au contrôle DropDownList selectBackColor.
selectBackColor.DataBind()
selectBackColor.DataBind();
1.5.1.5.6.3
Pour affecter la sélection de couleur d'arrièreplan dans un site Web
Contexte
Ajoutez ensuite du code à l'événement de clic Button pour réafficher le rapport en fonction de la sélection
DropDownList selectBackColor.
Ce code est différent pour un site Web et un projet Windows. Sélectionnez la procédure appropriée à votre cas cidessous.
Procédure
1.
Ouvrez le Web Form.
2.
3.
[C#] au début de la classe pour l'espace de noms System.Drawing (si cet espace de noms n'a pas déjà été
déclaré).
Imports System.Drawing
322
using System.Drawing;
4.
Dans le gestionnaire d'événements redisplay_Click(), ajoutez le code suivant : dans le contrôle
DropDownList selectBackColor, extrayez l'élément sélectionné sous la forme d'une chaîne, puis transmettezle à la méthode FromName() de la classe Color. Affectez la valeur Color à la propriété BackColor du contrôle
myCrystalReportViewer.BackColor =
Color.FromName(selectBackColor.SelectedItem.Text)
crystalReportViewer.BackColor =
Color.FromName(selectBackColor.SelectedItem.Text);
1.5.1.5.6.4
Pour affecter la sélection de couleur d'arrièreplan dans un projet Windows
Contexte
Vous êtes maintenant prêt à tester le bouton Réafficher le rapport. Passez à la section en question, ci-dessous.
Procédure
1.
2.
3.
[C#] au début de la classe pour l'espace de noms System.Drawing (si cet espace de noms n'a pas déjà été
déclaré).
4.
Dans le gestionnaire d'événements redisplay_Click(), ajoutez du code pour extraire l'élément
sélectionné du contrôle ComboBox selectBackColor et convertissez-le en une instance KnownColor.
Dim mySelectedKnownColor As KnownColor = CType(selectBackColor.SelectedItem,
KnownColor)
KnownColor selectedKnownColor = (KnownColor)selectBackColor.SelectedItem;
323
5.
Créez un bloc conditionnel qui vérifie que la couleur d'arrière-plan sélectionnée n'est pas transparente.
If Not mySelectedKnownColor = KnownColor.Transparent Then
End If
if (selectedKnownColor != KnownColor.Transparent)
{
}
6.
Dans le bloc If, transmettez l'instance KnownColor à la méthode FromKnownName() de la classe
System.Drawing.Color. Affectez la valeur Color à la propriété BackColor du contrôle CrystalReportViewer.
System.Drawing.Color.FromKnownColor(mySelectedKnownColor)
crystalReportViewer.BackColor =
System.Drawing.Color.FromKnownColor(selectedKnownColor);
1.5.1.5.6.5
Contexte
Vous êtes maintenant prêt à tester le bouton Réafficher le rapport.
Procédure
1.
2.
3.
Le contrôle DropDownList/ComboBox s'affiche ainsi que les contrôles ListBox et Button que vous avez
ajoutés à la procédure précédente.
4.
Dans le contrôle DropDownList selectBackColor, sélectionnez la couleur bleue.
Remarque
N'oubliez pas de sélectionner les éléments de rapport, plus particulièrement Main_Page, pour qu'ils soient
visibles.
5.
La page se recharge pour afficher le rapport avec un arrière-plan bleu.
6.
324
1.5.1.5.7
rapport
Ajout d'un code pour sélectionner une page de
Dans cette section, vous allez apprendre à coder l'option "Aller à la page" de la barre d'outils
La barre d'outils CrystalReportViewer comporte des boutons de navigation et une zone de texte permettant
de sélectionner les pages du rapport. Vous pouvez utiliser les méthodes suivantes de la classe
CrystalReportViewer pour coder manuellement les sélections de page :
●
ShowFirstPage()
●
ShowLastPage()
●
ShowNextPage()
●
ShowNthPage(int PageNumber)
●
ShowPreviousPage()
Lorsque vous appelez l'une de ces méthodes, la page sélectionnée s'affiche pour le rapport en cours.
1.5.1.5.7.1
Pour ajouter des contrôles TextBox et Button à
l'option "Aller à la page"
Procédure
1.
2.
Dans la Boîte à outils, faites glisser un contrôle TextBox vers la quatrième ligne de la première colonne du
tableau.
3.
a) Attribuez à ID (ou Name) la valeur "pageNumber".
b) Laissez la propriété Text vide.
4.
Dans la Boîte à outils, faites glisser un contrôle Button vers la quatrième ligne de la deuxième colonne du
tableau.
5.
Sélectionnez le contrôle Button, puis effectuez les opérations suivantes dans la fenêtre Propriétés :
a) Attribuez à ID (ou Name) la valeur "goToPage".
b) Attribuez à la propriété Text la valeur "Aller à la page".
325
1.5.1.5.7.2
Pour coder le gestionnaire d'événements Click()
pour le contrôle Button
Procédure
1.
Cliquez deux fois sur le contrôle Button Aller à la page.
La classe code-behind du rapport s'affiche et indique qu'un gestionnaire d'événements goToPage_Click() a
été automatiquement généré.
2.
Convertissez le texte saisi dans le contrôle TextBox en un nombre entier, puis transmettez la valeur à la
méthode ShowNthPage() du contrôle CrystalReportViewer.
Remarque
Vous n'avez pas validé l'entrée d'un nombre entier dans le contrôle TextBox. Dans des conditions réelles,
vous ajouteriez un contrôle de validation configuré par rapport au contrôle TextBox.
myCrystalReportViewer.ShowNthPage(Convert.ToInt32(pageNumber.Text))
crystalReportViewer.ShowNthPage(Convert.ToInt32(pageNumber.Text));
1.5.1.5.7.3
Pour vérifier le contrôle Button goToPage
Procédure
1.
2.
3.
Le rapport Chart et tous les contrôles que vous avez ajoutés s'affichent.
4.
Saisissez 3 dans le contrôle pageNumber TextBox, puis cliquez sur Aller à la page.
La page se recharge et affiche la page 3 du rapport.
5.
1.5.1.5.8
Modification du facteur de zoom
Par défaut, la barre d'outils CrystalReportViewer permet de sélectionner un facteur de zoom compris entre
25 % et 400 % par incréments fixes de 25 %, 50 % ou 100 %. Dans cette section, vous allez ajouter un code
permettant de sélectionner n'importe quel facteur de zoom.
326
Vous avez besoin d'un contrôle TextBox dans lequel vous saisissez le facteur de zoom souhaité et d'un contrôle
Button afin de recharger la page.
1.5.1.5.8.1
Pour ajouter des contrôles TextBox et Button à
l'option Zoom
Procédure
1.
2.
Dans la Boîte à outils, faites glisser un contrôle TextBox vers la quatrième ligne de la troisième colonne du
tableau.
3.
a) Attribuez à ID (ou Name) la valeur "zoomFactor".
4.
Dans la Boîte à outils, faites glisser un contrôle Button vers la quatrième ligne de la quatrième colonne du
tableau.
5.
a) Attribuez à ID (ou Name) la valeur "updateZoomFactor".
b) Attribuez à Text la valeur "% Zoom".
1.5.1.5.8.2
Pour coder le gestionnaire d'événements Click()
pour le contrôle Button
Procédure
1.
Cliquez deux fois sur le contrôle Button updateZoomFactor.
La classe code-behind du rapport s'affiche et indique qu'un gestionnaire d'événements
updateZoomFactor_Click() a été automatiquement généré.
2.
Convertissez le texte saisi dans le contrôle TextBox en un nombre entier, puis transmettez la valeur à la
méthode Zoom() du contrôle CrystalReportViewer.
Remarque
myCrystalReportViewer.Zoom(Convert.ToInt32(zoomFactor.Text))
crystalReportViewer.Zoom(Convert.ToInt32(zoomFactor.Text));
327
1.5.1.5.8.3
Pour vérifier le contrôle Button
updateZoomFactor
Procédure
1.
2.
3.
4.
Saisissez "38" dans la zone de texte zoomFactor, puis cliquez sur Zoom.
La page se recharge et affiche la page en cours à une taille 38 % inférieure à sa taille d'origine.
5.
1.5.1.5.9
Recherche dans le rapport
Dans cette section, vous allez apprendre à rechercher un texte dans un rapport Crystal lié au contrôle
Vous avez besoin d'un contrôle TextBox pour y saisir la chaîne recherchée, d'un contrôle Button pour lancer la
recherche dans le rapport et d'un contrôle Label pour être informé de la réussite ou de l'échec de la recherche.
1.5.1.5.9.1
Pour ajouter des contrôles TextBox, Button et
Label à l'option Rechercher
Procédure
1.
2.
Dans la Boîte à outils, faites glisser un contrôle TextBox vers la cinquième ligne de la première colonne du
tableau.
3.
a) Attribuez à ID (ou Name) la valeur "searchText".
4.
Dans la Boîte à outils, faites glisser un contrôle Button vers la cinquième ligne de la deuxième colonne du
tableau.
5.
a) Attribuez à ID (ou Name) la valeur "search".
b) Attribuez à Text la valeur "Rechercher le texte".
6.
328
Dans la Boîte à outils, faites glisser un contrôle Label vers la cinquième ligne de la troisième colonne du
tableau.
a) Attribuez à ID (ou Name) la valeur "message".
c) Attribuez à ForeColor la valeur Red (couleur rouge).
7.
Créez la classe MessageConstants pour stocker les réponses standard sous forme de constantes chaîne pour
la recherche.
1.5.1.5.9.2
Pour coder le gestionnaire d'événements
search_Click() d'un site Web
Contexte
Vous devez ensuite appeler la méthode SearchAndHighlightText() dans le contrôle Button de recherche.
Remarque
Le comportement de la méthode SearchAndHighlightText() est différent selon que vous créez un site
Web ou un projet Windows.
Etant donné que le comportement de la méthode est différent pour un site Web et pour un projet Windows, suivez
la procédure adaptée à votre site Web ou votre projet Windows.
Procédure
1.
Cliquez deux fois sur le contrôle Button de recherche search.
La classe code-behind du rapport s'affiche et indique qu'un gestionnaire d'événements search_Click() a
2.
Extrayez le texte saisi dans le contrôle TextBox, puis transmettez la valeur à la méthode
SearchAndHighlightText() du contrôle CrystalReportViewer. Affectez l'appel de méthode à une variable
booléenne.
Remarque
Pour que la classe SearchDirection soit accessible, vous devez inclure une instruction "Imports"
[Visual Basic] ou "using" [C#] au début de la classe code-behind pour l'espace de noms
CrystalDecisions.Shared. (Vous avez ajouté cette déclaration dans la procédure Configuration d'un projet
[page 15].)
Dim mySearchResult As Boolean =
myCrystalReportViewer.SearchAndHighlightText(searchText.Text,
SearchDirection.Forward)
bool searchResult = crystalReportViewer.SearchAndHighlightText(searchText.Text,
SearchDirection.Forward);
329
3.
Créez un bloc conditionnel qui vérifie si la recherche a été fructueuse.
If Not mySearchResult Then
Else
End If
if(!searchResult)
{
}
else
{
}
4.
Dans le bloc If, affectez la constante MessageConstants.SUCCESS à la propriété Text du contrôle Label
message.
message.Text = MessageConstants.SUCCESS
message.Text = MessageConstants.SUCCESS;
5.
Dans le bloc Else, affectez la constante MessageConstants.FAILURE à la propriété Text du contrôle Label
message.
message.Text = MessageConstants.FAILURE
message.Text = MessageConstants.FAILURE;
1.5.1.5.9.3
Pour coder le gestionnaire d'événements
search_Click() d'un projet Windows
Contexte
Ignorez la procédure suivante pour les projets Windows et passez directement à la procédure de vérification qui
suit.
Procédure
1.
Cliquez deux fois sur le contrôle Button de recherche search.
La classe code-behind du rapport s'affiche et indique qu'un gestionnaire d'événements search_Click() a
330
2.
Extrayez le texte saisi dans le contrôle TextBox, puis transmettez la valeur à la méthode
SearchAndHighlightText() du contrôle CrystalReportViewer. Affectez l'appel de méthode à une variable
booléenne.
Dim mySearchResult As Boolean =
myCrystalReportViewer.SearchAndHighlightText(searchText.Text)
bool searchResult = crystalReportViewer.SearchAndHighlightText(searchText.Text);
3.
Créez un bloc conditionnel qui vérifie si la recherche a été fructueuse.
If mySearchResult Then
Else
End If
if(searchResult)
{
}
else
{
}
4.
Dans le bloc If, affectez la constante MessageConstants.SUCCESS à la propriété Text du contrôle Label
message.
5.
Dans le bloc Else, affectez la constante MessageConstants.FAILURE à la propriété Text du contrôle
message Label.
message.Text = MessageConstants.FAILURE
message.Text = MessageConstants.FAILURE;
1.5.1.5.9.4
Pour vérifier le contrôle Button de recherche
Procédure
1.
2.
331
3.
4.
Saisissez China dans la zone de texte searchText, puis cliquez sur Rechercher.
La page se recharge et affiche le résultat de la recherche ainsi qu'un message de réussite.
5.
Saisissez hello dans la zone de texte searchText, puis cliquez sur Rechercher.
La page se recharge et affiche un message d'échec.
6.
Résultats
Les autres options de personnalisation sont disponibles uniquement pour la version Web du contrôle
CrystalReportViewer. En conséquence, si vous développez un site Web, effectuez la procédure Ajout d'une
bordure au rapport pour un site Web [page 332].
Si vous développez un projet Windows, vous avez maintenant terminé le tutoriel.
1.5.1.5.10
Ajout d'une bordure au rapport pour un site Web
Dans cette section, vous allez apprendre à ajouter une bordure personnalisée au rapport Crystal pour un site Web.
Pour un projet Windows, les propriétés de largeur, de style et de couleur de la bordure ne sont pas disponibles.
Les styles de bordure sont répertoriés dans l'énumération BorderStyle. Les couleurs sont répertoriées dans
l'énumération KnownColor. Cependant, la propriété BorderColor du contrôle CrystalReportViewer extrait les
valeurs de la classe Color. Vous devez par conséquent convertir la valeur KnownColor en valeur Color.
Pour commencer, vous ajoutez les contrôles nécessaires au Web Form. Vous avez besoin d'un contrôle TextBox,
de deux contrôles DropDownList et d'un contrôle Button pour dessiner la bordure.
1.5.1.5.10.1 Pour ajouter les contrôles afin de définir la
largeur, le style et la couleur de la bordure
Procédure
1.
Ouvrez le Web Form.
2.
3.
Dans la boîte à outils, faites glisser un contrôle Label vers la sixième ligne de la première colonne du tableau.
4.
Sélectionnez le contrôle Label, puis dans la fenêtre Propriétés, attribuez à la propriété Text la valeur "Largeur
de la bordure".
5.
Dans la boîte à outils, faites glisser un contrôle TextBox dans la même cellule du tableau que le contrôle Label.
332
6.
Sélectionnez le contrôle TextBox, puis dans la fenêtre Propriétés, attribuez à ID (ou Name) la valeur
"borderWidth".
7.
Dans la boîte à outils, faites glisser un second contrôle Label vers la sixième ligne de la deuxième colonne du
tableau.
8.
Sélectionnez le contrôle Label, puis dans la fenêtre Propriétés, attribuez à Text la valeur "Style de bordure".
9.
Dans la boîte à outils, faites glisser un contrôle DropDownList dans la même cellule du tableau que le contrôle
Label.
10. Sélectionnez le contrôle DropDownList, puis dans la fenêtre Propriétés, attribuez à ID (ou Name) la valeur
"selectBorderStyle".
11. Dans la boîte à outils, faites glisser un troisième contrôle Label vers la sixième ligne de la troisième colonne du
tableau.
12. Sélectionnez le contrôle Label, puis dans la fenêtre Propriétés, attribuez à Textla valeur "Couleur de la
bordure".
13. Dans la boîte à outils, faites glisser un contrôle DropDownList dans la même cellule du tableau que le contrôle
Label.
14. Sélectionnez le contrôle DropDownList, puis dans la fenêtre Propriétés, attribuez à ID (ou Name) la valeur
"selectBorderColor".
15. Dans la boîte à outils, faites glisser un contrôle Button vers la sixième ligne de la quatrième colonne du
tableau.
16. Sélectionnez le contrôle Button, puis effectuez les opérations suivantes dans la fenêtre Propriétés :
a) Attribuez à ID (ou Name) la valeur "drawBorder".
b) Attribuez à la propriété Text la valeur "Dessiner une bordure".
1.5.1.5.10.2
Pour remplir les contrôles DropDownList
Contexte
Vous devez à présent remplir les contrôles DropDownList avec les styles ou les couleurs de bordure disponibles
pour le contrôle CrystalReportViewer. Les contrôles DropDownList sont remplis dans la méthode
Pour un site Web, les styles de bordure sont stockés dans l'énumération
System.Web.UI.WebControls.BorderStyle. Les couleurs de bordure sont extraites à partir de l'énumération
System.Drawing.KnownColor.
333
Procédure
1.
[C#] au début de la classe de l'espace de noms System.Web.UI.WebControls et System.Drawing (si cet
espace de noms n'a pas déjà été déclaré).
2.
Dans le bloc conditionnel Not IsPostBack de la méthode ConfigureCrystalReports(), affectez
l'énumération BorderStyle à la propriété DataSource du contrôle DropDownList selectBorderStyle.
selectBorderStyle.DataSource = System.Enum.GetValues(GetType(BorderStyle))
selectBorderStyle.DataSource = System.Enum.GetValues(typeof(BorderStyle));
3.
Liez la source de données au contrôle DropDownList selectBorderStyle.
selectBorderStyle.DataBind()
selectBorderStyle.DataBind();
4.
Toujours dans le bloc conditionnel Not IsPostBack, affectez l'énumération BorderStyle à la propriété
DataSource du contrôle DropDownList selectBorderStyle.
selectBorderColor.DataSource =
System.Enum.GetValues(GetType(KnownColor))
selectBorderColor.DataSource =
System.Enum.GetValues(typeof(KnownColor));
5.
Liez la source de données au contrôle DropDownList selectBorderColor.
selectBorderColor.DataBind()
selectBorderColor.DataBind();
334
1.5.1.5.10.3
bordure
Pour coder le contrôle Button Dessiner une
Contexte
Ensuite, vous allez affecter les valeurs aux propriétés BorderWidth, BorderStyle et BorderColor du contrôle
Procédure
1.
Ouvrez le Web Form.
2.
3.
Cliquez deux fois sur le contrôle Button Dessiner une bordure.
La classe code-behind du rapport s'affiche et indique qu'un gestionnaire d'événements
drawBorder_Click() a été automatiquement généré.
4.
Dans le gestionnaire d'événements drawBorder_Click(), affectez le texte saisi dans le contrôle TextBox
borderWidth à la propriété BorderWidth du contrôle CrystalReportViewer.
Remarque
myCrystalReportViewer.BorderWidth =
Unit.Parse(borderWidth.Text.ToString())
crystalReportViewer.BorderWidth =
Convert.ToInt32(borderWidth.Text);
5.
Dans le contrôle DropDownList selectBorderStyle, extrayez l'index sélectionné, puis convertissez-le en
une valeur BorderStyle. Affectez la valeur BorderStyle à la propriété BorderStyle du contrôle
myCrystalReportViewer.BorderStyle = CType(selectBorderStyle.SelectedIndex,
BorderStyle)
crystalReportViewer.BorderStyle = (BorderStyle)selectBorderStyle.SelectedIndex;
335
6.
Dans le contrôle DropDownList selectBorderColor, extrayez l'élément sélectionné sous la forme d'une chaîne,
puis transmettez-le à la méthode FromName() de la classe Color. Affectez la valeur Color à la propriété
BorderColor du contrôle CrystalReportViewer.
myCrystalReportViewer.BorderColor =
Color.FromName(selectBorderColor.SelectedItem.Text)
crystalReportViewer.BorderColor =
Color.FromName(selectBorderColor.SelectedItem.Text);
1.5.1.5.10.4
Crystal
Pour dessiner une bordure autour du rapport
Procédure
1.
2.
3.
4.
Pour la largeur de la bordure, saisissez10.
5.
Pour le style de la bordure, sélectionnez Double.
6.
Pour la couleur de la bordure, sélectionnez SteelBlue.
7.
Cliquez sur le bouton Dessiner une bordure.
La page se recharge et affiche une bordure autour du rapport Crystal.
8.
1.5.1.5.11
site Web
Configuration de la persistance Session pour un
Dans cette section, vous allez apprendre à configurer la persistance Session pour les événements de clic.
Lorsqu'une page Web est rechargée lors d'un événement de clic, les modifications apportées au modèle d'objet
CrystalReportViewer sont perdues.
336
1.5.1.5.11.1
Web
Pour montrer le manque de persistance d'un site
Procédure
1.
2.
3.
4.
Dans le contrôle DropDownList selectBackColor, sélectionnez la couleur bleue.
5.
La page se recharge pour afficher le rapport sans aucune barre d'outils, avec un arrière-plan bleu.
6.
Pour la largeur de la bordure, saisissez "10".
7.
Pour le style de la bordure, sélectionnez "Double".
8.
Pour la couleur de la bordure, sélectionnez "SteelBlue".
9.
Cliquez sur Dessiner Bordure.
La page se recharge pour afficher une bordure autour du rapport Crystal et la couleur bleue de l'arrière-plan
disparaît.
10. Saisissez "3" dans le contrôle TextBox pageNumber, puis cliquez sur Aller à la page.
La page se recharge pour afficher la page 3 et la bordure du rapport n'est plus visible.
11. Revenez dans Visual Studio, puis cliquez sur Arrêter pour quitter le mode débogage.
1.5.1.5.11.2
Pour ajouter un code d'affectation Session au
gestionnaire d'événements drawBorder_Click()
Contexte
Vous devez ajouter un code de persistance à votre application afin que les modifications apportées au modèle
d'objet CrystalReportViewer soient rendues persistantes lorsque les pages Web sont rechargées.
Pour commencer, vous ajoutez un code de persistance pour les valeurs de bordure au gestionnaire d'événements
drawBorder_Click(), auquel ces valeurs sont affectées en premier. Puis, dans la méthode
ConfigureCrystalReports(), les valeurs stockées dans Session sont extraites et affectées aux propriétés
respectives de la classe CrystalReportViewer.
337
Procédure
Dans le gestionnaire d'événements drawBorder_Click(), à la suite du code existant, ajoutez les quatre
affectations Session BackColor, BorderColor, BorderStyle et BorderWidth.
Session("myBorderColor") =
myCrystalReportViewer.BorderColor.ToString()
Session("myBorderStyle") = myCrystalReportViewer.BorderStyle
Session("myBorderWidth") = myCrystalReportViewer.BorderWidth
Session["borderColor"] =
crystalReportViewer.BorderColor.ToString();
Session["borderStyle"] = crystalReportViewer.BorderStyle;
Session["borderWidth"] = crystalReportViewer.BorderWidth;
1.5.1.5.11.3
Pour ajouter un code d'extraction Session à la
méthode ConfigureCrystalReports()
Contexte
Vous pouvez maintenant extraire ces valeurs de Session dans la méthode ConfigureCrystalReports().
Procédure
1.
A la fin de la méthode ConfigureCrystalReports(), créez un bloc If qui vérifie si la variable Session
BackColor est null.
Si elle n'est pas null, dans le bloc If, extrayez la propriété BackColor de Session et effectuez un cast de
celle-ci en chaîne. Transmettez la chaîne à la méthode FromName() de la classe Color et affectez l'instance
Color à la propriété BackColor de l'instance CrystalReportViewer.
If Not IsNothing(Session("myBackColor")) Then
Color.FromName(CType(Session("myBackColor"), String))
End If
if (Session["backColor"] != null)
{
crystalReportViewer.BackColor = Color.FromName((string)Session["backColor"]);
}
2.
Créez un second bloc If qui vérifie si la variable Session BorderColor est null. Si elle n'est pas null, dans le
bloc If, extrayez la propriété BorderColor de Session et effectuez un cast de celle-ci en chaîne.
338
Transmettez la chaîne à la méthode FromName() de la classe Color et affectez l'instance Color à la
propriété BorderColor de l'instance CrystalReportViewer.
If Not IsNothing(Session("myBorderColor")) Then
myCrystalReportViewer.BorderColor =
Color.FromName(CType(Session("myBorderColor"), String))
End If
if (Session["borderColor"] != null)
{
crystalReportViewer.BorderColor =
Color.FromName((string)Session["borderColor"]);
}
3.
Créez un troisième bloc If qui vérifie si la variable Session BorderStyle est null. Si elle n'est pas null, dans le
bloc If, extrayez la propriété BorderStyle de Session et effectuez un cast de celle-ci en BorderStyle.
myCrystalReportViewer.BorderStyle = CType(Session("myBorderStyle"), BorderStyle)
if (Session["borderStyle"] != null)
{
crystalReportViewer.BorderStyle = (BorderStyle)Session["borderStyle"];
}
4.
Créez un quatrième bloc If qui vérifie si la variable Session BorderWidth est null. Si elle n'est pas null, dans le
bloc If, extrayez la propriété BorderWidth de Session et convertissez-la en entier.
myCrystalReportViewer.BorderWidth = Convert.ToInt32(Session("myBorderWidth"))
if (Session["borderStyle"] != null)
{
crystalReportViewer.BorderWidth = Convert.ToInt32(Session["borderStyle"]);
}
1.5.1.5.11.4
Pour coder le contrôle Button drawBorder
Contexte
Dans la procédure suivante, vous ajoutez une persistance Session au gestionnaire d'événements de clic du
contrôle Button de réaffichage.
339
Procédure
1.
Dans le gestionnaire d'événements redisplay_Click(), affectez l'élément sélectionné du contrôle
DropDownList selectBackColor à Session.
Session("myBackColor") = selectBackColor.SelectedItem.Text
Session["backColor"] = selectBackColor.SelectedItem.Text;
2.
Dans le gestionnaire d'événements drawBorder_Click(), affectez la propriété Text du contrôle TextBox
borderWidth à Session.
Session("myBorderWidth") = borderWidth.Text
Session["borderWidth"] = borderWidth.Text;
3.
Affectez l'index sélectionné dans DropDownList selectBorderStyle à Session.
Session("myBorderStyle") = selectBorderStyle.SelectedIndex
Session["borderStyle"] = selectBorderStyle.SelectedIndex;
4.
Affectez l'élément sélectionné dans DropDownList selectBorderColor à Session.
Session("myBorderColor") = selectBorderColor.SelectedItem.Text
Session["borderColor"] = selectBorderColor.SelectedItem.Text;
Résultats
Vous pouvez maintenant générer et exécuter le projet, afin de vérifier que les changements apportés au rapport
sont persistants entre les événements de clic.
1.5.2
Tutoriels du modèle d'objet ReportDocument
340
1.5.2.1
Tutoriel : Persistance du modèle d'objet
ReportDocument à l'aide de Session
programmation sur un rapport au moment de l'exécution. Vous apprendrez également à utiliser Session pour
garantir la persistance de ces modifications au fur et à mesure du rechargement des pages Web.
Seules les applications Web nécessitant une persistance Session, ce tutoriel ne s'applique pas aux projets
Windows.
Introduction
Le projet que vous allez créer dans ce tutoriel utilise un Web Form contenant un contrôle CrystalReportViewer et
deux boutons qui modifient l'ordre de tri du rapport dans le modèle d'objet ReportDocument.
Vous allez tout d'abord créer le projet sans la méthode de persistance Session. Sans la persistance, vous pouvez
constater que la modification de l'ordre de tri ne dure que le temps d'un événement de clic.
Vous ajouterez ensuite la méthode de persistance Session au projet. L'instance ReportDocument est placée
dans Session au moment de la création, ainsi qu'à chaque modification de l'état de cette instance
ReportDocument.
Chaque fois que le rapport doit être réaffiché, l'instance ReportDocument est extraite de Session et liée au
contrôle CrystalReportViewer. Ceci permet de garantir que chaque fois que le rapport est affiché, l'utilisateur
visualise la version la plus récente de l'instance ReportDocument.
Remarque
Ce tutoriel utilise la méthode Session, car vous allez rendre persistantes les modifications apportées au modèle
d'objet ReportDocument. Si vous envisagez d'utiliser uniquement le modèle d'objet limité contenu dans le
contrôle CrystalReportViewer, utilisez exclusivement ViewState.
Lors de l'utilisation de Session pour rendre persistant un objet
ReportDocument, d'autres modèles de persistance sont-ils utilisés ?
Lors de l'utilisation de Session pour rendre persistant un objet ReportDocument, d'autres modèles de persistance
sont-ils utilisés ?
Oui. Dans une application Web ASP.NET, les objets utilisent généralement Session pour la persistance, tandis que
les contrôles serveur Web utilisent ViewState. Du fait qu'une application SAP Crystal Reports, version
développeur pour Microsoft Visual Studio utilise des objets et des contrôles serveur Web pour interagir avec les
rapports, la persistance est partagée par Session et ViewState :
341
●
Session rend persistant le modèle d'objet ReportDocument, qui interagit par programmation avec le rapport
au moment de l'exécution.
●
ViewState rend persistant le contrôle CrystalReportViewer, qui affiche le rapport. Plus particulièrement,
ViewState rend persistantes les propriétés affichées, définies dans la barre d'outils de CrystalReportViewer.
ViewState rend également persistants les événements (tels que zoom et NextPage) déclenchés à partir des
boutons de la barre d'outils.
La persistance de ViewState est gérée automatiquement. Vous ne codez donc que la persistance de Session dans
ce tutoriel.
Exemple de code
version terminée.
●
Site Web C# : CS_Web_RDObjMod_Session
●
Site Web Visual Basic : VB_Web_RDObjMod_Session
1.5.2.1.1
Configuration des boutons sur le Web Form
Vous allez tout d'abord ajouter deux boutons au Web Form, leur donner un nom, puis créer des événements de
clic pour chacun d'eux.
1.5.2.1.1.1
Pour ajouter des boutons au Web Form
Procédure
1.
2.
3.
Cliquez sur le contrôle CrystalReportViewer et appuyez sur la FLECHE GAUCHE du clavier afin de faire
apparaître un curseur clignotant, puis appuyez sur la touche ENTREE.
342
Le contrôle CrystalReportViewer descend d'une ligne.
4.
Dans la boîte à outils, faites glisser un contrôle serveur Web Button au-dessus du contrôle
5.
Cliquez à droite du contrôle Button afin de faire apparaître un curseur clignotant, puis appuyez deux fois sur la
barre espace.
6.
Dans la boîte à outils, faites glisser un second contrôle serveur Web Button à droite du premier contrôle
Button.
1.5.2.1.1.2
Pour définir les propriétés Text et ID de chaque
contrôle Button
Procédure
1.
Cliquez sur le premier contrôle serveur Web Button pour le sélectionner.
2.
Dans la fenêtre Propriétés :
○
Attribuez à ID la valeur "sortOrderDescending".
○
Attribuez à Text la valeur "Trier par ordre décroissant".
3.
Cliquez sur le second contrôle serveur Web Button pour le sélectionner.
4.
○
Attribuez à ID la valeur "sortOrderAscending".
○
Attribuez à Text la valeur "Trier par ordre croissant".
1.5.2.1.1.3
Création d'événements de clic pour chaque
contrôle Button
Procédure
1.
Cliquez deux fois sur le premier contrôle serveur Web Button.
La classe code-behind s'ouvre et une méthode d'événement sortOrderDescending_Click() est créée
dans la partie inférieure de la classe.
2.
Revenez au mode Design de la page Default.aspx.
3.
Cliquez deux fois sur le second contrôle serveur Web Button.
La classe code-behind s'ouvre et une méthode d'événement sortOrderAscending_Click() est créée dans
la partie inférieure de la classe.
343
1.5.2.1.2
Programmation des événements Button avec un
ordre de tri
Dans cette procédure, vous allez programmer le modèle d'objet ReportDocument du rapport dans la méthode
d'événement et définir un ordre de tri croissant dans une méthode d'événement et un ordre de tri décroissant
dans l'autre méthode d'événement.
1.5.2.1.2.1
Pour programmer le modèle d'objet
ReportDocument du rapport dans la méthode d'événement
sortOrderDescending_Click
Procédure
1.
Ouvrez la classe code-behind et recherchez la méthode d'événement sortOrderDescending_Click().
2.
Dans la méthode d'événement, extrayez la propriété SortFields de la propriété DataDefinition de
l'instance de rapport et affectez-la à une instance de la classe indexée SortFields.
Dim mySortFields As SortFields =
hierarchicalGroupingReport.DataDefinition.SortFields
SortFields sortFields = hierarchicalGroupingReport.DataDefinition.SortFields;
3.
Extrayez la première instance SortField de la classe indexée SortFields et affectez-la à une variable
appelée firstSortField.
Remarque
La classe indexée SortFields est basée sur 0.
Dim firstSortField As SortField = mySortFields(0)
SortField firstSortField = sortFields[0];
4.
Affectez à la propriété SortDirection de firstSortField un ordre décroissant, en utilisant la sélection
DescendingOrder de l'énumération SortDirection.
firstSortField.SortDirection = SortDirection.DescendingOrder
firstSortField.SortDirection = SortDirection.DescendingOrder;
344
5.
Réaffectez maintenant ce rapport (avec l'ordre de tri modifié dans le modèle d'objet ReportDocument) à la
propriété ReportSource du contrôle CrystalReportViewer.
myCrystalReportViewer.ReportSource = hierarchicalGroupingReport
crystalReportViewer.ReportSource = hierarchicalGroupingReport;
Résultats
Dans la procédure suivante, vous allez saisir le code de la méthode d'événement
sortOrderAscending_Click(). Le code est identique, à l'exception du paramètre de propriété
SortDirection.
1.5.2.1.2.2
Pour programmer le modèle d'objet
ReportDocument du rapport dans la méthode d'événement
sortOrderAscending_Click
Procédure
1.
Ouvrez la classe code-behind et recherchez la méthode d'événement sortOrderAscending_Click().
2.
Dans la méthode d'événement, extrayez la propriété SortFields de la propriété DataDefinition de
l'instance de rapport et affectez-la à une instance de la classe indexée SortFields.
Dim mySortFields As SortFields =
hierarchicalGroupingReport.DataDefinition.SortFields
SortFields sortFields = hierarchicalGroupingReport.DataDefinition.SortFields;
3.
Extrayez la première instance SortField de la classe indexée SortFields et affectez-la à une variable
appelée firstSortField.
Remarque
La classe indexée SortFields est basée sur 0.
Dim firstSortField As SortField = mySortFields(0)
SortField firstSortField = sortFields[0];
345
4.
Attribuez à la propriété SortDirection de l'instance firstSortField un ordre croissant, en utilisant la
sélection AscendingOrder de l'énumération SortDirection.
firstSortField.SortDirection = SortDirection.AscendingOrder
firstSortField.SortDirection = SortDirection.AscendingOrder;
5.
Réaffectez maintenant ce rapport (avec l'ordre de tri modifié dans le modèle d'objet ReportDocument) à la
propriété ReportSource du contrôle CrystalReportViewer.
myCrystalReportViewer.ReportSource = hierarchicalGroupingReport
crystalReportViewer.ReportSource = hierarchicalGroupingReport;
Résultats
La programmation du modèle d'objet ReportDocument du rapport dans chaque méthode d'événement est
terminée. La section suivante va permettre de vérifier le bon fonctionnement de ces modifications d'ordre de tri et
leur persistance lorsque la méthode Session n'est pas appliquée.
1.5.2.1.3
Vérification et détermination des erreurs de
persistance
Dans cette section, vous verrez que, sans l'utilisation de la méthode de persistance Session, les modifications de
tri ne sont pas conservées lorsque la page est rechargée afin de refléter les changements apportés aux
paramètres d'affichage.
1.5.2.1.3.1
Pour vérifier les modifications par
programmation apportées à l'ordre de tri codé dans le projet
Procédure
1.
2.
3.
Si vous ne rencontrez aucune erreur lors de la génération, la page Default.aspx est chargée dans le
navigateur, avec le rapport Hierarchical Grouping généré dans le formulaire.
346
4.
Observez attentivement l'ordre de tri. Vous pouvez imprimer la page pour comparer les modifications dans
l'ordre de tri.
5.
Cliquez sur le bouton Trier par ordre décroissant.
L'ordre de tri s'inverse.
6.
Cliquez sur le bouton Trier par ordre croissant.
L'ordre de tri reprend sa valeur d'origine (croissant).
1.5.2.1.3.2
Pour vérifier si les modifications de tri sont
conservées lorsque les paramètres d'affichage sont modifiés
Contexte
Dans la procédure suivante, vous allez vérifier si l'ordre de tri est conservé lorsque d'autres modifications (de
paramètres d'affichage, par exemple) sont apportées à la page.
Procédure
1.
2.
Dans la barre d'outils du rapport, ajustez le zoom de 100 % à 125 %.
La page recharge le rapport avec un facteur de zoom égal à 125 %, mais l'inversion du tri n'a pas été
conservée.
3.
Cliquez à nouveau sur le bouton Trier par ordre décroissant.
4.
5.
La page recharge le rapport avec un facteur de zoom égal à 100 %, mais l'inversion du tri n'a pas été
conservée.
6.
Résultats
Ce test permet de constater qu'à ce stade du tutoriel la persistance échoue. L'ordre de tri n'est appliqué que
lorsque l'utilisateur clique sur l'un des boutons de tri. L'ordre de tri est annulé lorsque l'utilisateur interagit avec la
page pour régler le zoom ou ouvrir une autre page dans un rapport comprenant plusieurs pages. Par conséquent,
vous devez ajouter du code pour rendre persistant le changement d'ordre de tri effectué avec Session dans le
modèle d'objet ReportDocument.
347
1.5.2.1.4
Ajout de code Session
Dans cette section, vous allez apprendre à utiliser Session pour rendre persistant le changement d'ordre de tri du
rapport. Vous allez ajouter, à la méthode ConfigureCrystalReports() créée lors de la configuration de votre
projet (voir Configuration d'un projet [page 15]), du code permettant de rechercher Session et de recharger
immédiatement l'instance du rapport dans Session lorsqu'un utilisateur modifie l'ordre de tri.
1.5.2.1.4.1
Pour ajouter à la méthode
ConfigureCrystalReports() du code permettant de rechercher
Session
Procédure
1.
Dans la méthode ConfigureCrystalReports(), avant le code existant, créez un bloc conditionnel if/else
vérifiant si un objet Session nommé hierarchicalGroupingReport existe.
Vous pouvez utiliser le nom d'identificateur de votre choix pour cet objet Session. Choisissez un identificateur
unique tel que le nom de l'instance de rapport.
If (Session("hierarchicalGroupingReport") Is Nothing) Then
Else
End If
if(Session["hierarchicalGroupingReport"] == null)
{
}
else
{
}
2.
Si vous utilisez un rapport incorporé, déplacez la ligne de code qui déclare et instancie le rapport de son
emplacement actuel vers le bloc If.
hierarchicalGroupingReport = New Hierarchical_Grouping()
Else
End If
if (Session["hierarchicalGroupingReport"] == null)
{
hierarchicalGroupingReport = new Hierarchical_Grouping();
}
else
{
}
348
3.
Si vous utilisez un rapport non incorporé, déplacez les deux lignes de code qui déclarent et instancient le
rapport, puis le chargent de son emplacement actuel dans le répertoire vers le bloc If.
Remarque
Consultez le lien Répertoire d'exemples de rapports [page 15] pour déterminer le chemin correct des
exemples de rapports.
hierarchicalGroupingReport = New ReportDocument()
hierarchicalGroupingReport.Load("C:\Program Files\Microsoft Visual Studio
9.0\Crystal Reports\Samples\fr\Reports\Feature Examples\Hierarchical
Grouping.rpt")
Else
End If
if(Session["hierarchicalGroupingReport"] == null)
{
hierarchicalGroupingReport = new ReportDocument();
hierarchicalGroupingReport.Load("C:\Program Files\Microsoft Visual Studio
9.0\Crystal Reports\Samples\fr\Reports\Feature Examples\Hierarchical
Grouping.rpt");
}
else
{
}
4.
Dans le bloc If, affectez le rapport dans Session, en utilisant le nom de la variable du rapport comme
identificateur Session.
Session("hierarchicalGroupingReport") = hierarchicalGroupingReport
Session["hierarchicalGroupingReport"] = hierarchicalGroupingReport;
Ce bloc est maintenant finalisé. Le bloc If est appliqué si le rapport ne se trouve pas dans Session. Le bloc Else
est appliqué si le rapport se trouve dans Session ; par conséquent, le but du bloc Else est d'extraire le rapport
de Session vers une instance du rapport.
5.
Dans le bloc Else, affectez le rapport stocké dans Session à l'instance du rapport.
hierarchicalGroupingReport = CType(Session("hierarchicalGroupingReport"),
ReportDocument)
hierarchicalGroupingReport =
(ReportDocument)Session["hierarchicalGroupingReport"];
Remarque
Session ne renvoyant que des objets génériques, vous devez effectuer un transtypage du rapport en type
de rapport. Que vous utilisiez des rapports incorporés ou non incorporés, effectuez un transtypage de
l'objet extrait en objet de type ReportDocument.
349
En dehors et en dessous du bloc conditionnel, le code restant lie l'instance du rapport à la propriété
Résultats
Comme cela est expliqué dans la section Configuration d'un projet (voir Configuration d'un projet [page 15]), la
méthode ConfigureCrystalReports() est appelée à chaque rechargement de page. La modification de cette
méthode garantit par conséquent l'extraction et le chargement du rapport le plus récent (qu'il soit nouveau ou
stocké dans Session). Toutefois, rien n'a encore été écrit pour mettre réellement à jour l'instance du rapport.
Dans la section suivante, vous allez mettre à jour l'instance de rapport dans Session à chaque modification de
l'ordre de tri.
1.5.2.1.4.2
Pour mettre à jour l'instance de rapport dans
Session pour la méthode d'événement
sortOrderDescending_Click
Procédure
1.
Dans la méthode d'événement sortOrderDescending_Click(), supprimez la dernière ligne de code qui lie
le contrôle CrystalReportViewer au rapport.
Vous devez donc obtenir les trois lignes de code permettant de modifier le sens du tri.
2.
Sous ces trois lignes de code, affectez l'instance hierarchicalGroupingReport (mise à jour avec un nouvel
ordre de tri) dans Session à l'aide du même identificateur que celui utilisé dans la méthode
Remarque
Pour simplifier l'opération, copiez et collez cette ligne de code depuis la méthode
3.
Enfin, ajoutez un appel à la méthode ConfigureCrystalReports() afin d'obtenir la dernière instance
hierarchicalGroupingReport de Session (celle que vous venez de mettre jour) et liez-la au contrôle
350
Résultats
Répétez maintenant les mêmes étapes pour la seconde méthode d'événement.
1.5.2.1.4.3
Pour mettre à jour l'instance de rapport dans
Session pour la méthode d'événement
sortOrderAscending_Click
Procédure
1.
Dans la méthode d'événement sortOrderAscending_Click(), supprimez la dernière ligne de code qui lie
le contrôle CrystalReportViewer au rapport.
Vous devez donc obtenir les trois lignes de code permettant de modifier le sens du tri.
2.
Sous ces trois lignes de code, affectez l'instance hierarchicalGroupingReport (mise à jour avec un nouvel
ordre de tri) dans Session à l'aide du même identificateur que celui utilisé dans la méthode
Pour simplifier l'opération, copiez et collez cette ligne de code depuis la méthode
3.
Enfin, ajoutez un appel à la méthode ConfigureCrystalReports() afin d'obtenir la dernière instance
hierarchicalGroupingReport de Session (celle que vous venez de mettre jour) et liez-la au contrôle
Résultats
Vous pouvez à présent vérifier si les modifications de tri ont bien été rendues persistantes.
351
1.5.2.1.5
Vérification et détermination du caractère correct
de la persistance
Dans cette section, vous allez vérifier si les modifications de tri ont bien été rendues persistantes à présent que
Session est utilisée.
1.5.2.1.5.1
Pour vérifier si les modifications de tri ont bien
été rendues persistantes
Procédure
1.
2.
Si vous ne rencontrez aucune erreur lors de la génération, la page Default.aspx est chargée dans le
navigateur, avec le rapport Hierarchical Grouping généré dans le formulaire.
3.
Observez attentivement l'ordre de tri. Vous pouvez imprimer la page pour comparer les modifications dans
l'ordre de tri.
4.
5.
La page recharge le rapport avec un facteur de zoom égal à 125 %. L'inversion de l'ordre de tri a bien été
conservée.
6.
Cliquez sur le bouton Trier par ordre croissant.
L'ordre de tri est rétabli.
7.
La page recharge le rapport avec un facteur de zoom égal à 100 %. L'ordre de tri a conservé le paramétrage
de l'étape précédente.
Résultats
Ce test permet de constater que la persistance fonctionne maintenant correctement.
352
1.5.2.2
Server sécurisée à l'aide de l'authentification SQL
Introduction
Pour vous connecter à une base de données SQL Server sécurisée, vous utilisez des classes du modèle d'objet
ReportDocument.
L'objet ReportDocument comporte une propriété Database qui renvoie une instance Database. Cette instance
Database contient les informations de base de données pour le rapport, notamment une propriété Tables qui
renvoie une instance de classe indexée Tables. Chaque instance Table peut être extraite de la classe indexée
Tables.
La connexion se produit au niveau granulaire de chaque instance Table, qui doit obtenir une autorisation d'accès
individuel à la base de données SQL Server sécurisée. Ceci s'effectue en plaçant les informations de connexion
dans une instance ConnectionInfo puis, à l'intérieur d'une boucle for, en appliquant cette instance
ConnectionInfo à la propriété ConnectionInfo de chaque instance Table.
Les propriétés de la classe ConnectionInfo sont les suivantes :
●
ServerName
●
DatabaseName
●
UserID
●
Password
●
IntegratedSecurity (non utilisée dans ce tutoriel)
Remarque
Si vous souhaitez suivre un tutoriel qui utilise l'authentification Windows (et utilise donc la propriété
IntegratedSecurity au lieu des propriétés UserID et Password), voir Tutoriel : Connexion à une base de données
SQL Server sécurisée à l'aide de la sécurité intégrée [page 370].
Si vous définissez uniquement les propriétés DatabaseName, UserID et Password, vous serez connecté au
serveur et à la base de données par défaut spécifiés dans le rapport. Toutefois, si vous affectez une autre
propriété ServerName, vous pouvez rediriger le rapport vers un serveur différent au moment de l'exécution.
Vous allez tout d'abord créer un rapport contenant des données d'une base de données SQL Server sécurisée.
Vous pouvez effectuer ce tutoriel en utilisant les classes du modèle d'objet CrystalReportViewer ; cependant, il est
recommandé d'utiliser le modèle d'objet ReportDocument.
353
Exemple de code
version terminée.
●
Site Web C# : CS_Web_RDObjMod_DBLogon
●
Projet Windows C# : CS_Win_RDObjMod_DBLogon
●
Site Web Visual Basic : VB_Web_RDObjMod_DBLogon
●
Projet Windows Visual Basic : VB_Win_RDObjMod_DBLogon
Tutoriel : Connexion à une base de données SQL Server sécurisée [page 244]
1.5.2.2.1
données SQL Server sécurisée
Créez tout d'abord un rapport dont les informations proviennent de la base de données Northwind.
Remarque
Northwind est un exemple de base de données fourni avec SQL Server.
Une configuration préalable est requise avant de commencer ce tutoriel.
Tutoriel : Connexion à une base de données SQL Server sécurisée à l'aide de l'authentification SQL [page 353]
354
1.5.2.2.1.1
données
Configuration préalable requise de la base de
Procédure
1.
○
Si vous disposez de SQL Server (ou de la version OEM, MSDE), il doit être configuré de manière à exiger
une authentification SQL Server pour l'utiliser dans ce tutoriel.
○
Si vous ne disposez pas de SQL Server (ou de la version OEM, MSDE), vous devez installer MSDE en
attribuant à l'authentification SQL Server la valeur True pour l'utiliser dans ce tutoriel.
2.
l'authentification SQL Server est bien acceptée.
3.
Vous devez créer un compte à accès limité qui sera utilisé au sein du site Web.
1.5.2.2.1.2
sécurisées à partir de la base de données Northwind
Contexte
Remarque
configuration.
Procédure
1.
2.
Crystal.
3.
4.
5.
6.
7.
355
8.
9.
Saisissez les valeurs correspondant à votre serveur de base de données, l'ID utilisateur et le mot de passe
dans les champs Serveur, ID utilisateur et Mot de passe.
Laissez la case à cocher Sécurité intégrée désactivée, car vous utilisez l'authentification SQL Server au lieu de
14. Maintenez la touche CTRL enfoncée et cliquez sur CompanyName, ContactName et City.
Suivant.
Résultats
Vous êtes maintenant prêt à lier le rapport au contrôle CrystalReportViewer et à configurer par
programmation la connexion à la base de données.
1.5.2.2.2
Liaison du rapport
Web Form ou Windows Form. Lors de l'étape précédente, vous avez ajouté un rapport NorthwindCustomers au
projet.
Dans cette section, vous allez instancier le rapport NorthwindCustomers et le lier au contrôle
CrystalReportViewer. Vous allez ensuite vérifier si le rapport s'affiche correctement lorsque les valeurs actuelles
n'ont pas été définies pour ce paramètre.
Vous pouvez instancier et lier le rapport de deux façons :
●
En tant que rapport incorporé.
●
En tant que rapport non incorporé.
Choisissez l'une des deux (mais pas les deux) procédures ci-dessous.
●
Si vous utilisez des rapports incorporés, effectuez la procédure suivante afin d'instancier le rapport sous
forme de rapport incorporé.
●
Si vous utilisez des rapports non incorporés, effectuez la seconde procédure afin d'instancier le rapport sous
forme de rapport non incorporé.
356
1.5.2.2.2.1
Pour instancier le rapport NorthwindCustomers
sous forme de rapport incorporé et le lier au contrôle
CrystalReportViewer
Procédure
1.
2.
3.
Ajoutez une nouvelle déclaration de niveau classe pour la classe wrapper du rapport NorthwindCustomers, en
utilisant la variable northwindCustomersReport. Définissez le modificateur d'accès à private.
Private northwindCustomersReport As NorthwindCustomers
private NorthwindCustomers northwindCustomersReport;
4.
Dans la méthode ConfigureCrystalReports(), instanciez la classe wrapper du rapport.
Remarque
Vous avez créé la méthode ConfigureCrystalReports() dans Configuration d'un projet [page 15].
northwindCustomersReport = New NorthwindCustomers()
northwindCustomersReport = new NorthwindCustomers();
5.
Sur la ligne suivante, au-dessous de l'instanciation du rapport, liez la propriété ReportSource du contrôle
CrystalReportViewer à la classe de rapport instanciée (nom de la variable : northwindCustomersReport).
myCrystalReportViewer.ReportSource = northwindCustomersReport
crystalReportViewer.ReportSource = northwindCustomersReport;
Résultats
357
1.5.2.2.2.2
sous forme de rapport non incorporé et le lier au contrôle
CrystalReportViewer
Procédure
1.
2.
3.
Ajoutez une nouvelle déclaration de niveau classe pour la classe wrapper du rapport ReportDocument, en
Private northwindCustomersReport As ReportDocument
private ReportDocument northwindCustomersReport;
Remarque
La classe ReportDocument est un membre de l'espace de noms CrystalDecisions.CrystalReports.Engine.
Vous avez ajouté une déclaration "Imports" [Visual Basic] ou "using" [C#] pour cet espace de
noms dans la section Configuration d'un projet [page 15]. Lorsque vous instanciez ReportDocument et
chargez un rapport dans l'espace de noms, vous accédez au rapport via le SDK sans l'incorporer.
4.
projet [page 15]), instanciez la classe ReportDocument.
northwindCustomersReport = New ReportDocument()
northwindCustomersReport = new ReportDocument();
5.
Windows :
○
○
358
Remarque
exécutable.
6.
Appelez la méthode Load() de l'instance ReportDocument et transmettez-lui la variable chaîne reportPath.
northwindCustomersReport.Load(reportPath)
northwindCustomersReport.Load(reportPath);
7.
1.5.2.2.2.3
NorthwindCustomers
Contexte
Que vous ayez choisi d'instancier une classe de rapport incorporé ou une classe de rapport non incorporé via la
classe ReportDocument, le nom de la variable utilisée est identique : northwindCustomersReport. Vous pouvez
ainsi utiliser un bloc de code commun dans les procédures suivantes.
Procédure
1.
2.
3.
sous-répertoire.
359
Remarque
4.
Le rapport NorthwindCustomers ne s'affiche pas, car le code de connexion à la base de données n'a pas été
ajouté.
Remarque
Les résultats peuvent varier selon la version de SAP Crystal Reports utilisée. Par exemple, si vous avez
installé SAP Crystal Reports 10 ou une version ultérieure, un formulaire apparaît et vous demande de
fournir les informations de connexion à la base de données pour ce rapport. Il s'agit d'une nouvelle
fonctionnalité de SAP Crystal Reports Developer. Si vous exécutez une version antérieure de
SAP Crystal Reports, une exception est renvoyée. Dans les deux cas, vous devez effectuer la procédure
suivante pour créer une application entièrement fonctionnelle.
5.
1.5.2.2.3
1.5.2.2.3.1
Procédure
1.
2.
A la fin de la classe, créez une méthode privée nommée SetDBLogonForReport() avec deux paramètres :
ConnectionInfo et ReportDocument.
Private Sub SetDBLogonForReport(ByVal myConnectionInfo As ConnectionInfo, ByVal
myReportDocument As ReportDocument)
End Sub
private void SetDBLogonForReport(ConnectionInfo connectionInfo, ReportDocument
reportDocument)
{
}
360
3.
Dans cette méthode, extrayez l'instance Tables de la propriété Tables de la propriété Database du
paramètre ReportDocument.
Remarque
Dim myTables As Tables = myReportDocument.Database.Tables
Tables tables = reportDocument.Database.Tables;
4.
Créez une boucle foreach qui effectue une boucle sur chaque instance Table de l'instance de classe indexée
Tables.
Remarque
Vous devez inclure le chemin d'accès de l'espace de noms à la classe Table afin de la distinguer de la
classe Table de l'espace de noms System.Web.UI.WebControls.
For Each myTable As CrystalDecisions.CrystalReports.Engine.Table In myTables
Next
foreach(CrystalDecisions.CrystalReports.Engine.Table table in tables)
{
}
5.
Dans la boucle foreach, extrayez l'instance TableLogonInfo de la propriété LogOnInfo de l'instance Table.
Dim myTableLogonInfo As TableLogOnInfo = myTable.LogOnInfo
TableLogOnInfo tableLogonInfo = table.LogOnInfo;
6.
Dans la boucle foreach, attribuez à la propriété ConnectionInfo de TableLogonInfo le paramètre
ConnectionInfo.
myTableLogonInfo.ConnectionInfo = myConnectionInfo
tableLogonInfo.ConnectionInfo = connectionInfo;
7.
Dans la boucle foreach, transmettez maintenant l'instance TableLogonInfo comme paramètre à la
méthode ApplyLogonInfo de l'instance Table.
myTable.ApplyLogOnInfo(myTableLogonInfo)
table.ApplyLogOnInfo(tableLogonInfo);
361
Résultats
●
●
1.5.2.2.3.2
de données
Procédure
1.
Dans la méthode ConfigureCrystalReports(), créez plusieurs sauts de ligne dans le code au-dessus de
la ligne qui lie le rapport au contrôle CrystalReportViewer.
2.
Dans les sauts de ligne, déclarez et instanciez la classe ConnectionInfo.
Remarque
Pour que la classe ConnectionInfo soit accessible, incluez une instruction "Imports" [Visual Basic]
ou "using" [C#] au début de la classe code-behind pour l'espace de noms CrystalDecisions.Shared.
(Vous avez ajouté cette déclaration dans la procédure Configuration d'un projet [page 15].)
3.
Définissez les propriétés DatabaseName, UserID et Password de l'instance ConnectionInfo.
Remarque
limité.
mot de passe.
myConnectionInfo.UserID = "limitedPermissionAccount"
myConnectionInfo.Password = "
1234"
362
connectionInfo.UserID = "limitedPermissionAccount";
connectionInfo.Password = "
1234";
4.
Saisissez un appel à la méthode SetDBLogonForReport() en transmettant l'instance ConnectionInfo et le
rapport NorthwindCustomers.
SetDBLogonForReport(myConnectionInfo, northwindCustomersReport)
SetDBLogonForReport(connectionInfo, northwindCustomersReport);
Résultats
Cette procédure est suivie du code d'origine qui lie le rapport au contrôle CrystalReportViewer.
1.5.2.2.3.3
NorthwindCustomers
Procédure
1.
2.
3.
4.
Résultats
363
1.5.2.2.4
1.5.2.2.4.1
Procédure
1.
qui déclare et instancie la classe ConnectionInfo.
2.
Remarque
Dans votre propre code, remplacez l'exemple de nom de serveur DevDatabase (indiqué ci-dessous) par
votre propre nom de serveur.
myConnectionInfo.ServerName = "DevDatabase"
connectionInfo.ServerName = "DevDatabase";
1.5.2.2.4.2
l'exécution
Contexte
Procédure
1.
364
2.
3.
4.
1.5.2.2.5
Addenda : Améliorations du code de connexion à la
base de données
Vous avez correctement défini votre code pour modifier l'emplacement de la base de données au moment de
l'exécution. Dans cet exemple, le serveur de base de données est identique, la seule différence est que vous l'avez
appelé explicitement par son nom.
Toutefois, vous pouvez maintenant modifier le nom de ce serveur de base de données avec n'importe quel autre
serveur de base de données contenant la base de données Northwind. Si vous utilisez SAP Crystal Reports avec
Visual Studio 2005 ou 2008, vous avez accès aux fonctionnalités API améliorées pour la connexion à une base de
données SQL Server sécurisée. La fonctionnalité API de SAP Crystal Reports permet de réduire la quantité de
code nécessaire à la connexion à la base de données.
Dans les procédures précédentes, vous avez appris à créer la méthode d'assistance SetDBLogonForReport(),
qui utilise une boucle foreach pour définir la propriété ConnectionInfo de chaque table du rapport Crystal.
Dans ce tutoriel, vous allez apprendre à supprimer la méthode d'assistance et à ajouter un code afin d'utiliser la
classe DataSourceConnections provenant de l'espace de noms CrystalDecisions.Shared ou la méthode
SetDatabaseLogon() provenant de la classe ReportDocument.
La classe DataSourceConnections est une ArrayList qui contient les instances ConnectionInfo pour chaque
connexion utilisée par le rapport Crystal. Vous pouvez extraire les instances ConnectionInfo au niveau d'un
index donné, puis appeler les méthodes SetLogon() ou SetConnection() pour transmettre les informations
de connexion au rapport.
La méthode SetLogon() permet de définir le nom d'utilisateur et le mot de passe. Cette méthode utilise le
serveur et la base de données par défaut que vous avez spécifiés dans le rapport. La méthode SetConnection()
permet de définir le nom du serveur, le nom de la base de données, le nom d'utilisateur et le mot de passe.
Pour utiliser le nouveau code API, vous devez suivre les instructions des sections Création d'un rapport connecté à
une base de données SQL Server sécurisée [page 354] et Liaison du rapport [page 356] sans code de connexion.
Vous pouvez ensuite utiliser l'une des méthodes API améliorées suivantes :
●
Utilisation de la classe DataSourceConnections pour la connexion à la base de données [page 367]
●
Utilisation de la méthode SetDatabaseLogon() de la classe ReportDocument [page 369]
Si vous avez effectué toutes les procédures de la section Tutoriel : Connexion à une base de données SQL Server
sécurisée à l'aide de l'authentification SQL [page 353], vous devez d'abord supprimer certaines lignes de code
indiquées dans la section Modification du projet pour la connexion à la base de données [page 366] avant de
pouvoir utiliser l'une des méthodes API améliorées.
365
1.5.2.2.5.1
Modification du projet pour la connexion à la base
de données
Si vous avez effectué toutes les procédures de la section Tutoriel : Connexion à une base de données SQL Server
sécurisée à l'aide de l'authentification SQL [page 353], vous devez d'abord supprimer certaines lignes de code
indiquées dans la procédure suivante.
1.5.2.2.5.1.1
Pour modifier le projet afin d'utiliser les
fonctionnalités API améliorées de SAP Crystal Reports
Procédure
1.
Ouvrez le projet terminé de ce tutoriel.
2.
3.
4.
Supprimez la méthode d'assistance SetDBLogonForReport().
5.
Dans la méthode ConfigureCrystalReports(), supprimez les lignes de code suivantes :
a) Supprimez le code qui déclare une instance de la classe ConnectionInfo.
b) Supprimez le code qui utilise les propriétés ServerName, DatabaseName, UserID et Password provenant
de la classe ConnectionInfo.
c) Supprimez l'appel à la méthode SetDBLogonForReport().
Résultats
La méthode ConfigureCrystalReports() comporte à présent deux lignes de code.
northwindCustomersReport = new NorthwindCustomers()
End Sub
{
}
Vous pouvez à présent choisir d'utiliser l'une des méthodes API améliorées suivantes :
●
Utilisation de la classe DataSourceConnections pour la connexion à la base de données [page 367]
●
Utilisation de la méthode SetDatabaseLogon() de la classe ReportDocument [page 369]
366
1.5.2.2.5.2
Utilisation de la classe DataSourceConnections
pour la connexion à la base de données
Dans cette section, vous allez apprendre à ajouter deux lignes de code pour vous connecter à une base de
données SQL Server. Vous devez extraire l'instance DataSourceConnections, puis définir les informations de
connexion à la base de données à l'aide des méthodes SetLogon() ou SetConnection().
●
Vous devez créer un projet basé sur les instructions des sections Création d'un rapport connecté à une base
de données SQL Server sécurisée [page 354] et Liaison du rapport [page 356] sans code de connexion.
●
Ou vous devez créer un projet en suivant les instructions de la section Modification du projet pour la connexion
à la base de données [page 366].
Si vous souhaitez utiliser le serveur et la base de données par défaut, appelez la méthode SetLogon() à l'aide de
votre nom d'utilisateur et de votre mot de passe.
En revanche, si vous souhaitez modifier le serveur ou la base de données, appelez la méthode SetConnection()
à l'aide de vos nom de serveur, nom de base de données, nom d'utilisateur et mot de passe.
1.5.2.2.5.2.1
Pour utiliser la méthode SetLogon() de la classe
DataSourceConnections
Procédure
1.
Entre les deux lignes de code de la méthode ConfigureCrystalReports(), extrayez l'instance
DataSourceConnections à partir de la propriété DataSourceConnections de l'instance
NorthwindCustomers.
Dim myDataSourceConnections As DataSourceConnections =
northwindCustomersReport.DataSourceConnections
northwindCustomersReport.DataSourceConnections;
2.
Dim myConnectInfo As IConnectionInfo = myDataSourceConnections(0)
3.
Appelez la méthode SetLogon() à l'aide de votre nom d'utilisateur et votre mot de passe.
Remarque
limité.
367
mot de passe.
myConnectInfo.SetLogon("limitedPermissionAccount", "1234")
connectInfo.SetLogon("limitedPermissionAccount", "1234");
1.5.2.2.5.2.2
Pour utiliser la méthode SetConnection() de la
classe DataSourceConnections
Procédure
1.
Entre les deux lignes de code de la méthode ConfigureCrystalReports(), extrayez l'instance
DataSourceConnections à partir de la propriété DataSourceConnections de l'instance NorthwindCustomers.
Dim myDataSourceConnections As DataSourceConnections =
northwindCustomersReport.DataSourceConnections
northwindCustomersReport.DataSourceConnections;
2.
Dim myConnectInfo As IConnectionInfo = myDataSourceConnections(0)
3.
Appelez la méthode SetConnection() à l'aide de vos nom de serveur, nom de base de données, nom
d'utilisateur et mot de passe.
Remarque
limité.
mot de passe.
myConnectInfo.SetConnection("ServerName", "Northwind",
"limitedPermissionAccount", "1234")
connectInfo.SetConnection("ServerName", "Northwind", "limitedPermissionAccount",
"1234");
368
Résultats
Vous êtes maintenant prêt à générer et exécuter le projet afin de vous connecter à la base de données SQL Server
sécurisée.
1.5.2.2.5.3
Utilisation de la méthode SetDatabaseLogon() de
la classe ReportDocument
Contexte
Entre les deux lignes de code dans la méthode ConfigureCrystalReports(), appelez la méthode
SetDatabaseLogon() de l'instance NorthwindCustomers, puis transmettez l'un des ensembles de paramètres
suivants :
Procédure
1.
Appelez la méthode SetDatabaseLogon() à l'aide de votre nom d'utilisateur et votre mot de passe.
Remarque
limité.
mot de passe.
northwindCustomersReport.SetDatabaseLogon("limitedPermissionAccount","1234")
northwindCustomersReport.SetDatabaseLogon("limitedPermissionAccount","1234");
2.
Ou appelez la méthode SetDatabaseLogon() à l'aide de vos nom de serveur, nom de base de données, nom
d'utilisateur et mot de passe.
Remarque
Cette méthode ne modifie pas le serveur ni la base de données. Vous êtes limité au serveur et à la base de
données par défaut spécifiés dans le rapport.
mot de passe.
northwindCustomersReport.SetDatabaseLogon("limitedPermissionAccount","1234",
"ServerName", "Northwind")
369
northwindCustomersReport.SetDatabaseLogon("limitedPermissionAccount","1234",
"ServerName", "Northwind");
1.5.2.3
Server sécurisée à l'aide de la sécurité intégrée
Introduction
Pour vous connecter à une base de données SQL Server sécurisée, vous utilisez des classes du modèle d'objet
ReportDocument.
L'objet ReportDocument comporte une propriété Database qui renvoie une instance Database. Cette instance
Database contient les informations de base de données pour le rapport, notamment une propriété Tables qui
renvoie une instance de classe indexée Tables. Chaque instance Table peut être extraite de la classe indexée
Tables.
La connexion se produit au niveau granulaire de chaque instance Table, qui doit obtenir une autorisation d'accès
individuel à la base de données SQL Server sécurisée. Ceci s'effectue en plaçant les informations de connexion
dans une instance ConnectionInfo puis, à l'intérieur d'une boucle for, en appliquant cette instance
ConnectionInfo à la propriété ConnectionInfo de chaque instance Table.
Les propriétés de la classe ConnectionInfo sont les suivantes :
●
ServerName
●
DatabaseName
●
UserID (non utilisée dans ce tutoriel)
●
Password (non utilisée dans ce tutoriel)
●
IntegratedSecurity
Remarque
Si vous souhaitez suivre un tutoriel qui utilise l'authentification Windows (et utilise donc les propriétés UserID
et Password au lieu de la propriété IntegratedSecurity), voir Tutoriel : Connexion à une base de données SQL
Server sécurisée à l'aide de l'authentification SQL [page 353].
Si vous définissez uniquement les propriétés DatabaseName et IntegratedSecurity, vous serez connecté au
serveur et à la base de données par défaut spécifiés dans le rapport. Toutefois, si vous affectez une autre
propriété ServerName, vous pouvez rediriger le rapport vers un serveur différent au moment de l'exécution.
Vous allez tout d'abord créer un rapport contenant des données d'une base de données SQL Server sécurisée.
Vous pouvez effectuer ce tutoriel en utilisant les classes du modèle d'objet CrystalReportViewer ; cependant, il est
370
Exemple de code
version terminée.
●
Site Web C# : CS_Web_RDObjMod_DBLogonIntegratedSecurity
●
Projet Windows C# : CS_Win_RDObjMod_DBLogonIntegratedSecurity
●
Site Web Visual Basic : VB_Web_RDObjMod_DBLogonIntegratedSecurity
●
Projet Windows Visual Basic : VB_Win_RDObjMod_DBLogonIntegratedSecurity
1.5.2.3.1
données SQL Server sécurisée à l'aide de la sécurité intégrée
Créez tout d'abord un rapport dont les informations proviennent de la base de données Northwind.
Remarque
Northwind est un exemple de base de données fourni avec SQL Server.
Une configuration préalable est requise avant de commencer ce tutoriel.
1.5.2.3.1.1
données
Procédure
1.
○
Si vous disposez de SQL Server (ou de la version OEM, MSDE), il doit être configuré pour accepter
l'authentification Windows dans ce tutoriel.
○
Si vous ne disposez pas de SQL Server (ou de la version OEM, MSDE), vous devez installer MSDE avec
l'authentification Windows (par défaut) pour l'utiliser dans ce tutoriel.
371
2.
l'authentification Windows est bien acceptée.
Après avoir configuré SQL Server et la base de données Northwind conformément aux instructions des
sections ci-dessus, vous êtes prêt à créer un rapport dont les informations proviennent, de façon sécurisée,
de la base de données Northwind.
Remarque
Cette procédure fonctionne uniquement avec un projet créé à partir de la procédure Configuration d'un
projet [page 15]. La section Configuration d'un projet contient une configuration de références d'espaces
de noms et de code spécifique nécessaire à cette procédure. Il est impossible de suivre cette procédure
sans cette configuration.
1.5.2.3.1.2
sécurisées à partir de la base de données Northwind
Procédure
1.
2.
Crystal.
3.
4.
5.
6.
7.
8.
9.
Saisissez le nom de votre serveur de base de données dans le champ Serveur.
10. Activez la case à cocher Sécurité intégrée.
15. Maintenez la touche CTRL enfoncée et cliquez sur CompanyName, ContactName et City.
Suivant.
372
Résultats
Vous êtes maintenant prêt à lier le rapport au contrôle CrystalReportViewer et à configurer par programmation la
connexion à la base de données.
1.5.2.3.2
Liaison du rapport
Durant la procédure Configuration d'un projet [page 15], vous avez placé un contrôle CrystalReportViewer
dans un Web Form ou un Windows Form. Lors de l'étape précédente, vous avez ajouté un rapport
NorthwindCustomers au projet.
Dans cette section, vous allez instancier le rapport NorthwindCustomers et le lier au contrôle
CrystalReportViewer. Vous allez ensuite vérifier si le rapport s'affiche correctement lorsque les valeurs
actuelles n'ont pas été définies pour ce paramètre.
●
●
●
●
1.5.2.3.2.1
CrystalReportViewer
Procédure
1.
2.
3.
Ajoutez une nouvelle déclaration de niveau classe pour la classe wrapper du rapport NorthwindCustomers, en
Private northwindCustomersReport As NorthwindCustomers
373
private NorthwindCustomers northwindCustomersReport;
4.
Remarque
northwindCustomersReport = New NorthwindCustomers()
5.
CrystalReportViewer à la classe de rapport instanciée (nom de la variable :
northwindCustomersReport).
Résultats
1.5.2.3.2.2
CrystalReportViewer
Procédure
1.
2.
3.
Ajoutez une nouvelle déclaration de niveau classe pour la classe wrapper du rapport ReportDocument, en
Private northwindCustomersReport As ReportDocument
private ReportDocument northwindCustomersReport;
374
Remarque
4.
northwindCustomersReport = New ReportDocument()
northwindCustomersReport = new ReportDocument();
5.
Windows :
○
○
Remarque
exécutable.
6.
northwindCustomersReport.Load(reportPath)
northwindCustomersReport.Load(reportPath);
375
7.
Résultats
classe ReportDocument, le nom de la variable utilisée est identique : northwindCustomersReport. Vous pouvez
1.5.2.3.2.3
NorthwindCustomers
Procédure
1.
2.
3.
sous-répertoire.
Remarque
4.
Le rapport NorthwindCustomers ne s'affiche pas, car le code de connexion à la base de données n'a pas été
ajouté.
Remarque
Les résultats peuvent varier selon la version de SAP Crystal Reports utilisée. Par exemple, si vous avez
installé SAP Crystal Reports Developer, un formulaire apparaît et vous demande de fournir les informations
de connexion à la base de données pour ce rapport. Il s'agit d'une nouvelle fonctionnalité de
SAP Crystal Reports Developer. Si vous exécutez une version antérieure de SAP Crystal Reports, une
exception est renvoyée. Dans les deux cas, vous devez effectuer la procédure suivante pour créer une
application entièrement fonctionnelle.
376
5.
1.5.2.3.3
1.5.2.3.3.1
Procédure
1.
2.
A la fin de la classe, créez une méthode privée nommée SetDBLogonForReport() avec deux paramètres :
ConnectionInfo et ReportDocument.
Private Sub SetDBLogonForReport(ByVal myConnectionInfo As ConnectionInfo, ByVal
myReportDocument As ReportDocument)
End Sub
private void SetDBLogonForReport(ConnectionInfo connectionInfo, ReportDocument
reportDocument)
{
}
3.
Dans cette méthode, extrayez l'instance Tables de la propriété Tables de la propriété Database du paramètre
ReportDocument.
Remarque
Dim myTables As Tables = myReportDocument.Database.Tables
Tables tables = reportDocument.Database.Tables;
4.
Créez une boucle foreach qui effectue une boucle sur chaque instance Table de l'instance de classe indexée
Tables.
377
Remarque
Vous devez inclure le chemin d'accès de l'espace de noms à la classe Table afin de la distinguer de la classe
Table de l'espace de noms System.Web.UI.WebControls.
For Each myTable As CrystalDecisions.CrystalReports.Engine.Table In myTables
Next
foreach(CrystalDecisions.CrystalReports.Engine.Table table in tables)
{
}
5.
Dans la boucle foreach, extrayez l'instance TableLogonInfo de la propriété LogOnInfo de l'instance Table.
Dim myTableLogonInfo As TableLogOnInfo = myTable.LogOnInfo
TableLogOnInfo tableLogonInfo = table.LogOnInfo;
6.
Dans la boucle foreach, attribuez à la propriété ConnectionInfo de TableLogonInfo le paramètre
ConnectionInfo.
myTableLogonInfo.ConnectionInfo = myConnectionInfo
tableLogonInfo.ConnectionInfo = connectionInfo;
7.
Dans la boucle foreach, transmettez maintenant l'instance TableLogonInfo comme paramètre à la méthode
ApplyLogonInfo de l'instance Table.
myTable.ApplyLogOnInfo(myTableLogonInfo)
table.ApplyLogOnInfo(tableLogonInfo);
Résultats
●
●
378
1.5.2.3.3.2
de données
Procédure
1.
2.
Dans les sauts de ligne, déclarez et instanciez la classe ConnectionInfo.
Remarque
Pour que la classe ConnectionInfo soit accessible, incluez une instruction "Imports" [Visual Basic]
ou "using" [C#] au début de la classe code-behind pour l'espace de noms CrystalDecisions.Shared.
(Vous avez ajouté cette déclaration dans la procédure Configuration d'un projet [page 15].)
3.
Définissez les propriétés DatabaseName et IntegratedSecurity de l'instance ConnectionInfo.
myConnectionInfo.IntegratedSecurity = True
connectionInfo.IntegratedSecurity = true;
4.
Saisissez un appel à la méthode SetDBLogonForReport() en transmettant l'instance ConnectionInfo et le
rapport NorthwindCustomers.
SetDBLogonForReport(myConnectionInfo, northwindCustomersReport)
SetDBLogonForReport(connectionInfo, northwindCustomersReport);
Résultats
379
1.5.2.3.3.3
NorthwindCustomers
Procédure
1.
2.
3.
4.
Résultats
Dans la section suivante, vous allez apprendre à modifier l'emplacement de la base de données au moment de
l'exécution.
1.5.2.3.4
1.5.2.3.4.1
Procédure
1.
qui déclare et instancie la classe ConnectionInfo.
2.
Remarque
Dans votre propre code, remplacez l'exemple de nom de serveur DevDatabase (indiqué ci-dessous) par
votre propre nom de serveur.
myConnectionInfo.ServerName = "DevDatabase"
380
connectionInfo.ServerName = "DevDatabase";
Résultats
1.5.2.3.4.2
l'exécution
Procédure
1.
2.
3.
4.
1.5.2.3.5
Configuration avec la méthode SetConnection
Contexte
Dans cette section, vous allez apprendre à appliquer trois modifications (modification du nom du serveur, du nom
de la base de données et du paramètre de sécurité intégrée) à l'aide de la méthode SetConnection(). Cette
opération nécessite simplement une légère modification de l'instance ConnectionInfo.
Procédure
1.
Dans la méthode ConfigureCrystalReports(), après la ligne qui déclare et instancie la classe
ConnectionInfo, supprimez les lignes de code qui affectent les propriétés et ServerName, DatabaseName
et IntegratedSecurity.
381
2.
Saisissez une nouvelle ligne de code contenant un appel à la méthode SetConnection() de l'instance
ConnectionInfo, en transmettant le nom du serveur, le nom de la base de données et le paramètre de
sécurité intégrée à cette méthode.
myConnectionInfo.SetConnection("DevDatabase", "Northwind", True)
connectionInfo.SetConnection("DevDatabase", "Northwind", true);
Résultats
Vous êtes maintenant prêt à générer et exécuter votre projet.
1.5.2.4
Server sécurisée avec un sous-rapport
Dans ce tutoriel, vous allez traiter un problème supplémentaire concernant la connexion à une base de données
SQL Server sécurisée : que faire si le rapport qui nécessite une connexion à une base de données SQL Server
sécurisée contient un sous-rapport ?
Introduction
Dans ce tutoriel, vous allez apprendre à remplir les conditions requises pour la connexion d'un sous-rapport.
Vous devez apporter deux modifications au projet créé dans le précédent tutoriel :
●
Ce sous-rapport désigne la table Orders de la base de données Northwind. La table Orders est liée à la table
Customers utilisée par la clé externe CustomerID dans le tutoriel précédent.
●
Vous ajoutez une nouvelle méthode.
La méthode extrait les sous-rapports du rapport principal, puis transmet chaque sous-rapport à la méthode
d'assistance SetDBLogonForReport().
Vous pouvez également effectuer ce tutoriel en utilisant les classes du modèle d'objet CrystalReportViewer, bien
qu'il soit recommandé d'utiliser le modèle d'objet ReportDocument.
Pour créer ce tutoriel à l'aide du modèle d'objet CrystalReportViewer, voir Tutoriel : Connexion à une base de
données SQL Server sécurisée [page 244] à l'aide du modèle d'objet CrystalReportViewer.
382
Exemple de code
version terminée.
●
Site Web C# : CS_Web_RDObjMod_DBLogonSubrpt
●
Projet Windows C# : CS_Win_RDObjMod_DBLogonSubrpt
●
Site Web Visual Basic : VB_Web_RDObjMod_DBLogonSubrpt
●
Projet Windows Visual Basic : VB_Win_RDObjMod_DBLogonSubrpt
1.5.2.4.1
1.5.2.4.1.1
Procédure
1.
Ouvrez le projet que vous avez créé dans le tutoriel précédent Tutoriel : Connexion à une base de données SQL
Server sécurisée à l'aide de la sécurité intégrée [page 370].
2.
Dans l'Explorateur de solutions, cliquez deux fois sur le rapport NorthwindCustomers pour l'ouvrir.
3.
dessous.
4.
5.
6.
383
Remarque
7.
Dans le champ Nom du nouveau rapport, saisissez "CustomerOrders".
8.
9.
Dans le panneau Sources de données disponibles de la boîte de dialogue Assistant de création de rapports
standard, développez le dossier Créer une nouvelle connexion.
10. Développez le dossier OLE DB (ADO).
Le dossier contient le serveur de base de données qui a été configuré pour le rapport lorsque ce dernier a été
créé.
Remarque
Si le serveur ne s'affiche pas, suivez les instructions du tutoriel précédent pour vous connecter à la base de
données SQL Server.
11. Développez les nœuds Northwind, dbo et Tables.
13. Dans le panneau Champs disponibles, sélectionnez Order ID, Order Date, Shipped Date et Ship Name.
Terminer.
table Customers, sélectionnez CustomerID, puis cliquez sur le bouton >.
17. Dans le panneau Mise en relation du champ Customers.CustomerID qui s'affiche, laissez les sélections par
défaut.
18. Cliquez sur OK.
Remarque
Résultats
Vous pouvez à présent vérifier les paramètres du sous-rapport.
384
1.5.2.4.1.2
Procédure
1.
2.
Remarque
3.
4.
Vérifiez que le champ de paramètre Pm-Customers.CustomerID a été automatiquement généré lorsque le
sous-rapport a été relié.
5.
Dans la barre d'outils, cliquez sur Expert Sélection.
6.
Dans la boîte de dialogue Expert Sélection, vérifiez que le critère Orders.CustomerID est égal à {?PmCustomers.CustomerID} est défini, puis cliquez sur OK.
7.
Résultats
Vous avez réussi à ajouter un sous-rapport CustomerOrders au rapport NorthwindCustomers. Dans la section
suivante, vous allez ajouter un code permettant de définir les informations de connexion à la base de données SQL
Server sécurisée pour tous les sous-rapports présents dans le rapport principal.
1.5.2.4.2
Ajout du code de connexion au sous-rapport
Vous allez à présent ajouter le code de connexion du sous-rapport à la classe code-behind. Vous commencez par
créer une méthode d'assistance privée nommée SetDBLogonForSubreports().
385
1.5.2.4.2.1
SetDBLogonForSubreports()
Procédure
1.
2.
3.
A la fin de la classe, créez une méthode privée nommée SetDBLogonForSubreports() avec deux
paramètres : ConnectionInfo et ReportDocument.
Private Sub SetDBLogonForSubreports(ByVal myConnectionInfo As ConnectionInfo,
ByVal myReportDocument As ReportDocument)
End Sub
private void SetDBLogonForSubreports(ConnectionInfo connectionInfo,
ReportDocument reportDocument)
{
}
4.
Dans cette méthode, extrayez l'instance Section de la propriété Sections de la propriété ReportDefinition
du paramètre ReportDocument.
Remarque
Sections est une classe indexée contenant des instances de la classeSection.
Dim mySections As Sections = myReportDocument.ReportDefinition.Sections
Sections sections = reportDocument.ReportDefinition.Sections;
5.
Créez une boucle foreach qui effectue une boucle sur chaque instance Section de l'instance de classe
indexée Sections.
For Each mySection As Section In mySections
Next
foreach(Section section in sections)
{
}
6.
Dans la boucle foreach, extrayez l'instance ReportObjects de la propriété ReportObjects de l'instance
Section.
Dim myReportObjects As ReportObjects = mySection.ReportObjects
386
ReportObjects reportObjects = section.ReportObjects;
7.
Dans chaque boucle foreach, créez une boucle foreach imbriquée qui effectue une boucle sur chaque
instance ReportObject de l'instance de classe indexée ReportObjects.
For Each myReportObject As ReportObject In myReportObjects
Next
foreach(ReportObject reportObject in reportObjects)
{
}
8.
Dans la boucle foreach imbriquée, créez un bloc conditionnel qui vérifie si la propriété Kind de l'instance
ReportObject équivaut à la sélection SubreportObject de l'énumération ReportObjectKind.
If myReportObject.Kind = ReportObjectKind.SubreportObject Then
End If
if(reportObject.Kind == ReportObjectKind.SubreportObject)
{
}
9.
Dans le bloc conditionnel, effectuez un cast de l'instance ReportObject en instance SubreportObject.
Dim mySubreportObject As SubreportObject = CType(myReportObject, SubreportObject)
SubreportObject subreportObject = (SubreportObject)reportObject;
10. Toujours dans le bloc conditionnel, déclarez une nouvelle instance de ReportDocument sous la forme d'une
variable subReportDocument et remplissez-la en appelant la méthode OpenSubreport() de l'instance
SubreportObject.
Dim subReportDocument As ReportDocument =
mySubreportObject.OpenSubreport(mySubreportObject.SubreportName)
ReportDocument subReportDocument =
subreportObject.OpenSubreport(subreportObject.SubreportName);
11. Dans le bloc conditionnel, appelez la méthode SetDBLogonForReport() d'origine et transmettez-lui le
paramètre ConnectionInfo et la nouvelle variable subReportDocument.
SetDBLogonForReport(myConnectionInfo, subReportDocument)
SetDBLogonForReport(connectionInfo, subReportDocument);
387
1.5.2.4.2.2
de données des sous-rapports
Contexte
Cette procédure a créé une méthode permettant d'extraire tous les sous-rapports possibles sous forme
d'instances ReportDocument. Chaque instance ReportDocument de sous-rapport est ensuite transmise à la
méthode d'origine afin de définir la connexion à une base de données SQL Server sécurisée.
Cependant, vous devez maintenant modifier la méthode ConfigureCrystalReports() pour désigner cette
méthode et permettre le traitement des informations de connexion à la base de données des sous-rapports.
Procédure
1.
2.
Dans les sauts de ligne, saisissez un appel à la méthode SetDBLogonForSubreports() en transmettant
l'instance ConnectionInfo et le rapport NorthwindCustomers.
SetDBLogonForSubreports(myConnectionInfo, northwindCustomersReport)
SetDBLogonForSubreports(connectionInfo, northwindCustomersReport);
1.5.2.4.2.3
NorthwindCustomers
Contexte
Vous êtes maintenant prêt à générer et exécuter votre projet. Le chargement du rapport et de son sous-rapport
ne devrait poser aucun problème, car le code permettant de connecter n'importe quel sous-rapport à la base de
données est maintenant écrit.
Procédure
1.
388
2.
3.
Le rapport NorthwindCustomers et son nouveau sous-rapport CustomerOrders s'affichent correctement.
4.
1.5.2.5
Tutoriel : Lecture et définition des paramètres
discrets
paramètre discret.
Introduction
Un paramètre discret est une valeur unique alors qu'un paramètre de plage fait référence à une plage de valeurs.
Les éléments textuels (tels que les villes) sont généralement accessibles via des paramètres discrets. Les
éléments numériques (tels que les salaires des employés) sont généralement accessibles via des paramètres de
plage.
Dans ce tutoriel, vous allez définir une valeur de paramètre discret afin d'afficher un rapport sur les clients basé
sur un champ. Ce rapport affiche uniquement les clients vivant dans les villes sélectionnées dans une liste de
villes. Cette liste provient des valeurs par défaut du paramètre Ville. Les valeurs par défaut du paramètre Ville sont
encapsulées dans le rapport.
Créez tout d'abord un rapport sur les clients avec un paramètre de ville. Les données du rapport proviennent de
l'exemple de base de données fourni avec SAP Crystal Reports, version développeur pour Microsoft Visual Studio.
Lorsque vous instanciez le rapport dans le code, vous créez une instance ArrayList contenant des noms de ville
(Paris, Tokyo), puis transmettez cette instance à une méthode d'assistance qui définit ces noms de ville comme
les valeurs actuelles du paramètre Ville. Vous liez ensuite le rapport au contrôle CrystalReportViewer et seuls les
clients vivant à Paris ou à Tokyo sont affichés dans ce rapport.
Dans la partie suivante du tutoriel, vous allez effectuer les opérations suivantes :
●
Créer une méthode qui extrait toutes les valeurs par défaut et les renvoie dans une instance ArrayList.
●
Ajouter un contrôle ListBox au formulaire et le remplir avec les valeurs provenant de l'ArrayList.
●
Ajouter un contrôle Button pour réafficher le rapport en fonction des sélections ListBox.
Dans la dernière partie du tutoriel, vous coderez l'événement de clic pour extraire les éléments sélectionnés à
partir du contrôle ListBox et définir les valeurs actuelles du paramètre Ville. Le rapport est réaffiché, indiquant
uniquement les clients qui vivent dans les villes sélectionnées dans le contrôle ListBox.
Ce tutoriel peut également être effectué avec des classes du modèle d'objet CrystalReportViewer, bien qu'il soit
Pour créer ce tutoriel à l'aide du modèle d'objet CrystalReportViewer, voir Tutoriel : Connexion à une base de
données SQL Server sécurisée [page 244] à l'aide du modèle d'objet CrystalReportViewer.
389
Exemple de code
version terminée.
●
Site Web C# : CS_Web_RDObjMod_Parameters
●
Projet Windows C# : CS_Win_RDObjMod_Parameters
●
Site Web Visual Basic : VB_Web_RDObjMod_Parameters
●
Projet Windows Visual Basic : VB_Win_RDObjMod_Parameters
Ce tutoriel utilise un exemple de base de données appelée Xtreme. Le fichier de base de données xtreme.mdb est
fourni dans le package d'exemples de code du SDK de SAP Crystal Reports .NET. Pour utiliser la base de données
Xtreme, vous devez créer manuellement une connexion ODBC à cette base de données.
1.5.2.5.1
Création d'un rapport avec des paramètres
1.5.2.5.1.1
Procédure
1.
2.
Crystal.
3.
Dans le champ Nom, saisissez le nom CustomersByCity.rpt, puis cliquez sur Ajouter.
390
4.
5.
6.
Remarque
Dans SAP Visual Studio .NET 2003, l'application SAP Crystal Reports n'a pas été mise à niveau vers la
version complète et le dossier Créer une nouvelle connexion n'existe pas ; le contenu est indiqué au niveau
supérieur.
7.
8.
9.
Développez le nœud Tables et sélectionnez la table Clients.
10. Cliquez deux fois sur la table Clients pour l'ajouter au panneau Tables sélectionnées, puis cliquez sur Suivant.
11. Développez la table Clients, puis utilisez la combinaison de touches CTRL-clic pour sélectionner les champs
bouton Suivant.
13. Dans le panneau Champs disponibles, sous Champs du rapport, sélectionnez Clients.Ville, cliquez sur le
Le rapport CustomersByCity est créé et chargé dans la fenêtre principale de Visual Studio.
Résultats
Vous êtes maintenant prêt à ajouter un paramètre appelé Ville et à le remplir avec des valeurs par défaut.
1.5.2.5.1.2
Pour ajouter un paramètre Ville
Contexte
L'Explorateur de champs doit être visible, car il permet d'accéder à plusieurs fonctions du rapport, notamment
aux paramètres.
Procédure
1.
391
Remarque
2.
3.
a) Attribuez à Nom la valeur Ville.
b) Attribuez à Type la valeur Chaîne. Attribuez à Texte de l'invite la valeur Sélectionnez une ou
plusieurs villes.
c) Attribuez à Champ de valeur la valeur Ville.
d) Cliquez sur Actions, puis sélectionnez Ajouter toutes les valeurs de la base de données. La liste complète
des villes apparaît dans le volet du milieu.
e) Dans le volet Options de valeur, attribuez à Texte de l'invite la valeur Sélectionnez une ou
plusieurs villes.
f)
Dans ce même volet, attribuez à Autoriser plusieurs valeurs la valeur True.
g) Attribuez à Autoriser les valeurs discrètes la valeur True.
4.
Cliquez sur OK pour fermer la boîte de dialogue Créer un champ de paramètre.
Résultats
Vous venez de définir les valeurs par défaut de sorte qu'elles contiennent une liste importante de villes. Plus loin
dans ce tutoriel, vous accéderez par programmation à cette même liste de valeurs par défaut, via la propriété
DefaultValues de la classe ParameterFieldDefinition.
Vous devez maintenant utiliser l'Expert Sélection pour définir une formule permettant de connecter la colonne
Ville de la base de données au champ de paramètre Ville que vous venez de créer.
1.5.2.5.1.3
Pour connecter le paramètre Ville à la colonne
Ville de la base de données
Procédure
1.
2.
Dans la boîte de dialogue Choisir un champ, sous Champs du rapport, sélectionnez Clients.Ville, puis cliquez
sur OK.
3.
Dans la boîte de dialogue Expert Sélection, dans l'onglet Clients.Ville, choisissez est égal à dans la liste
déroulante.
4.
Dans la nouvelle liste déroulante qui s'affiche à droite, sélectionnez le premier élément de la liste, {?Ville}, puis
cliquez sur OK.
392
Remarque
Cette sélection, {?Ville}, correspond au paramètre Ville que vous avez créé précédemment.
5.
Résultats
Vous êtes maintenant prêt à lier le rapport au contrôle CrystalReportViewer et à définir le paramètre Ville avec
deux valeurs d'origine, Paris et Tokyo.
1.5.2.5.2
Liaison du rapport
tutoriel, vous avez placé un contrôle CrystalReportViewer sur le Web Form ou le Windows Form. Aux étapes
précédentes, vous avez ajouté un rapport CustomerByCity au projet.
Dans cette section, vous allez instancier le rapport CustomersByCity et le lier au contrôle CrystalReportViewer.
Vous allez ensuite vérifier si le rapport s'affiche correctement lorsque les valeurs actuelles n'ont pas été définies
pour ce paramètre.
●
●
●
●
1.5.2.5.2.1
Pour instancier le rapport CustomersByCity sous
forme de rapport incorporé et le lier au contrôle
CrystalReportViewer
Procédure
1.
2.
Form.
393
3.
Ajoutez une nouvelle déclaration de niveau classe pour la classe wrapper du rapport CustomersByCity, avec
la variable customersByCityReport. Définissez le modificateur d'accès à private.
Private customersByCityReport As CustomersByCity
private CustomersByCity customersByCityReport;
4.
Remarque
customersByCityReport = New CustomersByCity()
customersByCityReport = new CustomersByCity();
5.
CrystalReportViewer à la classe de rapport instanciée (nom de la variable : customersByCityReport).
myCrystalReportViewer.ReportSource = customersByCityReport
crystalReportViewer.ReportSource = customersByCityReport;
Remarque
L'instance du contrôle CrystalReportViewer est accessible dans le code, car vous avez ajouté le contrôle à
votre Web Form ou Windows Form. Si IntelliSense ne reconnaît pas l'instance du contrôle
CrystalReportViewer, vérifiez que le contrôle CrystalReportViewer a été ajouté sous la forme d'une
déclaration de niveau classe à cette classe code-behind.
1.5.2.5.2.2
Pour instancier le rapport CustomersByCity sous
forme de rapport non incorporé et le lier au contrôle
CrystalReportViewer
Contexte
permettant de définir une valeur pour le champ de paramètre Ville n'a pas encore été écrit.
394
Procédure
1.
2.
3.
Ajoutez une nouvelle déclaration de niveau classe pour la classe wrapper du rapport ReportDocument, avec la
variable customersByCityReport. Définissez le modificateur d'accès à private.
Private customersByCityReport As ReportDocument
private ReportDocument customersByCityReport;
Remarque
4.
Dans la méthode ConfigureCrystalReports() (que vous avez créée dans l'une des procédures de la
section Configuration d'un projet [page 15]), instanciez la classe ReportDocument.
customersByCityReport = New ReportDocument()
customersByCityReport = new ReportDocument();
5.
Windows :
○
Dim reportPath As String = Server.MapPath("CustomersByCity.rpt")
string reportPath = Server.MapPath("CustomersByCity.rpt");
○
395
Remarque
exécutable.
"CustomersByCity.rpt"
string reportPath = Application.StartupPath + "\\" + "CustomersByCity.rpt";
6.
customersByCityReport.Load(reportPath)
customersByCityReport.Load(reportPath);
7.
Sur la ligne suivante, sous le chargement du rapport, liez la propriété ReportSource du contrôle
CrystalReportViewer à l'instance ReportDocument.
Résultats
classe ReportDocument, le nom de la variable utilisée est identique : customersByCityReport. Vous pouvez ainsi
utiliser un bloc de code commun dans les procédures suivantes.
permettant de définir une valeur pour le champ de paramètre Ville n'a pas encore été écrit. Vous ajouterez une
valeur au paramètre Ville plus loin dans ce tutoriel.
1.5.2.5.2.3
CustomersByCity
Procédure
1.
2.
396
3.
sous-répertoire.
Remarque
4.
Le rapport CustomersByCity ne s'affiche pas. Il s'affiche après que vous avez ajouté une valeur au paramètre
Ville plus loin dans ce tutoriel.
Remarque
Les résultats peuvent varier selon la version de SAP Crystal Reports utilisée. Dans les versions plus
récentes, un formulaire s'affiche vous demandant de fournir des valeurs de paramètre pour ce rapport.
Dans les versions antérieures, une exception "Valeur actuelle du champ de paramètre introuvable" est
renvoyée. Dans les deux cas, vous devez ajouter du code supplémentaire pour créer une application
entièrement fonctionnelle.
5.
1.5.2.5.3
Définition manuelle des paramètres dans le code
Vous êtes maintenant prêt à créer deux valeurs ("Paris" et "Tokyo") dans le champ de paramètre Ville du rapport
CustomersByCity.
Cette opération nécessite un code qui peut être décomposé selon les processus suivants :
●
Une constante PARAMETER_FIELD_NAME est nécessaire pour contenir le champ de paramètre "Ville", qui
est utilisé plusieurs fois dans l'ensemble du code.
●
Le code permettant d'ajouter les valeurs actuelles au paramètre étant généralement utilisé dans deux
emplacements différents dans ce tutoriel, il est préférable de créer ce code en tant que méthode d'assistance
distincte.
●
Dans la méthode ConfigureCrystalReports(), vous devez ajouter les paramètres "Paris" et "Tokyo" à
une instance ArrayList, puis transmettre le rapport et l'instance à la méthode d'assistance pour le traitement.
Dans la section suivante, vous allez apprendre à extraire les valeurs par défaut du champ de paramètre et à définir
ces valeurs dans un contrôle ListBox. Ces valeurs seront utilisées à la fin du tutoriel pour sélectionner de façon
dynamique de nouvelles villes et filtrer le rapport en fonction des nouvelles villes sélectionnées.
Effectuez maintenant la procédure Création d'un contrôle ListBox qui affiche les paramètres par défaut [page
402].
397
1.5.2.5.3.1
Pour créer une constante
PARAMETER_FIELD_NAME
Procédure
1.
2.
Au niveau de la classe, créez une constante chaîne, PARAMETER_FIELD_NAME, et attribuez-lui la valeur
"Ville".
Private Const PARAMETER_FIELD_NAME As String = "City"
private const string PARAMETER_FIELD_NAME = "City";
1.5.2.5.3.2
Pour créer une méthode d'assistance permettant
d'ajouter les valeurs actuelles au paramètre dans le rapport
Contexte
Vous êtes maintenant prêt à créer la méthode d'assistance qui permet d'ajouter les valeurs actuelles au
paramètre dans le rapport.
Procédure
1.
2.
[C#] au début de la classe de l'espace de noms System.Collections (si cet espace de noms n'a pas déjà été
déclaré).
Imports System.Collections
using System.Collections;
Remarque
Cette déclaration est nécessaire pour accéder à la classe ArrayList.
3.
398
SetCurrentValuesForParameterField() avec deux variables dans la signature de la méthode.
Remarque
Plus loin dans ce tutoriel, si vous avez utilisé un rapport incorporé, vous transmettez votre classe de
rapport incorporé au paramètre de la méthode ReportDocument. Cette possibilité s'explique par le fait que
Toutes les classes de rapport incorporé présentes dans SAP Crystal Reports héritent de la classe de base
ReportDocument.
Private Sub SetCurrentValuesForParameterField(ByVal myReportDocument As
ReportDocument, ByVal myArrayList As ArrayList)
End Sub
private void SetCurrentValuesForParameterField(ReportDocument reportDocument,
ArrayList arrayList)
{
}
4.
Dans cette méthode, déclarez et instanciez la classe indexée ParameterValues en tant que variable
Remarque
Pour que la classe ParameterValues soit accessible, vous devez avoir inclus une déclaration "Imports"
projet [page 15].)
Dim currentParameterValues As ParameterValues = New ParameterValues()
ParameterValues currentParameterValues = new ParameterValues();
5.
Créez une boucle foreach pour extraire toutes les valeurs envoyées (comme type Objet) de l'instance
ArrayList.
Remarque
Dans cette méthode, vous extrayez les valeurs d'ArrayList. Par la suite, vous écrirez du code permettant
d'ajouter des valeurs à l'ArrayList.
For Each submittedValue As Object In myArrayList
Next
foreach(object submittedValue in arrayList)
{
}
399
6.
Dans la boucle foreach, déclarez et instanciez la classe ParameterDiscreteValue.
Dim myParameterDiscreteValue As ParameterDiscreteValue = New
ParameterDiscreteValue()
ParameterDiscreteValue parameterDiscreteValue = new ParameterDiscreteValue();
7.
Dans la boucle foreach, convertissez la valeur envoyée en chaîne et transmettez-la à la propriété Value de
l'instance ParameterDiscreteValue.
myParameterDiscreteValue.Value = submittedValue.ToString()
parameterDiscreteValue.Value = submittedValue.ToString();
8.
Dans la boucle foreach, ajoutez l'instance ParameterDiscreteValue dans la classe indexée
currentParameterValues.Add(myParameterDiscreteValue)
currentParameterValues.Add(parameterDiscreteValue);
L'écriture de code dans la boucle foreach est à présent terminée. Vous placez le code restant (à l'aide des
étapes suivantes) après la boucle foreach.
9.
En dehors de la boucle foreach, extrayez la classe indexée ParameterFieldDefinitions provenant de la
propriété DataDefinition de l'instance ReportDocument.
Dim myParameterFieldDefinitions As ParameterFieldDefinitions =
myReportDocument.DataDefinition.ParameterFields
ParameterFieldDefinitions parameterFieldDefinitions =
reportDocument.DataDefinition.ParameterFields;
10. Extrayez l'instance ParameterFieldDefinition de la classe indexée ParameterFieldDefinitions qui se base sur
l'entrée d'index de la constante PARAMETER_FIELD_NAME.
Dim myParameterFieldDefinition As ParameterFieldDefinition =
myParameterFieldDefinitions(PARAMETER_FIELD_NAME)
ParameterFieldDefinition parameterFieldDefinition =
parameterFieldDefinitions[PARAMETER_FIELD_NAME];
11. Transmettez l'instance currentParameterValues à la méthode ApplyCurrentValues de l'instance
ParameterFieldDefinition.
myParameterFieldDefinition.ApplyCurrentValues(currentParameterValues)
400
parameterFieldDefinition.ApplyCurrentValues(currentParameterValues);
1.5.2.5.3.3
Pour appeler la méthode
SetCurrentValuesForParameterField () avant la liaison du
rapport au contrôle CrystalReportViewer
Contexte
Cette procédure a permis de créer une méthode qui extrait les valeurs envoyées d'une instance ArrayList et les
place comme valeurs actuelles dans une instance ParameterFieldDefinition. Vous devez maintenant appeler cette
méthode avant que votre rapport ne soit lié au contrôle CrystalReportViewer afin que le rapport sache qu'il
dispose de paramètres.
Procédure
1.
Dans ces sauts de ligne, vous pouvez saisir du code supplémentaire qui modifie le rapport avant qu'il ne soit
lié au visualiseur.
2.
Dans les sauts de lignes, déclarez et instanciez une ArrayList.
3.
Ajoutez les noms de ville "Paris" et "Tokyo" comme chaînes à l'instance ArrayList.
4.
Appelez la méthode SetCurrentValuesForParameterField(), puis transmettez l'instance
CustomersByCityReport et l'instance ArrayList.
SetCurrentValuesForParameterField(customersByCityReport,
myArrayList)
401
SetCurrentValuesForParameterField(customersByCityReport,
arrayList);
1.5.2.5.3.4
CustomersByCity
Contexte
La dernière ligne de code de la méthode lie le rapport au contrôle CrystalReportViewer.
Vous êtes maintenant prêt à générer et exécuter votre projet. Le rapport doit s'afficher correctement, car le code
définissant les valeurs actuelles dans le champ de paramètre est désormais écrit.
Procédure
1.
2.
3.
Le rapport CustomersByCity s'affiche correctement, indiquant des listes de clients à Paris et à Tokyo.
4.
1.5.2.5.4
Création d'un contrôle ListBox qui affiche les
paramètres par défaut
Le reste du tutoriel concerne l'affichage de la liste complète des valeurs par défaut du champ de paramètre dans
un contrôle ListBox et le refiltrage du contenu du rapport en fonction des sélections effectuées à partir du
contrôle ListBox.
Dans cette section, vous allez apprendre à remplir le contrôle ListBox à partir des valeurs par défaut du champ de
paramètre.
Remarque
N'oubliez pas que vous avez défini les valeurs par défaut, une liste importante de villes, lors de la création du
rapport au début de ce tutoriel.
Pour ce faire, vous devez ajouter et configurer un contrôle ListBox, puis créer une méthode d'assistance pour
remplir ce contrôle.
402
1.5.2.5.4.1
Pour créer et configurer un contrôle ListBox sur
le formulaire
Procédure
1.
2.
3.
○
○
Appuyez sur la FLECHE GAUCHE du clavier afin de faire apparaître un curseur clignotant, puis appuyez
sur ENTREE.
4.
○
○
Dans la fenêtre Propriétés, attribuez à la propriété Dock la valeur "Bottom".
Remarque
Dans Visual Studio, lorsque vous sélectionnez la propriété Dock, un cadre apparaît à la place d'une liste
d'options. Sélectionnez la partie du cadre correspondant à "Bottom".
5.
○
Redimensionnez le Windows Form et le contrôle CrystalReportViewer de manière à ce que ce dernier soit
suffisamment grand pour afficher le rapport. Laissez de l'espace au-dessus du contrôle
CrystalReportViewer pour ajouter un contrôle ListBox.
○
Dans la fenêtre Propriétés, attribuez à la propriété Anchor la valeur "Top, Bottom, Left, Right".
○
Redimensionnez le Windows Form et le contrôle CrystalReportViewer de manière à ce que ce dernier soit
suffisamment grand pour afficher le rapport. Laissez de l'espace au-dessus du contrôle
CrystalReportViewer pour ajouter un contrôle ListBox.
Dans la boîte à outils, faites glisser un contrôle ListBox au-dessus du contrôle CrystalReportViewer.
Remarque
Si une tâche guidée apparaît dans le contrôle ListBox (dans Visual Studio), appuyez sur Echap pour la
fermer.
6.
Cliquez sur le contrôle ListBox pour le sélectionner.
7.
8.
○
Attribuez à ID ou Name la valeur "defaultParameterValuesList".
○
Attribuez à SelectionMode la valeur "Multiple" (ou "MultiExtended" dans un projet Windows).
403
Résultats
Vous êtes maintenant prêt à créer une méthode d'assistance qui extrait les valeurs par défaut du champ de
paramètre.
1.5.2.5.4.2
Pour créer une méthode d'assistance qui extrait
les valeurs par défaut du champ de paramètre
Procédure
1.
2.
3.
GetDefaultValuesFromParameterField() qui renvoie une instance ArrayList, en transmettant
ReportDocument dans la signature de la méthode.
Private Function GetDefaultValuesFromParameterField(ByVal myReportDocument As
ReportDocument) As ArrayList
End Function
private ArrayList GetDefaultValuesFromParameterField(ReportDocument
reportDocument)
{
}
4.
Dans la méthode GetDefaultValuesFromParameterField(), extrayez la classe indexée
ParameterFieldDefinitions provenant de la propriété DataDefinition de l'instance ReportDocument.
5.
Extrayez l'instance ParameterFieldDefinition de la classe indexée ParameterFieldDefinitions, basée sur
l'entrée d'index de la constante PARAMETER_FIELD_NAME.
myParameterFieldDefinitions(PARAMETER_FIELD_NAME)
parameterFieldDefinitions[PARAMETER_FIELD_NAME];
404
6.
Extrayez une classe indexée ParameterValues (en tant que variable defaultParameterValues) de la propriété
DefaultValues de l'instance ParameterFieldDefinition.
Dim defaultParameterValues As ParameterValues =
myParameterFieldDefinition.DefaultValues
ParameterValues defaultParameterValues = parameterFieldDefinition.DefaultValues;
7.
Déclarez et instanciez une ArrayList.
8.
Créez une boucle foreach pour extraire chaque instance ParameterValue de la variable
defaultParameterValues.
For Each myParameterValue As ParameterValue In defaultParameterValues
Next
foreach(ParameterValue parameterValue in defaultParameterValues)
{
}
Dans la boucle foreach, créez maintenant un bloc conditionnel imbriqué qui recherche des valeurs de
paramètre discret (par opposition aux valeurs de paramètre de plage). Il existe deux versions de ce bloc
conditionnel, car l'API a subi de légères modifications au cours de l'évolution des versions de
SAP Crystal Reports, version développeur pour Microsoft Visual Studio. Vérifiez votre API (à l'aide
d'IntelliSense) pour connaître la propriété disponible sous ParameterValue :
9.
Si la propriété disponible est IsRange, saisissez le code suivant dans la boucle foreach :
If (Not myParameterValue.IsRange) Then
End If
if(!parameterValue.IsRange)
{
}
10. Ou, si la propriété disponible est Kind (DiscreteOrRangeKind, une énumération comportant trois valeurs :
DiscreteValue, RangeValue, DiscreteAndRangeValue) saisissez le code suivant dans la boucle foreach :
If (myParameterValue.Kind = DiscreteOrRangeKind.DiscreteValue) Then
End If
if(parameterValue.Kind == DiscreteOrRangeKind.DiscreteValue)
405
{
}
11. Dans le bloc conditionnel imbriqué, effectuez un cast de l'instance ParameterValue en sa classe étendue,
DiscreteParameterValue.
Dim myParameterDiscreteValue As ParameterDiscreteValue = CType(myParameterValue,
ParameterDiscreteValue)
ParameterDiscreteValue parameterDiscreteValue =
(ParameterDiscreteValue)parameterValue;
12. Dans le bloc conditionnel imbriqué, ajoutez la propriété Value de l'instance ParameterDiscreteValue
(convertie en chaîne) dans l'instance ArrayList.
myArrayList.Add(myParameterDiscreteValue.Value.ToString())
arrayList.Add(parameterDiscreteValue.Value.ToString());
13. En dehors du bloc conditionnel et de la boucle foreach, en fin de méthode, renvoyez l'instance ArrayList
depuis la méthode.
Return myArrayList
return arrayList;
1.5.2.5.4.3
contrôle ListBox dans un projet Web
Contexte
Vous avez extrait les valeurs par défaut du champ de paramètre et les avez renvoyées de la méthode sous la
forme d'une ArrayList. Vous allez maintenant lier cette ArrayList au contrôle ListBox defaultParameterValuesList.
Le code varie légèrement selon que vous utilisez un projet Web ou un projet Windows ; en conséquence, vous ne
devez effectuer que l'une des procédures Web ou Windows ci-après.
Procédure
1.
Dans la méthode ConfigureCrystalReports(), créez plusieurs sauts de ligne dans le code
immédiatement après la ligne de code qui ajoute la valeur de chaîne Tokyo à l'instance ArrayList.
406
2.
Dans les sauts de ligne, créez un bloc conditionnel Not IsPostBack.
End If
if(!IsPostBack)
{
}
Remarque
Le bloc conditionnel Not IsPostBack est utilisé pour encapsuler du code devant être exécuté
uniquement lors du premier chargement de la page. Les contrôles sont généralement liés aux valeurs de
données dans des blocs conditionnels Not IsPostBack afin que leurs valeurs de données (et tout
événement de contrôle suivant) ne soient pas redéfinies lorsque les pages sont rechargées.
3.
Dans le bloc conditionnel Not IsPostBack, attribuez à la propriété DataSource du contrôle ListBox
defaultParameterValuesList la méthode d'assistance GetDefaultValuesFromParameterField() en
transmettant l'instance de rapport CustomersByCity en tant que paramètre de méthode.
GetDefaultValuesFromParameterField(customersByCityReport)
GetDefaultValuesFromParameterField(customersByCityReport);
4.
Toujours dans le bloc conditionnel Not IsPostBack, appelez la méthode DataBind() du contrôle ListBox
1.5.2.5.4.4
contrôle ListBox dans un projet Windows
Procédure
1.
Dans la méthode ConfigureCrystalReports(), créez plusieurs sauts de ligne dans le code
immédiatement après la ligne de code qui ajoute la valeur de chaîne Tokyo à l'instance ArrayList.
407
2.
Dans les sauts de lignes, attribuez à la propriété DataSource du contrôle ListBox defaultParameterValuesList
la méthode d'assistance GetDefaultValuesFromParameterField() en transmettant l'instance du
rapport CustomersByCity en tant que paramètre de méthode.
1.5.2.5.4.5
Contexte
Vous êtes maintenant prêt à générer et exécuter le projet pour vérifier si le contrôle ListBox
defaultParameterValuesList est rempli.
Procédure
1.
2.
3.
Le contrôle ListBox defaultParameterValuesList affiche la liste complète des valeurs par défaut (dans ce
tutoriel, il s'agit de villes).
4.
Résultats
Dans la section suivante, vous allez ajouter un bouton pour réafficher le rapport en fonction des sélections du
contrôle ListBox defaultParameterValuesList.
1.5.2.5.5
ListBox
Définition des paramètres à partir des sélections
Dans cette section, vous allez ajouter un bouton pour réafficher le rapport en fonction des sélections du contrôle
ListBox defaultParameterValuesList.
408
Dans la méthode d'événement de ce bouton, vous appellerez la même méthode que celle appelée lors du premier
chargement de la page : SetCurrentValuesForParameterField(). Mais cette fois, au lieu de transmettre des
valeurs arbitraires (Paris et Tokyo), vous transmettrez les valeurs sélectionnées depuis le contrôle ListBox
1.5.2.5.5.1
Procédure
1.
2.
3.
Dans la boîte à outils, faites glisser un contrôle Button à droite du contrôle ListBox.
4.
5.
○
Attribuez à ID ou Name la valeur "redisplay".
○
Attribuez à Text la valeur "Réafficher le rapport".
Résultats
Vous êtes maintenant prêt à créer une méthode d'événement de clic qui recherche des éléments sélectionnés
dans le contrôle ListBox et les transmet à la méthode SetCurrentValuesForParameterField().
Le code varie légèrement pour un projet Web ou un projet Windows ; en conséquence, vous ne devez effectuer
que l'une des procédures Web ou Windows ci-après.
1.5.2.5.5.2
contrôle Button de réaffichage dans un projet Web
Procédure
1.
2.
[C#] au début de la classe de l'espace de noms System.Web.UI.WebControls (si cet espace de noms n'a pas
déjà été déclaré).
409
Remarque
Cette déclaration est nécessaire pour accéder à la classe ListItem.
3.
4.
Créez une boucle foreach pour extraire chaque instance ListItem de la propriété Items de
For Each item As ListItem In defaultParameterValuesList.Items
Next
foreach(ListItem item in defaultParameterValuesList.Items)
{
}
5.
Dans la boucle foreach, créez un bloc conditionnel imbriqué qui ajoute l'instance Item à l'instance Arraylist si
la propriété Selected de l'instance actuelle Item a pour valeur True.
If item.Selected Then
myArrayList.Add(item.Value)
End If
if(item.Selected)
{
arrayList.Add(item.Value);
}
6.
En dehors du bloc conditionnel et de la boucle foreach, appelez la méthode
SetCurrentValuesForParameterField() et transmettez l'instance de rapport CustomersByCity et
l'instance ArrayList.
SetCurrentValuesForParameterField(customersByCityReport, myArrayList)
SetCurrentValuesForParameterField(customersByCityReport, arrayList);
410
7.
Liez à nouveau l'instance de rapport CustomersByCity à la propriété ReportSource du contrôle
1.5.2.5.5.3
contrôle Button de réaffichage dans un projet Windows
Procédure
1.
2.
3.
Créez une boucle foreach pour extraire chaque élément (sous forme de chaîne) de la propriété SelectedItems
de defaultParameterValuesList.
For Each item As String In defaultParameterValuesList.SelectedItems
Next
foreach(string item in defaultParameterValuesList.SelectedItems)
{
}
4.
Dans le bloc conditionnel, ajoutez l'instance chaîne Item à l'instance ArrayList.
myArrayList.Add(item)
arrayList.Add(item);
411
5.
En dehors du bloc conditionnel et de la boucle foreach, appelez la méthode
SetCurrentValuesForParameterField() et transmettez l'instance de rapport CustomersByCity et
l'instance ArrayList.
SetCurrentValuesForParameterField(customersByCityReport, myArrayList)
SetCurrentValuesForParameterField(customersByCityReport, arrayList);
6.
Liez à nouveau l'instance de rapport CustomersByCity à la propriété ReportSource du contrôle
1.5.2.5.5.4
Contexte
Procédure
1.
2.
3.
4.
Ctrl enfoncée.
5.
La page est rechargée, affichant les enregistrements des clients qui vivent dans les villes sélectionnées dans
la liste.
6.
412
Résultats
Si vous développez une application Windows, vous avez à présent terminé. Si vous développez un site Web,
effectuez maintenant la procédure Configuration de la persistance des paramètres [page 413].
1.5.2.5.6
Configuration de la persistance des paramètres
Dans cette section, vous allez configurer la persistance (dans un tutoriel via le Web) des sélections des champs de
paramètre effectuées à partir du contrôle ListBox.
Comme le montre le tutoriel Tutoriel : Persistance du modèle d'objet ReportDocument à l'aide de Session [page
341], les modifications apportées au modèle d'objet ReportDocument sont perdues lorsque la page est rechargée,
chaque fois que des utilisateurs cliquent sur des boutons de la barre d'outils CrystalReportViewer (Page suivante
et Zoom par exemple).
1.5.2.5.6.1
Pour montrer le manque de persistance des
sélections de paramètre
Procédure
1.
2.
3.
4.
la liste.
5.
La page se recharge, puis affiche les enregistrements clients de tous les clients dans toutes les villes. Il s'agit
6.
La liste des villes sélectionnées n'est pas rendue persistante. La page 2 du rapport ne s'affiche pas. A la place,
les paramètres de lancement apparaissent de nouveau (Paris et Tokyo).
7.
Résultats
Vous devez ajouter un code de persistance à votre application afin que les modifications apportées au modèle
d'objet ReportDocument soient rendues persistantes lorsque les pages Web sont rechargées.
Pour commencer, vous allez ajouter un code de persistance à la méthode ConfigureCrystalReports() en
ajoutant un bloc Else au bloc conditionnel Not IsPostBack. Vous allez ensuite définir des valeurs uniques pour
413
l'instance ArrayList pour l'une des deux conditions du bloc conditionnel. A l'ouverture de la page, vous allez définir
les valeurs par défaut ("Paris" et "Tokyo") dans l'instance ArrayList. Au rechargement de la page, vous allez
extraire l'instance ArrayList stockée dans Session.
1.5.2.5.6.2
Pour ajouter un code de persistance à la méthode
Procédure
1.
Dans la méthode ConfigureCrystalReports(), coupez et collez au bas du bloc conditionnel If Not
IsPostBack les deux lignes de code permettant d'ajouter Paris et Tokyo à l'instance ArrayList.
End If
if (!IsPostBack)
{
}
2.
Ajoutez une ligne de code finale au bloc conditionnel qui affecte l'instance ArrayList à Session.
Remarque
3.
Ajoutez une condition Else au bloc conditionnel Not IsPostBack.
4.
Dans le bloc Else, extrayez l'instance ArrayList de Session, puis effectuez un cast de celle-ci en objet
ArrayList.
414
Résultats
Ces modifications apportées à la méthode ConfigureCrystalReports() permettent de garantir que l'instance
actuelle ArrayList est toujours disponible pour être transmise à la méthode
Dans la section suivante, vous allez apporter deux modifications au code dans l'événement de clic :
●
Sélectionner l'instance ArrayList créée et l'affecter à Session.
●
Remplacer les deux dernières lignes de code (qui configurent et affichent le rapport) par un appel à la
méthode ConfigureCrystalReports() afin d'exécuter cette fonctionnalité sur un bloc de code commun.
1.5.2.5.6.3
Pour modifier le code de la méthode d'événement
de clic selon la persistance Session
Procédure
1.
Supprimez les deux dernières lignes de code suivantes dans la méthode d'événement de clic.
La première ligne de code à supprimer représente l'appel à la méthode
SetCurrentValuesForParameterField(). La deuxième ligne de code à supprimer représente le code qui
lie l'instance customersByCityReport à la propriété ReportSource du contrôle CrystalReportViewer.
Dans l'étape suivante, vous allez ajouter deux nouvelles lignes de code pour remplacer le code supprimé.
2.
Dans la méthode d'événement de clic, immédiatement en dehors de la boucle foreach, ajoutez une ligne de
code qui affecte l'instance ArrayList à Session.
Remarque
3.
Appeler la méthode ConfigureCrystalReports().
415
Cette méthode extrait l'instance ArrayList, l'applique au rapport, puis lie le rapport au contrôle
Résultats
Remarque
Une autre méthode consiste à rendre persistante l'instance ReportDocument. Pour apprendre à rendre
persistante l'instance ReportDocument avec Session, voir le tutoriel Tutoriel : Persistance du modèle d'objet
ReportDocument à l'aide de Session [page 341].
1.5.2.5.6.4
Procédure
1.
2.
3.
4.
la liste.
5.
La page se recharge et affiche les enregistrements clients de tous les clients dans toutes les villes. Il s'agit
6.
7.
La liste des villes sélectionnées est désormais rendue persistante. La page 2 du rapport s'affiche.
8.
416
1.5.2.5.7
discrets
Addenda : Améliorations du code des paramètres
Vous avez réussi à créer un rapport avec une valeur de paramètre discret et une méthode d'assistance pouvant
accepter n'importe quel ensemble de valeurs dans un format commun (ArrayList). Vous avez aussi réussi à
appliquer ces valeurs à un rapport en fonction d'un nom de champ de paramètre spécifique (constante
PARAMETER_FIELD_NAME).
Si vous avez installé Visual Studio 2005 ou version ultérieure, ou SAP Crystal Reports Developer, vous avez accès
à la fonctionnalité API améliorée définissant les paramètres discrets dans le rapport Crystal. L'API de
SAP Crystal Reports Developer permet de réduire la quantité de code nécessaire à la définition des paramètres
discrets.
Dans les procédures précédentes, vous avez appris à créer la méthode d'assistance
Dans ce tutoriel, vous pouvez supprimer la méthode d'assistance et appeler à la place la méthode
SetParameterValue() de la classe ReportDocument.
La méthode SetParameterValue() propose les méthodes surchargées suivantes :
●
SetParameterValue(int index, object value)
●
SetParameterValue(string parameterFieldName, object value)
●
SetParameterValue(string parameterFieldName, object value, string subreport)
Vous pouvez transmettre n'importe quel type d'objet dont la valeur correspond aux valeurs par défaut du champ
du paramètre. L'objet peut être une instance Array qui stocke une liste de valeurs de paramètre.
Conditions prérequises :
●
Vous devez créer un projet en suivant les instructions de la section Tutoriel : Lecture et définition des
paramètres discrets [page 389].
Toutefois, la section Définition manuelle des paramètres dans le code [page 397] nécessite uniquement la
création de la constante PARAMETER_FIELD_NAME. Vous n'avez pas besoin de créer la méthode
d'assistance SetCurrentValuesForParameterField().
●
Si vous avez déjà créé un projet à l'aide des instructions de la section Tutoriel : Lecture et définition des
paramètres discrets [page 389], supprimez la méthode d'assistance SetCurrentValuesForParameterField() et
l'appel dans la méthode ConfigureCrystalReports().
1.5.2.5.7.1
Pour utiliser la méthode SetParameterValue()
avec des paramètres discrets
Procédure
1.
2.
3.
4.
Dans la méthode ConfigureCrystalReports(), au-dessus de la ligne qui lie le rapport à la propriété
ReportSource du contrôle CrystalReportViewer, appelez la méthode SetParameterValue() à partir de la
417
classe CustomerByCity. Transmettez le nom de champ et les valeurs de paramètre d'une instance Array à la
méthode.
customersByCityReport.SetParameterValue(PARAMETER_FIELD_NAME,
arrayList.ToArray())
customersByCityReport.SetParameterValue(PARAMETER_FIELD_NAME,
arrayList.ToArray());
Résultats
Vous êtes maintenant prêt à générer et exécuter le projet pour lire et définir des paramètres discrets.
1.5.2.6
Tutoriel : Lecture et définition des paramètres avec
un sous-rapport
Dans ce tutoriel, vous allez traiter un problème supplémentaire : que faire si un rapport nécessitant des
paramètres contient un sous-rapport nécessitant des paramètres différents ?
Remarque
Pour suivre ce tutoriel, vous devez terminer le tutoriel précédent Tutoriel : Lecture et définition des paramètres
Introduction
Dans le tutoriel précédent, Tutoriel : Lecture et définition des paramètres discrets [page 389], vous avez appris à
créer un rapport avec un paramètre et à créer un code permettant de définir ce paramètre au moment de
l'exécution, en utilisant chaque fois des valeurs de paramètres codées en dur et des valeurs de paramètres
transmises à partir d'un contrôle ListBox.
Dans ce tutoriel, vous allez apprendre à ajouter des paramètres à un sous-rapport.
Vous devez apporter quatre modifications au projet que vous avez créé lors de la procédure Tutoriel : Lecture et
définition des paramètres discrets [page 389] :
●
Ce sous-rapport désigne la table Commandes de la base de données Xtreme. La table Commandes est liée à
la table Clients utilisée dans le tutoriel précédent par la clé externe ID client.
●
Vous ajoutez un paramètre de plage au sous-rapport qui effectue un filtrage selon une plage de dates de
commande.
●
Vous ajoutez deux contrôles Text au formulaire : orderStartDate et orderEndDate afin de définir la plage des
dates de commande au moment de l'exécution.
418
●
Vous ajoutez une nouvelle méthode.
Cette méthode crée une instance ParameterRangeValue contenant les valeurs startDate et endDate, puis
transmet cette instance ParameterRangeValue au paramètre de plage dans le sous-rapport.
Une fois le tutoriel terminé, vous pouvez filtrer les valeurs affichées dans le rapport au moment de l'exécution. Le
code que vous ajoutez limite le nombre de villes affichées dans le rapport principal ainsi que la plage de dates de
commande qui apparaîtront dans le sous-rapport.
Exemple de code
version terminée.
●
Site Web C# : CS_Web_RDObjMod_ParametersSubrpt
●
Projet Windows C# : CS_Win_RDObjMod_ParametersSubrpt
●
Site Web Visual Basic : VB_Web_RDObjMod_ParametersSubrpt
●
Projet Windows Visual Basic : VB_Win_RDObjMod_ParametersSubrpt
Tutoriel : Lecture et définition des paramètres de plage d'un sous-rapport [page 277]
Dans ce tutoriel, vous allez traiter un problème supplémentaire : que faire si un rapport contient un sousrapport nécessitant des paramètres différents ?
419
1.5.2.6.1
1.5.2.6.1.1
Procédure
1.
Ouvrez le projet que vous avez créé dans le tutoriel précédent Tutoriel : Lecture et définition des paramètres
2.
Dans l'Explorateur de solutions, cliquez deux fois sur le rapport CustomersByCity pour l'ouvrir.
3.
dessous.
4.
5.
6.
Remarque
7.
Dans le champ Nom du nouveau rapport, saisissez CustomerOrders.
8.
9.
10. Dans le sous-dossier qui s'ouvre, développez le dossier ODBC (RDO).
Le dossier contient le serveur de base de données qui a été configuré pour le rapport lorsque ce dernier a été
créé.
Remarque
Si le serveur ne s'affiche pas, suivez les instructions du tutoriel précédent pour vous connecter à la base de
données Xtreme.
12. Dans le panneau Champs disponibles, sélectionnez ID commande, Date de commande, Date d'expédition et
Transporteur.
Terminer.
420
table Clients, sélectionnez ID client, puis cliquez sur le bouton >.
16. Dans le panneau Mise en relation du champ Clients.ID client qui s'affiche, laissez les sélections par défaut.
17. Cliquez sur OK.
Remarque
Résultats
Vous pouvez à présent vérifier les paramètres du sous-rapport.
1.5.2.6.1.2
Procédure
1.
2.
Remarque
3.
4.
Vérifiez que le champ de paramètre Pm-Clients.ID Client a été automatiquement généré lorsque le sousrapport a été relié.
5.
6.
Dans la boîte de dialogue Expert Sélection, vérifiez que le critère Commandes.ID Client est égal à {PmClients.ID Client} est défini, puis cliquez sur OK.
7.
421
Résultats
Vous avez réussi à ajouter un sous-rapport CustomerOrders au rapport CustomersByCity. Dans la section
suivante, vous allez ajouter un paramètre OrderDateRange au sous-rapport.
1.5.2.6.1.3
Pour ajouter un paramètre OrderDateRange au
sous-rapport
Procédure
1.
2.
○
Attribuez à Nom la valeur OrderDateRange.
○
Attribuez à Type de valeur la valeur Date.
○
Attribuez à Texte de l'invite la valeur Spécifiez une plage de dates des commandes à afficher.
○
Attribuez au paramètre Options une seule sélection, la valeur Valeur(s) de plage.
3.
Cliquez sur OK.
4.
5.
Cliquez sur l'onglet Nouveau.
6.
Dans la boîte de dialogue Choisir un champ, développez la table Commandes, sélectionnez Date de
commande, puis cliquez sur OK.
7.
Dans le nouvel onglet Commandes.Date de commande sélectionnez formule dans la liste déroulante des
critères.
8.
Saisissez la formule suivante :{Commandes.Date de commande} in {?OrderDateRange}.
9.
Cliquez sur OK.
Résultats
Vous avez réussi à ajouter un paramètre OrderDateRange au sous-rapport et à l'associer à la colonne
Commandes.Date de commande. Dans la section suivante, vous allez ajouter un code afin de désigner le
paramètre OrderDateRange dans le sous-rapport.
1.5.2.6.2
Ajout du code de paramètre au sous-rapport
Vous allez à présent ajouter le code de paramètre du sous-rapport à la classe code-behind. Vous commencez par
créer une méthode d'assistance privée SetDateRangeForOrders().
422
1.5.2.6.2.1
SetDateRangeForOrders()
Procédure
1.
2.
3.
Au début de la classe, ajoutez deux nouvelles constantes sous la constante PARAMETER_FIELD_NAME
existante définie dans le tutoriel précédent.
Private Const SUBREPORT_PARAMETER_FIELD_NAME As String = "OrderDateRange"
Private Const SUBREPORT_NAME As String = "CustomerOrders"
private const string SUBREPORT_PARAMETER_FIELD_NAME = "OrderDateRange";
private const string SUBREPORT_NAME = "CustomerOrders";
4.
Dans la partie inférieure de la classe, créez une méthode privée appelée SetDateRangeForOrders() avec
les trois paramètres suivants : ReportDocument, une chaîne startDate et une chaîne endDate.
Private Sub SetDateRangeForOrders(ByVal myReportDocument As ReportDocument,
ByVal startDate As String, ByVal endDate As String)
End Sub
private void SetDateRangeForOrders(ReportDocument reportDocument, string
startDate, string endDate)
{
}
5.
Dans cette méthode, déclarez et instanciez la classe ParameterRangeValue.
Dim myParameterRangeValue As ParameterRangeValue = New
ParameterRangeValue()
ParameterRangeValue parameterRangeValue = new
ParameterRangeValue();
Remarque
Pour que la classe ParameterRangeValue soit accessible, vous devez inclure une instruction "Imports"
projet [page 15].)
6.
Attribuez à la propriété StartValue de l'instance ParameterRangeValue le paramètre de méthode startDate.
myParameterRangeValue.StartValue = startDate
423
parameterRangeValue.StartValue = startDate;
Remarque
Les propriétés StartValue et EndValue de la classe ParameterRangeValue acceptent les valeurs de type
Objet. Ce type générique permet de transmettre la valeur de plage sous plusieurs formes, y compris texte,
nombre, date, devise ou heure.
7.
Attribuez à la propriété EndValue de l'instance ParameterRangeValue le paramètre de méthode endDate.
myParameterRangeValue.EndValue = endDate
parameterRangeValue.EndValue = endDate;
8.
Définissez les limites inférieures et supérieures afin de les inclure.
myParameterRangeValue.LowerBoundType = RangeBoundType.BoundInclusive
myParameterRangeValue.UpperBoundType = RangeBoundType.BoundInclusive
parameterRangeValue.LowerBoundType = RangeBoundType.BoundInclusive;
parameterRangeValue.UpperBoundType = RangeBoundType.BoundInclusive;
Remarque
Pour le paramètre BoundInclusive, les valeurs de plage supérieures et inférieures sont incluses dans la
plage.
Vous allez à présent affecter l'instance ParameterRangeValue au paramètre du sous-rapport.
9.
Extrayez l'objet ParameterFieldDefinitions provenant de la propriété DataDefinition de l'instance
ReportDocument.
Remarque
ParameterFieldDefinitions est une classe indexée contenant des instances de la classe
10. Extrayez l'instance ParameterFieldDefinition de la classe indexée ParameterFieldDefinitions
basée sur les deux valeurs indexées suivantes : le nom du champ de paramètre du sous-rapport et le nom du
sous-rapport. Transmettez les deux valeurs de constante que vous avez déclarées au début de la classe.
424
myParameterFieldDefinitions(SUBREPORT_PARAMETER_FIELD_NAME,
SUBREPORT_NAME)
parameterFieldDefinitions[SUBREPORT_PARAMETER_FIELD_NAME,
SUBREPORT_NAME];
11. Appelez la méthode Clear() de la propriété CurrentValues de l'instance ParameterFieldDefinition
afin de supprimer les éventuelles valeurs existantes de la propriété CurrentValues.
myParameterFieldDefinition.CurrentValues.Clear()
parameterFieldDefinition.CurrentValues.Clear();
12. Ajoutez l'instance ParameterRangeValue que vous venez de créer à la propriété CurrentValues de
l'instance ParameterFieldDefinition.
myParameterFieldDefinition.CurrentValues.Add(myParameterRangeValue)
parameterFieldDefinition.CurrentValues.Add(parameterRangeValue);
13. Appelez la méthode ApplyCurrentValues() en lui transmettant la propriété CurrentValues de l'instance
myParameterFieldDefinition.ApplyCurrentValues(myParameterFieldDefinition.CurrentV
alues)
parameterFieldDefinition.ApplyCurrentValues(parameterFieldDefinition.CurrentValue
s);
Résultats
Cette procédure a défini des valeurs de date de début et de fin dans une instance ParameterRangeValue et les a
transmises au paramètre OrderDateRange du sous-rapport CustomerOrders.
1.5.2.6.3
Ajout de contrôles TextBox pour contenir les
valeurs de paramètres de plage
Dans cette section, vous allez ajouter deux contrôles TextBox pour transmettre au paramètre de plage
OrderDateRange des valeurs de date de début et de date de fin au moment de l'exécution dans le sous-rapport
CustomerOrders.
425
Remarque
Si vous implémentez ce tutoriel dans un site Web, la persistance des valeurs de date que les utilisateurs
saisissent dans les zones de texte est conservée par ViewState.
1.5.2.6.3.1
Procédure
1.
2.
3.
a) Cliquez entre le contrôle ListBox et le contrôle Button.
b) Appuyez trois fois sur ENTREE pour insérer deux lignes entre le contrôle ListBox et le contrôle Button.
c) Sur la première ligne créée sous le contrôle ListBox, saisissez "Date de début de la commande".
d) Sur la seconde ligne créée sous le contrôle ListBox, saisissez "Date de fin de la commande".
4.
a) Dans la boîte à outils, faites glisser deux contrôles Label à droite du contrôle ListBox. Placez une étiquette
sur l'autre, en positionnant les deux étiquettes au-dessus du contrôle Button.
b) Sélectionnez le premier contrôle Label. Dans la fenêtre Propriétés, attribuez à la propriété Text la valeur
"Date de début de la commande".
c) Sélectionnez le second contrôle Label. Dans la fenêtre Propriétés, attribuez à la propriété Text la valeur
"Date de fin de la commande".
5.
Dans la boîte à outils, faites glisser un contrôle TextBox à droite de "Date de début de la commande".
6.
7.
Dans la fenêtre Propriétés, attribuez à ID (ou Name) la valeur "orderStartDate."
8.
Dans la boîte à outils, faites glisser un contrôle TextBox à droite de "Date de fin de la commande."
9.
10. Dans la fenêtre Propriétés, attribuez à ID (ou Name) la valeur "orderEndDate".
1.5.2.6.4
Modification des méthodes d'appel du sous-rapport
Vous devez à présent modifier la méthode ConfigureCrystalReports() et la méthode d'événement
redisplay_Click() pour recevoir des informations de ces contrôles TextBox, les appliquer à la méthode
SetDateRangeForOrders() et traiter les informations de paramètre pour les sous-rapports.
Dans le tutoriel précédent, Tutoriel : Lecture et définition des paramètres discrets [page 389], vous avez conçu ces
méthodes de deux façons différentes si vous avez inclus la persistance Session.
426
Remarque
Les projets Windows ne nécessitent aucune persistance Session. Les sites Web nécessitent généralement la
persistance Session.
Choisissez l'une des deux (mais pas les deux) procédures ci-dessous. Modifiez les méthodes qui excluent la
persistance Session ou les méthodes qui incluent la persistance Session :
1.5.2.6.4.1
Modification des méthodes qui excluent la
persistance Session
Si vous avez créé le tutoriel précédent Tutoriel : Lecture et définition des paramètres discrets [page 389] et exclu
la persistance Session, effectuez les procédures suivantes. Si vous souhaitez inclure la persistance de Session,
voir Modification des méthodes qui incluent la persistance Session [page 428].
1.5.2.6.4.1.1
ConfigureCrystalReports() excluant la persistance Session
Procédure
1.
Dans la méthode ConfigureCrystalReports(), créez plusieurs sauts de ligne dans le code après les lignes
qui affectent "Paris" et "Tokyo" comme variables ArrayList.
2.
Dans les sauts de ligne, déclarez et définissez des valeurs en code dur pour les deux variables chaîne,
startDate et endDate.
Dim startDate As String = "8/1/1997"
Dim endDate As String = "8/31/1997"
string startDate = "8/1/1997";
string endDate = "8/31/1997";
3.
Créez plusieurs sauts de ligne dans le code au-dessus de la ligne qui lie le rapport au contrôle
4.
Dans les sauts de ligne, saisissez un appel à la méthode SetDateRangeForOrders(), puis transmettez le
rapport CustomersByCity et les variables startDate et endDate.
SetDateRangeForOrders(customersByCityReport, startDate, endDate)
SetDateRangeForOrders(customersByCityReport, startDate, endDate);
427
5.
Résultats
Modifiez ensuite la méthode d'événement redisplay_Click.
1.5.2.6.4.1.2
excluant la persistance Session
Procédure
1.
Dans la méthode d'événement redisplay_Click(), créez plusieurs sauts de ligne dans le code au-dessus
de la ligne qui lie le rapport au contrôle CrystalReportViewer.
2.
Dans les sauts de ligne, déclarez et définissez les valeurs des deux variables chaîne startDate et endDate à
partir des contrôles TextBox que vous avez ajoutés au Web Form ou Windows Form.
Dim startDate As String = orderStartDate.Text
Dim endDate As String = orderEndDate.Text
string startDate = orderStartDate.Text;
string endDate = orderEndDate.Text;
3.
Saisissez un appel à la méthode SetDateRangeForOrders(), puis transmettez le rapport CustomersByCity
et les variables startDate et endDate.
4.
1.5.2.6.4.2
Modification des méthodes qui incluent la
persistance Session
Si vous avez créé le tutoriel précédent Tutoriel : Lecture et définition des paramètres discrets [page 389] et inclus
méthodes qui excluent la persistance Session [page 427].
428
1.5.2.6.4.2.1
ConfigureCrystalReports() incluant la persistance Session
Procédure
1.
qui déclare et instancie ArrayList.
2.
Dans les sauts de ligne, déclarez deux variables chaîne, startDate et endDate.
Dim startDate As String
Dim endDate As String
string startDate;
string endDate;
3.
Dans le bloc conditionnel Not IsPostBack, saisissez des valeurs par défaut pour les variables startDate et
endDate.
startDate = "8/1/1997"
endDate = "8/31/1997"
startDate = "8/1/1997";
endDate = "8/31/1997";
4.
Dans le bloc conditionnel Not IsPostBack, affectez les variables startDate et endDate à Session.
Session("startDate") = startDate
Session("endDate") = endDate
Session["startDate"] = startDate;
Session["endDate"] = endDate;
5.
Dans le bloc Else, après l'extraction de l'instance ArrayList de Session, extrayez les variables startDate et
endDate de Session.
startDate = Session("startDate").ToString()
endDate = Session("endDate").ToString()
startDate = Session["startDate"].ToString();
endDate = Session["endDate"].ToString();
Cette approche permet d'atteindre la fin du bloc avec les variables de date affectées dans les deux cas. Cette
méthode suit la logique parallèle de l'affectation de la variable ArrayList que vous avez configurée dans le
tutoriel précédent.
6.
Créez plusieurs sauts de ligne dans le code au-dessus de la ligne qui lie le rapport au contrôle
429
7.
Dans ces nouveaux sauts de ligne, saisissez un appel à la méthode SetDateRangeForOrders(), puis
transmettez le rapport CustomersByCity et les variables startDate et endDate.
8.
Résultats
Modifiez ensuite la méthode d'événement redisplay_Click.
1.5.2.6.4.2.2
incluant la persistance Session
Procédure
1.
Dans la méthode d'événement redisplay_Click(), créez plusieurs sauts de ligne dans le code après la
ligne qui affecte l'instance ArrayList à Session.
2.
Dans les sauts de ligne, affectez la propriété Text des contrôles TextBox orderStartDate et orderEndDate aux
variables Session.
Session("startDate") = orderStartDate.Text
Session("endDate") = orderEndDate.Text
Session["startDate"] = orderStartDate.Text;
Session["endDate"] = orderEndDate.Text;
3.
Ces valeurs Session startDate et endDate sont à présent extraites et appliquées lors de l'appel de la méthode
Résultats
Vous êtes maintenant prêt à générer et exécuter le projet pour vérifier que les valeurs TextBox redéfinissent le
paramètre de plage dans le sous-rapport. w
430
1.5.2.6.5
Vérification du paramètre du sous-rapport
Vous allez à présent vérifier le paramètre du sous-rapport à partir des valeurs TextBox.
1.5.2.6.5.1
Pour vérifier le paramètre du sous-rapport
Procédure
1.
2.
3.
4.
Ctrl enfoncée.
5.
Dans le contrôle TextBox startDate, saisissez "1/1/1997".
6.
Dans le contrôle TextBox endDate , saisissez "31/12/1997".
7.
La page se recharge et affiche les enregistrements des clients qui vivent dans les villes que vous venez de
sélectionner dans la liste, ainsi qu'un sous-rapport indiquant les commandes correspondant à la plage de
dates spécifiées ci-dessus.
8.
Dans le contrôle CrystalReportViewer, augmentez le facteur de zoom à 125 %.
La page se recharge avec un facteur de zoom de 125 %. Les valeurs sélectionnées à la fois pour les villes et la
plage des dates de commande sont rendues persistantes.
9.
1.5.2.6.6
Addenda : Améliorations du code des paramètres
de plage pour des sous-rapports
Vous avez réussi à modifier votre projet de tutoriel pour utiliser un rapport contenant un sous-rapport, ainsi qu'à
définir une plage de dates de commande selon le paramètre de plage créé dans le sous-rapport. Dans cet
addenda, vous allez apprendre à lire et à définir des paramètres d'un sous-rapport avec des fonctionnalités API
améliorées.
Dans les étapes précédentes, vous avez appris à créer la méthode d'assistance SetDateRangeForOrders() qui
utilise les classes ParameterFieldDefinitions et ParameterFieldDefinition.
Dans ce tutoriel, vous devez supprimer les lignes de code utilisant les classes ParameterFieldDefinitions et
ParameterFieldDefinition. Vous apprendrez ensuite à utiliser les classes ParameterFields et
ParameterField des fonctionnalités API améliorées de SAP Crystal Reports pour coder la méthode
SetDateRangeForOrders().
Remarque
Les fonctionnalités API améliorées incluent la méthode SetParameterValue(string
parameterFieldName, object value, string subreport) pour les sous-rapports avec des champs de
431
paramètre discret. La méthode SetParameterValue() ne peut donc pas être utilisée dans ce tutoriel, car le
sous-rapport comporte un paramètre de plage.
1.5.2.6.6.1
Pour utiliser les fonctionnalités API améliorées
de SAP Crystal Reports pour les sous-rapports avec des
paramètres de plage
Prérequis
Vous devez créer un projet basé sur les instructions de la section Tutoriel : Lecture et définition des paramètres
avec un sous-rapport [page 418].
Procédure
1.
2.
3.
4.
Dans la méthode SetDateRangeForOrders(), supprimez les lignes de code qui utilisent les classes
ParameterFieldDefinitions ou ParameterFieldDefinition. Supprimez les lignes de code suivantes :
myParameterFieldDefinitions(SUBREPORT_PARAMETER_FIELD_NAME, SUBREPORT_NAME)
myParameterFieldDefinition.CurrentValues.Clear()
myParameterFieldDefinition.CurrentValues.Add(myParameterRangeValue)
myParameterFieldDefinition.ApplyCurrentValues(myParameterFieldDefinition.CurrentV
alues)
parameterFieldDefinitions[SUBREPORT_PARAMETER_FIELD_NAME, SUBREPORT_NAME];
parameterFieldDefinition.CurrentValues.Clear();
parameterFieldDefinition.CurrentValues.Add(parameterRangeValue);
parameterFieldDefinition.ApplyCurrentValues(parameterFieldDefinition.CurrentValue
s);
Dans l'étape suivante, vous allez ajouter les nouvelles méthodes API de SAP Crystal Reports à la méthode
SetDateRangeForOrders(), après le code définissant le type de limite de plage.
5.
Dans la méthode SetDateRangeForOrders(), extrayez l'instance ParameterFields à partir de la propriété
ParameterFields de l'instance ReportDocument.
Dim myParameterFields As ParameterFields = reportDocument.ParameterFields
432
ParameterFields parameterFields = reportDocument.ParameterFields;
6.
Extrayez l'instance ParameterField de la classe indexée ParameterFields, basée sur les deux valeurs indexées
suivantes : le nom du champ de paramètre du sous-rapport et le nom du sous-rapport. Transmettez les deux
valeurs de constante que vous avez déclarées au début de la classe.
myParameterFields(SUBREPORT_PARAMETER_FIELD_NAME, SUBREPORT_NAME)
ParameterField parameterField = parameterFields[SUBREPORT_PARAMETER_FIELD_NAME,
SUBREPORT_NAME];
7.
Appelez la méthode Clear() de la propriété CurrentValues de l'instance ParameterField afin de supprimer
les éventuelles valeurs existantes de la propriété CurrentValues.
myParameterField.CurrentValues.Clear()
8.
Ajoutez l'instance ParameterRangeValue que vous venez de créer à la propriété CurrentValues de l'instance
ParameterField.
myParameterField.CurrentValues.Add(myParameterRangeValue)
parameterField.CurrentValues.Add(parameterRangeValue);
Résultats
Vous êtes maintenant prêt à générer et exécuter le projet pour lire et définir des paramètres de plage pour un
sous-rapport.
1.5.2.7
Tutoriel : Exportation dans plusieurs formats
Dans ce tutoriel, vous allez apprendre à exporter le rapport par programmation.
Introduction
Dans ce tutoriel, vous allez apprendre à exporter le rapport par programmation. SAP Crystal Reports permet
d'exporter vers un grand nombre de formats. Les options disponibles dépendent de la version de
SAP Crystal Reports installée.
433
Toutes les versions de SAP Crystal Reports, version développeur pour Microsoft Visual Studio prennent en charge
les options d'exportation suivantes :
●
●
●
PDF
●
●
●
●
●
Microsoft Excel (2007) Données uniquement
●
HTML 4.0
SAP Crystal Reports Developer prend en charge les formats supplémentaires suivants :
●
●
●
●
Texte
Vous pouvez sélectionner n'importe lequel de ces formats ; cliquez sur le bouton Exporter du contrôle
CrystalReportViewer, puis exportez un rapport au format sélectionné vers votre ordinateur local qui exécute
SAP Crystal Reports dans une application Web ou Windows.
Vous pouvez également exporter des rapports par programmation vers des répertoires spécifiques sur un
serveur Web local ou un ordinateur utilisant Windows.
Pour commencer ce tutoriel, vous allez ajouter un contrôle DropDownList à votre Web Form ou Windows Form,
puis le remplir avec les valeurs de l'énumération ExportFormatType dans l'espace de noms
CrystalDecisions.Shared.
Vous allez ensuite créer trois méthodes d'assistance privées contenant la fonctionnalité d'exportation et
effectuant la configuration spécifique de chaque format d'exportation.
Enfin, vous allez créer une méthode d'événement de clic à partir d'un contrôle Button sur le Web Form ou le
Windows Form et appeler les trois méthodes d'assistance privées exécutant l'exportation.
Exemple de code
version terminée.
●
Site Web C# : CS_Web_RDObjMod_Export
●
Projets Windows C# : CS_Win_RDObjMod_Export
●
Site Web Visual Basic : VB_Web_RDObjMod_Export
●
Projet Windows Visual Basic : VB_Win_RDObjMod_Export
434
1.5.2.7.1
Ajout de contrôles au Web Form ou Windows Form
Dans cette section, vous allez ajouter des contrôles DropDownList, Button et Label au-dessus du contrôle
CrystalReportViewer sur le Web Form ou le Windows Form.
1.5.2.7.1.1
Pour ajouter des contrôles au Web Form ou
Windows Form
Procédure
1.
2.
3.
sur ENTREE.
4.
b) Redimensionnez le contrôle CrystalReportViewer pour laisser assez d'espace au-dessus afin d'ajouter un
contrôle ComboBox.
c) Dans la fenêtre Propriétés, attribuez à la propriété Anchor la valeur "Top, Bottom, Left, Right".
5.
Dans la Boîte à outils, faites glisser un contrôle DropDownList (dans les sites Web) ou un contrôle ComboBox
(dans les projets Windows) au-dessus du contrôle CrystalReportViewer.
Remarque
Si une tâche guidée apparaît dans le contrôle DropDownList (ComboBox) lorsque vous utilisez
Visual Studio 2005 ou version ultérieure, appuyez sur Echap pour la fermer.
6.
Cliquez sur le contrôle DropDownList (ComboBox) pour le sélectionner.
7.
Dans la fenêtre Propriétés, attribuez à la propriété ID la valeur "exportTypesList".
8.
Dans la Boîte à outils, faites glisser un contrôle Button à droite du contrôle DropDownList (ComboBox).
9.
10. Dans la fenêtre Propriétés, procédez comme suit :
○
Attribuez à la propriété ID la valeur "exportByType".
435
○
Attribuez à la propriété Text la valeur "Exporter au type sélectionné".
11. Dans la Boîte à outils, faites glisser un contrôle Label à droite du contrôle Button.
12. Cliquez sur le contrôle Label pour le sélectionner.
13. Dans la fenêtre Propriétés, procédez comme suit :
○
Attribuez à la propriété ID la valeur "message".
○
Laissez la propriété Text vide.
○
Attribuez à la propriété Visible la valeur "False".
Résultats
Vous devez à présent remplir le contrôle DropDownList à l'aide de l'énumération ExportFormatType de l'espace
de noms CrystalDecisions.Shared.
1.5.2.7.1.2
l'énumération ExportFormatType pour un site Web
Procédure
1.
Ouvrez le Web Form.
2.
3.
Ajoutez un bloc conditionnel Not IsPostBack à la fin de la méthode ConfigureCrystalReports().
End If
if (!IsPostBack)
{
}
4.
Dans le bloc conditionnel, attribuez à la propriété DataSource du contrôle ComboBox exportTypesList les
valeurs de l'énumération ExportFormatType.
exportTypesList.DataSource = System.Enum.GetValues(GetType(ExportFormatType))
exportTypesList.DataSource = System.Enum.GetValues(typeof(ExportFormatType));
5.
Appelez la méthode DataBind() du contrôle DropDownList exportTypesList pour lier les valeurs au contrôle.
exportTypesList.DataBind()
436
exportTypesList.DataBind();
1.5.2.7.1.3
l'énumération ExportFormatType pour un projet Windows
Procédure
1.
2.
3.
A la fin de la méthode ConfigureCrystalReports(), attribuez à la propriété DataSource du contrôle
ComboBox exportTypesList les valeurs de l'énumération ExportFormatType.
exportTypesList.DataSource = System.Enum.GetValues(GetType(ExportFormatType))
exportTypesList.DataSource = System.Enum.GetValues(typeof(ExportFormatType));
1.5.2.7.2
Création de méthodes exécutant l'exportation
Dans cette section, vous allez créer les méthodes d'assistance privées exécutant l'exportation suivantes.
●
ExportSetup()
●
ExportSelection()
●
ExportCompletion()
Ces méthodes sont appelées plus loin dans ce tutoriel à partir d'une méthode d'événement de clic. Vous
commencez par créer la méthode d'assistance ExportSetup().
1.5.2.7.2.1
Pour créer la méthode ExportSetup()
Procédure
1.
2.
3.
En haut de la classe, ajoutez trois déclarations de classe.
Private exportPath As String
Private myDiskFileDestinationOptions As DiskFileDestinationOptions
Private myExportOptions As ExportOptions
437
private string exportPath;
private DiskFileDestinationOptions diskFileDestinationOptions;
private ExportOptions exportOptions;
Vous instancierez ultérieurement ces classes d'assistance dans la méthode ExportSetup().
4.
A la fin de la classe, créez une méthode d'assistance privée appelée ExportSetup(), sans valeur renvoyée.
Public Sub ExportSetup()
End Sub
private void ExportSetup()
{
}
5.
Dans la méthode, définissez pour la variable de type chaîne exportPath le répertoire racine du disque dur.
exportPath = "C:\Exported\"
exportPath = "C:\\Exported\\";
Remarque
Si vous souhaitez placer le dossier Exported dans le répertoire Web de votre serveur Web, ajoutez la
propriété Request.PhysicalApplicationPath comme préfixe au nom de dossier.
6.
Créez un bloc conditionnel qui vérifie si le répertoire dans la chaîne exportPath existe déjà.
If Not System.IO.Directory.Exists(exportPath) Then
End If
if (!System.IO.Directory.Exists(exportPath))
{
}
7.
Dans le bloc conditionnel, appelez la méthode CreateDirectory() de System.IO.Directory pour créer le
répertoire dans la chaîne exportPath.
System.IO.Directory.CreateDirectory(exportPath)
System.IO.Directory.CreateDirectory(exportPath);
8.
En dehors du bloc conditionnel, instanciez la classe DiskFileDesintationOptions.
myDiskFileDestinationOptions = New DiskFileDestinationOptions()
438
diskFileDestinationOptions = new DiskFileDestinationOptions();
9.
Remplissez l'instance ExportOptions avec la propriété ExportOptions de l'instance
hierarchicalGroupingReport.
myExportOptions = hierarchicalGroupingReport.ExportOptions
exportOptions = hierarchicalGroupingReport.ExportOptions;
10. Attribuez à la propriété ExportDestinationType de l'instance ExportOptions l'énumération
ExportDestinationType.DiskFile.
myExportOptions.ExportDestinationType = ExportDestinationType.DiskFile
exportOptions.ExportDestinationType = ExportDestinationType.DiskFile;
11. Pour un projet Windows, effacez les valeurs de la propriété ExportFormatOptions de l'instance ExportOptions.
(Cette ligne de code est inutile pour un site Web car la variable est automatiquement effacée à chaque
événement de clic.)
myExportOptions.ExportFormatOptions = Nothing
exportOptions.ExportFormatOptions = null;
Résultats
Vous allez créer à présent la méthode d'assistance ExportSelection().
1.5.2.7.2.2
Pour créer la méthode ExportSelection()
Procédure
1.
2.
3.
Au début de la classe, ajoutez une déclaration booléenne utilisée pour vérifier qu'aucun format d'exportation
n'est sélectionné.
Private selectedNoFormat As Boolean = True
439
private bool selectedNoFormat = true;
4.
A la fin de la classe, créez une méthode d'assistance privée appelée ExportSelection(), sans valeur
renvoyée.
Public Sub ExportSelection()
End Sub
private void ExportSelection()
{
}
5.
Dans la méthode, créez une instruction "Select Case" [Visual Basic] ou "switch" [C#] qui
référence les membres de l'énumération ExportFormatType. L'énumération repose sur l'objet SelectedIndex
du contrôle DropDownList exportTypesList que vous avez créé dans la procédure précédente.
Select Case exportTypesList.SelectedIndex
Case ExportFormatType.NoFormat
Case ExportFormatType.CrystalReport
Case ExportFormatType.RichText
Case ExportFormatType.WordForWindows
Case ExportFormatType.Excel
Case ExportFormatType.PortableDocFormat
Case ExportFormatType.HTML32
Case Else
End Select
switch ((ExportFormatType)exportTypesList.SelectedIndex)
{
case ExportFormatType.NoFormat:
break;
case ExportFormatType.CrystalReport:
break;
case ExportFormatType.RichText:
break;
case ExportFormatType.WordForWindows:
break;
case ExportFormatType.Excel:
break;
case ExportFormatType.PortableDocFormat:
break;
case ExportFormatType.HTML32:
break;
break;
default:
440
}
break;
Résultats
Vous avez terminé la méthode ExportSelection(). Vous allez créer à présent la méthode d'assistance
ExportCompletion().
1.5.2.7.2.3
Pour créer la méthode ExportCompletion()
Procédure
1.
2.
3.
A la fin de la classe, créez une méthode d'assistance privée appelée ExportCompletion(), sans valeur
renvoyée.
Public Sub ExportCompletion()
End Sub
private void ExportCompletion()
{
}
4.
Dans la méthode, créez un bloc try/catch avec la classe Exception référencée en tant que variable intitulée
"ex".
Try
Catch ex As Exception
End Try
try
{
}
catch (Exception ex)
{
}
5.
Dans le bloc d'essai, créez un bloc conditionnel pour vérifier la variable booléenne selectedNoFormat.
If selectedNoFormat Then
Else
441
End If
if (selectedNoFormat)
{
}
else
{
}
6.
Dans le bloc If, attribuez à la propriété Text du contrôle Label message la constante
FORMAT_NOT_SUPPORTED de la classe MessageConstants.
message.Text = MessageConstants.FORMAT_NOT_SUPPORTED
message.Text = MessageConstants.FORMAT_NOT_SUPPORTED;
7.
Dans le bloc Else, appelez la méthode Export() de l'instance hierarchicalGroupingReport.
hierarchicalGroupingReport.Export()
hierarchicalGroupingReport.Export();
8.
Toujours dans le bloc Else, attribuez à la propriété Text du contrôle Label message la constante SUCCESS de
la classe MessageConstants.
9.
Dans le bloc catch, attribuez à la propriété Text du contrôle Label message la constante FAILURE de la classe
MessagesConstants, puis ajoutez-lui la propriété Message du paramètre Exception.
message.Text = MessageConstants.FAILURE & ex.Message
message.Text = MessageConstants.FAILURE + ex.Message;
10. En dehors du bloc try/catch, attribuez à la propriété Visible du contrôle Label message la valeur "True".
message.Visible = True
message.Visible = true;
442
Résultats
Vous venez de créer les trois méthodes d'assistance privées exécutant l'exportation.
1.5.2.7.3
Création de méthodes configurant plusieurs
formats d'exportation
Dans cette section, vous allez créer les méthodes d'assistance privées configurant plusieurs formats
d'exportation. Toutes ces méthodes sont utilisées de la même façon, à l'exception des méthodes
ConfigureExportToHtml32() et ConfigureExportToHtml40() qui offrent différents modes d'exportation au format
HTML.
●
ConfigureExportToRpt()
●
ConfigureExportToRtf()
●
ConfigureExportToDoc()
●
ConfigureExportToXls()
●
ConfigureExportToPdf()
●
ConfigureExportToHtml32()
●
1.5.2.7.3.1
Procédure
1.
2.
3.
A la fin de la classe, créez une méthode d'assistance privée appelée ConfigureExportToRpt(), sans valeur
renvoyée.
Public Sub ConfigureExportToRpt()
End Sub
private void ConfigureExportToRpt()
{
}
4.
Dans la méthode, attribuez à la propriété ExportFormatType de l'instance ExportOptions l'énumération
ExportFormatType CrystalReport.
myExportOptions.ExportFormatType = ExportFormatType.CrystalReport
443
exportOptions.ExportFormatType = ExportFormatType.CrystalReport;
5.
Attribuez à la propriété DiskFileName de l'instance DiskFileDestinationOptions la chaîne exportPath,
puis ajoutez-lui le nom d'un document avec une extension de fichier .rpt.
myDiskFileDestinationOptions.DiskFileName = exportPath &
"Report.rpt"
diskFileDestinationOptions.DiskFileName = exportPath +
"Report.rpt";
6.
Enfin, attribuez à la propriété ExportDestinationOptions de l'instance ExportOptions, l'instance
DiskFileDestinationOptions que vous avez configurée à l'étape précédente.
myExportOptions.ExportDestinationOptions = myDiskFileDestinationOptions
exportOptions.ExportDestinationOptions = diskFileDestinationOptions;
1.5.2.7.3.2
ConfigureExportToRtf
Procédure
1.
2.
3.
A la fin de la classe, créez une méthode d'assistance privée appelée ConfigureExportToRtf(), sans valeur
renvoyée.
Public Sub ConfigureExportToRtf()
End Sub
private void
{
}
4.
ExportFormatType RichText.
myExportOptions.ExportFormatType = ExportFormatType.RichText
exportOptions.ExportFormatType = ExportFormatType.RichText;
444
5.
Attribuez à la propriété DiskFileName de l'instance DiskFileDestinationOptions la chaîne exportPath, puis
ajoutez-lui le nom d'un document avec une extension de fichier .rtf.
myDiskFileDestinationOptions.DiskFileName = exportPath & "RichTextFormat.rtf"
diskFileDestinationOptions.DiskFileName = exportPath + "RichTextFormat.rtf";
6.
1.5.2.7.3.3
ConfigureExportToDoc
Procédure
1.
2.
3.
A la fin de la classe, créez une méthode d'assistance privée appelée ConfigureExportToDoc(), sans valeur
renvoyée.
Public Sub ConfigureExportToDoc()
End Sub
private void
{
}
4.
ExportFormatType WordForWindows.
myExportOptions.ExportFormatType = ExportFormatType.WordForWindows
exportOptions.ExportFormatType = ExportFormatType.WordForWindows;
445
5.
ajoutez-lui le nom d'un document avec une extension de fichier .doc.
myDiskFileDestinationOptions.DiskFileName = exportPath &
"Word.doc"
diskFileDestinationOptions.DiskFileName = exportPath + "Word.doc";
6.
1.5.2.7.3.4
ConfigureExportToXls
Procédure
1.
2.
3.
A la fin de la classe, créez une méthode d'assistance privée appelée ConfigureExportToXls(), sans valeur
renvoyée.
Public Sub ConfigureExportToXls()
End Sub
private void
{
}
4.
ExportFormatType Excel.
myExportOptions.ExportFormatType = ExportFormatType.Excel
exportOptions.ExportFormatType = ExportFormatType.Excel;
446
5.
ajoutez-lui le nom d'un document avec une extension de fichier .xls.
myDiskFileDestinationOptions.DiskFileName = exportPath & "Excel.xls"
diskFileDestinationOptions.DiskFileName = exportPath + "Excel.xls";
6.
1.5.2.7.3.5
ConfigureExportToPdf
Procédure
1.
2.
3.
A la fin de la classe, créez une méthode d'assistance privée appelée ConfigureExportToPdf(), sans valeur
renvoyée.
Public Sub ConfigureExportToPdf()
End Sub
private void
{
}
4.
ExportFormatType PortableDocFormat.
myExportOptions.ExportFormatType = ExportFormatType.PortableDocFormat
exportOptions.ExportFormatType = ExportFormatType.PortableDocFormat;
447
5.
ajoutez-lui le nom d'un document avec une extension de fichier .pdf.
myDiskFileDestinationOptions.DiskFileName = exportPath & "PortableDoc.pdf"
diskFileDestinationOptions.DiskFileName = exportPath + "PortableDoc.pdf";
6.
1.5.2.7.3.6
ConfigureExportToHtml32
Procédure
1.
2.
3.
A la fin de la classe, créez une méthode d'assistance privée appelée ConfigureExportToHtml32(), sans
valeur renvoyée.
Public Sub ConfigureExportToHtml32()
End Sub
private void
{
}
4.
ExportFormatType HTML32.
myExportOptions.ExportFormatType = ExportFormatType.HTML32
exportOptions.ExportFormatType = ExportFormatType.HTML32;
5.
Déclarez et instanciez la classe HTMLFormatOptions avec le nom de variable "html32FormatOptions".
Dim html32FormatOptions As HTMLFormatOptions = New
HTMLFormatOptions()
448
6.
Attribuez à la propriété HTMLBaseFolderName de l'instance html32FormatOptions la chaîne exportPath et le
nom "Html32Folder".
html32FormatOptions.HTMLBaseFolderName = exportPath &
"Html32Folder"
html32FormatOptions.HTMLBaseFolderName = exportPath +
"Html32Folder";
7.
Attribuez à la propriété HTMLFileName de l'instance html32FormatOptions le nom "html32.html".
html32FormatOptions.HTMLFileName = "html32.html"
html32FormatOptions.HTMLFileName = "html32.html";
8.
Attribuez à la propriété HTMLEnableSeparatedPages de l'instance html32FormatOptions la valeur "False".
html32FormatOptions.HTMLEnableSeparatedPages = False
html32FormatOptions.HTMLEnableSeparatedPages = false;
9.
Attribuez à la propriété HTMLHasPageNavigator de l'instance html32FormatOptions la valeur "False".
html32FormatOptions.HTMLHasPageNavigator = False
html32FormatOptions.HTMLHasPageNavigator = false;
10. Enfin, affectez l'instance html32FormatOptions à la propriété FormatOptions de l'instance ExportOptions.
myExportOptions.ExportFormatOptions = html32FormatOptions
exportOptions.ExportFormatOptions = html32FormatOptions;
1.5.2.7.3.7
ConfigureExportToHtml40
Procédure
1.
449
2.
3.
A la fin de la classe, créez une méthode d'assistance privée appelée ConfigureExportToHtml40(), sans
valeur renvoyée.
Public Sub ConfigureExportToHtml40()
End Sub
private void
{
}
4.
ExportFormatType HTML40.
myExportOptions.ExportFormatType = ExportFormatType.HTML40
exportOptions.ExportFormatType = ExportFormatType.HTML40;
5.
Déclarez et instanciez la classe HTMLFormatOptions avec le nom de variable "html40FormatOptions".
Dim html40FormatOptions As HTMLFormatOptions = New
HTMLFormatOptions()
6.
Attribuez à la propriété HTMLBaseFolderName de l'instance html40FormatOptions la chaîne exportPath et le
nom "Html40Folder".
html40FormatOptions.HTMLBaseFolderName = exportPath &
"Html40Folder"
html40FormatOptions.HTMLBaseFolderName = exportPath +
"Html40Folder";
7.
Attribuez à la propriété HTMLFileName de l'instance html40FormatOptions le nom "html40.html".
html40FormatOptions.HTMLFileName = "html40.html"
html40FormatOptions.HTMLFileName = "html40.html";
8.
Attribuez à la propriété HTMLEnableSeparatedPages de l'instance html40FormatOptions la valeur "True".
html40FormatOptions.HTMLEnableSeparatedPages = True
450
html40FormatOptions.HTMLEnableSeparatedPages = true;
9.
Attribuez à la propriété HTMLHasPageNavigator de l'instance html40FormatOptions la valeur "True".
html40FormatOptions.HTMLHasPageNavigator = True
html40FormatOptions.HTMLHasPageNavigator = true;
10. Attribuez à la propriété FirstPageNumber de l'instance html40FormatOptions la valeur 1.
html40FormatOptions.FirstPageNumber = 1
html40FormatOptions.FirstPageNumber = 1;
11. Attribuez à la propriété LastPageNumber de l'instance html40FormatOptions la valeur 3.
html40FormatOptions.LastPageNumber = 3
html40FormatOptions.LastPageNumber = 3;
12. Enfin, affectez l'instance html40FormatOptions à la propriété FormatOptions de l'instance ExportOptions.
myExportOptions.FormatOptions = html40FormatOptions
exportOptions.FormatOptions = html40FormatOptions;
Résultats
Vous avez créé les méthodes d'assistance privées configurant plusieurs formats d'exportation.
1.5.2.7.4
Appel des méthodes à partir de l'instruction Case
Précédemment, vous avez créé une instruction Case dans la méthode ExportSelection() avec plusieurs cas
de figure. Chaque cas est lié à une sélection de l'énumération ExportFormatType. Vous pouvez désormais
appeler chaque méthode de configuration selon les cas correspondants, ainsi que définir la valeur de la valeur
booléenne selectedNoFormat.
451
1.5.2.7.4.1
Pour appeler les méthodes à partir de
l'instruction Case
Procédure
1.
2.
Localisez la méthode ExportSelection() que vous avez créée dans le cours précédent.
Dans l'instruction Select Case [Visual Basic] ou switch [C#], dans le cas correspondant à
ExportFormatType.NoFormat, attribuez à la variable booléenne selectedNoFormat la valeur True.
selectedNoFormat = True
selectedNoFormat = true;
3.
ExportFormatType.CrystalReport, appelez la méthode ConfigureExportToRpt().
selectedNoFormat = False
selectedNoFormat = false;
ConfigureExportToRpt();
4.
ExportFormatType.RichText, appelez la méthode ConfigureExportToRtf().
ConfigureExportToRtf();
5.
ExportFormatType.WordForWindows, appelez la méthode ConfigureExportToDoc().
ConfigureExportToDoc();
6.
ExportFormatType.Excel, appelez la méthode ConfigureExportToXls().
452
ConfigureExportToXls();
7.
ExportFormatType.PortableDocFormat, appelez la méthode ConfigureExportToPdf().
ConfigureExportToPdf();
8.
ExportFormatType.HTML32, appelez la méthode ConfigureExportToHtml32().
ConfigureExportToHtml32();
9.
ExportFormatType.HTML40, appelez la méthode ConfigureExportToHtml40().
ConfigureExportToHtml40();
10. Dans le instructions conditionnelles Select Case [Visual Basic] ou switch [C#], dans le cas de
Switch Else [Visual Basic] ou default: [C#], attribuez à la variable booléenne selectedNoFormat
la valeur True.
Résultats
Si vous créez un projet dans Visual Studio 2005 ou une version ultérieure, vous devez suivre les procédures de la
section Création de méthodes pour les nouveaux formats d'exportation [page 455] avant de consulter la section
Appel des méthodes pour exécuter l'exportation [page 454].
453
1.5.2.7.5
Appel des méthodes pour exécuter l'exportation
Vous pouvez à présent créer la méthode d'événement de clic du contrôle Button exportByType, puis appeler les
méthodes afin d'effectuer l'exportation à partir de cette méthode d'événement.
1.5.2.7.5.1
Pour créer la méthode d'événement
exportByType_Click
Procédure
1.
2.
3.
Cliquez deux fois sur le contrôle Button exportByType.
La méthode d'événement exportByType_Click() est créée et s'affiche en mode code.
4.
Dans la méthode d'événement exportByType_Click(), saisissez les appels aux trois méthodes
d'événement que vous avez créées précédemment afin d'effectuer l'exportation.
ExportSetup()
ExportSelection()
ExportCompletion()
ExportSetup();
ExportSelection();
ExportCompletion();
Résultats
Vous êtes maintenant prêt à générer et exécuter votre projet, puis exporter votre rapport dans plusieurs formats.
1.5.2.7.5.2
Pour vérifier le projet
Procédure
1.
2.
3.
454
L'application Web ou Windows compile et affiche le rapport Hierarchical Grouping. Un contrôle DropDownList
affiche plusieurs formats d'exportation et un bouton Exporter au type sélectionné apparaît permettant
d'exécuter l'exportation.
4.
Sélectionnez un des formats d'exportation dans le contrôle DropDownList, puis cliquez sur le bouton Exporter
au type sélectionné.
Un message s'affiche en regard du bouton et indique si l'exportation a réussi. Dans le cas contraire, un
message d'erreur apparaît.
5.
Essayez d'effectuer des exportations avec différents formats.
6.
7.
Vérifiez le répertoire de fichiers Exported sur votre serveur Web ou votre ordinateur utilisant Windows pour
confirmer que les fichiers exportés ont été placés dans le répertoire.
1.5.2.7.6
Addenda : Améliorations apportées au code
d'exportation
Si vous avez installé Visual Studio 2005 ou version ultérieure, ou SAP Crystal Reports, vous avez accès aux
fonctionnalités API améliorées pour l'exportation de votre rapport Crystal dans différents formats.
Dans les fonctionnalités API améliorées de SAP Crystal Reports, l'énumération ExportFormatTypes comporte
deux nouveaux formats d'exportation : des enregistrements Microsoft Excel (fichier .xls contenant uniquement
les données) et des fichiers texte.
En outre, vous disposez à présent des méthodes d'exportation améliorées suivantes dans la classe
ReportDocument :
●
ExportToDisk(CrystalDecisions.Shared.ExportFormatType formatType, string fileName) :
exporte un rapport vers le disque local du serveur Web ou de l'ordinateur utilisant Windows.
●
ExportToHttpResponse(CrystalDecisions.Shared.ExportFormatType formatType,
System.Web.HttpResponse response, bool asAttachment, string attachmentName) : exporte
un rapport au type de format spécifié vers une fenêtre de navigateur, ou exporte le rapport sous la forme
d'une pièce jointe.
●
ExportToHttpResponse(CrystalDecisions.Shared.ExportOptions options,
System.Web.HttpResponse response, bool asAttachment, string attachmentName) : exporte
un rapport au type de format spécifié vers une fenêtre de navigateur, ou exporte le rapport sous la forme
d'une pièce jointe.
●
ExportToStream(CrystalDecisions.Shared.ExportFormatType formatType) : exporte les
données d'un rapport avec un type de format spécifié vers un flux d'entrée/sortie.
1.5.2.7.6.1
Création de méthodes pour les nouveaux formats
d'exportation
Dans cette section, vous allez apprendre à modifier votre projet (que vous avez précédemment créé dans ce
tutoriel) afin d'inclure les nouveaux formats d'exportation.
455
Avant de modifier le code pour inclure les nouveaux formats d'exportation, effectuez toutes les procédures de la
section Tutoriel : Exportation dans plusieurs formats [page 433].
1.5.2.7.6.1.1
Pour modifier le code afin d'inclure les
nouveaux formats d'exportation
Procédure
1.
2.
3.
4.
Dans l'instruction "Select Case" [Visual Basic] ou "switch" [C#] de la méthode
ExportSelection(), ajoutez une instruction Case pour le format ExcelRecord.
Case ExportFormatType.ExcelRecord
case ExportFormatType.ExcelRecord:
break;
Créez les méthodes d'assistance privées configurant plusieurs formats d'exportation. Vous créez d'abord la
méthode ConfigureExportToXlsRec() afin de définir les options d'exportation ExcelRecord.
5.
A la fin de la classe, créez une méthode d'assistance privée appelée ConfigureExportToXlsRec(), sans
valeur renvoyée.
Public Sub ConfigureExportToXlsRec()
End Sub
private void ConfigureExportToXlsRec()
{
}
6.
ExportFormatType ExcelRecord.
myExportOptions.ExportFormatType = ExportFormatType.ExcelRecord
exportOptions.ExportFormatType = ExportFormatType.ExcelRecord;
7.
ajoutez-lui le nom d'un document avec une extension de fichier .xls.
myDiskFileDestinationOptions.DiskFileName = exportPath & "ExcelRecord.xls"
456
diskFileDestinationOptions.DiskFileName = exportPath + "ExcelRecord.xls";
8.
Attribuez à la propriété ExportDestinationOptions de l'instance ExportOptions, l'instance
Résultats
Vous avez réussi à ajouter deux nouveaux formats d'exportation à votre projet.
Pour continuer l'exploration des fonctionnalités API améliorées, choisissez l'une des méthodes d'exportation
améliorées suivantes :
●
Si vous souhaitez réduire la quantité de code et n'avez pas besoin de définir l'instance ExportOptions,
effectuez la procédure Utilisation de la méthode ExportToDisk() [page 457].
●
Pour un site Web, si vous souhaitez exporter votre rapport dans une fenêtre de navigateur ou sous forme de
pièce jointe dans une fenêtre de navigateur, effectuez la procédure Utilisation de la méthode
ExportToHttpResponse() [page 467].
●
Si vous souhaitez transmettre les données de votre rapport vers un flux d'entrée/sortie, effectuez la
procédure Utilisation de la méthode ExportToStream() [page 473].
1.5.2.7.6.2
Utilisation de la méthode ExportToDisk()
La méthode ExportToDisk() fait appel à une instance d'ExportFormatType et à un paramètre de nom de fichier.
Cette méthode simplifie l'utilisation des méthodes de configuration d'exportation que vous avez créées dans la
section Création de méthodes configurant plusieurs formats d'exportation [page 443].
Dans cette section, vous allez apprendre à créer un projet, à modifier un projet existant et à ajouter un code au
projet pour utiliser la méthode ExportToDisk().
●
Vous devez créer un projet en suivant les instructions de la section Configuration d'un projet pour la méthode
ExportToDisk() [page 458].
●
Ou vous devez créer un projet en suivant les instructions de la section Création de méthodes pour les
nouveaux formats d'exportation [page 455].
Vous devez ensuite modifier le projet comme indiqué dans la section Préparation du projet pour la méthode
ExportToDisk() [page 460].
457
1.5.2.7.6.2.1
Configuration d'un projet pour la méthode
ExportToDisk()
Dans cette section, vous allez apprendre à créer un projet pour la méthode ExportToDisk().
1.5.2.7.6.2.1.1
Pour configurer un nouveau projet pour la
méthode ExportToDisk()
Procédure
1.
2.
Suivez les instructions de la section Ajout de contrôles au Web Form ou Windows Form [page 435].
Créez la méthode ExportSetup() et la méthode ExportSelection() indiquées dans la section Création
de méthodes exécutant l'exportation [page 437].
3.
break;
4.
Créez un bloc conditionnel pour vérifier la variable booléenne selectedNoFormat.
Else
End If
{
}
else
{
}
5.
458
6.
Dans le bloc Else, attribuez à la propriété Text du contrôle Label message la constante SUCCESS de la classe
MessageConstants.
7.
Créez un bloc try/catch avec la classe Exception référencée en tant que variable intitulée "ex". Le bloc try
inclut l'instruction "Select Case" [Visual Basic] ou "switch" [C#] et le bloc conditionnel.
Try
End Try
try
{
}
{
}
8.
9.
En dehors du bloc try/catch, attribuez à la propriété Visible du contrôle Label message la valeur "True".
10. Dans le menu Affichage, cliquez sur Concepteur.
11. Cliquez deux fois sur le contrôle Button exportByType.
La méthode d'événement exportByType_Click() est créée et vous passez en mode code.
12. Dans la méthode d'événement exportByType_Click(), saisissez les appels aux méthodes ExportSetup()
et ExportSelection().
ExportSetup()
ExportSelection()
ExportSetup();
ExportSelection();
459
1.5.2.7.6.2.2
Préparation du projet pour la méthode
ExportToDisk()
Dans cette section, vous allez apprendre à modifier un projet résultant de la procédure de la section Création de
méthodes pour les nouveaux formats d'exportation [page 455].
Vous devez à présent supprimer certaines lignes de code inutiles pour la méthode ExportToDisk().
1.5.2.7.6.2.2.1
Pour modifier le projet afin d'utiliser la
méthode ExportToDisk()
Procédure
1.
Ouvrez le projet.
2.
3.
4.
En haut de la classe, supprimez les déclarations de classe suivantes :
5.
Dans la méthode ExportSetup(), supprimez toutes les lignes de code situées après le bloc conditionnel. (La
dernière ligne de code qui appelle la propriété ExportFormatOptions s'applique uniquement à un projet
Windows.)
6.
460
Supprimez les méthodes de configuration d'exportation suivantes :
○
○
○
○
○
7.
○
○
○
ConfigureExportToXlsRec()
○
ConfigureExportToTxt()
Dans les instructions Case Select Case [Visual Basic] ou switch [C#] de ExportSelection(),
supprimez les appels aux méthodes de configuration d'exportation.
8.
Dans la méthode ExportCompletion(), supprimez l'appel à la méthode Export().
9.
Copiez et collez la totalité du code de la méthode ExportCompletion() au début de la méthode
ExportSelection().
10. Supprimez la méthode ExportCompletion() et l'appel à la méthode ExportCompletion() dans
l'événement de clic exportByType.
11. Dans la méthode ExportSelection(), coupez et collez les instructions Case Select Case [Visual
Basic] ou switch [C#] au-dessus du bloc If dans le bloc try.
Le bloc try/catch ressemble maintenant à ceci :
Try
End Select
Else
End If
End Try
try
{
{
break;
break;
break;
break;
461
break;
break;
break;
break;
break;
}
{
}
else
{
}
}
{
}
1.5.2.7.6.2.3
Modification de la méthode ExportSetup()
Dans cette section, vous allez apprendre à modifier la méthode ExportSetup() pour créer des dossiers destinés
aux formats d'exportation HTML32 et HTML40.
1.5.2.7.6.2.3.1
Pour modifier la méthode ExportSetup()
Procédure
1.
Au début de la classe, ajoutez les déclarations de classe suivantes :
Private exportPathHTML32 As String
Private exportPathHTML40 As String
private string exportPathHTML32;
private string exportPathHTML40;
2.
Dans la méthode ExportSetup(), instanciez les variables de type chaîne exportPathHTML32 et
exportPathHTML40 sur le répertoire racine du disque dur.
exportPathHTML32 = "C:\Exported\HTML32\"
exportPathHTML40 = "C:\Exported\HTML40\"
exportPathHTML32 = "C:\\Exported\\HTML32\\";
exportPathHTML40 = "C:\\Exported\\HTML40\\";
462
Remarque
Si vous souhaitez placer les dossiers dans le répertoire Web de votre serveur Web, ajoutez la propriété
Request.PhysicalApplicationPath comme préfixe au nom de dossier.
3.
Créez un bloc conditionnel qui vérifie si le répertoire dans la chaîne exportPathHTML32 existe déjà.
If Not System.IO.Directory.Exists(exportPathHTML32) Then
End If
if (!System.IO.Directory.Exists(exportPathHTML32))
{
}
4.
répertoire dans la chaîne exportPathHTML32.
System.IO.Directory.CreateDirectory(exportPathHTML32)
System.IO.Directory.CreateDirectory(exportPathHTML32);
5.
Créez un bloc conditionnel qui vérifie si le répertoire dans la chaîne exportPathHTML40 existe déjà.
If Not System.IO.Directory.Exists(exportPathHTML40) Then
End If
if (!System.IO.Directory.Exists(exportPathHTML40))
{
}
6.
répertoire dans la chaîne exportPathHTML40.
System.IO.Directory.CreateDirectory(exportPathHTML40)
System.IO.Directory.CreateDirectory(exportPathHTML40);
1.5.2.7.6.2.4
Appel de la méthode ExportToDisk()
Dans cette section, vous allez apprendre à appeler la méthode ExportToDisk() dans chaque instruction Case
de la méthode ExportSelection().
463
1.5.2.7.6.2.4.1
Pour appeler la méthode ExportToDisk() dans
la méthode ExportSelection()
Procédure
1.
Dans la méthode ExportSelection(), déclarez une variable de type chaîne et instanciez la variable sur une
chaîne vide.
Dim myFileName As String = ""
string fileName = "";
2.
Dans l'instruction Case ExportFormatType.CrystalReport, procédez comme suit :
a) Attribuez à la chaîne de nom de fichier la chaîne exportPath, puis ajoutez-lui le nom d'un document avec
une extension de fichier .rpt.
myFileName = exportPath & "Report.rpt"
fileName = exportPath + "Report.rpt";
b) Appelez la méthode ExportToDisk() à partir de l'instance hierarchicalGroupingReport, puis
transmettez ExportFormatType.CrystalReport et la chaîne de nom de fichier.
hierarchicalGroupingReport.ExportToDisk(ExportFormatType.CrystalReport,
myFileName)
hierarchicalGroupingReport.ExportToDisk(ExportFormatType.CrystalReport,
fileName);
3.
Dans l'instruction Case ExportFormatType.RichText, procédez comme suit :
une extension de fichier .rtf.
myFileName = exportPath & "RichTextFormat.rtf"
fileName = exportPath + "RichTextFormat.rtf";
transmettez ExportFormatType.RichText et la chaîne de nom de fichier.
hierarchicalGroupingReport.ExportToDisk(ExportFormatType.RichText,
myFileName)
hierarchicalGroupingReport.ExportToDisk(ExportFormatType.RichText,
fileName);
464
4.
Dans l'instruction Case ExportFormatType.WordForWindows, procédez comme suit :
une extension de fichier .doc.
myFileName = exportPath & "Word.doc"
fileName = exportPath + "Word.doc";
transmettez ExportFormatType.WordForWindows et la chaîne de nom de fichier.
hierarchicalGroupingReport.ExportToDisk(ExportFormatType.WordForWindows,
myFileName)
hierarchicalGroupingReport.ExportToDisk(ExportFormatType.WordForWindows,
fileName);
5.
Dans l'instruction Case ExportFormatType.Excel, procédez comme suit :
une extension de fichier .xls.
myFileName = exportPath & "Excel.xls"
fileName = exportPath + "Excel.xls";
transmettez ExportFormatType.Excel et la chaîne de nom de fichier.
hierarchicalGroupingReport.ExportToDisk(ExportFormatType.Excel,
myFileName)
hierarchicalGroupingReport.ExportToDisk(ExportFormatType.Excel,
fileName);
6.
Dans l'instruction Case ExportFormatType.PortableDocFormat, procédez comme suit :
une extension de fichier .pdf.
myFileName = exportPath & "PortableDoc.pdf"
fileName = exportPath + "PortableDoc.pdf";
465
transmettez ExportFormatType.PortableDocFormat et la chaîne de nom de fichier.
hierarchicalGroupingReport.ExportToDisk(ExportFormatType.PortableDocFormat,
myFileName)
hierarchicalGroupingReport.ExportToDisk(ExportFormatType.PortableDocFormat,
fileName);
7.
Dans l'instruction Case ExportFormatType.HTML32 procédez comme suit :
a) Attribuez à la chaîne de nom de fichier la chaîne exportPathHTML32, puis ajoutez-lui le nom d'un
document avec une extension de fichier .html.
myFileName = exportPathHTML32 & "HTML32.html"
fileName = exportPathHTML32 + "HTML32.html";
transmettez ExportFormatType.HTML32 et la chaîne de nom de fichier.
hierarchicalGroupingReport.ExportToDisk(ExportFormatType.HTML32, myFileName)
hierarchicalGroupingReport.ExportToDisk(ExportFormatType.HTML32, fileName);
8.
Dans l'instruction Case ExportFormatType.HTML40 procédez comme suit :
a) Attribuez à la chaîne de nom de fichier la chaîne exportPathHTML40, puis ajoutez-lui le nom d'un
document avec une extension de fichier .html.
myFileName = exportPathHTML40 & "HTML40.html"
fileName = exportPathHTML40 + "HTML40.html";
transmettez ExportFormatType.HTML40 et la chaîne de nom de fichier.
hierarchicalGroupingReport.ExportToDisk(ExportFormatType.HTML40,
myFileName)
hierarchicalGroupingReport.ExportToDisk(ExportFormatType.HTML40,
fileName);
9.
466
Dans l'instruction Case ExportFormatType.ExcelRecord procédez comme suit :
une extension de fichier .xls.
myFileName = exportPath & "ExcelRecord.xls"
fileName = exportPath + "ExcelRecord.xls";
transmettez ExportFormatType.ExcelRecord et la chaîne de nom de fichier.
hierarchicalGroupingReport.ExportToDisk(ExportFormatType.ExcelRecord,
myFileName)
hierarchicalGroupingReport.ExportToDisk(ExportFormatType.ExcelRecord,
fileName);
Résultats
Vous êtes maintenant prêt à générer et exécuter le projet pour exporter votre rapport Crystal dans différents
formats.
Si vous souhaitez utiliser d'autres méthodes API améliorées, cliquez sur un des liens ci-dessous pour atteindre la
section qui vous intéresse :
●
Utilisation de la méthode ExportToHttpResponse() [page 467]
●
Utilisation de la méthode ExportToStream() [page 473]
1.5.2.7.6.3
Utilisation de la méthode
ExportToHttpResponse()
La méthode ExportToHttpResponse() permet d'exporter votre rapport Crystal vers une fenêtre de navigateur
ou sous forme de pièce jointe. Cette méthode s'applique uniquement aux sites Web.
Les méthodes surchargées disponibles pour la méthode ExportToHttpResponse() sont notamment les
suivantes :
●
ExportToHttpResponse(CrystalDecisions.Shared.ExportFormatType formatType,
System.Web.HttpResponse response, bool asAttachment, string attachmentName)
●
ExportToHttpResponse(CrystalDecisions.Shared.ExportOptions options,
System.Web.HttpResponse response, bool asAttachment, string attachmentName)
La méthode ExportToHttpResponse() ne prend pas en charge les exportations vers HTTP Response pour les
formats HTML32 et HTML40. Par conséquent, lorsque vous essayez d'effectuer une exportation au format
HTML32 ou HTML40, un message d'erreur s'affiche.
467
Si la variable booléenne asAttachment a la valeur True, une boîte de dialogue Téléchargement de fichier apparaît.
Si la variable booléenne asAttachment a la valeur False, le rapport exporté s'ouvre dans la fenêtre du navigateur.
Lorsque vous choisissez d'enregistrer le fichier, le nom de fichier a pour valeur la variable de type chaîne
attachmentName. Si vous ne spécifiez pas la variable attachmentName, le nom de fichier par défaut est "Sans
titre" avec l'extension de fichier spécifiée. Le nom de fichier peut être modifié dans la boîte de dialogue Enregistrer
sous.
1.5.2.7.6.3.1
ExportToHttpResponse() avec l'énumération
ExportFormatType
Pour utiliser la méthode ExportToHttpResponse()avec le paramètre ExportFormatType, vous devez effectuer la
procédure Ajout de contrôles au Web Form ou Windows Form [page 435] pour un site Web. Vous n'avez pas
besoin des méthodes ExportSetup(), ExportSelection() et ExportCompletion(). Le code nécessaire est placé dans
la méthode d'événement de clic exportByType.
1.5.2.7.6.3.1.1
Pour utiliser la méthode
ExportToHttpResponse() avec le paramètre ExportFormatType
Procédure
1.
Ouvrez le Web Form.
2.
3.
4.
Au début de la classe, ajoutez une déclaration de classe ExportOptions.
5.
Dans la méthode d'événement exportByType_Click(), instanciez l'instance ExportOptions.
myExportOptions = New ExportOptions()
exportOptions = new ExportOptions();
6.
Créez un bloc try/catch avec la classe Exception référencée en tant que variable intitulée "ex".
Try
468
End Try
try
{
}
{
}
7.
Dans le bloc try, créez un bloc conditionnel pour vérifier si l'élément sélectionné à partir de l'instance
exportTypesList est égal à l'instance ExportFormatType.NoFormat.
If (exportTypesList.SelectedIndex = ExportFormatType.NoFormat) Then
Else
End If
if ((ExportFormatType)exportTypesList.SelectedIndex == ExportFormatType.NoFormat)
{
}
else
{
}
8.
9.
Dans le bloc Else, affectez l'instance ExportFormatType sélectionnée dans exportTypesList à la propriété
ExportFormatType de l'instance ExportOptions.
myExportOptions.ExportFormatType = exportTypesList.SelectedIndex
exportOptions.ExportFormatType =
(ExportFormatType)exportTypesList.SelectedIndex;
10. Dans le bloc Else, appelez la méthode ExportToHttpResponse() de l'instance hierarchicalGroupingReport.
Transmettez l'instance ExportOptions, l'objet de réponse ASP.NET, une valeur booléenne True et une chaîne
de nom de fichier comme paramètres de la méthode.
469
Remarque
La chaîne de nom de fichier de la pièce jointe ne nécessite aucune extension, car celle-ci est
automatiquement ajoutée au fichier exporté.
hierarchicalGroupingReport.ExportToHttpResponse(myExportOptions,
Response, True, "ExportedReport")
hierarchicalGroupingReport.ExportToHttpResponse(exportOptions,
Response, True, "ExportedReport");
11. Dans le bloc catch, attribuez à la propriété Text du contrôle Label message la constante FAILURE de la classe
12. En dehors du bloc try/catch, attribuez à la propriété Visible du contrôle Label message la valeur "True".
Résultats
formats.
Si vous souhaitez utiliser la méthode ExportToHttpResponse() avec la classe ExportOptions, voir Utilisation de la
méthode ExportToHttpResponse() avec la classe ExportOptions [page 470].
Pour utiliser d'autres méthodes API améliorées, cliquez sur un des liens ci-dessous pour atteindre la section qui
vous intéresse :
●
Utilisation de la méthode ExportToDisk() [page 457]
●
1.5.2.7.6.3.2
ExportToHttpResponse() avec la classe ExportOptions
Pour utiliser la méthode ExportToHttpResponse() avec le paramètre ExportOptions, vous devez effectuer la
procédure Ajout de contrôles au Web Form ou Windows Form [page 435] pour un site Web. Vous n'avez pas
470
besoin des méthodes ExportSetup(), ExportSelection() et ExportCompletion(). Le code nécessaire est placé dans
la méthode d'événement de clic exportByType.
1.5.2.7.6.3.2.1
Pour utiliser la méthode
ExportToHttpResponse() avec le paramètre ExportOptions
Procédure
1.
Ouvrez le Web Form.
2.
3.
4.
Dans la méthode d'événement exportByType_Click(), créez un bloc try/catch avec la classe Exception
référencée en tant que variable intitulée "ex".
Try
End Try
try
{
}
{
}
5.
Dans le bloc try, créez un bloc conditionnel pour vérifier si l'élément sélectionné à partir de l'instance
exportTypesList est égal à l'instance ExportFormatType.NoFormat.
If (exportTypesList.SelectedIndex = ExportFormatType.NoFormat) Then
Else
End If
if ((ExportFormatType)exportTypesList.SelectedIndex ==
ExportFormatType.NoFormat)
{
}
else
{
}
6.
471
Remarque
La condition If est remplie lorsque la valeur NoFormat du contrôle DropDownList est sélectionnée.
7.
Dans le bloc Else, appelez la méthode ExportToHttpResponse() de l'instance hierarchicalGroupingReport.
Transmettez l'instance ExportFormatType sélectionnée, l'objet de réponse ASP.NET, une valeur booléenne
True et une chaîne de nom de fichier comme paramètres de la méthode.
Remarque
La chaîne de nom de fichier de la pièce jointe ne nécessite aucune extension, car celle-ci est
automatiquement ajoutée au fichier exporté.
hierarchicalGroupingReport.ExportToHttpResponse(exportTypesList.SelectedIndex,
Response, True, "ExportedReport")
hierarchicalGroupingReport.ExportToHttpResponse((ExportFormatType)exportTypesList
.SelectedIndex,
Response, True, "ExportedReport");
8.
9.
Résultats
formats.
Pour utiliser d'autres méthodes API améliorées, cliquez sur un des liens ci-dessous pour atteindre la section qui
vous intéresse :
472
●
●
1.5.2.7.6.4
Utilisation de la méthode ExportToStream()
Dans cette section, vous allez apprendre à utiliser la méthode ExportToStream() pour exporter le rapport vers le
flux d'entrée/sortie sous la forme d'une séquence d'octets. Vous allez ensuite apprendre à écrire la séquence
d'octets dans un fichier au format que vous avez spécifié.
Lorsque vous exportez le rapport au format HTML, les images ne sont pas exportées. Il est recommandé d'utiliser
les méthodes ExportToHttpResponse() pour exporter des rapports au format HTML.
●
Vous devez créer un projet en suivant les instructions de la section Configuration d'un projet pour la méthode
ExportToStream() [page 473].
●
Ou vous devez créer un projet en suivant les instructions de la section Création de méthodes pour les
nouveaux formats d'exportation [page 455].
Vous devez ensuite modifier le projet comme indiqué dans la section Préparation du projet pour la méthode
ExportToStream() [page 475].
1.5.2.7.6.4.1
Configuration d'un projet pour la méthode
ExportToStream()
Dans cette section, vous allez apprendre à créer un projet pour la méthode ExportToStream().
1.5.2.7.6.4.1.1
Pour configurer un nouveau projet pour la
méthode ExportToStream()
Procédure
1.
Suivez les instructions de la section Ajout de contrôles au Web Form ou Windows Form [page 435].
2.
Créez la méthode ExportSetup() et la méthode ExportSelection() indiquées dans la section Création
de méthodes exécutant l'exportation [page 437].
3.
break;
473
4.
Créez un bloc conditionnel pour vérifier la variable booléenne selectedNoFormat.
Else
End If
{
}
else
{
}
5.
6.
Dans le bloc Else, attribuez à la propriété Text du contrôle Label message la constante SUCCESS de la classe
MessageConstants.
7.
Créez un bloc try/catch avec la classe Exception référencée en tant que variable intitulée "ex". Le bloc try
inclut l'instruction "Select Case" [Visual Basic] ou "switch" [C#] et le bloc conditionnel.
Try
End Try
try
{
}
{
}
8.
474
9.
11. Cliquez deux fois sur le contrôle Button exportByType.
12. Dans la méthode d'événement exportByType_Click(), saisissez les appels aux méthodes ExportSetup()
et ExportSelection().
ExportSetup()
ExportSelection()
ExportSetup();
ExportSelection();
1.5.2.7.6.4.2
Préparation du projet pour la méthode
ExportToStream()
Dans cette section, vous allez apprendre à modifier un projet résultant de la procédure de la section Création de
méthodes pour les nouveaux formats d'exportation [page 455].
Vous devez à présent supprimer certaines lignes de code inutiles pour la méthode ExportToStream().
1.5.2.7.6.4.2.1
Pour modifier le projet afin d'utiliser la
méthode ExportToStream()
Procédure
1.
Ouvrez le projet.
2.
3.
4.
En haut de la classe, supprimez les déclarations de classe suivantes :
475
5.
Dans la méthode ExportSetup(), supprimez toutes les lignes de code situées après le bloc conditionnel. (La
dernière ligne de code qui appelle la propriété ExportFormatOptions s'applique uniquement à un projet
Windows.)
6.
7.
Supprimez les méthodes de configuration d'exportation suivantes :
○
○
○
○
○
○
○
○
ConfigureExportToXlsRec()
Dans les instructions Case Select Case [Visual Basic] ou switch [C#] de ExportSelection(),
supprimez les appels aux méthodes de configuration d'exportation.
8.
Dans la méthode ExportCompletion(), supprimez l'appel à la méthode Export().
9.
Copiez et collez la totalité du code de la méthode ExportCompletion() au début de la méthode
ExportSelection().
10. Supprimez la méthode ExportCompletion() et l'appel à la méthode ExportCompletion() dans
l'événement de clic exportByType.
11. Dans la méthode ExportSelection(), coupez et collez les instructions Case Select Case [Visual
Basic] ou switch [C#] au-dessus du bloc If dans le bloc try.
Le bloc try/catch ressemble maintenant à ceci :
Try
476
End Select
Else
End If
End Try
try
{
{
break;
break;
break;
break;
break;
break;
break;
break;
break;
}
{
}
else
{
}
}
{
}
1.5.2.7.6.4.3
Modification des instructions Case dans la
méthode ExportSelection()
Dans cette section, vous allez apprendre à définir une chaîne de nom de fichier pour chaque instruction Case
ExportFormatType.
477
1.5.2.7.6.4.3.1
Pour modifier les instructions Case dans la
méthode ExportSelection()
Procédure
1.
Dans la méthode ExportSelection(), déclarez une variable de type chaîne et instanciez la variable sur une
chaîne vide.
Dim myFileName As String = ""
string fileName = "";
2.
Dans l'instruction Case ExportFormatType.CrystalReport, attribuez à la chaîne de nom de fichier la chaîne
exportPath, suivie d'un nom de document avec une extension de fichier .rpt.
myFileName = exportPath & "Report.rpt"
myFileName = exportPath + "Report.rpt";
3.
Dans l'instruction Case ExportFormatType.RichText, attribuez à la chaîne de nom de fichier la chaîne
exportPath suivie d'un nom de document avec une extension de fichier .rtf.
myFileName = exportPath & "RichTextFormat.rtf"
myFileName = exportPath + "RichTextFormat.rtf";
4.
Dans l'instruction Case ExportFormatType.WordForWindows, attribuez à la chaîne de nom de fichier la chaîne
exportPath suivie d'un nom de document avec une extension de fichier .doc.
myFileName = exportPath & "Word.doc"
fileName = exportPath + "Word.doc";
5.
Dans l'instruction Case ExportFormatType.Excel, attribuez à la chaîne de nom de fichier la chaîne exportPath
suivie d'un nom de document avec une extension de fichier .xls.
myFileName = exportPath & "Excel.xls"
fileName = exportPath + "Excel.xls";
6.
Dans l'instruction Case ExportFormatType.PortableDocFormat, attribuez à la chaîne de nom de fichier la
chaîne exportPath suivie d'un nom de document avec une extension de fichier .pdf.
myFileName = exportPath & "PortableDoc.pdf"
478
fileName = exportPath + "PortableDoc.pdf";
7.
Dans l'instruction Case ExportFormatType.HTML32, attribuez à la chaîne de nom de fichier la chaîne
exportPath suivie d'un nom de document avec une extension de fichier .html.
myFileName = exportPath & "HTML32.html"
fileName = exportPath + "HTML32.html";
8.
Dans l'instruction Case ExportFormatType.HTML40, attribuez à la chaîne de nom de fichier la chaîne
exportPath suivie d'un nom de document avec une extension de fichier .html.
myFileName = exportPath & "HTML40.html"
fileName = exportPath + "HTML40.html";
9.
Dans l'instruction Case ExportFormatType.ExcelRecord, attribuez à la chaîne de nom de fichier la chaîne
exportPath suivie d'un nom de document avec une extension de fichier .xls.
myFileName = exportPath & "ExcelRecord.xls"
fileName = exportPath + "ExcelRecord.xls";
1.5.2.7.6.4.4
Appel de la méthode ExportToStream()
Dans cette section, vous allez apprendre à appeler la méthode ExportToStream() et à écrire les données du
rapport exporté dans un fichier au format que vous avez spécifié.
1.5.2.7.6.4.4.1
Pour appeler la méthode ExportToStream()
dans la méthode ExportSelection()
Procédure
1.
[C#] au début de la classe pour l'espace de noms System.IO.
Imports System.IO
using System.IO;
479
2.
Dans le bloc Else de la méthode ExportSelection(), appelez la méthode ExportToStream() de l'instance
hierarchicalGroupingReport, transmettez l'instance ExportFormatType sélectionnée dans le contrôle
dropdownlist exportTypesList et affectez l'instance à la classe Stream.
Stream myStream =
hierarchicalGroupingReport.ExportToStream(exportTypesList.SelectedIndex)
Stream stream =
hierarchicalGroupingReport.ExportToStream((ExportFormatType)exportTypesList.Selec
tedIndex);
3.
Créez un tableau d'octets de même longueur que l'instance Stream.
Dim myDataArray As byte() = New byte(myStream.Length)
byte[] dataArray = new byte[stream.Length];
4.
Envoyez les données de l'instance Stream au tableau d'octets d'un décalage de zéro jusqu'à la longueur de
l'instance Stream.
myStream.Read(myDataArray, 0, Convert.ToInt32(myStream.Length));
stream.Read(dataArray, 0, Convert.ToInt32(stream.Length));
5.
Créez une instance FileStream qui crée le fichier spécifié par la variable chaîne de nom de fichier.
Dim myFileStream As FileStream = New FileStream(myFileName,
System.IO.FileMode.Create)
FileStream fileStream = new FileStream(fileName, System.IO.FileMode.Create);
6.
Transférez les données stockées dans le tableau d'octets vers le fichier d'un décalage de zéro jusqu'à la
longueur du tableau d'octets.
myFileStream.Write(myDataArray, 0, myDataArray.Length)
fileStream.Write(dataArray, 0, dataArray.Length);
7.
Fermez l'instance FileStream et l'instance Stream.
myFileStream.Close()
myStream.Close()
fileStream.Close();
stream.Close();
480
8.
Attribuez à la propriété Text du contrôle Label message la constante SUCCESS de la classe
MessageConstants.
Résultats
formats.
Si vous souhaitez utiliser d'autres méthodes API améliorées, cliquez sur un des liens ci-dessous pour atteindre la
section qui vous intéresse :
●
●
Utilisation de la méthode ExportToHttpResponse() [page 467]
1.5.2.8
Tutoriel : Filtrage des données à l'aide des formules
de sélection
Dans ce tutoriel, vous allez apprendre à filtrer les données dans le modèle d'objet ReportDocument en définissant
la propriété RecordSelectionFormula de la classe DataDefinition.
Introduction
Les formules de sélection servent à filtrer les enregistrements à afficher dans un rapport Crystal. Pour écrire des
formules de sélection, vous pouvez utiliser la syntaxe Basic ou la syntaxe Crystal.
Dans ce tutoriel, vous allez créer une formule de sélection afin de filtrer les enregistrements clients dans lesquels
le champ Ventes de l'année dernière est supérieur à une valeur spécifique et le champ Nom du client est comparé
à une autre chaîne. Un contrôle DropDownList (Web) ou ComboBox (Windows) sélectionne un opérateur de
comparaison pour le champ Nom du client. Vous pouvez choisir d'afficher les noms de client qui sont égaux,
inférieurs, supérieurs, inférieurs ou égaux, supérieurs ou égaux, ou pas égaux à la valeur de chaîne que vous avez
spécifiée.
La formule est transmise sous forme de variable chaîne à la propriété SelectionFormula de la classe
CrystalReportViewer. Une fois la propriété définie, le rapport Crystal lié au contrôle CrystalReportViewer est filtré
avant d'être affiché.
481
Exemple de code
version terminée.
Les exemples de code sont stockés dans des dossiers classés par langue et par type de projet. Les fichiers de
chaque version d'exemple de code sont stockés dans les dossiers suivants :
●
Site Web C# : CS_Web_RDObjMod_SavedDataSelectionFormula
●
Projet Windows C# : CS_Win_RDObjMod_SavedDataSelectionFormula
●
Site Web Visual Basic : VB_Web_RDObjMod_SavedDataSelectionFormula
●
Projet Windows Visual Basic : VB_Win_RDObjMod_SavedDataSelectionFormula
1.5.2.8.1
Création d'un rapport
Pour commencer, vous allez créer un rapport Crystal dans lequel vous allez filtrer les données.
1.5.2.8.1.1
Pour créer un rapport Crystal
Contexte
Remarque
configuration.
482
Procédure
1.
2.
Crystal.
3.
Dans le champ Nom, saisissez le nom "CustomerBySalesName.rpt", puis cliquez sur Ajouter.
4.
5.
6.
7.
8.
9.
11. Utilisez la combinaison de touches CTRL-clic pour sélectionner Nom du client, Ventes de l'année dernière et
Ville.
bouton Terminer.
Le rapport CustomerBySalesName est créé et chargé dans la fenêtre principale de Visual Studio.
13. Cliquez sur Aperçu Rapport principal.
Un aperçu du rapport s'affiche contenant toutes les données disponibles. Vous filtrerez ensuite ces données
par programmation.
14. Cliquez sur Rapport principal pour quitter le mode Aperçu.
1.5.2.8.2
Liaison du rapport
Web Form ou Windows Form. Lors de l'étape précédente, vous avez ajouté un rapport CustomerBySalesName au
projet.
Dans cette section, vous allez instancier le rapport CustomerBySalesName et le lier au contrôle
●
●
●
483
●
1.5.2.8.2.1
Pour instancier le rapport CustomerBySalesName
CrystalReportViewer
Procédure
1.
2.
3.
Ajoutez une nouvelle déclaration de niveau classe pour la classe wrapper du rapport CustomerBySalesName,
en utilisant la variable customerBySalesNameReport. Définissez le modificateur d'accès à private.
Private customerBySalesNameReport As CustomerBySalesName
private CustomerBySalesName customerBySalesNameReport;
4.
Remarque
customerBySalesNameReport = New CustomerBySalesName()
customerBySalesNameReport = new CustomerBySalesName();
5.
CrystalReportViewer à la classe de rapport instanciée (nom de la variable : customerBySalesNameReport).
myCrystalReportViewer.ReportSource = customerBySalesNameReport
crystalReportViewer.ReportSource = customerBySalesNameReport;
Résultats
Vous êtes maintenant prêt à générer et exécuter votre projet. Passez à la section suivante ci-dessous.
484
1.5.2.8.2.2
Pour instancier le rapport CustomerBySalesName
CrystalReportViewer
Procédure
1.
2.
3.
variable customerBySalesNameReport. Définissez le modificateur d'accès à private.
Private customerBySalesNameReport As ReportDocument
private ReportDocument customerBySalesNameReport;
Remarque
La classe ReportDocument est un membre de l'espace de noms
CrystalDecisions.CrystalReports.Engine. Vous avez ajouté une déclaration "Imports" [Visual
Basic] ou "using" [C#] pour cet espace de noms dans la section Configuration d'un projet [page 15].
Lorsque vous instanciez ReportDocument et chargez un rapport dans l'espace de noms, vous accédez au
rapport via le SDK sans l'incorporer.
4.
customerBySalesNameReport = New ReportDocument()
customerBySalesNameReport = new ReportDocument();
5.
Windows :
○
Dim reportPath As String = Server.MapPath("CustomerBySalesName.rpt")
string reportPath = Server.MapPath("CustomerBySalesName.rpt");
○
485
Remarque
exécutable.
"CustomerBySalesName.rpt"
string reportPath = Application.StartupPath + "\\" +
"CustomerBySalesName.rpt";
6.
customerBySalesNameReport.Load(reportPath)
customerBySalesNameReport.Load(reportPath);
7.
CrystalReportViewer à l'instance ReportDocument.
Résultats
classe ReportDocument, le nom de la variable utilisée est identique : customerBySalesNameReport. Vous pouvez
1.5.2.8.2.3
CustomerBySalesName
Procédure
1.
2.
486
3.
sous-répertoire.
Remarque
4.
Le rapport apparaît et affiche toutes les lignes de données disponibles. Dans la section suivante, vous allez
commencer à filtrer les données à l'aide de la propriété RecordSelectionFormula.
5.
1.5.2.8.3
Application d'un filtre aux données du rapport
Dans cette section, vous allez apprendre à appliquer un filtre aux données du rapport.
1.5.2.8.3.1
Pour appliquer un filtre aux données du rapport
Procédure
1.
2.
3.
Au début de la classe, ajoutez trois nouvelles déclarations de variables de niveau classe qui représenteront les
valeurs selon lesquelles les données seront filtrées.
Private salesAmount As String
Private operatorValue As String
Private customerName As String
private string salesAmount;
private string operatorValue;
private string customerName;
4.
Si vous créez un projet Windows, ajoutez une déclaration de variable de niveau classe supplémentaire, une
variable booléenne appelée useDefaultValues, puis affectez-lui la valeur True.
Private useDefaultValues As Boolean = True
private bool useDefaultValues = true;
5.
Dans la méthode ConfigureCrystalReports(), créez un bloc conditionnel.
487
○
Si vous créez un site Web, créez un bloc conditionnel Not IsPostBack. Placez ce bloc au-dessus du code
existant dans la méthode.
End If
if (!IsPostBack)
{
}
○
Si vous créez un projet Windows, créez un bloc conditionnel useDefaultValues. Placez ce bloc au-dessus
du code existant dans la méthode.
If useDefaultValues Then
End If
if (useDefaultValues)
{
}
6.
Dans le bloc conditionnel, affectez les valeurs 4000, < et K aux trois variables de niveau classe.
Ces valeurs sont affectées dans un bloc conditionnel, car plus tard vous les remplacerez par un événement de
clic.
salesAmount = "4000"
operatorValue = "<"
customerName = "K"
salesAmount = "4000";
operatorValue = "<";
customerName = "K";
7.
Immédiatement en dessous et en dehors du bloc conditionnel, créez une chaîne selectionFormula dans
laquelle vous ajoutez des littéraux aux variables de niveau classe que vous venez de créer.
Dim selectionFormula As String = "{Customer.Last Year's Sales} >
" _
& salesAmount _
& " AND Mid({Customer.Customer Name}, 1, 1) " _
& operatorValue _
& "'" _
& customerName _
& "'"
string selectionFormula = "{Customer.Last Year's Sales} > "
+ salesAmount
+ " AND Mid({Customer.Customer Name}, 1, 1) "
+ operatorValue
+ "'"
+ customerName
+ "'";
488
8.
Dans le code de liaison de rapport que vous avez créé précédemment, créez un saut de ligne juste au-dessus
de la ligne de code dans laquelle customerBySalesName est affecté à la propriété ReportSource du contrôle
9.
Dans ce saut de ligne, affectez la variable chaîne selectionFormula à l'instance ReportDocument.
customerBySalesNameReport.DataDefinition.RecordSelectionFormula =
selectionFormula
selectionFormula;
10. Compilez et affichez votre application.
Les données devraient maintenant être filtrées.
11. Revenez dans Visual Studio, puis cliquez sur Arrêter pour quitter le mode débogage.
Résultats
Dans la section suivante, vous allez créer des contrôles sur le formulaire qui permettront d'ajuster de façon
dynamique la formule de sélection.
1.5.2.8.4
Ajout de contrôles pour le filtrage dynamique
Dans cette section, vous allez ajouter des contrôles que vous utiliserez dans la formule de sélection. Ces contrôles
permettront de filtrer les données de façon dynamique.
1.5.2.8.4.1
sélection
Pour ajouter des contrôles dans la formule de
Procédure
1.
2.
3.
cinq fois sur ENTREE.
Le contrôle CrystalReportViewer descend de cinq lignes.
4.
489
c) Redimensionnez le contrôle CrystalReportViewer afin d'afficher environ trois lignes au-dessus.
5.
Dans la boîte à outils, faites glisser un contrôle Label en haut à gauche du formulaire.
6.
Dans la fenêtre Propriétés, attribuez à la propriété Text la valeur "Afficher les clients suivants :".
7.
Dans la boîte à outils, faites glisser un second contrôle Label sur le formulaire en dessous du premier.
8.
Dans la fenêtre Propriétés, attribuez à la propriété Text la valeur "- ventes de l'année dernière > $".
9.
Dans la boîte à outils, faites glisser un troisième contrôle Label sur le formulaire en dessous du second.
10. Dans la fenêtre Propriétés, attribuez à la propriété Text la valeur "- première lettre du nom".
11. Dans la boîte à outils, faites glisser un contrôle TextBox à droite du second contrôle Label.
12. Dans la fenêtre Propriétés, attribuez à ID la valeur "lastYearsSales".
13. Dans la boîte à outils, faites glisser un contrôle DropDownList (Web) ou ComboBox (Windows) à droite du
troisième contrôle Label.
14. Dans la fenêtre Propriétés, attribuez à ID la valeur "operatorValueList".
15. Dans la boîte à outils, faites glisser un contrôle TextBox à droite du contrôle DropDownList (Web) ou du
contrôle ComboBox (Windows).
16. Dans la fenêtre Propriétés, attribuez à ID la valeur "letterOfName".
17. Dans la boîte à outils, faites glisser un contrôle Button en dessous du troisième contrôle Label.
18. Dans la fenêtre Propriétés, attribuez à ID la valeur "redisplay" et à Text la valeur "Réafficher le rapport".
19. Dans la boîte à outils, faites glisser un contrôle Label en dessous du contrôle Button.
20. Dans la fenêtre Propriétés, attribuez à ID la valeur "formula" et laissez la propriété Text vide.
Vérifiez que le contrôle CrystalReportViewer se trouve bien juste en dessous de ces contrôles.
Résultats
Dans la section suivante, vous allez remplir le contrôle DropDownList (Web) ou ComboBox (Windows).
1.5.2.8.5
Définition du contenu du contrôle DropDownList ou
ComboBox
Le contrôle DropDownList (Web) ou le contrôle ComboBox (Windows) requiert une liste de valeurs d'opérateurs
(égal à, supérieur à, etc.). Le moyen le plus courant de remplir ce contrôle consiste à fournir cette liste de valeurs
sous la forme d'un énumérateur.
490
1.5.2.8.5.1
ComboBox
Pour remplir le contrôle DropDownList ou
Procédure
1.
2.
Dans la boîte de dialogue Ajouter un nouvel élément, sélectionnez Classe.
3.
Saisissez le nom "CeComparisonOperator", puis cliquez sur OK.
4.
Dans le fichier de classe, remplacez le mot class par enum.
Remarque
Dans Visual Basic, n'oubliez pas de remplacer à la fois la signature d'ouverture et de fermeture. Dans C#,
supprimez le constructeur.
5.
Saisissez les valeurs d'énumération suivantes.
EqualTo
GreaterThan
GreaterThanOrEqualTo
LessThan
LessThanOrEqualTo
NotEqualTo
EqualTo,
GreaterThan,
GreaterThanOrEqualTo,
LessThan,
LessThanOrEqualTo,
NotEqualTo
6.
7.
8.
Dans la méthode ConfigureCrystalReports(), vous remplissez maintenant l'instance operatorValueList
avec des valeurs de l'énumération CeComparisonOperator. Ce code est placé dans un emplacement différent
selon que vous créez un site Web ou un projet Windows.
○
Dans un site Web, insérez l'affectation et la liaison de la propriété DataSource au sein du bloc conditionnel
Not IsPostBack.
operatorValueList.DataSource =
operatorValueList.DataBind()
operatorValueList.DataBind();
491
○
Dans un projet Windows, insérez uniquement l'affectation de la propriété DataSource au sein du bloc
conditionnel useDefaultValues.
Remarque
Dans un projet Windows, il est inutile d'appeler une méthode DataBind().
9.
Au bas de la méthode ConfigureCrystalReports(), affectez la chaîne selectionFormula à la propriété
Text du contrôle Label formula.
formula.Text = selectionFormula
formula.Text = selectionFormula;
10. Compilez et affichez l'application.
La liste d'opérateurs et tous les autres contrôles devraient s'afficher correctement.
11. Fermez votre navigateur.
Résultats
Dans la section suivante, vous allez créer une méthode qui extrait des sélections à partir de ce contrôle lorsqu'un
utilisateur clique sur le bouton Réafficher le rapport.
1.5.2.8.6
Extraction des sélections à partir du contrôle
Dans cette section, vous allez extraire des sélections à partir du contrôle DropDownList (Web) ou ComboBox
(Windows).
1.5.2.8.6.1
Pour extraire des sélections à partir du contrôle
Procédure
1.
2.
492
3.
A la fin de la classe, créez une méthode d'assistance privée GetSelectedOperator() qui renvoie une valeur de
chaîne.
Private Function GetSelectedOperator() As String
End Function
private string GetSelectedOperator()
{
}
4.
Dans la méthode, déclarez une chaîne selectedOperator et affectez-lui une valeur de chaîne vide.
Dim selectedOperator As String = ""
string selectedOperator = "";
5.
Toujours dans la méthode, créez une instruction Select Case/switch case qui vérifie l'index sélectionné dans
le contrôle de liste et renvoie la valeur d'énumération correspondante.
Remarque
Dans C#, vous devez effectuer explicitement un cast de l'index sélectionné en énumération dans la
signature switch.
Select Case operatorValueList.SelectedIndex
Case CeComparisonOperator.EqualTo
selectedOperator = "="
Case CeComparisonOperator.GreaterThan
selectedOperator = ">"
Case CeComparisonOperator.GreaterThanOrEqualTo
selectedOperator = ">="
Case CeComparisonOperator.LessThan
selectedOperator = "<"
Case CeComparisonOperator.LessThanOrEqualTo
selectedOperator = "<="
Case CeComparisonOperator.NotEqualTo
selectedOperator = "<>"
End Select
switch ((CeComparisonOperator)operatorValueList.SelectedIndex)
{
case CeComparisonOperator.EqualTo:
selectedOperator = "=";
break;
case CeComparisonOperator.GreaterThan:
selectedOperator = ">";
break;
case CeComparisonOperator.GreaterThanOrEqualTo:
selectedOperator = ">=";
break;
case CeComparisonOperator.LessThan:
selectedOperator = "<";
break;
case CeComparisonOperator.LessThanOrEqualTo:
selectedOperator = "<=";
break;
493
}
6.
case CeComparisonOperator.NotEqualTo:
selectedOperator = "<>";
break;
Renvoyez la chaîne selectedOperator à partir de la méthode.
Return selectedOperator
return selectedOperator;
7.
Résultats
Dans la dernière section, vous allez ajouter un événement de clic pour que les nouvelles valeurs de formule de
sélection soient appliquées au rapport lorsqu'un utilisateur clique sur le bouton.
1.5.2.8.7
Ajout d'un événement de clic
La dernière étape de configuration du filtrage dynamique consiste à ajouter l'événement de clic et à écrire le code
permettant d'appliquer les nouvelles valeurs de formule de sélection au rapport.
1.5.2.8.7.1
Pour ajouter l'événement de clic
Procédure
1.
2.
Cliquez deux fois sur le contrôle Button.
3.
La classe code-behind est chargée et un événement de clic est créé.
4.
Dans la méthode, attribuez à la variable de niveau classe "salesAmount" la propriété Text de l'instance du
contrôle lastYearsSales.
salesAmount = lastYearsSales.Text
salesAmount = lastYearsSales.Text;
5.
Attribuez à la variable de niveau classe "operatorValue" la valeur renvoyée par la méthode d'assistance
GetSelectedOperator.
operatorValue = GetSelectedOperator()
494
operatorValue = GetSelectedOperator();
6.
Attribuez à la variable de niveau classe "customerName" la propriété Text de l'instance du contrôle
letterOfName.
customerName = letterOfName.Text
customerName = letterOfName.Text;
7.
Si vous générez un projet Windows, attribuez à la variable de niveau classe "useDefaultValues" la valeur False.
Remarque
Ceci permet d'ignorer le bloc conditionnel de la méthode ConfigureCrystalReports() qui définit les valeurs
par défaut des variables de niveau classe.
useDefaultValues = False
useDefaultValues = false;
8.
Toujours dans la méthode, appelez la méthode ConfigureCrystalReports() pour procéder au filtrage et à
la liaison du rapport.
Résultats
Vous pouvez maintenant tester l'application.
1.5.2.8.8
Test du filtrage des données
Dans la section finale, vous testez le filtrage des données.
495
1.5.2.8.8.1
Pour tester le filtrage des données
Procédure
1.
Compilez et affichez votre application.
2.
Vérifiez que le rapport s'affiche avec les valeurs de filtrage par défaut.
3.
Saisissez "200000" dans Ventes de l'année dernière.
4.
Sélectionnez GreaterThan dans le contrôle DropDownList (Web) ou ComboBox (Windows).
5.
Saisissez "M" dans le contrôle TextBox, puis cliquez sur Réafficher le rapport.
Les données du rapport qui s'affiche sont filtrées de la manière spécifiée ci-dessus.
6.
Fermez votre navigateur.
1.5.2.8.9
Addenda : Améliorations apportées au code des
formules de sélection
Si vous avez installé SAP Crystal Reports 2008, vous avez accès aux fonctionnalités API améliorées qui filtrent les
données dans le modèle d'objet ReportDocument en définissant la formule SavedDataSelection de la classe
DataDefinition.
Dans les procédures précédentes, vous avez appris à utiliser la formule RecordSelection pour filtrer les
données après un événement de clic.
Dans ce tutoriel, vous allez modifier la méthode redisplay_Click afin d'utiliser la formule SavedDataSelection
pour filtrer les données après un événement de clic. La formule SavedDataSelection permet de d'appliquer le
filtrage sur les données enregistrées sans qu'il soit nécessaire d'accéder une nouvelle fois à la base de données.
1.5.2.8.9.1
Modification du projet pour la formule
SavedDataSelection
Si vous avez effectué toutes les procédures de la section Tutoriel : Filtrage des données à l'aide des formules de
sélection [page 481], vous devez d'abord supprimer certaines lignes de code indiquées dans la procédure
suivante.
496
1.5.2.8.9.1.1
Pour modifier le projet afin d'utiliser la formule
SavedDataSelection
Procédure
1.
2.
3.
4.
Si vous développez un projet Windows, supprimez la variable de niveau classe nommée
"useDefaultValues".
5.
Si vous développez un projet Web, dans la méthode ConfigureCrystalReports(), supprimez le bloc
conditionnel sans supprimer le code qu'il contient.
La méthode ConfigureCrystalReports() modifiée doit ressembler à ceci :
salesAmount = "4000"
operatorValue = "<"
customerName = "K"
Dim selectionFormula As String = "{Customer.Last Year's Sales} > " &
salesAmount _
& " AND Mid({Customer.Customer Name}, 1, 1) " & operatorValue & "'" &
customerName & "'"
operatorValueList.DataBind()
customerBySalesNameReport = New ReportDocument()
Dim reportPath As String = Server.MapPath("CustomerSalesByReport.rpt")
customerBySalesNameReport.Load(reportPath)
selectionFormula
End Sub
{
salesAmount = "4000";
operatorValue = "<";
customerName = "K";
string selectionFormula = "{Customer.Last Year's Sales} > " + salesAmount
+ " AND Mid({Customer.Customer Name}, 1, 1) " + operatorValue + "'" +
customerName + "'";
operatorValueList.DataBind();
customerBySalesNameReport = new ReportDocument();
string reportPath = Server.MapPath("CustomerBySalesName.rpt");
customerBySalesNameReport.Load(reportPath);
selectionFormula;
}
497
1.5.2.8.9.2
Ajout d'un événement qui applique la formule
SavedDataSelection
Dans cette section, vous allez modifier la méthode redisplay_Click en appliquant la formule
SavedDataSelection aux valeurs selectionFormula du rapport.
1.5.2.8.9.2.1
Pour ajouter l'événement de clic
Procédure
1.
2.
3.
Dans la méthode redisplay_Click, supprimez la ligne qui appelle la méthode
4.
Créez une chaîne selectionFormula dans laquelle vous ajoutez des littéraux aux variables de niveau classe.
Dim selectionFormula As String = "{Customer.Last Year's Sales} > " _
& salesAmount _
& " AND Mid({Customer.Customer Name}, 1, 1) " _
& operatorValue _
& "'" _
& customerName _
& "'"
string selectionFormula = "{Customer.Last Year's Sales} > "
+ salesAmount
+ " AND Mid({Customer.Customer Name}, 1, 1) "
+ operatorValue
+ "'"
+ customerName
+ "'";
5.
Affectez la variable chaîne selectionFormula à l'instance ReportDocument.
customerBySalesNameReport.DataDefinition.SavedDataSelectionFormula =
selectionFormula
customerBySalesNameReport.DataDefinition.SavedDataSelectionFormula =
selectionFormula;
6.
Sur la ligne suivante, liez la propriété ReportSource du contrôle CrystalReportViewer à l'instance
ReportDocument.
7.
Au bas de la méthode , affectez la chaîne selectionFormula à la propriété Text du contrôle Label de la
formule.
498
Résultats
Vous pouvez maintenant tester l'application.
1.5.2.8.9.3
Test du filtrage des données
Dans cette section, vous testez le filtrage des données.
1.5.2.8.9.3.1
Pour tester le filtrage des données
Procédure
1.
Compilez et affichez votre application.
2.
Vérifiez que le rapport s'affiche avec les valeurs de filtrage par défaut.
3.
Saisissez "30000" dans Ventes de l'année dernière.
4.
Sélectionnez GreaterThan dans le contrôle DropDownList (Web) ou ComboBox (Windows).
5.
Saisissez "H" dans le contrôle TextBox, puis cliquez sur Réafficher le rapport.
Le rapport est réaffiché, avec tous les clients dont le nom commence par les lettres H à K et dont les ventes
sont supérieures à 30 000 $.
6.
Remplacez "H" par "S" dans le contrôle TextBox, puis cliquez sur Réafficher le rapport.
Le rapport est réaffiché sans aucune donnée. Cela est dû au fait que la lettre "S" est en dehors des
paramètres initiaux définis dans la méthode ConfigureCrystalReports().
7.
Fermez votre navigateur.
1.5.2.9
Tutoriel : Affichage de parties de rapport à l'aide du
contrôle CrystalReportPartsViewer
cliquant sur une série de liens hypertexte successifs.
Introduction
cliquant sur une série de liens hypertexte successifs. Les liens hypertexte vont du groupe de résumé de rapport
499
de base aux informations les plus détaillées sur le rapport. Vous allez définir le point de départ, puis chaque lien
hypertexte successif du rapport. Pour afficher le rapport en plusieurs parties, vous allez affecter le rapport à un
autre contrôle appelé CrystalReportPartsViewer.
Remarque
Les parties de rapport sont utilisées uniquement dans les sites Web ; elles ne sont pas disponibles pour les
projets Windows.
Il existe deux principaux moyens de visualiser un rapport :
●
Vous pouvez visualiser la totalité du rapport.
●
Vous pouvez visualiser le rapport sous forme de série de parties de rapport liées.
Visualisation de la totalité du rapport
Les rapports s'affichent généralement sous la forme d'un document unique (composé d'une ou de plusieurs
pages) dans lequel des informations détaillées sont regroupées par catégories, sous-catégories et lignes de
détails individuelles.
Par exemple, la base de données Xtreme Access fournie avec SAP Crystal Reports contient des données client
sur les magasins de bicyclettes dans de nombreux endroits du monde. L'un des moyens classiques de visualiser
les données dans un rapport consiste à regrouper les magasins de bicyclettes en fonction des régions, puis des
villes et à faire apparaître des lignes d'informations sur chaque magasin au niveau des détails.
Le contrôle CrystalReportViewer permet d'afficher la totalité d'un rapport.
Visualisation d'un rapport sous la forme d'une série de parties liées
Avec l'avènement des portails Web et de la navigation Web sur les téléphones cellulaires, lesquels offrent tous
deux une surface de visualisation très limitée pour consulter les informations, une nouvelle méthode d'affichage
des rapports a été mise au point.
Pour ce faire, le rapport complet qui se compose de catégories de groupes, de sous-catégories et de lignes de
détails est redéfini sous la forme d'une série de parties de rapport. Ces parties s'affichent ensuite à travers une
série de pages liées. Dans ce scénario, le groupe d'informations de la catégorie la plus élevée s'affiche en premier.
Lorsqu'un élément de ce groupe de niveau supérieur est sélectionné, le groupe d'informations d'une souscatégorie s'affiche. Cette exploration continue jusqu'à ce que les lignes de détails individuelles d'une souscatégorie donnée soient atteintes.
Par exemple, les données client sur les magasins de bicyclettes de la base de données Xtreme s'affichent au
départ sous la forme d'une liste de régions. Lorsque vous sélectionnez une région, les villes de cette région
apparaissent. Lorsque vous sélectionnez une ville, les lignes de détails sur les magasins de bicyclettes de la ville
en question apparaissent.
Cette division en plusieurs parties d'un rapport permet d'accéder facilement à un rapport long et complexe sur
une surface de visualisation très limitée.
500
Le contrôle CrystalReportPartsViewer permet d'afficher des rapports sous la forme d'une série de parties
liées.
Exemple de code
version terminée.
●
Site Web C# : CS_Web_RDObjMod_ReportParts
●
Site Web Visual Basic : VB_Web_RDObjMod_ReportParts
1.5.2.9.1
Création d'un rapport
1.5.2.9.1.1
Procédure
1.
2.
Dans la boîte de dialogue Ajouter un nouvel élément, dans la vue Modèles, sélectionnez le modèle "Rapport
Crystal".
501
3.
Dans le champ Nom, saisissez le nom "Customers.rpt", puis cliquez sur Ajouter.
4.
5.
6.
7.
8.
9.
11. Utilisez la combinaison de touches CTRL-clic pour sélectionner Pays, Nom du client, Ventes de l'année
dernière, Région et Ville.
bouton Suivant.
13. Dans le panneau Champs disponibles, sous Champs du rapport, suivez les instructions suivantes :
a) Sélectionnez Pays et cliquez sur le bouton > pour déplacer le champ dans le panneau Regrouper par.
b) Sélectionnez Région et cliquez sur le bouton > pour déplacer le champ dans le panneau Regrouper par.
c) Cliquez sur Suivant.
Des champs résumés sont créés pour le champ Ventes de l'année dernière dans les groupes Pays et
Région.
Le rapport Customers est créé et chargé dans la fenêtre principale de Visual Studio.
15. En bas de la fenêtre, cliquez sur Aperçu Rapport principal.
Le rapport s'affiche selon des niveaux hiérarchiques triés d'abord par pays, puis par région. Si vous changez
l'affichage du rapport pour afficher des parties de rapport, chaque niveau s'affiche séparément.
Résultats
Vous pouvez maintenant convertir le rapport pour afficher des parties de rapport.
1.5.2.9.2
rapport
Conversion du rapport afin d'afficher des parties de
Dans cette section, vous allez apprendre à définir des liens hypertexte dans le rapport pour lier les informations
générales aux informations plus détaillées.
502
1.5.2.9.2.1
Pour convertir le rapport afin d'afficher des
parties de rapport
Procédure
1.
En bas de la fenêtre, cliquez sur Rapport principal.
Remarque
Le groupe de plus haut niveau, Nom du groupe n° 1, s'affiche en deux endroits, au début et en bas du
rapport.
Au bas du rapport dans la section Pied de page de groupe n° 1, Nom du groupe n° 1 est une étiquette suivie
d'un champ résumé de Clients.Ventes de l'année dernière. Cette étiquette est à utiliser de préférence
comme point d'entrée des parties de rapport.
2.
Cliquez avec le bouton droit de la souris sur Nom du groupe n° 1 situé dans la section Pied de page de groupe n
° 1, puis cliquez sur Copier.
3.
Cliquez avec le bouton droit de la souris sur une zone vide du rapport, pointez sur Rapport, puis cliquez sur
Options du rapport.
4.
Dans la boîte de dialogue Options du rapport, cliquez sur Coller le lien.
L'ID de l'étiquette du groupe 1 "GroupNamePays2" est collée dans le champ Nom de l'objet.
Le champ Contexte des données accepte une valeur de chaîne qui filtre les données du rapport. Pour le
moment, ce champ doit rester vide.
5.
Cliquez sur OK.
6.
Cliquez avec le bouton droit de la souris sur Nom du groupe n° 1 qui se trouve dans la section Pied de page de
groupe n° 1, puis cliquez sur Mettre en forme l'objet.
7.
Dans l'Editeur de mise en forme, cliquez sur l'onglet Lien hypertexte, puis sélectionnez Exploration des parties
du rapport.
8.
Dans le panneau Champs disponibles, développez Pied de page de groupe n° 2, cliquez deux fois sur
GroupNameRégion2, puis cliquez sur OK.
Vous avez configuré Groupe n° 1 pour le lier à Groupe n° 2 lorsqu'un utilisateur clique sur Groupe n° 1 au
moment de l'exécution.
9.
Cliquez avec le bouton droit de la souris sur Nom du groupe n° 2 qui se trouve dans la section Pied de page de
groupe n° 2, puis cliquez sur Mettre en forme l'objet.
10. Dans l'Editeur de mise en forme, cliquez sur l'onglet Lien hypertexte, puis sélectionnez Exploration des parties
du rapport.
11. Dans le panneau Champs disponibles, procédez de la manière suivante :
a) Développez Détails.
b) Utilisez la combinaison de touches CTRL-clic pour sélectionner Nomduclient1, Ventesdelannéedernière1
et Ville1.
c) Cliquez sur le bouton > pour déplacer ces champs dans le panneau Champs à afficher.
d) Cliquez sur OK.
Vous avez défini Groupe n° 2 pour le lier aux informations détaillées sur le client lorsqu'un utilisateur
clique sur Groupe n° 2 au moment de l'exécution.
503
1.5.2.9.3
Liaison du rapport
tutoriel, vous avez placé un contrôle CrystalReportViewer sur le Web Form. Or, pour afficher des parties de
rapport, vous devez utiliser le contrôle CrystalReportPartsViewer.
Dans cette section, vous allez instancier le rapport Customers et le lier au contrôle
CrystalReportPartsViewer. Vous vérifierez ensuite si le rapport affiche les parties de rapport que vous avez
créées dans les procédures précédentes.
●
●
●
●
Effectuez maintenant la procédure Filtrage des données du rapport [page 507].
1.5.2.9.3.1
Pour instancier le rapport Customers sous forme
de rapport incorporé et le lier au contrôle
CrystalPartsReportViewer
Procédure
1.
Ouvrez le Web Form.
2.
3.
Supprimez le contrôle CrystalReportViewer.
4.
Dans la boîte à outils, ouvrez le nœud Crystal Reports afin de localiser le contrôle CrystalReportPartsViewer.
5.
Faites glisser le contrôle CrystalReportPartsViewer sur le Web Form.
6.
Dans la fenêtre Propriétés, définissez la propriété ID de la manière suivante :
○
Pour les sites Web Visual Basic, attribuez à la propriété ID la valeur "myCrystalReportPartsViewer".
○
Pour les sites Web C#, attribuez à la propriété ID la valeur "crystalReportPartsViewer".
7.
Dans le menu Affichage, cliquez sur Code pour afficher la classe code-behind de ce Web Form.
8.
Ajoutez une nouvelle déclaration de niveau classe pour la classe wrapper du rapport Customers, avec la
variable customerReport. Définissez le modificateur d'accès à private.
Private customersReport As Customers
private Customers customersReport;
504
9.
Remarque
customersReport = New Customers()
customersReport = new Customers();
10. Sur la ligne suivante, au-dessous de l'instanciation du rapport, liez la propriété ReportSource du contrôle
CrystalReportPartsViewer à la classe de rapport instanciée (nom de la variable : customersReport).
myCrystalReportPartsViewer.ReportSource = customersReport
crystalReportPartsViewer.ReportSource = customersReport;
Remarque
L'instance du contrôle CrystalReportPartsViewer est accessible dans le code, car vous avez ajouté le
contrôle à votre Web Form ou Windows Form. Si IntelliSense ne reconnaît pas l'instance du contrôle
CrystalReportPartsViewer, vérifiez que le contrôle CrystalReportPartsViewer a été ajouté sous la forme
d'une déclaration de niveau classe à cette classe code-behind.
1.5.2.9.3.2
Pour instancier le rapport Customers sous forme
de rapport non incorporé et le lier au contrôle
CrystalReportPartsViewer
Contexte
Procédure
1.
Ouvrez le Web Form.
2.
3.
variable customersReport. Définissez le modificateur d'accès à private.
Private customersReport As ReportDocument
505
private ReportDocument customersReport;
Remarque
4.
Dans la méthode ConfigureCrystalReports() (que vous avez créée dans l'une des procédures de la
section Configuration d'un projet [page 15]), instanciez la classe ReportDocument.
customersReport = New ReportDocument()
customersReport = new ReportDocument();
5.
Windows :
○
Dim reportPath As String = Server.MapPath("Customers.rpt")
string reportPath = Server.MapPath("Customers.rpt");
○
Remarque
exécutable.
Dim reportPath As String = Application.StartupPath & "\" & "Customers.rpt"
string reportPath = Application.StartupPath + "\\" + "Customers.rpt";
6.
customersReport.Load(reportPath)
customersReport.Load(reportPath);
506
7.
CrystalReportPartsViewer à l'instance ReportDocument.
myCrystalReportPartsViewer.ReportSource = customersReport
crystalReportPartsViewer.ReportSource = customersReport;
1.5.2.9.3.3
Pour tester le chargement du rapport Customers
Contexte
classe ReportDocument, le nom de la variable utilisée est identique : customersReport. Vous pouvez ainsi utiliser
un bloc de code commun dans les procédures suivantes.
permettant de définir une valeur pour le champ de paramètre Ville n'a pas encore été écrit. Vous ajouterez une
valeur au paramètre Ville plus loin dans ce tutoriel.
Procédure
1.
2.
3.
Le rapport Customers s'affiche dans le navigateur Web.
4.
Cliquez sur un pays pour afficher une liste des régions.
5.
Cliquez sur une région pour afficher les champs Nom du client, Ventes de l'année dernière et Ville.
6.
1.5.2.9.4
Filtrage des données du rapport
Dans cette section, vous allez apprendre à définir le champ Contexte des données pour filtrer les données qui
s'affichent dans le rapport. Pour en savoir plus sur les paramètres de Contexte des données, voir Implémentation
de l'exploration de parties de rapport [page 747].
507
1.5.2.9.4.1
Pour filtrer les données du rapport
Procédure
1.
Ouvrez le rapport Crystal.
2.
Cliquez avec le bouton droit de la souris sur une zone vide du rapport. Sélectionnez Rapport, puis cliquez sur
Options du rapport.
3.
Dans le champ Contexte des données, saisissez "/Pays[Etats-Unis]".
4.
Cliquez sur OK pour fermer la boîte de dialogue Options du rapport.
5.
6.
7.
Le rapport affiche uniquement les enregistrements des Etats-Unis.
8.
1.5.3
Tutoriels de programmation allégée dans Visual Studio
Cette section présente divers tutoriels consacrés au modèle de développement de programmation allégée.
Remarque
Pour les tutoriels qui font appel au modèle de programmation classique, voir Tutoriels du modèle d'objet
ReportDocument [page 340].
1.5.3.1
Tutoriel : Configuration par programmation allégée
d'un site Web avec SAP Crystal Reports à l'aide du panneau
des tâches guidées
Dans ce tutoriel, vous allez apprendre à utiliser le nouveau modèle de développement d'applications avec balises
dans Visual Studio. Vous allez suivre un modèle de développement par programmation allégée pour configurer un
site Web avec SAP Crystal Reports, à l'aide des tâches guidées.
Introduction
Dans ce tutoriel, vous allez créer un site Web ASP.NET dans Visual Studio. Vous allez ensuite ajouter un contrôle
CrystalReportViewer au Web Form, afin de lancer le nouveau panneau des tâches guidées. Dans le panneau
des tâches guidées, vous allez créer un contrôle CrystalReportSource, puis créer un rapport Crystal. Le
rapport est référencé dans le contrôle CrystalReportSource.
508
Ce tutoriel permet d'afficher un aperçu du rapport de trois façons :
●
Dans le concepteur SAP Crystal Reports incorporé, à l'aide du nouveau bouton Aperçu de
●
Dans le Web Form, à l'aide de données factices.
Remarque
C'est grâce à une nouvelle fonctionnalité nommée Aperçu au moment de la conception qu'il est désormais
possible d'obtenir un aperçu du Web Form.
●
Au moment de l'exécution, lorsque vous créez et compilez l'application.
A la fin de ce tutoriel, vous allez passer en mode HTML (mode Source) et découvrir la relation entre le contrôle
CrystalReportViewer et le contrôle CrystalReportSource dans le nouveau modèle de développement
d'applications avec balises de Visual Studio 2005 ou version ultérieure.
Exemple de code
version terminée.
●
Site Web C# : CS_Web_ReducedCode_WebSiteSetup
●
Site Web Visual Basic : VB_Web_ReducedCode_WebSiteSetup
Affichage d'un rapport au moment de la conception [page 224]
509
1.5.3.1.1
Création d'un site Web avec un contrôle
CrystalReportViewer
Prérequis
Avant de créer un site Web, vérifiez que SAP Crystal Reports, version développeur pour Microsoft Visual Studio a
été installé sur votre système.
Procédure
1.
2.
3.
Dans la boîte de dialogue Nouveau site Web, cliquez sur Site Web ASP.NET.
4.
Dans la liste déroulante Emplacement, sélectionnez Système de fichiers.
5.
Dans la liste déroulante Langage, sélectionnez le langage de programmation que vous souhaitez utiliser.
6.
Dans le champ de texte Emplacement, saisissez le chemin d'accès du répertoire C:\WebSites\, suivi du nom
de votre projet.
7.
Cliquez sur OK.
Votre projet s'affiche dans l'Explorateur de solutions et contient une page Default.aspx.
8.
Ouvrez la page Default.aspx (le Web Form).
9.
Remarque
Vous pouvez également basculer en mode Design en cliquant sur le bouton Design en bas du formulaire.
10. Dans la Boîte à outils, ouvrez le nœud Reporting afin de localiser le contrôle CrystalReportViewer.
11. Faites glisser le contrôle CrystalReportViewer sur le Web Form.
Le panneau des tâches guidées "Tâches CrystalReportViewer" s'affiche.
Eléments à installer [page 10]
510
1.5.3.1.2
Configuration du contrôle CrystalReportSource
dans les tâches guidées
Visual Studio 2005 et version ultérieure disposent d'une nouvelle fonctionnalité d'interface utilisateur graphique
destinée aux contrôles .NET, appelée tâches guidées. Pour le contrôle CrystalReportViewer dans des sites Web, le
panneau des tâches guidées s'intitule "Tâches CrystalReportViewer".
Ce panneau "Tâches CrystalReportViewer" permet de configurer plusieurs fonctionnalités du contrôle
CrystalReportViewer, sans avoir à écrire de code. Les sélections que vous effectuez à l'aide des tâches guidées
sont appliquées sous forme de paramètres avec balises dans la page ASPX.
Dans cette section, vous allez apprendre à configurer l'option CrystalReportSource disponible dans le panneau
des tâches guidées "Tâches CrystalReportViewer".
Plus loin dans ces tutoriels de programmation allégée, vous examinerez d'autres fonctionnalités du panneau
"Tâches CrystalReportViewer".
1.5.3.1.2.1
Pour configurer le contrôle CrystalReportSource
à l'aide des tâches guidées
Procédure
1.
Si le panneau des tâches guidées est ouvert, cliquez sur le Web Form pour le fermer.
2.
Le panneau des tâches guidées intitulé "Tâches CrystalReportViewer" s'affiche de nouveau. Dans la liste
Sélectionner la source du rapport, la valeur <Aucune> s'affiche.
3.
Cliquez sur la liste Sélectionner la source du rapport, puis sélectionnez <Source du nouveau rapport…>.
La boîte de dialogue Créer la source du rapport s'ouvre.
4.
Dans la zone Indiquer le nom du contrôle CrystalReportSource, laissez l'entrée par défaut
CrystalReportSource1.
5.
Cliquez sur la liste Spécifier un rapport Crystal pour le contrôle CrystalReportSource, puis sélectionnez
<Nouveau rapport>.
L'autre sélection possible est <Parcourir…>. Cette option permet de sélectionner un rapport Crystal existant
dans le répertoire de fichiers. Cependant, dans ce tutoriel, vous allez créer un rapport.
6.
Dans la boîte de dialogue Créer un rapport Crystal, saisissez le nom "XtremeCustomers.rpt", puis cliquez sur
OK.
7.
Cliquez à nouveau sur OK pour fermer la boîte de dialogue Créer la source du rapport.
1.5.3.1.3
Configuration du rapport pour le contrôle
CrystalReportSource
Dans cette section, vous utilisez l'Assistant de création de rapports pour configurer le rapport et l'ajouter au
contrôle CrystalReportSource. Vous créez une connexion à une base de données, configurez les champs du
511
rapport, puis ajoutez le rapport au contrôle. Lorsque vous avez terminé ces opérations, vous testez le site Web
que vous avez créé par programmation allégée.
1.5.3.1.3.1
Pour configurer le rapport pour le contrôle
CrystalReportSource
Procédure
1.
2.
3.
Dans le panneau Sources de données disponibles de la fenêtre de l'Assistant de création de rapports
standard, procédez comme suit :
a) Développez le dossier Créer une nouvelle connexion.
b) Développez le dossier ODBC (RDO).
4.
5.
6.
Cliquez deux fois sur la table Clients pour l'ajouter au panneau Tables sélectionnées, puis cliquez sur Suivant.
7.
Développez la table Clients, puis utilisez la combinaison de touches CTRL-clic pour sélectionner les champs
8.
Cliquez sur le bouton > pour déplacer ces champs dans le panneau Champs à afficher, puis cliquez sur
Suivant.
9.
Dans le panneau Champs disponibles, sous Champs du rapport, sélectionnez Clients.Ville, cliquez sur le
Le rapport XtremeCustomers est créé et chargé dans la fenêtre principale de Visual Studio.
Remarque
Le bouton Aperçu est pour la première fois disponible dans le concepteur SAP Crystal Reports incorporé,
fourni avec SAP Crystal Reports pour Visual Studio 2005.
Le rapport s'affiche en mode Aperçu et présente les données provenant de la base de données Xtreme.
11. En bas de la fenêtre, cliquez sur Rapport principal pour quitter le mode Aperçu.
12. Ouvrez le Web Form.
Le rapport s'affiche alors sous forme graphique dans le Web Form, en mode Aperçu au moment de la
conception.
512
1.5.3.1.3.2
allégée
Pour vérifier le site Web créé par programmation
Contexte
Votre rapport est créé et constitue le rapport désigné pour le contrôle CrystalReportSource. Vous êtes
maintenant prêt à générer et exécuter votre projet.
Procédure
1.
2.
3.
4.
Le rapport XtremeCustomers s'affiche dans le navigateur Web.
5.
1.5.3.1.4
Exploration du contrôle CrystalReportSource en
mode Source
Contexte
Dans cette section, vous allez découvrir le modèle de développement d'applications avec balises utilisé dans
ASP.NET version 2.0. Ce modèle permet de configurer un site Web avec SAP Crystal Reports, version
développeur pour Microsoft Visual Studio, sans avoir à écrire de code. Vous allez également découvrir la structure
du contrôle DataSource et le contrôle CrystalReportSource qui font partie d'ASP.NET 2.0.
Procédure
1.
2.
3.
En bas du Web Form, cliquez sur le bouton Source.
Le code HTML de la page Default.aspx s'affiche. Il contient deux balises apparentées pour SAP Crystal
Reports :
○
La balise CrystalReportSource, qui imbrique la balise Report. La balise Report référence le rapport dans
sa propriété FileName.
<CR:CrystalReportSource ID="CrystalReportSource1" Runat="server"
513
EnableCaching="False" GroupPath="">
<Report FileName="XtremeCustomers.rpt"></Report>
○
La balise CrystalReportViewer, qui référence le contrôle CrystalReportSource par ID.
<CR:CrystalReportViewer ID="CrystalReportViewer1" Runat="server"
AutoDataBind="True"
Height="1158px" CssFilename="CssFilename"
ReportSourceID="CrystalReportSource1" Width="1059px" />
Résultats
Le code présente le nouveau modèle de développement d'applications avec balises qui fait partie d'ASP.NET 2.0.
Comme dans ASP.NET version 1.0, le contrôle CrystalReportViewer est représenté par une balise XML.
Cependant, les propriétés disponibles pour ce contrôle sont plus nombreuses dans ASP.NET 2.0 afin de prendre
en charge le modèle de développement d'applications avec balises.
Dans ASP.NET 2.0, la connectivité des données a été encapsulée dans le contrôle DataSource. Le contrôle
CrystalReportSource s'adapte à la structure du contrôle DataSource, à la différence qu'il encapsule la
connectivité du rapport plutôt que la connectivité des données. Cette structure est gérée par la propriété
ReportSourceID dans le contrôle visuel principal.
Pour en savoir plus sur les autres propriétés du contrôle CrystalReportSource, voir Contrôle
CrystalReportSource [page 52]. Les propriétés sont également présentées dans les autres tutoriels de
programmation allégée de cette section.
1.5.3.2
Tutoriel : Configuration par programmation allégée
d'un projet Windows avec SAP Crystal Reports à l'aide des
tâches guidées
Introduction
Dans ce tutoriel, vous allez apprendre à créer un projet Windows dans SAP Crystal Reports, version développeur
pour Microsoft Visual Studio. Vous allez ensuite ajouter un contrôle CrystalReportViewer au Windows Form. Dans
le panneau des tâches guidées, vous allez ouvrir le concepteur SAP Crystal Reports incorporé et créer un rapport.
La fonctionnalité des tâches guidées génère le code qui lie le rapport au contrôle CrystalReportViewer.
Ce tutoriel permet d'afficher un aperçu du rapport de trois façons :
●
Dans le concepteur SAP Crystal Reports incorporé, à l'aide du nouveau bouton Aperçu de
●
Dans le Windows Form, à l'aide de données factices.
●
Au moment de l'exécution, lorsque vous créez et compilez l'application.
A la fin de ce tutoriel, vous allez passer en mode code pour observer comment le modèle de développement par
programmation allégée fonctionne dans SAP Crystal Reports, version développeur pour Microsoft Visual Studio.
514
Exemple de code
version terminée.
●
Projet Windows C# : CS_Win_ReducedCode_ProjectSetup.
●
Projet Windows Visual Basic : VB_Win_ReducedCode_ProjectSetup.
1.5.3.2.1
Création d'un projet Windows avec un contrôle
CrystalReportViewer
Prérequis
Avant de créer un projet Windows, vérifiez que SAP Crystal Reports, version développeur pour Microsoft
Visual Studio a été installé sur votre système.
Procédure
1.
2.
Dans le menu Fichier, sélectionnez Nouveau, puis cliquez sur Projet.
3.
Dans la boîte de dialogue Nouveau projet, dans la liste Types de projets, sélectionnez un dossier de langage
pour C# ou Visual Basic.
4.
Dans la liste Modèles, cliquez sur Application Windows.
5.
Dans le champ Nom, remplacez le nom de projet par défaut par le nom de votre projet.
515
6.
Cliquez sur OK.
Votre projet s'affiche dans l'Explorateur de solutions et contient une classe Form1.
7.
Ouvrez la classe Form1.
8.
9.
Faites glisser le contrôle CrystalReportViewer sur le Windows Form.
10. Dans la fenêtre Propriétés, définissez la propriété Name de la manière suivante :
○
Pour les projets Visual Basic, attribuez la valeur "myCrystalReportViewer".
○
Pour les projets C#, attribuez la valeur "crystalReportViewer".
Eléments à installer [page 10]
1.5.3.2.2
Configuration du rapport dans le panneau des
tâches guidées
Pour le contrôle CrystalReportViewer dans des projets Windows, le panneau des tâches guidées s'intitule Tâches
Les sélections que vous effectuez dans les tâches guidées sont générées sous forme de code dans une classe
partielle Form1. Dans cette section, vous allez configurer un nouveau rapport à l'aide du panneau des tâches
guidées Tâches CrystalReportViewer et du concepteur SAP Crystal Reports incorporé. Plus loin dans ces tutoriels
de programmation allégée, vous examinerez d'autres fonctionnalités des tâches guidées.
1.5.3.2.2.1
guidées
Configuration du rapport à l'aide des tâches
Procédure
1.
Le panneau des tâches guidées Tâches CrystalReportViewer s'affiche.
2.
Cliquez sur le lien Créer un rapport Crystal.
3.
Dans la boîte de dialogue Créer un rapport Crystal, saisissez le nom XtremeCustomers.rpt, puis cliquez sur
OK.
La boîte de dialogue Galerie de rapports Crystal s'affiche.
4.
5.
516
6.
Dans le panneau Sources de données disponibles de la fenêtre de l'Assistant de création de rapports
standard, procédez comme suit :
a) Développez le dossier Créer une nouvelle connexion.
b) Développez le dossier ODBC (RDO).
7.
8.
Développez le nœud Tables, puis sélectionnez la table Clients.
9.
Cliquez deux fois sur la table Clients pour l'ajouter au panneau Tables sélectionnées, puis cliquez sur Suivant.
10. Utilisez la combinaison de touches CTRL-clic pour sélectionner les champs Nom du client, Titre, Adresse 1 et
Ville.
Suivant.
12. Dans le panneau Champs disponibles, sous Champs du rapport, sélectionnez Clients.Ville, cliquez sur le
Le rapport XtremeCustomers est créé et chargé dans la fenêtre principale de Visual Studio.
Remarque
Le bouton Aperçu est une nouvelle fonctionnalité du concepteur SAP Crystal Reports incorporé fourni avec
14. En bas de la fenêtre, cliquez sur Rapport principal pour quitter le mode Aperçu.
15. Revenez à la classe Form1.
Le rapport s'affiche sous forme graphique dans le Web Form, en mode Aperçu au moment de la conception.
Sous la classe Form1, le rapport XtremeCustomers s'affiche dans la barre d'état des composants.
1.5.3.2.2.2
Pour renommer la variable du rapport
Contexte
Votre rapport est créé et constitue le rapport désigné pour le contrôle CrystalReportViewer. A ce stade, vous
pouvez renommer la variable de rapport.
Procédure
1.
Cliquez sur XtremeCustomers1 dans la barre d'état des composants pour le sélectionner.
2.
Dans la fenêtre Propriétés, attribuez au champ Name la valeur "xtremeCustomersReport".
517
1.5.3.2.2.3
Pour vérifier le projet Windows créé par
programmation allégée
Contexte
Procédure
1.
2.
3.
4.
Le rapport XtremeCustomers s'affiche dans une nouvelle application Windows.
5.
1.5.3.2.3
Exploration du code généré par des tâches guidées
Dans cette section, vous allez explorer le code généré par les tâches guidées, qui a permis de configurer un projet
Windows avec SAP Crystal Reports sans avoir à écrire de code.
1.5.3.2.3.1
guidées
Pour explorer le code généré par les tâches
Procédure
1.
Ouvrez la classe Form1.
2.
La classe Form1 s'ouvre en mode code et affiche une classe vide.
Remarque
Dans C#, la classe vide affiche le constructeur de classe.
public Form1()
{
}
518
1.5.3.2.3.2
Pour afficher la classe Form1 partielle masquée
Contexte
Notez que le code suivant est absent :
●
la déclaration de l'instance du contrôle CrystalReportViewer ;
●
l'instance du rapport XtremeCustomers ;
●
le code qui lie le rapport au contrôle CrystalReportViewer.
Le code absent a été masqué dans une classe partielle. Elles permettent à une classe d'accepter un addenda
provenant d'un autre fichier de classe, en attribuant à ce fichier le même nom de classe avec le préfixe "partial".
Les classes partielles contiennent généralement du code généré automatiquement.
Pour visualiser le code généré automatiquement qui n'apparaît pas dans la classe Form1, vous allez explorer les
instances CrystalReportViewer et les instances du rapport dans la classe partielle masquée Form1.
Procédure
1.
Dans l'Explorateur de solutions, cliquez sur l'icône de barre d'outils Afficher tous les fichiers.
2.
Développez Form1.cs ou Form1.vb.
La classe Form1.Designer.cs ou .vb s'affiche.
3.
Cliquez avec le bouton droit de la souris sur la classe Form1.Designer.cs ou .vb, puis sélectionnez Afficher le
code.
La classe partielle Form1 s'ouvre et affiche le code généré de façon automatique pour cette classe. Cela inclut
la déclaration de l'instance du contrôle CrystalReportViewer, l'instance du rapport XtremeCustomers et le
code qui lie le rapport à l'instance du contrôle CrystalReportViewer.
Remarque
Si vous préférez écrire le code et le placer dans la classe code-behind, voir Configuration d'un projet [page
15].
519
1.5.3.3
Tutoriel : Connexion à une base de données sécurisée
à programmation allégée dans un site Web
Dans ce tutoriel de création de site Web par programmation allégée, vous allez apprendre à afficher un rapport
contenant des informations provenant d'une base de données SQL Server sécurisée.
Introduction
Dans ce tutoriel de création de site Web par programmation allégée, vous allez apprendre à afficher un rapport
contenant des informations provenant d'une base de données SQL Server sécurisée. Pour créer une connexion à
une base de données sécurisée, vous affectez la propriété DataSources du rapport au contrôle SQLDataSource
faisant partie de la nouvelle structure du contrôle DataSource dans .NET 2.0.
Dans ce tutoriel, pour afficher un rapport contenant des informations provenant d'une base de données SQL
Server sécurisée, vous allez utiliser le nouveau modèle de développement d'applications avec balises pour
connecter les composants clés :
●
Connecter un contrôle CrystalReportViewer à un contrôle CrystalReportSource.
●
Connecter le contrôle CrystalReportSource à un rapport.
●
Connecter la propriété DataSources du rapport à un contrôle SqlDataSource.
Remarque
La propriété DataSources s'affiche sous forme de propriété de rapport dans la fenêtre Propriétés, ou sous
forme de balise en mode HTML (mode Source).
Toutes ces opérations sont réalisées sans écrire de code.
Remarque
Un modèle de développement de codage de ce tutoriel est également disponible. Voir Tutoriel : Connexion à
une base de données SQL Server sécurisée à l'aide de l'authentification SQL [page 353] ou Tutoriel : Connexion
à une base de données SQL Server sécurisée à l'aide de la sécurité intégrée [page 370].
Pour commencer, vous allez ajouter un contrôle CrystalReportViewer au Web Form. Dans le panneau des tâches
guidées, vous allez créer un contrôle CrystalReportSource, puis un rapport Crystal à l'aide du concepteur
SAP Crystal Reports incorporé. Ce rapport se connecte à une base de données SQL Server sécurisée. Le rapport
est référencé dans le contrôle CrystalReportSource.
Vous allez ensuite apprendre à configurer la connexion à la base de données SQL Server sécurisée afin de
renvoyer les tables requises utilisées par le rapport Crystal. Pour commencer, vous allez sélectionner l'option
"Activer l'invite de connexion à la base de données" dans le panneau des tâches guidées. Lorsque cette option est
sélectionnée, l'exception renvoyée lorsque la connexion à la base de données échoue est remplacée par une invite
demandant à l'utilisateur de se connecter manuellement.
Pour configurer une connexion cohérente à la base de données requise, vous ajoutez un contrôle SqlDataSource,
puis le configurez de manière à ce qu'il désigne la base de données SQL Server sécurisée et renvoie les tables
requises.
Enfin, vous affectez la propriété DataSource du rapport au contrôle SqlDataSource que vous avez créé.
520
Exemple de code
version terminée.
●
Site Web C# : CS_Web_ReducedCode_DBLogon
●
Site Web Visual Basic : VB_Web_ReducedCode_DBLogon
1.5.3.3.1
Création d'un site Web avec un contrôle
CrystalReportViewer
Avant de créer un site Web, vérifiez que SAP Crystal Reports, version développeur pour Microsoft Visual Studio, a
été installé sur votre système.
Une configuration préalable de la base de données est requise avant de commencer ce tutoriel.
1.5.3.3.1.1
données
●
Conf

SAP Crystal Report pour le Guide du développeur

Transcription

Documents pareils

SAP - Ressources Humaines (HR)

Offre d_emploi consultant SAP

Offre d`emploi : Consultant junior SRM REF : 012CJ - SAP

GUIDE RECHERCHE DE STAGE 1 année CAP SAPVER Année

Détail de l`offre : Consultant confirmé SAP FI/CO H/F

Introduction à Snoot Technologies

Détail de l`offre : Consultant SAP FI CO H/F Date de

ANALYSTE PROGRAMMEUR (m/f)

Accédez à un poste de… Consultant Fonctionnel SAP FI/CO

SAP utilisateur, Comptabilité Financière FI (Financial