Création de classes LabVIEW

Aide LabVIEW 2014

Date d'édition : June 2014

Numéro de référence : 371361L-0114

»Afficher les infos sur le produit
Télécharger l'aide (Windows uniquement)

Pour créer des types de données définis par l'utilisateur dans LabVIEW, vous devez créer des classes LabVIEW. Les classes LabVIEW définissent les données associées à un objet ainsi que les méthodes qui définissent les actions à effectuer sur les données. L'encapsulation et l'héritage vous permettent de créer du code modulaire que vous pouvez facilement modifier sans affecter tout le code de l'application.

Dans LabVIEW, les données d'une classe sont privées ; autrement dit, seuls les VIs membres de la classe y ont accès. Vous définissez les données de la classe dans la commande de données privées. Lorsque vous créez et que vous enregistrez une classe LabVIEW, LabVIEW crée un fichier de bibliothèque de classe (.lvclass) qui définit un nouveau type de données. Le fichier de bibliothèque de classe enregistre la commande de données privées et les informations sur les VIs membres que vous créez, comme la liste des VIs et les différentes propriétés des VIs. La bibliothèque de classe est similaire à la bibliothèque de projet (.lvlib). Toutefois, la bibliothèque de classe définit un nouveau type de données.

La commande de données privées est un fichier de bibliothèque de classe unique qui définit un cluster de données pour le nouveau type de données, qui correspond au type des données du fil de liaison de la classe. LabVIEW n'enregistre pas la commande de données privées sur disque. LabVIEW l'enregistre dans le fichier de bibliothèque de classe. En enregistrant la commande de données privées dans le fichier de bibliothèque de classe, LabVIEW garantit que les données privées seront toujours celles de la définition de la classe.

Astuce   Vous pouvez créer un répertoire sur disque et lui donner le nom de la classe LabVIEW pour enregistrer le fichier de bibliothèque de classe, les VIs membres de la classe et les sondes par défaut personnalisées de la classe. Vous pouvez inclure dans ce répertoire les fichiers dont la bibliothèque de classe est propriétaire. Si vous incluez des fichiers pour plusieurs bibliothèques de classe dans le même répertoire, des conflits peuvent avoir lieu si vous tentez d'inclure des VIs du même nom dans différentes bibliothèques de classe. Des conflits de noms peuvent survenir dans le processus de développement si vous créez des VIs membres pour des VIs membres dynamiques.

Encapsulation

Chaque classe LabVIEW comprend un cluster de données et des méthodes pour écrire et lire les données de ce cluster. Les données d'une classe LabVIEW sont toujours privées ou invisibles pour les VIs qui ne sont pas membres de la classe. Pour accéder aux données privées, vous créez des méthodes, sous forme de VIs membres de la classe, qui effectuent des opérations sur les données privées de la classe. L'encapsulation est un regroupement des données et des méthodes dans une classe qui limite l'accès aux données aux VIs membres de la classe. L'encapsulation vous permet de créer des blocs de code modulaires que vous pouvez mettre à jour ou modifier facilement sans affecter les autres sections de code de l'application.

Les données de la classe sont toujours privées, mais il existe plusieurs niveaux d'accès utilisateur aux VIs membres. Vous pouvez définir l'accès à une méthode avec les options suivantes :

  • Public — N'importe quel VI peut appeler le VI membre comme sous-VI.
  • Communauté — Seuls les VIs se trouvant dans la même classe, les VIs amis de la classe et les VIs se trouvant dans une bibliothèque amie de la classe peuvent appeler le VI membre. Les VIs membres de la communauté affichent un symbole de clé bleu foncé dans la fenêtre de l'Explorateur de projet.
  • Protégé — Seuls les VIs de la même classe ou d'une classe descendante peuvent appeler le VI membre. Les VIs membres protégés affichent un symbole de clé jaune foncé dans la fenêtre de l'Explorateur de projet.
  • Privé — Seuls les VIs de la même classe peuvent appeler le VI membre. Les VIs membres privés affichent un symbole de clé rouge dans la fenêtre de l'Explorateur de projet.
  • Non spécifié — Cette option n'apparaît que si vous sélectionnez un dossier. Le dossier n'a aucun élément d'accès spécifié. L'accès est public. Par défaut, il n'y a pas d'accès spécifié pour les dossiers d'une classe, ce qui signifie qu'ils sont publics.
    Remarque  Si vous spécifiez des options d'accès pour un dossier, le paramètre d'accès est appliqué à tous les éléments du dossier et est utilisé à la place des options d'accès des différents éléments du dossier.
