Discussion :

[D3Vavenir]

Bonjour à tous!

Et merci d'avance à ceux qui pourront m'aider!

Comme l'indique mon intitulé, je travaille actuellement sur une liste de liste de type structuré.

Voici mon code (parfois mieux vaut l'exemple qu'un long discours) :

- Tout d'abord, la structure servant à la liste de listes comportant ce type structuré EN ENTRÉE :

Code :

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

1
2
3
4
5
    'structure permettant la récupération des éléments d'impression de la table étiquette
    Public Structure LabelPrintingElement
        Public etiq_num As String
        Public etiq_dateheure As Date
    End Structure

-Voici la structure servant à la liste de liste de type structurée EN SORTIE :

Code :

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

1
2
3
4
5
    'structure permettant la récupération des éléments loftware
    Public Structure ElementsEtiquetteLWL
        Public LibelleElementLWL As String
        Public ValeurElementLWL As String
    End Structure

Pourquoi ce changement de type en cours de route? Tout simplement car j'ai créé une classe permettant d'utiliser n'importe quel type d'informations avec ce formalisme afin de produire des étiquettes industrielles.

Voici le code en question (C'est une fonction "rustine" qui fait le lien entre 2 classes ayant leur propre méthode, et c'est pour moi la manière la plus propre de m'en sortir et également celle qui me prendrait normalement le moins de temps... puisque je dois finaliser le tout pour vendredi ) :

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
19
20
21
22
23
24
25
26
27
28
29
30
    Function conversion_ListofLabels_en_ListeElemParEtiq(ByVal ListofLabels As List(Of data_access.LabelPrintingElement)) _
                As List(Of List(Of loftware_access.ElementsEtiquetteLWL))
        'Déclaration des variables
        Dim ListeElemsParEtiq As New List(Of List(Of loftware_access.ElementsEtiquetteLWL))
        Dim ListeUnElemParEtiq As New List(Of loftware_access.ElementsEtiquetteLWL)
        Dim ElementsEtiquetteLWL As loftware_access.ElementsEtiquetteLWL

        'Exécution
        For i As Integer = 0 To ListofLabels.Count - 1
            ElementsEtiquetteLWL.LibelleElementLWL = "etiq_num"
            ElementsEtiquetteLWL.ValeurElementLWL = ListofLabels.Item(i).etiq_num
            'on ajoute l'élement dans ListeUnElemParEtiq (ajout d'1 seul élement de liste structurée)
            ListeUnElemParEtiq.Add(ElementsEtiquetteLWL)

            ElementsEtiquetteLWL.LibelleElementLWL = "etiq_dateheure"
            ElementsEtiquetteLWL.ValeurElementLWL = Format(ListofLabels.Item(i).etiq_dateheure, "dd/MM/yyyy")
            'on ajoute l'élement dans ListeUnElemParEtiq (ajout d'1 seul élement de liste structurée)
            ListeUnElemParEtiq.Add(ElementsEtiquetteLWL)
            '----------------------------------------------------------
            'on ajoute le tout dans la liste de liste ListeElemsParEtiq
            '----------------------------------------------------------
            ListeElemsParEtiq.Add(ListeUnElemParEtiq)
            'on nettoie les valeurs précédemment passées dans ListeUnElemParEtiq.Clear
            ' afin que cela ne produise pas un comportement anormal dans ListeElemsParEtiq
            ListeUnElemParEtiq.Clear()

        Next
        ' ListeElemParEtiq.Add(ListeUnElemParEtiq)
        Return ListeElemsParEtiq
    End Function

Le ListeUnElemParEtiq.Clear() est "obligatoire" car sinon je vais "concaténer" (désolé pour l'abus de langage) les même éléments à chaque fois que je vais boucler (je suis censé avoir forcément 2 branches et X troncs).

SAUF QUE lorsque j'efface ListeUnElemParEtiq avec ListeUnElemParEtiq.Clear(), cela impacte également l'ensemble des élements déja présents dans ListeElemsParEtiq qui est une liste composée de ListeUnElemParEtiq.

J'avais pensé également à une variable du même type que ListeUnElemParEtiq qui jouerait le rôle d'intermédiaire entre ListeUnElemParEtiq et ListeElemsParEtiq, sauf que cela ne marche pas non plus : J'en conclus donc que tout se fait en mémoire (à la manière de variables pointées)...

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
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
Function conversion_ListofLabels_en_ListeElemParEtiq(ByVal ListofLabels As List(Of data_access.LabelPrintingElement)) _
                As List(Of List(Of loftware_access.ElementsEtiquetteLWL))
        'Déclaration des variables
        Dim ListeElemsParEtiq As New List(Of List(Of loftware_access.ElementsEtiquetteLWL))
        Dim ListeUnElemParEtiq As New List(Of loftware_access.ElementsEtiquetteLWL)

        Dim ListeTemp As New List(Of loftware_access.ElementsEtiquetteLWL)

        Dim ElementsEtiquetteLWL As loftware_access.ElementsEtiquetteLWL

        'Exécution
        For i As Integer = 0 To ListofLabels.Count - 1
            ElementsEtiquetteLWL.LibelleElementLWL = "etiq_num"
            ElementsEtiquetteLWL.ValeurElementLWL = ListofLabels.Item(i).etiq_num
            'on ajoute l'élement dans ListeUnElemParEtiq (ajout d'1 seul élement de liste structurée)
            ListeUnElemParEtiq.Add(ElementsEtiquetteLWL)

            ElementsEtiquetteLWL.LibelleElementLWL = "etiq_dateheure"
            ElementsEtiquetteLWL.ValeurElementLWL = Format(ListofLabels.Item(i).etiq_dateheure, "dd/MM/yyyy")
            'on ajoute l'élement dans ListeUnElemParEtiq (ajout d'1 seul élement de liste structurée)
            ListeUnElemParEtiq.Add(ElementsEtiquetteLWL)
            '----------------------------------------------------------
            'on ajoute le tout dans la liste de liste ListeElemsParEtiq
            '----------------------------------------------------------
            ListeTemp = ListeUnElemParEtiq

            ListeElemsParEtiq.Add(ListeTemp)
            'on nettoie les valeurs précédemment passées dans ListeUnElemParEtiq.Clear
            ' afin que cela ne produise pas un comportement anormal dans ListeElemsParEtiq
            ListeUnElemParEtiq.Clear()

        Next
        ' ListeElemParEtiq.Add(ListeUnElemParEtiq)
        Return ListeElemsParEtiq
    End Function

Peut-être existe-t'il une manière plus simple d'allouer les valeurs sans passer par des étapes intermédiaires ou une astuce... Enfin je vous laisse libre de tout choix technique tant que je garde les mêmes entrées/sorties.

Merci de vous êtes accroché(e)s jusqu'au bout!

[Pol63]

que veux tu faire plutot parce que le pavé de code en noir j'ai pas suivi ...
et y a ptete d'autres méthodes

[D3Vavenir]

Je souhaiterais convertir ma "structure d'entrée" en "structure de sortie" de manière partiellement dynamique (en correspondance avec les champs etiq_num et etiq_dateheure).

Toute solution autre sera bonne à prendre et très probablement prise! (J'avais pensé à une arborescence en XML ... mais je ne maîtrise pas du tout). Au fait, je travaille sous le framework2 de .net et VS2005.

Bien cordialement.

PS : (Je suis également prêt à faire sauter ma structure de sortie si je garde une arborescence).

X troncs, 2 branches, 2 fruits (faisant référence à ma structure de données composée de 2 élèments)!

[neptune]

Tu as deux solutions, soit implémenter le cast explicit, soit avoir une méthode statique sur la classe à convertir qui retourne le classe convertie.

Je te montre comment implémenter le cast.

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
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
 
    class ClassA
    {
        private string m_name;
 
        public ClassA()
        {
        }
 
        public ClassA(string name)
        {
            m_name = name;
        }
 
        public string Name
        {
            get { return m_name; }
            set { m_name = value; }
        }
    }
 
    ...
 
    class ClassB
    {
        private string m_firstName;
 
        public ClassB()
        {
        }
 
        public ClassB(string firstName)
        {
            m_firstName = firstName;
        }
 
        public string FirstName
        {
            get { return m_firstName; }
            set { m_firstName = value; }
        }
 
        public static explicit operator ClassB(ClassA from)
        {
            return new ClassB(from.Name);
        }
    }
 
    ...
 
    ClassA objA = new ClassA("Jean Dupont");
    ClassB objB = (ClassB)objA;

[Pol63]

Je souhaiterais convertir ma "structure d'entrée" en "structure de sortie" de manière partiellement dynamique (en correspondance avec les champs etiq_num et etiq_dateheure).

Toute solution autre sera bonne à prendre et très probablement prise! (J'avais pensé à une arborescence en XML ... mais je ne maîtrise pas du tout). Au fait, je travaille sous le framework2 de .net et VS2005.

Bien cordialement.

PS : (Je suis également prêt à faire sauter ma structure de sortie si je garde une arborescence).

X troncs, 2 branches, 2 fruits (faisant référence à ma structure de données composée de 2 élèments)!

ce n'est pas très explicite
les interfaces pourraient peut etre t'aider ou alors des classes (Of ..) ou encore une classe générique avec des overrides sur les choses différentes

[D3Vavenir]

Comme vous vous en doutez, je ne suis pas un pro de l'architecture .net . Et VB .Net ne déroge pas à la règle (cast explicit,... tout ça, je ne connais pas).
(Des fois, on peut vraiment se sentir con... )

Désolé de manquer de clarté, mais il me parait difficile d'être plus clair.

Je récapitule :

1)J'ai une liste structurée en entrée.

Cette liste structurée représente une étiquette composée de :
-son numéro d'étiquette (etiq_num) (libellé+valeur)
-sa date/son heure (etiq_dateheure) (libellé+valeur)


2)je souhaite récupérer en sortie cette liste sous la structure suivante :
-Libellé ("etiq_num" ou "etiq_date")
-Valeur ("451000" ou "14/02/2005")

Sachant que j'aurais pour chaque étiquette à produire 2 libellé ET 2 valeurs (puisqu'une étiquette est composée de "etiq_num" ET "etiq_date" (d'où l'idée d'une liste de listes).

La contrainte : Je dois absolument garder une structure "générique" de sortie, donc non prévue pour un cas spécifique : genre ceci (en imageant):

listof (tab[2] of string)

Cdlt.

[Pol63]

désolé mais je cromprends pas trop quand meme

pourquoi ne pas faire

structure machin
lib as string
valeur as object

structure etiquette
num as machin
date as machin


sinon il est aussi possible de faire
class machin (Of blabla)
public lib as string
public valeur as blabla

et d'instancier de la sorte dim a as new machin(of datetime)



enfin j'ai l'impression que vous n'etes pas partie sur la bonne piste
vous parlez d'entrée et de sortie, qu'y a t il au milieu ? que doit faire le programme exactement ?

[D3Vavenir]

En gros : enregistrer des étiquettes dans la base, en incrémentant le tout (avec un ensemble de contrôles et de contraintes) et sortir des étiquettes à un format spécifique.

Contrainte particulière : Je dois passer par une classe générique pour pondre mes étiquettes --> Loftware_access!

------------------------------------------------------------------------
Classe Data_access
------------------------------------------------------------------------
J'ai une classe "Data_access" avec ses méthodes qui accédent aux données de la base.
Dans cette classe, j'ai une méthode "SetCollectionOfNewLabels" qui permet la génération de X nouvelles étiquettes (elle crée une collection de nouvelles étiquettes). Ces X nouvelles étiquettes sont enregistrées dans une liste structurée avec leur Date/heure de création

CF :

1)J'ai une liste structurée en entrée.

Cette liste structurée représente une étiquette composée de :
-son numéro d'étiquette (etiq_num) (libellé+valeur)
-sa date/son heure (etiq_dateheure) (libellé+valeur)

Avec cette méthode, je sors également les informations de l' "environnement" de l'étiquette (Produit et Client).

Ces derniers informations ne changent que lors de l'impression d'un lot différent d'étiquettes, Tandis que le numéro d'étiquette change à chaque étiquette imprimée.

-----------------------------------------------------------------------
Classe Loftware_access
------------------------------------------------------------------------
Cette classe permet de générer un fichier de type .PAS nécessaire à l'applicatif Loftware qui génère les étiquettes.
Je dois reproduire le formalisme nécessaire dans un fichier .PAS

Le formalisme en image:
Les zones obligatoires sont en gras.
Les lignes en noir : avant la virgule = nom du champ utilisé dans l'étiquette Loftware
Après la virgule = valeur du champ à imprimer.

Le fichier doit porter le nom xxxxxxx.PAS ( format texte )
_____________________________________________________________________________________
*FORMAT,xxx.lwl
*QUANTITY,1
*PRINTERNUMBER,1
REFERENCE_PRODUIT,450020
CLIENT_NOM,toto
ETIQ_NUM,00001
*PRINTLABEL

*FORMAT,xxx.lwl
*QUANTITY,1
*PRINTERNUMBER,1
REFERENCE_PRODUIT,450020
CLIENT_NOM,toto
ETIQ_NUM,00002
*PRINTLABEL

*FORMAT,xxx.lwl
*QUANTITY,1
*PRINTERNUMBER,1
REFERENCE_PRODUIT,450020
CLIENT_NOM,toto
ETIQ_NUM,00003
*PRINTLABEL
_____________________________________________________________________________________
On voit que mon numéro d'étiquette varie, c'est pour cela que j'utilise une liste, tandis que ma référence produit non! Différence de variable par lot et par étiquette.

--> Ce qui implique 2 rustines dont la fameuse qui ne fonctionne pas (l'autre étant beaucoup plus simple)

-----------------------------------------------------------------------
Mon programme appelant
------------------------------------------------------------------------

Appelle d'abord la méthode "SetCollectionOfNewLabels" de la classe data_access
Lance mes fonctions "rustines" (celle qui me pose problème et Une plus simple)
Appelle enfin la méthode "CreateFilePAS" de la classe loftware_access.


Plus de détails, pour pas forcément plus de compréhension!

Si quelqu'un comprend mieux! Je suis preneur.

Je vais en même temps, chercher d'autres alternatives!

Merci bien

[neptune]

J'avoue aussi avoir du mal à comprendre, mais j'aimerais t'aider.

En relisant ton premier message:

Pourquoi ce changement de type en cours de route? Tout simplement car j'ai créé une classe permettant d'utiliser n'importe quel type d'informations avec ce formalisme afin de produire des étiquettes industrielles.

Donc, tu voudrais pouvoir utiliser un systéme générique pour imprimer des étiquettes. Tu as un classe qui fait le boulot de créer un fichier texte. Cette classe doit pouvoir recevoir différente classe contenant différente information.

Si c'est bien ca, je vois ca comme ca:

- Une interface IDataClass, qui définit une méthode GetLabelData()
- Ta classe métier (qui crée le fichier) avec une méthode Print(IDataClass)
- Tes différentes classes qui implémente ton interface et selon chaque classe retourne les données nécessaires via la méthode GetLabelData()

[Pol63]

je comprends deja un peu mieux, il manque plus que la source qui te dit quoi faire et quel type


sinon un truc dans le genre ca t'irais pas ?

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
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
 
 
 
Public Class FilePAS
 
    Private elements_fichier As New System.Collections.Generic.List(Of element_to_print)
 
    Public Overloads Sub add_new_etiquette(ByVal ref_prod As String, ByVal client_name As String)
        Dim e As New element_to_print
        e.ref_prod = ref_prod
        e.client_name = client_name
        e.etiquette_num = elements_fichier.Count
        elements_fichier.Add(e)
    End Sub
 
 
    ''' <summary>
    ''' pour en faire x pareil (juste le num qui change)
    ''' </summary>
    ''' <param name="ref_prod"></param>
    ''' <param name="client_name"></param>
    ''' <param name="nb_pareil"></param>
    ''' <remarks></remarks>
    Public Overloads Sub add_new_etiquette(ByVal ref_prod As String, ByVal client_name As String, ByVal nb_pareil As Integer)
        For i As Integer = 1 To nb_pareil
            add_new_etiquette(ref_prod, client_name)
        Next
    End Sub
 
    Public Function CreateFile() As Boolean
        Try
 
            'code qui créé le fichier
            Dim chaine_fichier As String = GetStringFile()
 
            Return True
        Catch ex As Exception
            MsgBox(ex.Message)
            Return False
        End Try
    End Function
 
    Private Function GetStringFile() As String
        GetStringFile = ""
        For Each e As element_to_print In elements_fichier
            GetStringFile = GetStringFile & _
                            "*FORMAT,xxx.lwl" & vbCrLf & _
                            "*QUANTITY,1" & vbCrLf & _
                            "*PRINTERNUMBER,1" & vbCrLf & _
                            "REFERENCE_PRODUIT," & e.ref_prod & vbCrLf & _
                            "CLIENT_NOM," & e.client_name & vbCrLf & _
                            "ETIQ_NUM," & e.etiquette_num & vbCrLf & _
                            "*PRINTLABEL" & vbCrLf & vbCrLf
 
        Next
        Return GetStringFile
    End Function
 
 
End Class
 
 
Public Class element_to_print
 
    Public ref_prod As String
    Public client_name As String
    Public etiquette_num As Integer
 
End Class

avec un appel du type

Code :

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

1
2
3
4
5
6
 
        Dim f As New FilePAS
        f.add_new_etiquette("450020", "toto")
        f.add_new_etiquette("450020", "toto", 10)
        f.add_new_etiquette("AAAA", "client2")
        f.CreateFile

enfin après reste plus qu'à nous dire où il peut y avoir des types différents
sachant que le type object passe partout
si tu complètes la description (car ca va ptete pas t'aller à fond) je complète le code

[D3Vavenir]

Merci à vous,

Je ne vais pas avoir le temps de me repencher sur le problème avant demain car... une réunion m'attend! Je sens que la soirée va être longue au boulot et courte à la maison.

Je me replonge dessus demain et je vous donnerais d'autres infos.

J'avais bien pensé aux surcharges pour d'autres méthodes mais là...en fait ce n'est qu'une fonction du programme principal pour pallier à un problème de "stockage" de l'information.

Très bonne soirée à tous! Demain est un autre jour (j'aurais probablement les yeux plus en face des trous) et la nuit porte conseil !

[D3Vavenir]

Bon j'ai simplifié le traitement et supprimé la liste de liste... en reprenant l'idée de Sperot51, c'est à dire créer plusieurs méthodes surchargées de ma classe setnewcollection (dans data_access) (en gros ma méthode surchargée permet de produire directement en sortie la structure voulue)

Merci encore, je cherchais un problème que je pouvais résoudre en amont.

Très cordialement!