Discussion :

[yaume91]

Bonjour,

Comment procéderiez vous pour pouvoir gérer dynamiquement une structure pour un objet

exemple, j'ai un objet ma carte avec les propriété "type" et "mapping"

Je voudrais que mapping est une certaines structures en fonction de la valeur de la propriété type:

Le mapping représente le type de mémoire de la carte:

Je voudrais un truc du genre:


Si Carte.type = 2 alors carte.mapping aurait une structure ressemblant a ceci:

Address1 C1 C2 C3 C4
Address2 C1 C2 C3 C4
Address3 C1 C2 C3 C4
Address4 C1 C2 C3 C4

Si Carte.type = 3 alors carte.mapping aurait une structure ressemblant a ceci:


Address1 C1 C2 C3 C4 C5 C6 C7
Address2 C1 C2 C3 C4 C5 C6 C7
Address3 C1 C2 C3 C4 C5 C6 C7
Address4 C1 C2 C3 C4 C5 C6 C7
Address5 C1 C2 C3 C4 C5 C6 C7
Address6 C1 C2 C3 C4 C5 C6 C7
Address7 C1 C2 C3 C4 C5 C6 C7

Sachant qu'il peut y avoir une multitude de mapping qui peuvent etre rajouter par la suite.

Comment pouvoir organiser le code pour pouvoir gérer simplement et dynamiquement l'ajout de structure mapping.

Mon idée était de mettre l'ensemble des structures dans un fichier à part.

J'imagine que ce genre de problématique doit souvent être gérés dans l'industrie, lorsqu'un logiciel gère par exemple de nouveau format

Comment s'y prend t on pour pouvoir faire quelque chose de propre ?

Merci

[yaume91]

Ayant l'esprit un peu plus clair et pour imager mon idée, voila comment je comptai faire.

Déclarer une fonction dans un nouveau module , avec uniquement les mapping memoire, l'idée etant d'avoir un peu plus de clarté et de simplicité le jour ou il y aurait besoin d'ajouter de nouveau mapping:

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
Public Module CARD_SRI_Mapping
 
	Public Function Mapping_CARD_SRI(ByVal ICCODE As ICCODE) As Byte(,)
		'Dim Mapping() As Byte
		Select Case ICCODE
			'Initialise un tableau image du mapping du SRT512
			Case ICCODE.SRT512
				' //17 Blocks adresses contenant chacun 4 octets
				Dim Mapping = New Byte(16,3) { _
					{&HFF, &HFF, &HFF, &HFF}, _
					{&HFF, &HFF, &HFF, &HFF}, _
					{&HFF, &HFF, &HFF, &HFF}, _
					{&HFF, &HFF, &HFF, &HFF}, _
					{&HFF, &HFF, &HFF, &HFF}, _
					{&HFF, &HFF, &HFF, &HFF}, _
					{&HFF, &HFF, &HFF, &HFF}, _
					{&HFF, &HFF, &HFF, &HFF}, _
					{&HFF, &HFF, &HFF, &HFF}, _
					{&HFF, &HFF, &HFF, &HFF}, _
					{&HFF, &HFF, &HFF, &HFF}, _
					{&HFF, &HFF, &HFF, &HFF}, _
					{&HFF, &HFF, &HFF, &HFF}, _
					{&HFF, &HFF, &HFF, &HFF}, _
					{&HFF, &HFF, &HFF, &HFF}, _
					{&HFF, &HFF, &HFF, &HFF}, _
					{&HFF, &HFF, &HFF, &HFF} _
				}
				Return Mapping
		End Select
 
	End Function
 
End Module

Par contre mon code m'amene un warning que je n'arrive pas à résoudre

La fonction 'Mapping_CARD_SRI' ne retourne pas une valeur pour tous les chemins de code.

Ok , mais si je déclare un tableau "Mapping" fictif apres le end Select , la j'ai une erreur

Code :

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

1
2
3
4
End Select
		Dim Mapping As Byte(0,0)
		Return Mapping
	End Function

La variable 'Mapping' masque une variable dans un bloc englobant. (BC30616)

[Phil Rob]

Bonjour,

Je ne sais si ça va t'aider (vu ton post de cette nuit) mais je t'envoie quand même ceci : TableauMultiDynamique.zip