Remarque  Les VIs de dispatch dynamique sont brisés s'ils sont configurés à l'étendue Communauté. Pour accorder un accès d'ami à un VI de dispatch dynamique en étendue protégée, créez un VI wrapper de dispatch statique que l'ami appelera et définissez ce VI wrapper avec une étendue Communauté.

Désignation d'amis de bibliothèques

Désignez un VI en tant qu'ami d'une bibliothèque pour permettre au VI d'appeler un membre de la bibliothèque qui est en étendue Communauté. Vous pouvez aussi désigner une autre bibliothèque comme ami d'une bibliothèque.

L'amitié n'est pas transitive. Par exemple, si la bibliothèque 1 désigne la bibliothèque 2 comme amie et que la bibliothèque 2 désigne la bibliothèque 3 comme ami, ceci n'implique pas que la bibliothèque 3 est une amie de la bibliothèque 1. La bibliothèque 3 ne peut accéder aux VIs de la bibliothèque 1 que si cette dernière désigne la bibliothèque 3 comme ami. Si une bibliothèque à étendue d'accès de communauté désigne une classe comme amie, les VIs membres de cette classe peuvent accéder aux VIs de la bibliothèque, mais cette amitié ne s'étend pas aux descendants de la classe.

Vous pouvez créer un VI en dehors de la classe LabVIEW et utiliser des VIs membres publics comme sous-VIs sur le diagramme. Les VIs membres publics permettent aux utilisateurs de manipuler les données privées de la classe. Vous pouvez utiliser des VIs membres publics ou protégés sur les diagrammes des VIs membres pour manipuler les données privées de la classe qui n'est pas exposée aux utilisateurs de la classe LabVIEW. Un VI qui se trouve en dehors de la classe peut être désigné ami de la classe, ce qui lui permet d'appeler les membres de communauté de la classe. En limitant les points d'entrée d'une classe, vous diminuez le risque d'introduire des erreurs dans les données, ce qui peut faciliter la mise au point du code.

Reportez-vous aux projets suivants comme exemples d'encapsulation et d'étendue d'accès dans les classes LabVIEW.

  • labview\examples\Object-Oriented Programming\Data Encapsulation\Data Encapsulation with LabVIEW Classes.lvproj

  • labview\examples\Object-Oriented Programming\Access Scope\Access Scope with LabVIEW Classes.lvproj

Définition de commande de données privées

LabVIEW crée automatiquement une commande de données privées pour la classe lorsque vous créez une classe LabVIEW. Dans la fenêtre suivante de l'Explorateur de projet, notez que l'icône de la classe LabVIEW est un cube de couleur. Le cube représente une classe LabVIEW. L'icône de la commande de données privées est un cube de couleur avec un cylindre vert. Le cylindre représente le stockage des données. L'icône de la commande de données privées comporte aussi un symbole de clé marron qui indique que la commande est privée.

Vous utilisez la fenêtre de l'Éditeur de commande pour personnaliser la commande de données privées d'une classe. LabVIEW affiche la fenêtre de l'Éditeur de commande lorsque vous double-cliquez sur la commande de données privées de la classe dans la fenêtre de l'Explorateur de projet. Vous pouvez déposer des commandes et des indicateurs dans le cluster de données privées de la classe pour définir le type de données privées d'une classe LabVIEW. Les valeurs par défaut que vous définissez pour les commandes dans le cluster de données privées de la classe sont les valeurs par défaut de la classe.

Remarque  Une commande de données privées ne peut pas contenir une commandeX ou un refnum de commandeX.

Dans l'exemple suivant, le type de données de la classe Véhicule contient trois numériques, Nombre de vitesses, Nombre de portes et Couleur, ainsi que deux chaînes, Marque et Modèle.

Remarque  Vous pouvez laisser le cluster de données privées de la classe vide si la classe ne requiert pas de données privées.

Vous pouvez créer des icônes qui représentent visuellement des objets de la classe sur le diagramme ou la face-avant. Cliquez sur le bouton Éditer sur la page Paramètres généraux de la boîte de dialogue Propriétés de la classe pour afficher la boîte de dialogue Éditeur d'icône. Créez une icône pour la classe que LabVIEW applique à tous les objets de la classe. Ensuite, modifiez l'icône individuelle pour chaque objet de la classe.

Création de VIs membres

