Discussion :

[Btacorn]

Bonjour à tous,
Je voudrais être plus précis et modeste car je pense avoir perdu beaucoup de monde.
Je souhaite extraire des informations entre guillemet pour cela j'ai la piste du tableau string[] ou des variables string et pouvoir récupérer PX PY TX TY Icone etc..
Voici le code :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
 
fenetre/ APP1
        .titre             = "My first window !"
        .px                = "100"
        .py                = "100"
        .tx                 = "420"
        .ty                = "263"
        .Opacite           = "100"
        .Parametres        = "TYPE:0 ALPHAMODE:0"
        .CouleurFenetre    = "050,050,100"
        .CouleurTitre      = "255,255,255"
        .CouleurFond       = "150,000,220"
        .Icone             = "%OS_GUI%/ICO_DEF.png"
        rem/ .ImgTitre                  = "IMG_TITRE.PNG"
        .event             = "%HOST_OS%/TEST.CPC"
    @#Handle_Fenetre creer/
Fin/ fenetre

Quel code VB.NET me proposez vous en exemple ?
Merci

[Phil Rob]

Bonour,

Voici un algorithme qui pourra sans doute t'inspirer ...

Vois la vidéo : https://www.dropbox.com/s/cm06t24hyc...emets.mp4?dl=0

Et voici le programme qui contient cet algo.: CSV_0B.zip.

Bon amusment ...

[Btacorn]

Bonjour phil

Merci pour ton petit programme perso ça m'a fait très plaisir.
C'est un bon début
J'ai cependant des questions tant que on y est
Imagine un formulaire comme celui ci


Comment puis je le remplir à partir du fichier text ?

J'ai réussi à subdiviser les couleurs en 3 colonnes (RVB)




Je te remercie

[Phil Rob]

Bravo pour la séparation des couleurs !

En reprenant le code de mon exemple et le fichier Donnees.txt qui a servi pour la vidéo :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
       ' Aquisition des données
Dim CompteurLignes as Integer = 0
        Do Until FichierALire.Peek = -1
             LigneLue = FichierALire.ReadLine
             DonneesTMP = LigneLue.Split(SeparateurSplit)
             LesDonnees.Rows.Add(DonneesTMP)
 CompteurLignes += 1
        Loop
'...
' Le tableau de chaine DonneesTMP contient tout ce dont tu as besoin pour remplir ton Form, par exemple :
TextBox_PX.Text = LesDonnees.Rows(2).Item(1)
TextBox_PY.Text = LesDonnees.Rows(3).Item(1)
TextBox_TX.Text = LesDonnees.Rows(4).Item(1)
TextBox_PY.Text = LesDonnees.Rows(5).Item(1)
'...

Note que le compteur de ligne n'est nécessaire que pour les mises au point, et même pas si tu sais où se trouvent les valeurs qui t'intéressent ...

[Btacorn]

Hey merci c'est top

Il y a pas un système qui permet de dire si un élément de la colonne verticale = .fenetre, alors on dit que la textbox1 = à la deuxième colonne horizontale de la même ligne que .fenetre trouvé.
Ça éviterai de mettre 10 000 conditions (je précise que les paramètres .nanana peuvent se retrouver dans n'importe quel ordre c'est pour ça)

Merci

[Btacorn]

Excuse moi
2 choses
Si je dois utiliser le même principe mais directement à partir d'une RichTextBox comment transformer le code ?
Et comment supprimer/ne pas tenir compte des espaces dans la datagrid ?
Merci

[Phil Rob]

@StringBuilder

désolé d'arriver (une fois de plus) comme un cheveux sur la soupe

C'est vrai ...
Mais ici, tu fais autre chose que de la critique acerbe et stérile ...