Il s'agit d'un projet de test qui permet la gestion d'un tableau dynamique sur 2 dimensions : Nombre de lignes selon l'encodage et longueurs des lignes selon l'encodage aussi.

Bien sûr, il ne manquera pas de participants pour te dire qu'il existe des collections strictement dynamiques faites pour ça et blabla blabla ..., mais pour qui connait ses fondamentaux algorithmiques, les codes que je t'envoie ne sont guère compliqués et gèrent une "collection de String" strictement dynamique.

Bon amusement,

[ebastien]

Bonjour,

Et pourquoi ne pas passer par de l'héritage. Chaque carte héritée fournirait son propre mapping. Cela éviterait des IF et autres Case sur le type de carte et rendrait le code plus générique.

[StringBuilder]

+1 pour l'héritage.

Mais surtout, tout dépend de ce que tu veux faire de tes objets…
- Ils viennent d'où ?
- Tu en fais quoi ?
- Ils vont où ?

Car ça pourrait aussi bien être un simple string[][] où tbl[x][0] = le type, tout comme ça pourrait être un objet JSON ou n'importe quoi d'autre en fait...

[Thumb down]

Bonsoir,
juste une idée!

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
 Public Class Form1
    Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
        Dim MyObject(4, 4) As MyByte
        For Each f As MyByte In MyObject
            Debug.Print(f)
        Next
    End Sub
End Class
 
 
Public Class MyByte
    Private _value As Byte = Nothing
    Public Property Value
        Get
            Return _value
        End Get
        Set(value)
            _value = value
        End Set
    End Property
    Public Shared Widening Operator CType(ByVal val As Byte) As MyByte
        Return New MyByte(val)
    End Operator
    Public Shared Widening Operator CType(ByVal val As MyByte) As Byte
        If val Is Nothing Then val = New MyByte(&HFF)
        Return val.Value
    End Operator
    Public Sub New(ByVal Defaut As Byte)
        _value = Defaut
    End Sub
End Class

[yaume91]

Merci pour vos réponses.

Pour répondre à StringBuilder, je récupère le contenu d'une EPROM sous forme de tableau à 1 dimension de longueur variable contenant des Bytes

ContenuEPROM() as Byte = 03h , 12h,52h, ......

Le premier Byte de cette EPROM m'indique le type de carte utilisée qui peut avoir différentes structures:

Si Carte.type = 2 alors carte.mapping aurait une structure ressemblant a ceci:

Address1 C1 C2 C3 C4
Address2 C1 C2 C3 C4
Address3 C1 C2 C3 C4
Address4 C1 C2 C3 C4

Si Carte.type = 3 alors carte.mapping aurait une structure ressemblant a ceci:


Address1 C1 C2 C3 C4 C5 C6 C7
Address2 C1 C2 C3 C4 C5 C6 C7
Address3 C1 C2 C3 C4 C5 C6 C7
Address4 C1 C2 C3 C4 C5 C6 C7
Address5 C1 C2 C3 C4 C5 C6 C7
Address6 C1 C2 C3 C4 C5 C6 C7
Address7 C1 C2 C3 C4 C5 C6 C7

Ensuite chaque type de carte peut avoir une organisation des données différentes suivant un champ que je récupère ailleurs qui s'appelle PID

Par exemple pour le Carte.type = 3, je peux avoir:

Si PID = 0 alors DATA() = Byte( Address5 ,C2) & Byte( Address7 ,C6) & Byte( Address2 ,C3) & Byte( Address4 ,C1)
Si PID = 1 alors DATA() = Byte( Address6 ,C5) & Byte( Address3 ,C2) & Byte( Address7 ,C4) & Byte( Address1 ,C6)
Si PID = 2 alors DATA() = Byte( Address3 ,C4) & Byte( Address7 ,C1) & Byte( Address2 ,C7) & Byte( Address4 ,C5)
....

Et ensuite, j'ai encore une étape pour décoder les différents éléments contenu dans DATA comme ceci

ELEMENT1 = bit0 à 7 de DATA()
ELEMENT2 = bit8 à 12 de DATA()
ELEMENT3 = bit13 à 17 de DATA()
ELEMENT4 = bit18 à 29 de DATA()