Créez des VIs membres pour effectuer des opérations sur les données privées de la classe. Les VIs membres sont les méthodes de la classe LabVIEW. Les VIs membres sont membres de la classe LabVIEW dans laquelle ils sont créés ; ils apparaissent dans la fenêtre de l'Explorateur de projet sous la commande de données privées de la classe.

LabVIEW définit les données de la classe dans un cluster. Tout VI membre peut lire ou écrire des données dans le cluster des données de la classe. LabVIEW fournit un raccourci pour créer un VI permettant d'accéder aux différents éléments du cluster. Les VIs d'accès sont membres de la classe LabVIEW ; ils peuvent lire ou écrire les données de la classe. Si vous créez un VI d'accès pour lire les données de la classe, LabVIEW désassemble les données pour vous, comme l'illustre l'image suivante.

Si vous créez un VI d'accès pour écrire les données de la classe, LabVIEW intègre la nouvelle valeur aux données de la classe pour vous, comme l'illustre l'image suivante.

Vous pouvez aussi utiliser les fonctions Désassembler et Désassembler par nom pour désassembler les données privées de la classe sur le diagramme d'un VI membre. Utilisez les fonctions Assembler et Assembler par nom pour réassembler le cluster de données privées lorsque vous avez terminé d'accéder aux données et de les manipuler. Comme les données d'une classe sont privées, les nœuds Assembler et Désassembler sont brisés si vous essayez de les utiliser avec les données de classe sur le diagramme d'un VI qui n'est pas membre de la classe.

Remarque  Dans la mesure du possible, utilisez les fonctions Assembler par nom et Désassembler par nom plutôt qu'Assembler et Désassembler pour éviter de briser des VIs si vous insérez un nouvel élément dans le cluster de données privées.

Si vous écrivez un VI membre qui désassemblera une valeur, la modifiera et l'assemblera à nouveau dans l'objet, vous obtiendrez de meilleures performances en utilisant la structure Élément en place avec une paire de nœuds Assembler et Désassembler sur sa bordure. L'utilisation de cette structure garantira que LabVIEW appliquera certains mécanismes d'optimisation de la mémoire. Ces mêmes mécanismes d'optimisation de la mémoire peuvent être appliqués lorsque vous utilisez les nœuds Assembler et Désassembler normaux, mais dans certaines circonstances et avec certains VIs complexes, le compilateur de LabVIEW peut considérer ces optimisations comme présentant un risque de sécurité et éviter de les appliquer, ce qui dégradera les performances. Le nœud structure garantit la sécurité de ces optimisations, et par conséquent, les meilleures performances possibles de votre VI.

Il y a plusieurs façons de créer un VI membre. Cliquez avec le bouton droit sur la classe et sélectionnez l'un des éléments suivants dans le menu local :

  • Nouveau»VI — Ouvre un VI membre vide.
  • Nouveau»Dossier de définition de propriété — Crée un dossier de définition de propriété, dans lequel vous pouvez créer des VIs membres ou en ajouter des existants. Si une classe LabVIEW contient un dossier de définition de propriété, vous pouvez câbler la classe LabVIEW à un nœud de propriété pour accéder aux données privées.
  • Nouveau»VI à partir d'un modèle de dispatch dynamique — LabVIEW dote le nouveau VI membre de clusters d'entrée d'erreur et de sortie d'erreur, d'une structure Condition pour la gestion des erreurs, de la classe LabVIEW en entrée et de la classe LabVIEW en sortie. LabVIEW définit les terminaux d'entrée et de sortie comme dynamiques sur le connecteur du VI.
  • Nouveau»VI à partir d'un modèle de dispatch statique — LabVIEW dote le nouveau VI membre de clusters d'entrée d'erreur et de sortie d'erreur, d'une structure Condition pour la gestion des erreurs, de la classe LabVIEW en entrée et de la classe LabVIEW en sortie. Contrairement à ce qui se passe quand vous créez un VI de dispatch dynamique, LabVIEW ne définit pas les terminaux d'entrée et de sortie comme étant dynamiques sur le connecteur du VI de dispatch statique.
  • Nouveau»VI pour accéder aux membres de données — Ouvre la boîte de dialogue Créer un VI d'accès. Utilisez cette boîte de dialogue pour créer rapidement des VIs membres qui ont accès aux données de classe LabVIEW.
    Remarque  Vous devez enregistrer une nouvelle classe LabVIEW avant d'utiliser cette option. LabVIEW grise l'option VI d'accès aux membres de données si vous n'avez pas enregistré la nouvelle classe.
  • Nouveau»VI de redéfinition — Crée un VI membre qui redéfinit un VI membre ancêtre. LabVIEW utilise l'icône du VI ancêtre et superpose le masque d'icône de la classe enfant pour créer l'icône du nouveau VI.
    Remarque  LabVIEW grise l'option Nouveau»VI de redéfinition s'il n'y a pas de VI membre valide à redéfinir. Reportez-vous à la section Héritage pour obtenir des informations complémentaires sur les VIs dynamiques et la redéfinition.