Tes propos sont tout-à-fait justes, mais tu viens avec de notions de programmation plus complexes. D'autant que tous les objets concernés n'ont tous les même propriétés, cela met un cran de difficulté supplémentaire. Et puis, comme tu le mentionnes, il faudra implémenter une méthode de sérialisation et assurer la persistance des données. Idem pour la relecture avec désérialisation.
Tout cela me paraît fort complexe pour enregistrer finalement peu de choses. Alors, perso, je trouve le fichier TXT relu avec usage de la méthode SPLIT est une alternative facile pour un non professionel (note que je ne connais pas la capacité de programmation de Btacorn).

Comme tu notes d'entrée de jeu, il faut comprendre ses besoins. Pour avoir l'historique de la discussion, il faut revoir le post " (DesignSurface Class) Form Designer génération de code et lecture de fichier" du 14/4. Mais quels que soient ses besoins, ses données peuvent se trouver aussi bien sous forme littérale dans des TXT, ou dans une DB, ou sous forme d'objets sérialisés dans un fichier ou une DB.

Finalement, c'est à Btacorn de voir ce qu'il peut gérer.

J'ai nettoyé un peu mes codes d'hier soir et je les renvoie ici avec ce mot d'explication sur l'algorithmique illustrée. Tu peux donc prendre connaissance de l'ensemble. Comme tu sembles très "pour" la POO, pourquoi n'écrirais-tu pas quelques exemples conduisant aux mêmes résultats ? Cette question n'est pas une taquinerie de ma part. Si tu disposes d'un peu de temps, cela te permettrait peut-être de te rendre compte que la POO n'et pas toujours aussi simple pour tout le monde. Je crois que beaucoup de demandeur d'infos sur le forum ne sont pas des professionnels de la programmation.

@Youtpout
Bien sûr XML sert à cela. Mais là aussi je me demande s'il est vraiment à la portée de non-professionels de la programmation.

@Btacorn
Voici donc le projet amélioré (meilleure présentation des données relues) : CSV_0C.zip

Voici les quelques algorithmes presqu’indépendants les uns des autres (hormis 3 variables globales).
En principal, ces algos sont :
Sub BCharge_Click( … )

Lecture de tes fichiers TXT originaux et remplissage d’un DGV après élimination des caractères inutiles.

Sub BEnregistre_Click( … )

Enregistrement dans un fichier « Data » (tu donnes le nom et l’extension que tu veux) des données présentes dans le DGV. Ces données utilisent UNE ligne du fichier « Data ». L’enregistrement d’un autre DGV crée une autre ligne dans ce même fichier.

Sub BLire_Click( … )

Lecture d’un fichier « Data » et remplissage d’un ListBox avec les lignes du fichier.

Sub LBData_SelectedIndexChanged( … )

La sélection d’une ligne du ListBox provoque le remplissage du DGV avec les données de cette ligne.

En secondaire, quelques algos :
Sub FTest_CSV_Load( … )

Notamment, remplissage d’un ListBox de présentation des noms des fichiers « Sources » disponibles dans le dossier, pour permettre le choix de celui à charger et montrer dans le DGV.

Sub LBFichiersSources_SelectedIndexChanged( … )[/INDENT]Sub VideDonnees()

Nettoyage du DataTable et du DGV. Ces lignes de codes factorisées dans cette Sub pour éviter leur récriture là où elles sont nécessaires.

Sub Nettoyer()

Eliminations des caractères inutiles dans les données du DataTable (usage des Trim). Ces lignes de codes factorisées dans cette Sub pour éviter leur récriture là où elles sont nécessaires.

J’espère que tu y trouveras de quoi avancer …

Bonne soirée à tous

[StringBuilder]

@StringBuilder

Comme tu sembles très "pour" la POO, pourquoi n'écrirais-tu pas quelques exemples conduisant aux mêmes résultats ? Cette question n'est pas une taquinerie de ma part. Si tu disposes d'un peu de temps, cela te permettrait peut-être de te rendre compte que la POO n'et pas toujours aussi simple pour tout le monde. Je crois que beaucoup de demandeur d'infos sur le forum ne sont pas des professionnels de la programmation.

