XL 2016 Depuis un Module Standard pouvoir Récupérer la Photocopie d'une Classe (dont/Avec) la collection qui est incluse dans le Module de Classe.

laurent950

XLDnaute Barbatruc
Bonjour Le Forum,

J'ai réalisé un Module de classe (CPays) avec une Variable de Type Collection (Coll) qui inclut dans le Module de classe.

Le Principe avec une boucle For je viens Créer une nouvelle instance à chaque itération
de l'objet Pays, dont je me sers pour remplir cette classe.

Je souhaite une fois cette classe remplie consigner cette classe dans la collection qui elle est incluse dans le module de classe.

Par la suite je souhaite appeler cette collection depuis le module standard, car cette collection se trouve dans le module de classe, avec un code pour y retrouver la photocopie de la classe correspondante a ce qui a était précédemment enregistré et remplis !

J'ai réalisé la macro, mais cela ne fonctionne pas.

En Exemple :
j'ai écrit le code, dans la zone de texte sur la Feuil à côté du tableau structurée.
la collection se situe dans le module standard, et cela me renvois les bon résultat.
je souhaite l'inverse la collection dans le module de classe et aucune collection dans le module standard.

Je poste le code qui ne fonctionne pas ci-dessous avec le fichier joint.

Si vous avez l'explication et même la solution je vous remercie car je ne trouve pas la solution après plusieurs recherches ?

Module Standard : Ci-Dessous

VB:
Sub CollectionDansModuleDeClasse()

Dim data As Variant ' ............................................................. 1)
data = Sheets("Collections").ListObjects(1).DataBodyRange.Value2 ' ................ 1)
Dim i As Long ' ................................................................... 1)

Dim PaysGlobal As New ClsPays ' ................................................... 2)

Dim Pays As ClsPays ' ............................................................. 3)

For i = 1 To UBound(data, 1) ' .................................................... 1)
    Set Pays = PaysGlobal.Item(data(i, 1))
    Set Pays = Pays
    Pays.Code = data(i, 1) ' ...................................................... 4)
    Pays.Nom = data(i, 2) ' ....................................................... 4)
    Pays.Capitale = data(i, 3) ' .................................................. 4)
Next i

For i = 1 To UBound(data, 1)
    Set Pays = Pays.TransferCollection(data(i, 1)) ' .............................. Bloque) Un seule Item est remplis avec mauvais code !
        Debug.Print Pays.Code, Pays.Nom, Pays.Capitale
Next i
End Sub

Module De Classe(ClsPays) : Ci-Dessous

Code:
Private mCode As String
Private mNom As String
Private mCapitale As String
Private mCLn As Collection
'
Property Get Code() As String
    Code = mCode
End Property
Property Let Code(ByVal NewValue As String)
    mCode = NewValue
End Property
'
Property Get Nom() As String
    Nom = mNom
End Property
Property Let Nom(ByVal NewValue As String)
    mNom = NewValue
End Property
'
Property Get Capitale() As String
    Capitale = mCapitale
End Property
Property Let Capitale(ByVal NewValue As String)
    mCapitale = NewValue
End Property
'
Property Get PhtosCopieClassWithKey() As String
    Capitale = mCapitale
End Property
'
Public Function TransferCollection(ByVal NewValue As String) As ClsPays
   Set TransferCollection = mCLn(NewValue)
End Function
Private Sub Class_Initialize()
   Set mCLn = New Collection
   End Sub
Public Function Item(ByVal NewValue As String) As ClsPays
   On Error Resume Next
   Set Item = mCLn(NewValue)
   If Err Then
      Set Item = New ClsPays
      Set Item = Me
      mCLn.Add Item, NewValue
   End If
   End Function
 

Pièces jointes

  • Test Module de classe Inclus Object Collection.xlsm
    31.7 KB · Affichages: 6
Dernière édition:

Dranreb