Cliquez avec le bouton droit sur une constante de classe, une commande ou un indicateur sur la face-avant ou le diagramme et sélectionnez Afficher la bibliothèque de classe dans le menu local pour mettre en évidence la classe dans la fenêtre de l'Explorateur de projet. Si la classe avec laquelle vous travaillez ne se trouve pas dans un projet LabVIEW, LabVIEW ouvre une fenêtre de classe pour afficher la classe.

Héritage

L'héritage vous permet d'utiliser une classe existante comme point de départ d'une nouvelle classe. Si vous créez une nouvelle classe LabVIEW et que vous la définissez pour qu'elle hérite des données et des VIs membres d'une autre classe, la nouvelle classe peut utiliser les VIs membres publics et protégés de la classe dont elle hérite. Elle peut aussi ajouter ses propres données et VIs membres pour accroître ses fonctionnalités. Par exemple, les données privées de la classe Véhicule contiennent Nombre de vitesses, Nombre de portes, Couleur, Marque et Modèle. Si vous créez une nouvelle classe que vous appelez Camion, vous pouvez définir la classe Camion pour qu'elle hérite des données de Véhicule et lui ajouter les données booléennes Benne ? et Quatre roues motrices ?. Toutefois, comme le montre la figure suivante, quand vous assemblez ou désassemblez une classe LabVIEW, les nœuds n'affichent que les terminaux des données privées de la classe actuelle ; ils n'affichent pas de terminal pour les données héritées des classes ancêtres.

Les données d'une classe ancêtre sont privées ; vous pouvez les modifier en utilisant les fonctions fournies par la classe ancêtre par le biais des VIs membres. Les VIs membres des classes descendantes peuvent appeler n'importe quel VI membre public, tout comme les autres VIs de LabVIEW. Cependant, les VIs membres d'une classe descendante peuvent aussi appeler les VIs membres protégés d'une classe ancêtre. Lorsque vous définissez un VI membre d'une classe ancêtre comme protégé, les VIs membres des classes enfants peuvent appeler la méthode, mais les VIs qui ne se trouvent pas dans la hiérarchie d'héritage ne le peuvent pas. Pour accéder à Nombre de vitesses de la classe Véhicule dans la classe Camion, vous pouvez créer un VI membre public ou protégé dans la classe Véhicule et l'appeler Obtenir les vitesses.vi. Vous pouvez désassembler la classe Véhicule sur le diagramme de Obtenir les vitesses.vi pour avoir accès à Nombre de vitesses. Vous pouvez alors assigner Nombre de vitesses à un terminal de sortie du connecteur, ce qui vous permettra d'accéder à des données privées spécifiques à la classe Véhicule dans une classe descendante, comme la classe Camion.

Vous pouvez aussi accéder à Nombre de vitesses en créant un VI membre permettant d'accéder aux membres de données dans la classe Véhicule. Lorsque vous créez le VI membre, sélectionnez l'option Rendre disponible via les nœuds de propriété dans la boîte de dialogue Créer un VI d'accès. Vous pouvez alors câbler la classe Camion à un nœud de propriété, cliquer avec le bouton droit sur le terminal de propriété et sélectionner Sélectionner une propriété»Nombre de vitesses.

Remarque  Les classes LabVIEW ne peuvent pas appeler les VIs membres privés d'une autre classe LabVIEW, y compris la classe parente. Vous ne pouvez utiliser les VIs membres privés que sur les diagrammes des autres VIs membres de la même classe.
Remarque   (Module FPGA) Vous pouvez utiliser un héritage avec certaines restrictions lors de la création de VIs FPGA.

Objet LabVIEW