C'est ce que j'ai déjà commencé à faire.
Sauf que... bah VB.NET j'en ai jamais écrit une ligne, je suis passé du VB6 au C#, donc mon programme est en C# (ceci dit, à la syntaxe près, on peut parfaitement le transcoder en VB.NET en quelques minutes).

Oui, je sais, on est sur le forum VB.NET mais y'a jamais de question sur le C# ou alors c'est des trucs ultra pointus sur des domaines que je ne connais pas

Edit : Grrr, je suis comme un con parti sur un projet Windows Form avec comme target .NET Core... Et il faut mettre à jour Visual Studio car pas de concepteur dans ma version... et vu que c'est très bien fait, une fois la mise à jour commencée on ne peut plus l'arrêter. 4 Go à télécharger, mon bout de code ne sera pas pour ce soir

[cpcdos]

Le bout de code CpcdosC+ que Btacorn (Fallait que tu le précises!) à publié, s'agit d'un bout de code exécutable format texte (qui sera compilé par la suite..), ce n'est pas un fichier de configuration à la INI, mais bien du code que le shell cpcdos va compiler.
D'ailleurs la syntaxe française est un peu dépassée, faudra te concentrer sur la syntaxe anglaise.

Je comprend qu'il souhaite créer un outil qui génère du code CC+ en format texte, et ce pour l'interface graphique, pas mal!
Et qu'il souhaite également récupérer le contenu des valeurs entre guillemets pour "visualiser" sur un "WinForm" sur-adapté à la VB4, c'est faisable

Par contre l'intégration xml de type XAML est dans la todo du projet, notamment dans les ressources des exécutable .exe (Win32).

Bonne journée

[StringBuilder]

Merci cpcdos pour ces précisions.

Voici quelques bouts de code (buggés et tout comme il faut) tapés en vitesse dans Notepad++.

Je suis parti du principe que pour faire simple, mes objets "spécialisés" allaient tous être basé sur une même objet de base (héritage).
Cet objet permet, à partir d'un ensemble de lignes, de charger un dictionnaire pour convenir toutes les propriétés.

Voici donc le code du "parseur", qui se contente, à partir d'un ensemble de lignes, d'alimenter le dictionnaire :

Code csharp :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
        protected CpcDosCPlusObjet((string[] declaration))
        {
            Attributes = new Dictionary<string, string>();
			string typeObjet = declaration[0].Split('/')[0].Trim());
            ID = declaration[0].Split('/')[1].Trim());
 
			if (typeObjet == "fonction")
			{
				Attributes.Add(".code", declaration[1..^1].Join('\n'));
			}
			else
			{
				for (int i = 1, length = declaration.Length; i < length; i++)
				{
					string ligne = declaration[i].Trim();
					if (ligne.StartsWith("rem/"))
					{
						// Cette ligne est en commentaire, on l'ignore
						continue;
					}
					else if (ligne.Contains('='))
					{
						// Il s'agit d'une ligne de déclaration d'un attribut
						string[] keyval = ligne.Split('=');
						string key = keyval[0].Trim().ToLower();
						string val = keyval[1].Trim();
						if (val.StartsWith("\"") && val.EndsWith("\""))
						{
							val = val[1..^1]; // .SubString(1, val.Length - 1)
						}
						attributes.Add(key, val);
					}
					else
					{
						// Il s'agit d'un autre type de ligne
						if (ligne.StartsWith("@#Handle_Fenetre"))
						{
							// Ca j'ai pas compris ce que c'était
						}
					}
				}
			}
        }

Comme on le voit, c'est assez simple, pas de spécificités (sauf pour les fonctions qui n'ont pas d'attributs, mais du code à la place.

Ensuite, pour un objet de type "fenetre", on a cette classe :

