Bonjour,
je tente de faire des indirections en utilisant un nom de classe, c'est possible ?
Je n'arrive qu' à des erreurs de syntaxe.
Code:
1
2
3
4 sFichier est une chaîne = "Clients" gclClasse est un {"M" + sFichier}
Version imprimable
Bonjour,
je tente de faire des indirections en utilisant un nom de classe, c'est possible ?
Je n'arrive qu' à des erreurs de syntaxe.
Code:
1
2
3
4 sFichier est une chaîne = "Clients" gclClasse est un {"M" + sFichier}
Oui, un objet en fait , c'est pour avoir un objet instancié sur une classe non definie a l'avance
Bonjour,
Je ne comprend pas le but.
Je reformule :
-Tu as un ensemble de classes (dont MClient qui en plus est mappé.)
-Tu veux créer un objet à partir d'une classe dont tu connais le nom sans utiliser directement le om de cette classe.
En fait c'est comme si tu déclarais une variable sans vraiment connaître le type.
Dans ce cas, on utilise un variant
Par contre tu perd l'avantage de l'objet dans la mesure où les méthodes ne sont pas directement accessibles, il faut passer par une variable de type "Procedure"Code:
1
2
3
4 Personne est un Variant Personne.Nom = "DUPONT" Personne.Prénom = "Michel"
Ce que j'essaie de faire, c'est créer une fenêtre générique qui permet de gérer les fichiers (tables) simples de forme ID / Libelle
Par exemple les types de client, les types d'interventions, etc ... le genre de fichiers qui alimentent souvent des combos de choix.
J'ai déjà une fenêtre générique qui permet de gérer le CRUD sur ces fichiers, mais faites de manière "traditionnelles", et je tente de la recréer en POO.
Pièce jointe 632058
L'idée est de passer le nom d'une classe, par exemple "MClients_Types" à cette fenêtre et tout le reste est géré
Il faut passer par une classe Générique qui va contenir toutes les méthodes génériques e.g. Ajouter/Lire/Modifier/Supprimer.
Les classes "principales" e.g. CClient, CIntervention (et par la même occasion les classes qui héritent de ces classes e.g. CClient1) hériteront de ce méthodes.
Il suffira de passer le type en constructeur pour accéder à la bonne classe.
Un truc du style :
Constructeur 1/2Code:
1
2
3
4
5
6
7
8
9
10
11
12 ETypeClasse est une Enumération Client1 Client2 Client3 Intervention1 Intervention2 Facture FIN CGénérique est une Classe m_pclTravail est un objet dynamique FIN
Constructeur 2/2Code:
1
2 PROCEDURE Constructeur()
Supprimer (dans le cas d'une classe mappée. Pour une classe classique, il faudra une méthode par classe):Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 PROCÉDURE Constructeur(eTypeObjet est ETypeClasse) SELON eTypeObjet CAS Client1 :m_pclTravail=allouer un CClient1 CAS Client2 :m_pclTravail=allouer un CClient2 CAS Client3 :m_pclTravail=allouer un CClient3 CAS Intervention1 :m_pclTravail=allouer un CInter1 CAS Intervention2 :m_pclTravail=allouer un CInter2 CAS Facture :m_pclTravail=allouer un CFacture FIN
Méthode de test :Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 FONCTION Supprimer(pkIdentifiant est entier sur 8):booléen HLitRecherchePremier(MonFichierMappé,MaCléUniqueMappée,pkIdentifiant) HSupprime(MonFichierMappé) RENVOYER Vrai CAS EXCEPTION: Trace("CAS EXCEPTION de Supprimer") RENVOYER Faux CAS ERREUR: ErreurPropage(ErreurInfo()) Trace("CAS ERREUR de Supprimer") RENVOYER Faux
Utilisation :Code:
1
2
3
4
5
6 PROCÉDURE AfficheNomClasse() defObjet est un Définition defObjet=RécupèreDéfinition(m_pclTravail) Trace(defObjet..Nom)
Code:
1
2
3
4
5 clMonGénérique est CGénérique clMonGénérique=allouer un CGénérique(CGénérique.Client1) clMonGénérique:AfficheNomClasse()
Oui c'est possible tu devra implémenter une méthode qui une instance de la classe voulu
exemple
Ensuite, ton objet lui par contre ne pourra pas être typé. Du coup tu perdra l'autocomplétion la compilation sera dynamiqueCode:
1
2
3
4
5
6
7
8 PROCEDURE RetourneInstanceClasse(NomClasse est une chaine) SELON NomClasse cas "MClients" RENVOYER Allouer une MClients() FIN
Code:
1
2
3 gclClasse est un objet dynamique = RetourneInstanceClasse("MClients")
Merci pour toutes ces infos !!
Je vais tester tout cela et mettrai les résultats ici !
Outch , le gros switch avec les noms de classe.
il y a beaucoup plus simple :)
nomClasse est un paramètre chaine passé à ta fonction (et il peut être obtenu depuis un objet déjà instancié avec ..Classe)Code:
1
2 oObj est un objet dynamique oObj <- allouer un nomClasse
Et tu renvoies l'objet
Par contre c'est vrai tu perds l'autocomplétion.
Pour générer des tableaux d'objets par contre ça ne marche pas, mais pour ça je te renvoie à ça https://www.developpez.net/forums/d2.../#post11384029
Quand à ce que disait @Voroltinquo, il te faut de l'héritage même si je n'en ai pas vu dans ses extraits de code, mais il le dit bien dans son message.
Et moyennant le polymorphisme que tu cherches, la méthode delete n'est à coder qu'une fois: ma classe mère ne contient qu'une fois le _getById, qu'une fois le _delete...Tout est factorisé.