L'expression Objet LabVIEW est le nom d'une classe spécifique. Objet LabVIEW est l'ancêtre racine de l'arborescence d'héritage dans programmation orientée objet sous LabVIEW. Par défaut, toutes les classes LabVIEW héritent de l'objet LabVIEW. Vous pouvez utiliser l'objet LabVIEW pour créer des VIs capables d'effectuer des opérations génériques sur plusieurs classes LabVIEW. Par exemple, si vous créez un tableau de classes LabVIEW, les données du tableau sont hétérogènes car le tableau contient des éléments du type de classe du tableau ou des classes descendantes. Si le type d'un tableau est Objet LabVIEW, le tableau peut comporter Véhicule, Camion et Boule de bowling. La classe Boule de bowling n'hérite ni de la classe Véhicule ni de la classe Camion ; LabVIEW crée un tableau de la classe de base ancêtre commune qui correspond, dans ce cas, à Objet LabVIEW.

L'illustration suivante montre Tableau de véhicules, un tableau qui contient la classe Véhicule et la classe Camion. Comme la classe Camion hérite de Véhicule, la classe de base ancêtre commune de ce tableau est du type Véhicule. L'illustration montre aussi Tableau d'objets LabVIEW qui contient les classes Objet LabVIEW, Véhicule, Camion et Boule de bowling. Boule de bowling n'hérite ni de Véhicule ni de Camion, mais ces trois classes héritent d'Objet LabVIEW. Par conséquent, Tableau d'objets LabVIEW est du type Objet LabVIEW.

Définition de l'héritage

Par défaut, toutes les classes LabVIEW héritent de l'Objet LabVIEW. Si vous voulez modifier de quelle classe une classe hérite, vous devez modifier l'héritage après avoir créé les classes concernées. Vous pouvez configurer l'héritage et les autres options de la classe dans la boîte de dialogue Propriétés de la classe. Vous pouvez afficher la hiérarchie de classes LabVIEW dans la fenêtre Hiérarchie de classes LabVIEW. La hiérarchie d'héritage de classes peut comporter les types de classes suivants.

  • Classe parente — Classe LabVIEW dont les autres classes LabVIEW héritent les données et les VIs membres publics et protégés.
  • Classe enfant — Classe LabVIEW qui hérite des VIs membres publics et protégés de la classe parente. La classe enfant n'hérite pas de données privées à moins que la classe parent fournisse un VI d'accès.
  • Classe sœur — Classe LabVIEW qui a la même classe parente qu'une autre classe LabVIEW.
  • Classe ancêtre — Classe LabVIEW qui est la classe parente, grand-parent, arrière-grand-parent, et ainsi de suite, d'une classe LabVIEW. Objet LabVIEW est l'ancêtre racine de toutes les classes LabVIEW.
  • Classe descendante — Classe LabVIEW qui est la classe enfant, petit-enfant, arrière-petit-enfant, et ainsi de suite, d'une classe LabVIEW.

Apparence du fil de liaison

Les classes définissent de nouveaux types de données. Sur le diagramme, les fils de liaison de ces types de classes ont l'apparence du fil de liaison par défaut de LabVIEW ou héritent de l'apparence du fil de liaison de la classe parente. Vous pouvez changer l'apparence du fil de liaison d'une classe LabVIEW dans la boîte de dialogue Propriétés de la classe. Pour créer un diagramme facile à interpréter, vous pouvez modifier l'apparence du fil de liaison de différentes classes LabVIEW lorsque c'est justifié. Le diagramme devient plus difficile à comprendre s'il y a trop de couleurs et de modèles de fils de liaison. L'illustration suivante présente l'apparence des fils de liaison fournis avec LabVIEW à gauche, et des possibilités de fils de liaison personnalisés à droite.

Reportez-vous aux astuces de la Liste de vérification de style LabVIEW pour éviter de créer des modèles et des couleurs trop chargés dans LabVIEW.

VIs membres de dispatch dynamique et statique

Une méthode est une opération pouvant être réalisée sur ou par un objet. Dans la programmation orientée objet LabVIEW, les méthodes sont des VIs membres que vous créez. Les VIs membres effectuent une opération sur les données de la classe LabVIEW. Vous pouvez définir certaines méthodes avec un VI unique. Ces méthodes sont appelées méthodes de dispatch statique car LabVIEW appelle le même VI à chaque fois. Vous pouvez aussi définir des méthodes avec plusieurs VIs du même nom dans toute la hiérarchie de classes. Ces méthodes sont appelées méthodes de dispatch dynamique car ce n'est qu'à l'exécution que l'on sait quel ensemble de VIs est appelé par LabVIEW. Les méthodes de dispatch dynamique sont similaires aux VIs polymorphes. Alors que les VIs polymorphes déterminent quel VI appeler en fonction du type de données câblé, les méthodes de dispatch dynamique attendent l'exécution pour déterminer quel VI membre de la hiérarchie de classes appeler en fonction des données qui parviennent au terminal d'entrée.