XLDnaute Barbatruc
Bonsoir.
Par rapport à une Property Let, une procédure Property Set ou Let doit être munie d'un faux paramètre formel supplémentaire souvent nommé RHS (Right Hand Side) qui représente l'expression à droite du signe égal de l'affectation.
Une telle procédure ne permet en général d'affecter qu'une seule propriété. Cependant si elle est utilisée en dehors d'une classe et s'il est convenu que l'expression traitée est un tableau, une Property Let peut en dispatcher le contenu vers plusieurs variable, à l'inverse de la fonction Array qui en rassemble plusieurs dans un tableau.
 

laurent950

XLDnaute Barbatruc
Bonsoir @Dranreb

Voilà ce que j'ai compris ? je pense 50%

Par rapport à une Property Let, une procédure Property Set ou Let doit être munie d'un faux paramètre formel supplémentaire souvent nommé RHS (Right Hand Side) qui représente l'expression à droite du signe égal de l'affectation.

dim a as Variant
dim b as Variant
dim c as Variant
dim c as Variant

Depuis le module standard vers le module de classe

dim Cls as ClasseExemple
set Cls = New ClasseExemple
Demo : depuis le module standard
Cls.Demo(a, b, c) = d
' Lecture depuis le module de classe avec Get
MsgBox Cls.Demo1
MsgBox Cls.Demo2
MsgBox Cls.Demo3
MsgBox Cls.Demo4
1697485315398.png

Private Val_a as Variant
Private Val_b as Variant
Private Val_c as Variant
Private Val_d as Variant

Property Let Demo(w, x, y, z)
Val_a = w
Val_b = x
Val_c = y
Val_d = z
End Property
Une telle procédure ne permet en général d'affecter qu'une seule propriété
C'est a dire une variable Let Ou Set (Pour un seule renvois avec Get) strictement du même Type