Code csharp :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
 
    class CpcDosCPlusFenetre : CpcDosCPlusObjet
    {
        public string Titre
        {
            get
            {
                Attributes.TryGetValue(".titre", out string value);
                return value;
            }
            set
            {
                if (string.IsNullOrWhiteSpace(value) && Attributes.ContainsKey(".titre"))
                {
                    Attributes.Remove(".titre");
                }
                else
                {
                    Attributes[".titre"] = value;
                }
            }
        }
        public string Px
        {
            get
            {
                Attributes.TryGetValue(".px", out string value);
                return value;
            }
            set
            {
                if (string.IsNullOrWhiteSpace(value) && Attributes.ContainsKey(".px"))
                {
                    Attributes.Remove(".px");
                }
                else
                {
                    Attributes[".px"] = value;
                }
            }
        }
        public string Py
        {
            get
            {
                Attributes.TryGetValue(".py", out string value);
                return value;
            }
            set
            {
                if (string.IsNullOrWhiteSpace(value) && Attributes.ContainsKey(".py"))
                {
                    Attributes.Remove(".py");
                }
                else
                {
                    Attributes[".py"] = value;
                }
            }
        }
        public string Tx
        {
            get
            {
                Attributes.TryGetValue(".tx", out string value);
                return value;
            }
            set
            {
                if (string.IsNullOrWhiteSpace(value) && Attributes.ContainsKey(".tx"))
                {
                    Attributes.Remove(".tx");
                }
                else
                {
                    Attributes[".tx"] = value;
                }
            }
        }
        public string Ty
        {
            get
            {
                Attributes.TryGetValue(".ty", out string value);
                return value;
            }
            set
            {
                if (string.IsNullOrWhiteSpace(value) && Attributes.ContainsKey(".ty"))
                {
                    Attributes.Remove(".ty");
                }
                else
                {
                    Attributes[".ty"] = value;
                }
            }
        }
        public string Opacite
        {
            get
            {
                Attributes.TryGetValue(".Opacite", out string value);
                return value;
            }
            set
            {
                if (string.IsNullOrWhiteSpace(value) && Attributes.ContainsKey(".Opacite"))
                {
                    Attributes.Remove(".Opacite");
                }
                else
                {
                    Attributes[".Opacite"] = value;
                }
            }
        }
        public string Parametres
        {
            get
            {
                Attributes.TryGetValue(".Parametres", out string value);
                return value;
            }
            set
            {
                if (string.IsNullOrWhiteSpace(value) && Attributes.ContainsKey(".Parametres"))
                {
                    Attributes.Remove(".Parametres");
                }
                else
                {
                    Attributes[".Parametres"] = value;
                }
            }
        }
        public string CouleurFenetre
        {
            get
            {
                Attributes.TryGetValue(".CouleurFenetre", out string value);
                return value;
            }
            set
            {
                if (string.IsNullOrWhiteSpace(value) && Attributes.ContainsKey(".CouleurFenetre"))
                {
                    Attributes.Remove(".CouleurFenetre");
                }
                else
                {
                    Attributes[".CouleurFenetre"] = value;
                }
            }
        }
        public string CouleurTitre
        {
            get
            {
                Attributes.TryGetValue(".CouleurTitre", out string value);
                return value;
            }
            set
            {
                if (string.IsNullOrWhiteSpace(value) && Attributes.ContainsKey(".CouleurTitre"))
                {
                    Attributes.Remove(".CouleurTitre");
                }
                else
                {
                    Attributes[".CouleurTitre"] = value;
                }
            }
        }
        public string CouleurFond
        {
            get
            {
                Attributes.TryGetValue(".CouleurFond", out string value);
                return value;
            }
            set
            {
                if (string.IsNullOrWhiteSpace(value) && Attributes.ContainsKey(".CouleurFond"))
                {
                    Attributes.Remove(".CouleurFond");
                }
                else
                {
                    Attributes[".CouleurFond"] = value;
                }
            }
        }
        public string Icone
        {
            get
            {
                Attributes.TryGetValue(".Icone", out string value);
                return value;
            }
            set
            {
                if (string.IsNullOrWhiteSpace(value) && Attributes.ContainsKey(".Icone"))
                {
                    Attributes.Remove(".Icone");
                }
                else
                {
                    Attributes[".Icone"] = value;
                }
            }
        }
        public string ImgTitre
        {
            get
            {
                Attributes.TryGetValue(".ImgTitre", out string value);
                return value;
            }
            set
            {
                if (string.IsNullOrWhiteSpace(value) && Attributes.ContainsKey(".ImgTitre"))
                {
                    Attributes.Remove(".ImgTitre");
                }
                else
                {
                    Attributes[".ImgTitre"] = value;
                }
            }
        }
        public string Event
        {
            get
            {
                Attributes.TryGetValue(".event", out string value);
                return value;
            }
            set
            {
                if (string.IsNullOrWhiteSpace(value) && Attributes.ContainsKey(".event"))
                {
                    Attributes.Remove(".event");
                }
                else
                {
                    Attributes[".event"] = value;
                }
            }
        }
    }

