Discussion :

[hellalaboy]

bonjour
je n ai pas compris la signification du point d'exclamation dans le code suivant:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
Set rs = cn.OpenSchema(adSchemaColumns)
    While Not rs.EOF
        If rs!table_name = listbox1.Text Then
            Champs.AddItem rs!COLUMN_NAME
        End If
        rs.MoveNext
    Wend
    rs.Close

merci

[=JBO=]

Bonjour hellalaboy,

Le caractère "!" est un "opérateur d'accès spécial".
C'est un raccourci syntaxique pour accéder à un élément au sein d'une hiérarchie de classes.
Cet opérateur d'accès utilise les propriétés par défaut des classes.

Dans ton cas, la racine est rs un objet instance de la classe Recordset.

La propriété par défaut de la classe Recordset est Get Fields() qui retourne un objet instance de la classe Fields.

Un objet Fields recense une collection d'objets instances de la classe Field, et qu'il peut désigner au moyen de 2 index:
* un index numérique qui représente la position de l'objet Field dans la collection;
* un index textuel pour désigner un objet Field au moyen d'un "nom" (une clé textuelle).

La propriété par défaut de la classe Fields est Get Item(vIndex As Variant) qui retourne un objet appartenant à la collection, désigné par une valeur d'index.

Tu n'es pas obligé d'utiliser l'opérateur d'accès "!".
A la place, on peut employer la syntaxe complète équivalente qui serait celle-ci:

Code VBA :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
    Set rs = cn.OpenSchema(adSchemaColumns)
 
    While Not rs.EOF
        If rs.Fields.Item("table_name").Value = listbox1.Text Then
            Champs.AddItem rs.Fields.Item("COLUMN_NAME").Value
        End If
        rs.MoveNext
    Wend
    rs.Close

Le fonctionnement de l'opérateur d'accès "!" est générique et s'appuie sur les propriétés par défaut (et pas sur les noms des propriétés).
Le développement "en interne" de l'expression:

Code texte :

Sélectionner tout - Visualiser dans une fenêtre à part

<objet racine>!<valeur d'index>

donnerait ceci:

Code texte :

Sélectionner tout - Visualiser dans une fenêtre à part

<objet racine>.<propriété par défaut de la racine>.<propriété par défaut de la classe "collection">("<valeur d'index>")

Il est donc possible à un développeur VB/VBA de concevoir sa propre hiérarchie de classes compatible avec l'emploi de "!".
_

[=JBO=]

Bonjour,

En fait l'opérateur d'accès aux membres "!" n'est pas documenté dans mes vieilles versions de VB6 ou VBA !?

Mais j'ai trouvé une info sur MSDN.
Voici un lien vers le site MSDN qui donne des explications plus précises:
Visual Basic: caractères spéciaux dans le code


Une information pour les curieux !

En effectuant des tests, je me suis rendu compte que l'opérateur d'accès aux membres "!" est très puissant...
Il peut parcourir par itération toute une hiérarchie de classes, d'une profondeur quelconque (!!!), pour s'arrêter seulement quand il accède à une propriété Get par défaut qui accepte un paramètre de type String.

Saviez-vous que cet opérateur était aussi puissant ???

[EDIT]

BONUS !

Et ce qui est vrai pour "!" l'est aussi pour l'utilisation des parenthèses !
En effet, l'expression <objet racine>(chaîne clé d'index) est aussi évaluée avec parcours itératif de toute une hiérarchie de classes jusqu'à atteindre la propriété par défaut qui convient !

En conclusion:
__ rs("table_name")
aussi fort que
__ rs!table_name
tout deux équivalents à
__ rs.Fields.Item("table_name")

[/EDIT]
_

[Jean-Philippe André]

salut,
et un pavé dans la mare :
l'accès lié au "!" est-il aussi plus rapide ?

[=JBO=]

Salut jpcheck !

et un pavé dans la mare :
l'accès lié au "!" est-il aussi plus rapide ?

Avant de te répondre, je fais un commentaire sur les informations données par Microsoft dans le lien que j'ai donné précédemment:

Remarque

Les références aux collections par défaut doivent être explicites.
En particulier, vous ne pouvez pas utiliser l'opérateur ! dans une variable à liaison tardive.

Cette remarque est peut être vraie pour les versions .NET de Visual Basic, mais elle ne s'applique pas pour VBA et VB6.

En effet, le code ci-dessous s'exécute parfaitement (on suppose une exécution avec Access, dans une BD qui contient une table nommée T_Table avec un champ nommé Id):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
    Dim o As Object
 
    Set o = CurrentDb.OpenRecordset("T_Table")
 
    Debug.Print o!Id

Il s'agit d'une liaison tardive... et les propriétés par défaut sont "découvertes" au moment de l'exécution !

Donc (maintenant je peux te répondre ) l'utilisation de l'opérateur "!" est plus lente, comparée à une expression complète qui énumère les propriétés utilisées.

Mais son intérêt réside d'abord dans la généricité et l'universalité de son emploi, notamment grâce à la liaison tardive.
_

[chris92]

L'utilisation des ces raccourcis sous VB6 et VBA:
! au debut pour .fields (!nomChamp),
$ pour le type string etc (var$)

est absolument a proscrire.
ca fait gagner 2 millisecondes et quelques caractères a l'écriture...

Par contre ca fait perdre deux heures au pauvre type qui doit reprendre le code.... Bref, au point de vue maintenance c'est une horreur !

[Tofalu]

Par contre ca fait perdre deux heures au pauvre type qui doit reprendre le code.... Bref, au point de vue maintenance c'est une horreur !

Hmm ... faut quand même espérer qu'un developpeur VB est quand même capable de comprendre la syntaxe ! et les autres $ ... Partant du constat que le développeur connait son domaine, je ne vois pas en quoi cela devrait être évité.