Share via

Création d’un composant de conception d’élément de rapport personnalisé

  • Article

Un composant au moment de la conception d'élément de rapport personnalisé est un contrôle qui peut être utilisé dans l'environnement du Concepteur de rapports Visual Studio. Le composant au moment de la conception d'élément de rapport personnalisé fournit une aire de conception activée qui prend en charge les opérations de glisser-déplacer et l'intégration avec l'Explorateur de propriétés Visual Studio, tout en fournissant des éditeurs de propriété personnalisée.

Avec un composant au moment de la conception d'élément de rapport personnalisé, l'utilisateur peut positionner un élément de rapport personnalisé sur un rapport dans l'environnement de conception, définir des propriétés de données personnalisées sur l'élément de rapport personnalisé, puis enregistrer cet élément en tant que partie du projet de rapport.

Les propriétés définies à l’aide du composant au moment du design dans l’environnement de développement sont sérialisées et désérialisées par l’environnement de conception de l’hôte. Les propriétés sont ensuite stockées en tant qu’éléments dans le fichier RDL (Report Definition Language). Lorsque le processeur de rapports exécute le rapport, les propriétés définies à l’aide du composant au moment du design sont transmises par le processeur de rapports à un composant d’exécution d’élément de rapport personnalisé, qui restitue l’élément de rapport personnalisé et le transmet au processeur de rapports.

Remarque

Le composant design-time de l’élément de rapport personnalisé est implémenté en tant que composant Microsoft .NET Framework. Ce document décrit les détails d'implémentation spécifiques au composant au moment de la conception d'élément de rapport personnalisé.

Pour un exemple d’élément de rapport personnalisé totalement implémenté, consultez SQL Server Reporting Services Product Samples (Exemples Reporting Services pour le produit SQL Server).

Implémenter un composant au moment du design

La classe principale d’un composant au moment de la conception d’élément de rapport personnalisé est héritée de la classe Microsoft.ReportDesigner.CustomReportItemDesigner. En plus des attributs standard utilisés pour un contrôle .NET Framework, votre classe de composant doit définir un attribut CustomReportItem. Cet attribut doit correspondre au nom de l'élément de rapport personnalisé tel que défini dans le fichier reportserver.config. Pour obtenir la liste des attributs .NET Framework, consultez la documentation relative aux attributs du SDK .NET Framework.

L'exemple de code suivant illustre l'application d'attributs à un contrôle au moment de la conception d'élément de rapport personnalisé :

namespace PolygonsCRI  
{  
    [LocalizedName("Polygons")]  
    [Editor(typeof(CustomEditor), typeof(ComponentEditor))]  
        [ToolboxBitmap(typeof(PolygonsDesigner),"Polygons.ico")]  
        [CustomReportItem("Polygons")]  
  