C'est un peu long, mais si on regarde bien, toutes les propriétés ont rigoureusement le même code : elles se contentent de manipuler le dictionnaire qui a été chargé au départ.

Pour un bouton :

Code csharp :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
 
    class CpcDosCPlusBouton : CpcDosCPlusObjet
    {
        public string Handle
        {
            get
            {
                Attributes.TryGetValue(".handle", out string value);
                return value;
            }
            set
            {
                if (string.IsNullOrWhiteSpace(value) && Attributes.ContainsKey(".handle"))
                {
                    Attributes.Remove(".handle");
                }
                else
                {
                    Attributes[".handle"] = value;
                }
            }
        }
        public string Px
        {
            get
            {
                Attributes.TryGetValue(".px", out string value);
                return value;
            }
            set
            {
                if (string.IsNullOrWhiteSpace(value) && Attributes.ContainsKey(".px"))
                {
                    Attributes.Remove(".px");
                }
                else
                {
                    Attributes[".px"] = value;
                }
            }
        }
        public string Py
        {
            get
            {
                Attributes.TryGetValue(".py", out string value);
                return value;
            }
            set
            {
                if (string.IsNullOrWhiteSpace(value) && Attributes.ContainsKey(".py"))
                {
                    Attributes.Remove(".py");
                }
                else
                {
                    Attributes[".py"] = value;
                }
            }
        }
        public string Tx
        {
            get
            {
                Attributes.TryGetValue(".tx", out string value);
                return value;
            }
            set
            {
                if (string.IsNullOrWhiteSpace(value) && Attributes.ContainsKey(".tx"))
                {
                    Attributes.Remove(".tx");
                }
                else
                {
                    Attributes[".tx"] = value;
                }
            }
        }
        public string Ty
        {
            get
            {
                Attributes.TryGetValue(".ty", out string value);
                return value;
            }
            set
            {
                if (string.IsNullOrWhiteSpace(value) && Attributes.ContainsKey(".ty"))
                {
                    Attributes.Remove(".ty");
                }
                else
                {
                    Attributes[".ty"] = value;
                }
            }
        }
        public string Opacite
        {
            get
            {
                Attributes.TryGetValue(".Opacite", out string value);
                return value;
            }
            set
            {
                if (string.IsNullOrWhiteSpace(value) && Attributes.ContainsKey(".Opacite"))
                {
                    Attributes.Remove(".Opacite");
                }
                else
                {
                    Attributes[".Opacite"] = value;
                }
            }
        }
        public string Parametres
        {
            get
            {
                Attributes.TryGetValue(".Parametres", out string value);
                return value;
            }
            set
            {
                if (string.IsNullOrWhiteSpace(value) && Attributes.ContainsKey(".Parametres"))
                {
                    Attributes.Remove(".Parametres");
                }
                else
                {
                    Attributes[".Parametres"] = value;
                }
            }
        }
        public string Texte
        {
            get
            {
                Attributes.TryGetValue(".texte", out string value);
                return value;
            }
            set
            {
                if (string.IsNullOrWhiteSpace(value) && Attributes.ContainsKey(".texte"))
                {
                    Attributes.Remove(".texte");
                }
                else
                {
                    Attributes[".texte"] = value;
                }
            }
        }
        public string Image
        {
            get
            {
                Attributes.TryGetValue(".image", out string value);
                return value;
            }
            set
            {
                if (string.IsNullOrWhiteSpace(value) && Attributes.ContainsKey(".image"))
                {
                    Attributes.Remove(".image");
                }
                else
                {
                    Attributes[".image"] = value;
                }
            }
        }
        public string Event
        {
            get
            {
                Attributes.TryGetValue(".event", out string value);
                return value;
            }
            set
            {
                if (string.IsNullOrWhiteSpace(value) && Attributes.ContainsKey(".event"))
                {
                    Attributes.Remove(".event");
                }
                else
                {
                    Attributes[".event"] = value;
                }
            }
        }
    }