Vous définissez un VI membre comme statique ou dynamique dans son connecteur. Si le connecteur comporte un terminal d'entrée de dispatch dynamique, le VI membre fait partie d'une méthode de dispatch dynamique. S'il n'y a pas de terminal d'entrée de dispatch dynamique, le VI membre définit une méthode de dispatch statique.

Si une classe LabVIEW hérite d'une autre classe LabVIEW, la classe enfant hérite de toutes les méthodes publiques et protégées définies pour la classe parente. En donnant à un VI membre d'une classe enfant le même nom qu'à un VI membre de la classe parente, vous définissez l'implémentation de la méthode pour l'enfant.

LabVIEW définit les méthodes de dispatch statiques par un seul VI ; ne renommez donc pas un VI membre d'une classe enfant avec le nom d'un VI membre de dispatch statique de la classe ancêtre. Par exemple, si la classe parente Véhicule comporte un VI membre de dispatch statique, le VI Ouvrir une porte, la classe enfant Camion ne peut pas avoir un VI membre appelé Ouvrir une porte. Le VI de méthode Ouvrir une porte est déjà défini sur la classe Camion car elle hérite du VI membre de la classe Véhicule. Si vous placez des VIs membres de dispatch statiques sur le diagramme d'un sous-VI, ils se comportent en tous points comme un appel à un sous-VI standard.

Vous pouvez définir plusieurs VIs de dispatch dynamique pour une méthode, un par niveau de hiérarchie d'héritage. Si un VI de dispatch dynamique est défini comme parent d'une classe et aussi comme enfant dans la classe, alors l'implémentation de la classe enfant écrase ou étend l'implémentation de la classe parent. Dans l'exemple suivant, la classe Véhicule et la classe Camion définissent toutes deux une implémentation de la méthode de dispatch dynamique Définir la marque.vi. Si vous placez un VI de dispatch dynamique sur le diagramme en tant que sous-VI, le nœud sur le diagramme se comporte exactement comme un appel de sous-VI standard lorsque LabVIEW est en mode Édition. Cependant, si vous exécutez le VI, les données qui arrivent au terminal d'entrée de dispatch dynamique déterminent quel VI membre dynamique de la hiérarchie de classes est appelé par LabVIEW. Comme le fil de liaison d'une classe LabVIEW peut transmettre des données de son propre type ou du type d'une classe enfant, le nœud exécute l'implémentation du VI de dispatch dynamique que vous définissez pour les données de la classe. Examinez de nouveau l'exemple suivant. Seule l'implémentation du VI Définir la marque de la classe Véhicule se trouve sur le diagramme du VI principal. À la première itération de la boucle, LabVIEW exécute l'implémentation du VI Définir la marque de la classe Véhicule car les données de la classe Véhicule sont sur le fil de liaison de la classe. À la deuxième itération de la boucle, LabVIEW exécute l'implémentation du VI Définir la marque de la classe Camion car les données de la classe Camion sont sur le fil de liaison de la classe.

Si la classe parente définit un VI de dispatch dynamique mais ne fournit pas d'implémentation de ce VI, chaque classe enfant doit redéfinir le VI parent. Dans de nombreux cas, il vous est possible de fournir tout comportement significatif dans le VI de la classe parente. Supposons par exemple que la classe Forme définit le VI Aire. Le VI Aire renvoie l'aire de la forme dans l'objet Forme. Il n'existe pas de formule unique pour calculer l'aire de toutes les formes ou même de la plupart des formes. Par conséquent, chaque classe descendante doit redéfinir le VI Aire par la formule qui correspond à sa forme. Donc, si vous créez une classe enfant Cercle, la classe Cercle doit fournir un VI Aire qui calcule pi * rayon * rayon.

Si vous ne définissez pas d'implémentation du VI de la classe parente, alors de VI parent n'est qu'une définition du connecteur et des propriétés de VI auxquelles tous les VIs de redéfinition doivent correspondre. Chaque classe enfant doit fournir un VI de redéfinition. Pour être sûr que LabVIEW applique cette condition, vous pouvez désigner le VI dans la classe parent comme un VI que chaque classe enfant doit redéfinir et laisser LabVIEW appliquer cette condition.