Voilà, en ésperant que ce soit plus clair.

ce que je me disais c'est qu'il y avait peut etre la possibilité de passer du contenu de l'EPROM à DATA() sans forcement avoir une fonction puisque finalement il suffirait de récuperer les valeurs contenu aux adresses de l'EPROM.
Est il possible qu'implicitement DATA() contienne la bonne chaine d'octet sans faire une fonction qui va lire les octets dans le mapping de la carte.

Pour l'instant j'ai une fonction qui permet de renseigner le mapping de l'EPROM avec les valeurs de ContenuEPROM()
puis une fonction qui renseigne DATA() en fonction de PID qui va lire les valeurs contenu le mapping de l'EPROM

Note: je ne peux pas passer de ContenuEPROM() directement a DATA(), car j'ai besoin d'avoir le contenu dans Mapping à un moment dans mon pogramme.

Pensez vous qu'il est possible de faire autrement ?

MErci

[Thumb down]

bonjour,
je ne comprends pas pourquoi une structure de ce type là ne ferait pas l'affaire!

Address1	C1	C2	C3	C4	C5	C6	C7
Address2	C1	C2	C3	C4	C5	C6	C7
Address3	C1	C2	C3	C4	C5	C6	C7
Address4	C1	C2	C3	C4	C5	C6	C7
Address5	C1	C2	C3	C4	C5	C6	C7
Address6	C1	C2	C3	C4	C5	C6	C7
Address7	C1	C2	C3	C4	C5	C6	C7

[StringBuilder]

Pour moi l'héritage et le polymorphisme sont là pour ça...

Tu crées une classe générique et autant de classes dérivées qu'il y a de types de cartes mémoires.

Ensuite tu crées un "builder" d'instance static sur ta classe générique, qui prend en paramètre les bytes lus sur l'EPROM.
Il instancie alors selon le premier byte du tableau la bonne classe dérivée et retourne l'instance.

MaClasseGenerique instance1 = MaClasseGenerique.Build(ContenuEPROM())
MaClasseGenerique instance2 = MaClasseGenerique.Build(ContenuEPROM())
MaClasseGenerique instance3 = MaClasseGenerique.Build(ContenuEPROM())

Chaque "instance" ici sera potentiellement d'une classe dérivée différente et permettra de faire des traitements spécialisés en fonction du type de données qu'elle contient.

[StringBuilder]

Voici un rapide exemple (en C#) illustrant ma proposition :

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
 
using System;
 
namespace SandBox
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
 
            byte[] ligne1 = new byte[] { 1, 5, 12, 8 };
            byte[] ligne2 = new byte[] { 2, 5, 12 };
 
            MyBaseClass o1 = MyBaseClass.Builder(ligne1);
            MyBaseClass o2 = MyBaseClass.Builder(ligne2);
 
            Console.WriteLine(o1);
            Console.WriteLine(o2);
        }
    }
 
public abstract class MyBaseClass
    {
        public static MyBaseClass Builder(byte[] values)
        {
            switch (values[0])
            {
                case 1:
                    return new Type1Class(values);
                case 2:
                    return new Type2Class(values);
                default:
                    throw new NotImplementedException($"Type de ligne non reconnue : {values[0]:d}");
            }
        }
 
        public override string ToString()
        {
            throw new NotImplementedException($"Seules cles classes dérivées peuvent implémenter cette méthode");
        }
    }
 
    public class Type1Class : MyBaseClass
    {
        public Type1Class(byte[] values)
        {
            C1 = values[1];
            C2 = values[2];
            C3 = values[3];
        }
 
        public byte C1 { get; set; }
        public byte C2 { get; set; }
        public byte C3 { get; set; }
 
        public override string ToString()
        {
            return $"Type1Class : {C1}, {C2}, {C3}";
        }
    }
 
    public class Type2Class : MyBaseClass
    {
        public Type2Class(byte[] values)
        {
            C1 = values[1];
            C2 = values[2];
        }
 
        public byte C1 { get; set; }
        public byte C2 { get; set; }
 
        public override string ToString()
        {
            return $"Type2Class : {C1}, {C2}";
        }
    }
}

Sortie :

Hello World!
Type1Class : 5, 12, 8
Type2Class : 5, 12