Et une fonction :

Code csharp :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
    class CpcDosCPlusFonction : CpcDocCPlusObjet
    {
       public string Code
        {
            get
            {
                Attributes.TryGetValue(".code", out string value);
                return value;
            }
            set
            {
                if (string.IsNullOrWhiteSpace(value) && Attributes.ContainsKey(".code"))
                {
                    Attributes.Remove(".code");
                }
                else
                {
                    Attributes[".code"] = value;
                }
            }
        }
    }

Reste à implémenter par exemple la gestion des couleurs.
L'avantage de passer par des accesseurs qui se basent sur un dictionnaire de chaînes, c'est qu'on n'a pas grand chose à manipuler : il suffit d'implémenter une conversion implicite vers et depuis string pour n'avoir qu'à modifier le type de la propriété sans devoir toucher à son corps.

Enfin, on charge tout ce petit monde à partir d'une autre classe, qui permet de générer une liste d'objets spécialisés à partir d'un fichier contenant plusieurs déclarations d'objets :

Code csharp :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
    class CpcDosCPlusListeObjets : List<CpcDosCPlusObjet>
    {
		public static List<CpcDosCPlusObjet> LoadFromFile(string path)
		{
			List<CpcDosCPlusObjet> objets = new List<CpcDosCPlusObjet>();
			string[] lignes = File.ReadAllLines(path);
 
			bool chercheDebut = true;
			int debutObjet;
			string typeObjet;
 
			for (int i = 0, length = lignes.Length; i < length; i++)
			{
				string ligne = lignes[i].Trim().ToLower();
				if (chercheDebut && ligne.Contains('/'))
				{
					string[] tmp = ligne.Split('/');
					if (tmp.Length > 2)
					{
						throw new Exception($"Je n'arrive pas à décoder cette ligne : {i}");
					}
					debutObjet = i;
					typeObjet = tmp[0];
					chercheDebut = false; // Maintenant on va chercher la fin
				}
				else if (chercheFin && ligne.StartsWith("Fin/"))
				{
					if (!ligne.EndsWith(typeObjet))
					{
						throw new Exception($"Fin d'objet {typeObjet} attendue, mais trouvé \"{ligne}\" à la ligne {i}");
					}
					switch (typeObjet)
					{
						case "fenetre":
							this.Add(new CpcDocCPlusFenetre(lignes.Take(debutObjet, i));
							break;
						case "bouton":
							this.Add(new CpcDocCPlusBouton(lignes.Take(debutObjet, i));
							break;
						case "fonction":
							this.Add(new CpcDocCPlusFonction(lignes.Take(debutObjet, i));
							break;
						default:
							throw new Exception($"Type d'objet non pris en charge {typeObjet}");
					}
					chercheDebut = true;
				}
			}
 
			return objets;
		}
    }

Reste alors dans la GUI plus qu'à manipuler les objets spécialisés depuis la liste. A mon sens, c'est bien plus pratique pour ensuite jouer avec dans l'IDE.

A l'image du décodage, il faudra aussi écrire une fonction qui génère le fichier avec les objets modifiés. Rien d'insurmontable à priori.

Désolé pour les indentations... Notepad++ a converti des " " en "\t" et du coup ça pète dans le forum... Faut vraiment que je termine cette mise à jour de Visual Studio !

[StringBuilder]

D'ailleurs la syntaxe française est un peu dépassée, faudra te concentrer sur la syntaxe anglaise.

A partir de là, j'ai un peu envie de dire qu'il me semble plus judicieux de privilégier la syntaxe anglaise.

Surtout que si demain ton projet nécessite des intervenants étrangers, ils vont galérer avec la syntaxe française, et je te raconte pas si c'est tout mélangé !

[Phil Rob]

@StringBuilder

C'est ce que j'ai déjà commencé à faire.
Sauf que... bah VB.NET j'en ai jamais écrit une ligne, je suis passé du VB6 au C#, donc mon programme est en C# (ceci dit, à la syntaxe près, on peut parfaitement le transcoder en VB.NET en quelques minutes).

Super, mais sans l'IDE, faut le faire ! Moi, je n'y arriverais pas.

@Sam Placi
Bien content que tu comprennes mes codes

Le principal avantage d’exemples implémentant des technologies différentes et de permettre à celui qui a posé la question, et à tous les autres lecteurs de la discussion ensuite, de « faire son marché »

Et là, je suis bien d'accord avec toi.

[StringBuilder]

Bonjour,

Voilà, j'ai un truc qui compile (ouf).

Finalement j'ai abandonné .NET Core 3.1 car le designer de Form ne marche toujours pas, même après mise à jour.
Du coup obligé d'abandonner aussi C# 8.0, un vrai bonheur ^^

Voici donc un source .NET Framework 4.8 qui compile.

Il parse le fichier d'exemple trouvé sur le site https://cpcdos.net/fr et charge les objet dans une liste.

Il ne reste plus qu'à faire une série de UserControls pour faire le "rendu" des différents objets spécialisés (chaque UserControl affichant les attributs d'un type d'objet donné).

Si je un peu de temps, j'irai un peu plus loin dans cette direction dans les jours à venir.

Si tu ne veux pas t'amuser à traduire mon code, tu peux aussi target un projet DLL et l'inclure dans ton projet.

CpcDosCPlus.7z

[Phil Rob]

Tu peux toujours tester le contenu de la colonne 0, et avoir tes TextBox judicieusement disposées de TextBox 1 à TextBox ... N, ... mais ça ne va pas simplifier le travail.
Là, il faut imaginer autre chose ...

[Phil Rob]

La comparaison suivante de donnera la réponse à cette question :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
' Accès aux lignes d'un fichier TXT :
 
        Do Until FichierALire.Peek = -1
             LigneLue = FichierALire.ReadLine
' ... ... ...
        Loop
 
 
' Accès aux lignes d'un RichtTextBox :
 
        For L As Integer = 0 To LeRichtTextBoxEnQuestion.Lines.Count - 1
             LigneLue = LeRichtTextBoxEnQuestion.Lines(L)
 ' ... ... ...
        Next

Pour les espaces en début et en fin de chaîne, ils sont supprimés par LaChaine.Trim().

Bonne nuit

[Btacorn]

Pas de problème MERCI
Bonne nuit

[Phil Rob]

Bonjour,

A toutes fins utiles, un complément d'info suite à la question de la suppression des espaces.

La méthode Trim (ex. UneChaine.Trim()) enlève bien les espaces en début et en fin de la chaîne.
Mais Trim peut être utilisé avec en paramètre, le caractère à supprimer : UneChaine.Trim() et UneChaine.Trim(" ") sont équivalents.
Et il existe aussi TrimStart et TrimEnd qui enlève un caractère donné en début et en fin de chaîne (respectivement) :
UneChaine.TrimStart(".") supprime les caractères points situés au début de la chaine.
UneChaine.TrimEnd(" ") supprime les espaces situés à la fin de la chaine.

Voilà, tu sais tout des Trim ...

Excellente journée,

[Btacorn]

Effectivement les Trims me sont bien utiles Merci

J'allais reposter mais bon je sais pas si c'est nécessaire car c'est un peu le même sujet.
Désolé si c'est expliqué bizarrement
C'est au sujet des collections, j'aimerai enregistrer des éléments dans des collections.
Quand je parle d'objets c'est les objets de mon code CpcdosC+ que l'on a divisé dans la datagrid hier.
Une collection par type d'objet, (bouton, textbox, checkbox) pareil que (tomate, pomme, banane)
Ensuite, prenons la collection "bouton" par exemple, il y a les noms des boutons (qui sont dans la datagrid, je me charge de récupérer les noms) et quelque part je voudrais que des infos sur le bouton soit stockées grâce à son nom (on sait que ces infos appartiennent à ce bouton car elles sont associées à son nom) quelques screens plus parlants (j'ai rempli manuellement les textboxs pour montrer les résultats attendus)
Onglet fenêtre (il y en a toujours qu'une)


Onglet Objets (Il y a différents types d'objets (bouton, textbox etc...)
La deuxième combobox c'est la collection comprenant tous les boutons de la datagrid
Le panel enveloppe tous le bas à partir de au dessus la deuxième combobox.

Code :

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

1
2
3
4
5
6
7
8
 
'Bouton (remplir textboxs) cliqué alors
 Dim titre As String
        titre = LesDonnees.Rows(2).Item(0)
        If titre.Trim() = ".titre" Then
            TextBox1.Text = LesDonnees.Rows(2).Item(2)
        End If
' etc.......

J'ai mis en place ce type de condition pour savoir si telle cellule contient tel mot et si c'est le cas alors on rempli une telle textbox avec telle cellule de la même ligne je ne sais pas si il existe une méthode plus courte du coup je fais ça pour chaque cellule.
Je pourrai mettre en place le même principe avec le mot bouton, si la cellule contient le mot bouton alors ajouter un bouton à la collection "bouton" et on récupère son nom et ses infos et il faudrait garder tout ca en mémoire dans une collection...

Voilà voilà

Merci

[Phil Rob]

Bonjour,

Le DataTable est déjà un moyen de stocker une collection de données mais tu peux t’intéresser aussi à l'ArrayList, la List(Of), la Hashtable, la Dictionary(Of), ... et bien d'autres. Mais quelle que soit la structure que tu choisisses, il te faudra gérer l'encodage de ces infos et les stocker dans un fichier ou une DB pour les recharger au lancement du programme.
Au plus simple, les infos peuvent être enregistrées dans un fichier où elles sont séparées par ; et relues avec la même méthode que celle que j'ai utilisée pour extraire les infos du fichier TXT. A la lecture tu peux recharger un DataTable ou n'importe quelle collection.

...

[Btacorn]

Bonjour, Ah!

Faut que je réfléchisse, enfin de compte ce qui me perturbe dans tous ça c'est le dynamisme et l'imprévu. Sans savoir combien d'informations on attend ( nombre d'objets).. je veux bien enregistrer des infos dans un fichier texte mais faut trouver un moyen de dire de créer un fichier text à chaque fois que le logiciel lis la ligne commencant par bouton/ (nianiania) jusqu'a la ligne Fin/ bouton et de mettre chaque bloc d'objet dans un fichier text different tu sais comment faire ?
Merci