J'imagine que pour renvoyé a, b, c, d
il faut 4 Get (avec des noms différents de Demo

Cela ne peut pas fonctionner :
Property Get Demo() As Variant
Demo = Val_a
End Property

'
Property Get Demo() As Variant
Demo = Val_B
End Property


comme : ca fonctionne ici
Property Get Demo1() As Variant
Demo1 = Val_a
End Property

'
Property Get Demo2() As Variant
Demo2 = Val_b
End Property

'
Property Get Demo3() As Variant
Demo3 = Val_c
End Property

'
Property Get Demo4() As Variant
Demo4 = Val_d
End Property


Cependant si elle est utilisée en dehors d'une classe et s'il est convenu que l'expression traitée est un tableau, une Property Let peut en dispatcher le contenu vers plusieurs variable, à l'inverse de la fonction Array qui en rassemble plusieurs dans un tableau.
Par contre ici je ne vois pas ? Cependant si elle est utilisée en dehors d'une classe ?? (Property Let) ?
 
Dernière édition:

Dranreb

XLDnaute Barbatruc
Dans cet exemple, la Property Get Étalage renvoie la même chose que la fonction Array. Mais contrairement à celle ci, elle peut aussi fonctionner à l'envers !
VB:
Option Explicit
Sub test()
   Dim a, b, c
   Étalage(a, b, c) = Étalage("A", "B", "C")
   MsgBox "a = """ & a & """, b = """ & b & """, c = """ & c & """"
   End Sub
Property Let Étalage(ParamArray Éléments() As Variant, ByVal VArray As Variant)
   Dim N As Integer: For N = 0 To UBound(Éléments): Éléments(N) = VArray(N): Next N
   End Property
Property Get Étalage(ParamArray Éléments() As Variant)
   Étalage = Éléments
   End Property
 

laurent950

XLDnaute Barbatruc
Bonsoir @Dranreb

J'ai essayer de traduire mais je pense que je suis dans le vrai a 70%

Dans cet exemple, la Property Get Étalage renvoie la même chose que la fonction Array. Mais contrairement à celle ci, elle peut aussi fonctionner à l'envers !
VB:
Option Explicit
Sub test()
Dim a, b, c
Étalage(a, b, c) = Étalage("A", "B", "C")
MsgBox "a = """ & a & """, b = """ & b & """, c = """ & c & """"
End Sub
Property Let Étalage(ParamArray Éléments() As Variant, ByVal VArray As Variant)
Dim N As Integer: For N = 0 To UBound(Éléments): Éléments(N) = VArray(N): Next N
End Property
Property Get Étalage(ParamArray Éléments() As Variant)
Étalage = Éléments
  1. La procédure "test" est la procédure principale du code. Elle déclare trois variables, a, b et c.
  2. La ligne Étalage(a, b, c) = Étalage("A", "B", "C") est un peu complexe. En réalité, "Étalage" est une fonction avec "Property Get" (Propriété de lecture). Dans cette ligne, "Étalage("A", "B", "C")" est passé en tant que tableau de Variant à la propriété "Étalage" grâce à la syntaxe de Property Get. Ces valeurs sont stockées dans le tableau spécial "ParamArray Éléments()" qui contient les valeurs "A", "B" et "C" en tant que chaînes de caractères.
  3. Tout d'abord, l'exécution commence par "Property Get" car il y a un appel à "Étalage" avec des paramètres. Cela signifie que les valeurs "A", "B" et "C" sont extraites dans "ParamArray Éléments()" dans l'ordre.
  4. Ensuite, la procédure "Property Let Étalage" est exécutée. Cette procédure permet de définir de nouvelles valeurs pour les éléments du tableau "Étalage" en utilisant "ParamArray Éléments()" comme paramètres. La boucle "For" parcourt le tableau "Éléments" et les remplace par les éléments correspondants du tableau "VArray".
  5. La ligne Étalage(a, b, c) = Étalage("A", "B", "C") a donc pour effet de remplir les variables a, b et c avec les valeurs "A", "B" et "C" en utilisant la procédure "Property Let Étalage."
  6. Enfin, la boîte de message MsgBox affiche les valeurs de a, b et c.
  7. Les propriétés "Property Get" et "Property Let" d'Étalage sont utilisées pour stocker et accéder à un tableau de Variant qui peut être modifié avec "Property Let" et consulté avec "Property Get."
Le code utilise les fonctionnalités VBA pour lire et écrire des valeurs dans le tableau "Étalage" à travers les propriétés "Get" et "Let," respectivement, en utilisant la technique du "ParamArray" pour transmettre les valeurs. C'est en effet un peu complexe, mais c'est la manière dont le code est structuré pour fonctionner.
Mais contrairement à celle ci, elle peut aussi fonctionner à l'envers !
Je sais pas ce que cela veux dire à l'envers ?
 

Dranreb

XLDnaute Barbatruc
Ben à l'envers c'est avec les transferts de données en sens inverse: depuis les éléments du tableau vers les variables au lieu du seul sens permis par la fonction Array qui est depuis les expression spécifiées vers un tableau ainsi constitué. Les variables sont initialisées de telle sorte qu'on retrouverait le tableau initial si on l'utilisait avec les mêmes variables à droite d'un signe = d'affectation
 
Dernière édition:

patricktoulon

XLDnaute Barbatruc
re
bonsoir après m'être maté un bon film
pour en revenir à la classe dictionnaire
comme je disais a @RyuAutodidacte il n'y a pas besoins d'une usine a gaz
pardonnez moi j'ai fait en en 5 minutes ,c'est largement perfectible

pour le coup je montre même un exemple comportement identique a l'object scripting dictionary
quand on essaie de mettre un doublons
les fonctions accessibles sont
  1. Add
  2. items
  3. keys
le module classe nommé "dictionary"
VB:
Public col As Collection
Public col2 As Collection
Public count As Long
Public Function Add(clé, item)
    If col Is Nothing Then
        Set Me.col = New Collection
        Set Me.col2 = New Collection
    End If
    On Error Resume Next
    Me.col.Add item, clé: Me.col2.Add clé, item

    If Err.Number > 0 Then
        Me.col2.Remove (Me.col(clé)): Me.col.Remove clé
        Me.col.Add item, clé: Me.col2.Add clé, item
        On Error GoTo 0
    End If
    Me.count = Me.col.count
End Function

Public Function key(clé): key = Me.col(clé): End Function

Public Function item(it): item = Me.col2(it): End Function

Public Function Keys()
    ReDim t(1 To Me.col.count): For i = 1 To UBound(t): t(i) = Me.col2(i): Next: Keys = t
End Function
Public Function items()
    ReDim t(1 To Me.col.count): For i = 1 To UBound(t): t(i) = Me.col(i): Next: items = t
End Function

dans un module standard
VB:
Dim dico As dictionary

Sub test()
Set dico = New dictionary

'même principe que le dictionaire ;  (dico .Add "clé","item")
dico.Add "toto", "tartata"
dico.Add "titi", "turlututu"
'pour tester j'essaie de mettre un doublon avec un item différent mais une clé existante
dico.Add "toto", "darladididadada"

MsgBox dico.count
MsgBox dico.key("toto") 'la valeur de l'item de "toto" a bien changé(c'est le même comportement que le dico
MsgBox dico.item("turlututu")

MsgBox Join(dico.Keys, vbCrLf)
MsgBox Join(dico.items, vbCrLf)

End Sub
 

Dranreb

XLDnaute Barbatruc
Mais il n'y à rien à faire de plus: le code de la Property Let fait déjà l'inverse de celui de la Property Get encore que ce dernier est plus simple parce qu'avec un ParamArray les paramètres sont directement sous forme de tableau.
 

laurent950

XLDnaute Barbatruc
Ben pour moi une Property Let fonctionne à l'envers d'une Property Get puisque son fonctionnement dépend de sa position, à gauche ou à droite d'un signe = d'affectation.
C'est cela a l'envers ?
Étalage("A", "B", "C") = Étalage(a, b, c)
si j'ai le code l'endroit
puis celui a l'envers alors je serais faire
tu es très fort
tu peux m'écrire le code a l'envers s'il te plait Bernard
 

laurent950

XLDnaute Barbatruc
Re Bernard

' A l'endroit !
VB:
Option Explicit
Sub test()
' A l'endroit !
   Dim a, b, c
   a = "Lettre A"
   b = "Lettre B"
   c = "Lettre C"
   Étalage("A", "B", "C") = Étalage(a, b, c)
   MsgBox "a = """ & a & """, b = """ & b & """, c = """ & c & """"
   End Sub
Property Let Étalage(ParamArray Éléments() As Variant, ByVal VArray As Variant)
   Dim N As Integer: For N = 0 To UBound(Éléments): Éléments(N) = VArray(N): Next N
   End Property
Property Get Étalage(ParamArray Éléments() As Variant)
   Étalage = Éléments
   End Property

' A l'envers !
Code:
Option Explicit
Sub test()
' A l'envers !
   Dim a, b, c
   a = "Lettre A"
   b = "Lettre B"
   c = "Lettre C"
   Étalage("a", "b", "c") = Étalage(a, b, c)
   MsgBox "a = """ & a & """, b = """ & b & """, c = """ & c & """"
   End Sub
Property Let Étalage(ParamArray Éléments() As Variant, ByVal VArray As Variant)
   Dim N As Integer: For N = 0 To UBound(Éléments): VArray(N) = Éléments(N): Next N
   End Property
Property Get Étalage(ParamArray Éléments() As Variant)
   Étalage = Éléments
   End Property
 

Dranreb

XLDnaute Barbatruc
Je n'ai jamais proposé d'exemple avec des expressions pour la Let (à gauche du =), toujours que des variables. La Get récupère les paramètres, la Let, au contraire les réinitialise. Mais elle ne peut le faire si ce sont des constantes. Pas fou le VBA, il n'en confie en ByRef que des copies !
 
Dernière édition:

Discussions similaires

Membres actuellement en ligne

Aucun membre en ligne actuellement.

Statistiques des forums

Discussions
313 259
Messages
2 096 618
Membres
106 688
dernier inscrit
Cherif99