Il se peut que certaines classes enfant ne soient pas en mesure de redéfinir la fonctionnalité du VI membre. Par exemple, si la classe Quadrilatère est un enfant de la classe Forme, vous ne pouvez pas fournir la formule correcte pour calculer l'aire à moins que vous ne sachiez précisément de quel type de quadrilatère il s'agit. Pour éviter la création d'une implémentation vide du VI Aire dans la classe Quadrilatère, vous pouvez indiquer à la classe Quadrilatère qu'il faut transférer la condition de redéfinition à ses propres classes enfants. Pour cela, cliquez avec le bouton droit sur la classe enfant et sélectionnez Propriétés dans le menu local pour afficher la boîte de dialogue Propriétés de la classe. Sur la page Héritage, cochez l'option Transférer toutes les spécifications de redéfinition aux classes descendantes. LabVIEW requiert ensuite que les classes enfants de la classe Quadrilatère, comme Trapèze ou Rectangle, redéfinissent le VI Aire.

Requérir que les classes descendantes redéfinissent un VI membre d'une classe n'a pas d'effet sur la façon dont le VI membre s'exécute.

Remarque  Les LLBs ne peuvent pas comporter plusieurs fichiers du même nom. Par conséquent, si vous avez des VIs membres dynamiques du même nom dans une hiérarchie de classes, vous ne pouvez pas mettre ces classes dans la même LLB.

Remarque  Quand le VI d'une classe enfant redéfinit le VI d'une classe parent, le VI de la classe enfant doit correspondre au VI de la classe parent en ce qui concerne les paramètres de réentrance, les paramètres d'exécution privilégiée, les paramètres de priorité, le terminal du connecteur, le modèle de connecteur et l'étendue d'accès.

Double-cliquez sur un sous-VI de dispatch dynamique qui se trouve sur le diagramme pour afficher la boîte de dialogue Choisir une implémentation. Vous pouvez utiliser cette boîte de dialogue pour afficher toutes les implémentations d'un sous-VI de dispatch dynamique qui se trouvent actuellement en mémoire puis ouvrir une ou plusieurs implémentations du sous-VI.

Si vous créez un VI qui écrase l'implémentation ancêtre d'un VI membre de dispatch dynamique en sélectionnant Nouveau»VI de redéfinition, vous créez un autre VI membre de dispatch dynamique, car les VIs qui écrasent un VI membre ancêtre ont le même nom que l'ancêtre et sont aussi dotés de terminaux de dispatch dynamique. LabVIEW place un nœud Appeler la méthode parente sur le diagramme avec les terminaux de classe d'entrée et sortie de dispatch dynamique appropriés et les autres terminaux que le VI doit avoir pour correspondre au VI ancêtre. LabVIEW désactive l'option VI de redéfinition s'il n'y a pas de VI membre ancêtre à redéfinir.

Remarque   (Module FPGA) Vous pouvez utiliser le dispatch dynamique avec certaines restrictions lors de la création de VIs FPGA.

Sorties de dispatch dynamique

Vous pouvez définir un terminal de sortie de classe LabVIEW comme étant dynamique en cliquant avec le bouton droit sur le terminal de sortie sur le connecteur et en sélectionnant Sortie de dispatch dynamique (recommandée). Lorsque vous appelez un VI doté d'un terminal de sortie de dispatch dynamique comme sous-VI, le terminal de sortie de dispatch dynamique adopte le type de données du fil de liaison connecté au terminal d'entrée de dispatch dynamique. Par exemple, si vous connectez un fil de liaison de classe Véhicule à un terminal d'entrée de dispatch dynamique, la sortie du VI membre est du même type que l'entrée ; dans ce cas-ci, la sortie est la classe Véhicule. Vous pouvez modifier les données entre le terminal d'entrée de dispatch dynamique et le terminal de sortie de dispatch dynamique. Cependant, pour assurer la sécurité des classes LabVIEW à l'exécution, les données du terminal d'entrée de dispatch dynamique doivent arriver à tous les terminaux de sortie de dispatch dynamique. De plus, pour que LabVIEW ne lise le terminal d'entrée de dispatch dynamique qu'une seule fois et n'écrive à un terminal de sortie de dispatch dynamique qu'une seule fois, vous ne pouvez pas placer les terminaux de dispatch dynamique du diagramme dans une structure.

Remarque  Si vous mettez au point un VI membre de dispatch dynamique doté d'entrées et de sorties de dispatch dynamique, vous pouvez rechercher les erreurs sur le fil de liaison qui connecte l'entrée de dispatch dynamique à la sortie de dispatch dynamique. Au lieu d'être blanc, l'arrière-plan du fil de liaison est gris si le fil provient d'une entrée dynamique et qu'il ne passe par aucune fonction susceptible de changer le type de données à l'exécution. L'arrière-plan du fil de liaison devient rouge si le fil passe par une fonction susceptible de changer le type de données. Pour que les sorties dynamiques fonctionnent correctement, vous ne pouvez pas changer le type de données d'une classe LabVIEW.