    public class PolygonsDesigner : CustomReportItemDesigner  
    {  
...

Initialiser le composant

Pour passer des propriétés spécifiées par l'utilisateur pour un élément de rapport personnalisé, une classe CustomData doit être utilisée. Votre implémentation de la classe CustomReportItemDesigner doit se substituer à la méthode InitializeNewComponent pour créer une instance de la classe CustomData de votre composant et lui attribuer les valeurs par défaut.

L’exemple de code suivant illustre la substitution de la méthode CustomReportItemDesigner.InitializeNewComponent par une classe de composant au moment de la conception d’élément de rapport personnalisé pour initialiser la classe CustomData du composant :

public override void InitializeNewComponent()  
        {  
            CustomData = new CustomData();  
            CustomData.DataRowHierarchy = new DataHierarchy();  
  
            // Shape grouping  
            CustomData.DataRowHierarchy.DataMembers.Add(new DataMember());  
            CustomData.DataRowHierarchy.DataMembers[0].Group = new Group();  
            CustomData.DataRowHierarchy.DataMembers[0].Group.Name = Name + "_Shape";  
            CustomData.DataRowHierarchy.DataMembers[0].Group.GroupExpressions.Add(new ReportExpression());  
  
            // Point grouping  
            CustomData.DataRowHierarchy.DataMembers[0].DataMembers.Add(new DataMember());  
            CustomData.DataRowHierarchy.DataMembers[0].DataMembers[0].Group = new Group();  
            CustomData.DataRowHierarchy.DataMembers[0].DataMembers[0].Group.Name = Name + "_Point";  
            CustomData.DataRowHierarchy.DataMembers[0].DataMembers[0].Group.GroupExpressions.Add(new ReportExpression());  
  
            // Static column  
            CustomData.DataColumnHierarchy = new DataHierarchy();  
            CustomData.DataColumnHierarchy.DataMembers.Add(new DataMember());  
  
            // Points  
            IList<IList<DataValue>> dataValues = new List<IList<DataValue>>();  
            CustomData.DataRows.Add(dataValues);  
            CustomData.DataRows[0].Add(new List<DataValue>());  
            CustomData.DataRows[0][0].Add(NewDataValue("X", ""));  
            CustomData.DataRows[0][0].Add(NewDataValue("Y", ""));  
        }

Modifier les propriétés du composant

Vous pouvez modifier les propriétés CustomData de plusieurs façons dans l’environnement de conception. Vous pouvez modifier toute propriété exposée par le composant au moment de la conception et marquée avec l'attribut BrowsableAttribute, à l'aide de l'Explorateur de propriétés Visual Studio. Vous pouvez également modifier des propriétés en faisant glisser des éléments vers l’aire de conception de l’élément de rapport personnalisé ou en cliquant avec le bouton droit sur le contrôle dans l’environnement de conception et en sélectionnant Propriétés dans le menu contextuel pour afficher une fenêtre de propriétés personnalisées.

L’exemple de code suivant montre une propriété Microsoft.ReportDesigner.CustomReportItemDesigner.CustomData dont l’attribut BrowsableAttribute est appliqué :

[Browsable(true), Category("Data")]  
public string DataSetName  
{  
      get  
      {  
         return CustomData.DataSetName;  
      }  
      set  
      {  
         CustomData.DataSetName = value;  
      }  
   }

Vous pouvez fournir votre composant au moment de la conception avec une boîte de dialogue d'éditeur de propriétés personnalisées. L'implémentation d'éditeur de propriétés personnalisées doit hériter de la classe ComponentEditor et doit créer une instance d'une boîte de dialogue destinée à l'édition de propriétés.

L'exemple suivant montre l'implémentation d'une classe qui hérite de ComponentEditor et ouvre une boîte de dialogue d'éditeur de propriétés personnalisées :

internal sealed class CustomEditor : ComponentEditor  
{  
   public override bool EditComponent(  
      ITypeDescriptorContext context, object component)  
    {  
     PolygonsDesigner designer = (PolygonsDesigner)component;  
     PolygonProperties dialog = new PolygonProperties();  
     dialog.m_designerComponent = designer;  
     DialogResult result = dialog.ShowDialog();  
     if (result == DialogResult.OK)  
     {  
        designer.Invalidate();  
        designer.ChangeService().OnComponentChanged(designer, null, null, null);  
        return true;  
     }  
     else  
        return false;  
    }  
}

Votre boîte de dialogue d'éditeur de propriétés personnalisées peut appeler l'Éditeur d'expressions du Concepteur de rapports. Dans l'exemple suivant, l'Éditeur d'expressions est appelé lorsque l'utilisateur sélectionne le premier élément dans la zone de liste déroulante :

private void EditableCombo_SelectedIndexChanged(object sender,   
    EventArgs e)  
{  
   ComboBox combo = (ComboBox)sender;  
   if (combo.SelectedIndex == 0 && m_launchEditor)  
   {  
      m_launchEditor = false;  
      ExpressionEditor editor = new ExpressionEditor();  
      string newValue;  
      newValue = (string)editor.EditValue(null, m_designerComponent.Site, m_oldComboValue);  
      combo.Items[0] = newValue;  
   }  
}

Utiliser des verbes de concepteur

Un verbe de concepteur est une commande de menu liée à un gestionnaire d'événements. Vous pouvez ajouter des verbes de concepteur qui apparaissent dans le menu contextuel d’un composant lorsque votre contrôle d’exécution d’élément de rapport personnalisé est utilisé dans l’environnement de conception. Vous pouvez retourner la liste des verbes de concepteur disponibles de votre composant d’exécution à l’aide de la propriété Verbs.

L’exemple de code suivant montre un verbe de concepteur et un gestionnaire d’événements ajoutés DesignerVerbCollectionau . L’exemple montre également le code du gestionnaire d’événements :

public override DesignerVerbCollection Verbs  
{  
    get  
    {  
        if (m_verbs == null)  
        {  
            m_verbs = new DesignerVerbCollection();  
            m_verbs.Add(new DesignerVerb("Proportional Scaling", new EventHandler(OnProportionalScaling)));  
         m_verbs[0].Checked = (GetCustomProperty("poly:Proportional") == bool.TrueString);  
        }  
  
        return m_verbs;  
    }  
}  
  
private void OnProportionalScaling(object sender, EventArgs e)  
{  
   bool proportional = !  
        (GetCustomProperty("poly:Proportional") == bool.TrueString);  
   m_verbs[0].Checked = proportional;  
   SetCustomProperty("poly:Proportional", proportional.ToString());  
   ChangeService().OnComponentChanged(this, null, null, null);  
   Invalidate();  
}

Utiliser des ornements

Les classes d’éléments de rapports personnalisés peuvent également implémenter une classe Microsoft.ReportDesigner.Design.Adornment. Un ornement permet au contrôle d'élément de rapport personnalisé de fournir des zones à l'extérieur du rectangle principal de l'aire de conception. Ces zones permettent de gérer les événements de l'interface utilisateur, tels que les clics de souris et les opérations de glisser-déplacer. La classe Adornment définie dans l’espace de noms Reporting Services Microsoft.ReportDesigner est une implémentation directe de la classe Adorner dans Windows Forms. Pour obtenir la documentation complète de la classe Adorner, consultez Vue d’ensemble du service de comportement dans MSDN Library. Pour un exemple de code qui implémente une classe Microsoft.ReportDesigner.Design.Adornment, consultez SQL Server Reporting Services Product Samples (Exemples Reporting Services pour le produit SQL Server).

Pour plus d’informations sur la programmation et l’utilisation de Windows Forms dans Visual Studio, consultez les articles suivants dans MSDN Library :

  • Attributs au moment de la conception pour les composants

  • Composants dans Visual Studio

  • Procédure pas à pas : création d'un contrôle Windows Forms qui tire parti des fonctionnalités au moment de la conception de Visual Studio

Contenu connexe

Architecture d’élément de rapport personnalisée
Création d’un composant d’exécution d’élément de rapport personnalisé
Bibliothèques de classes d’éléments de rapport personnalisées
Guide pratique pour déployer un élément de rapport personnalisé