Certaines opérations modifient le type de données de la classe LabVIEW en entrée et renvoie un type différent en sortie. Si vous voulez effectuer une opération de ce genre sur le diagramme d'un VI membre, assurez-vous que le terminal de sortie dynamique de la classe LabVIEW sur le connecteur est défini à Recommandée plutôt qu'à Sortie de dispatch dynamique (recommandée). Par exemple, si l'entrée de classe LabVIEW est Véhicule et que vous obtiendrez la classe LabVIEW Camion en sortie, vous devriez modifier le terminal par défaut de classe LabVIEW sur le connecteur. Sinon, vous pouvez aussi créer le VI membre à partir d'un VI vide, ce qui vous permet de définir manuellement les terminaux du connecteur.

Remarque  Si vous utilisez une structure Condition ou Événement dans un VI membre doté d'entrées et de sorties de dispatch dynamique, vous ne pouvez pas sélectionner Utiliser la valeur par défaut si non câblé sur les tunnels de sortie. Si vous utilisez l'option Utiliser la valeur par défaut si non câblé sur le tunnel de sortie, le VI est brisé. Vous devez câbler toutes les conditions de la structure. Vous pouvez configurer les tunnels pour que les tunnels d'entrée et de sortie soient câblés automatiquement.

Optimisation des copies de mémoire pour le dispatch dynamique

Comme il a déjà été mentionné plus tôt, lorsque vous créez des méthodes de dispatch dynamiques, chaque classe enfant hérite de toutes les méthodes publiques et protégées définies dans la classe parente. La classe enfant peut redéfinir, ou étendre, ces VIs membres avec leur propre version. Cependant, si un VI appelle une méthode de dispatch dynamique, LabVIEW ne sait pas avant l'exécution quelle version de la méthode sera invoquée. Il optimise donc les allocations de mémoire du VI appelant en présumant que tout VI membre qui se trouve dans une classe enfant sera configuré de la même façon que le VI membre de la classe parente. Si les entrées sont des constantes dans le VI parent, le VI appelant suppose que ce sont des constantes dans tous les VIs enfants. Si les entrées sont renvoyées comme sorties dans le VI membre de la classe parente, le VI appelant suppose que c'est aussi le cas dans tous les VIs membres de la classe enfant.

Si une de ces suppositions est fausse, l'optimisation est perdue. Par exemple, vous pouvez créer un VI membre qui contient des entrées qui ne sont pas modifiées ; le VI appelant supposera qu'aucune de ces entrées ne sera modifiée dans le futur, même si toutes les implémentations de redéfinition ont la possibilité de modifier ces entrées. En outre, si vous ne câblez aucune des entrées à sa sortie sur le VI membre de la classe parente, le VI appelant suppose qu'aucune des sorties ne partage de mémoire avec les entrées, même si les VIs membres qui suivent peuvent câbler les entrées aux sorties. LabVIEW doit créer du code pour gérer le comportement inattendu des classes enfants, ce qui conduit à une optimisation inefficace.

Pour une meilleure optimisation, vous pouvez écrire le VI de la classe parente de manière à ce qu'il corresponde à ce qui doit se produire dans les VIs de la classe enfant. Un moyen de créer une méthode de dispatch dynamique de façon à indiquer clairement le comportement attendu de chaque terminal est d'utiliser la structure Élément en place. Placez la structure Élément en place dans le VI de dispatch dynamique de la classe parente et ajoutez des paires de nœuds Élément en place à la structure Élément en place. Avec ces paires de nœuds, vous pouvez indiquer à LabVIEW quelles entrées devraient être connectées à quelles sorties, quelles entrées devraient être traitées comme des constantes et quelles entrées devraient être traitées comme étant modifiées. LabVIEW est alors capable d'utiliser le VI appelant.

Reportez-vous aux projets suivants comme exemples d'utilisation de terminaux de dispatch dynamique.

  • labview\examples\Object-Oriented Programming\Dynamic Dispatching\Dynamic Dispatching.lvproj

  • labview\examples\Object-Oriented Programming\Dynamic Terminals\Dynamic Terminals.lvproj

CET ARTICLE VOUS A-T-IL ÉTÉ UTILE ?

Pas utile