Discussion :

[Neitsa]

Bonjour à tous,

Je suis en train d'écrire un lecteur de fichier PE (Portable Executable, la norme des fichiers exécutables microsoft) en C# 2.0.

J'ai un problème que je ne sais pas règler, je pense que les "génériques" peuvent m'aider, mais je ne sais pas comment faire, ni même si c'est possible.

Suivant la machine cible ou l'exécutable sera exécuté, certaines parties des fichiers PE (PE 32 bits, PE 64 bits, PE Rom, PE XBOX, etc.) sont différentes.

Prenons l'exemple d'une structure d'un fichier PE nommée IMAGE_OPTIONAL_HEADER, dont il existe plusieurs version, notamment 32 ou 64 bits.

voilà ma classe :

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
 
    public class ImageOptionalHeader : Region
    {
        PE_Struct.IMAGE_OPTIONAL_HEADER32 _IOH32; //struct 32 bits
        PE_Struct.IMAGE_OPTIONAL_HEADER64 _IOH64; // struct 64 bits
        bool _IsOptionalHeader64; // true si 64 bits
 
        public ImageOptionalHeader(FileStream fs)
        {
            ImageNtHeader INH = new ImageNtHeader(fs);//détermine si le PE est 32 ou 64 bits
            if (INH.IsPE64 == false)//PE 32 bits
            {
                _IOH32 = INH.IMAGE_NT_HEADER32.OptionalHeader;
                Length = INH.IMAGE_NT_HEADER32.FileHeader.SizeOfOptionalHeader;
            }
            else //PE 64 bits
            {
                _IOH64 = INH.IMAGE_NT_HEADER64.OptionalHeader;
                Length = INH.IMAGE_NT_HEADER64.FileHeader.SizeOfOptionalHeader;
                _IsOptionalHeader64 = true;
            }
 
            Start = INH.Start + sizeof(uint) + Marshal.SizeOf(typeof(PE_Struct.IMAGE_FILE_HEADER));            
        }
        public PE_Struct.IMAGE_OPTIONAL_HEADER32 IMAGE_OPTIONAL_HEADER32
        {
            get { return _IOH32; }
            set { _IOH32 = value; }
        }
        public PE_Struct.IMAGE_OPTIONAL_HEADER64 IMAGE_OPTIONAL_HEADER64
        {
            get { return _IOH64; }
            set { _IOH64 = value; }
        }
        public bool IsOptionalHeader64
        {
            get { return _IsOptionalHeader64; }
        }
    }

Le problème qui se pose, c'est que lorsque l'utilisateur tente d'accèder à un objet ImageOptionalHeader, il verra à la fois :
- IMAGE_OPTIONAL_HEADER32
- IMAGE_OPTIONAL_HEADER64

Hors seul l'un des deux à une signification ! (le PE est soit 32 bits, soit 64 bits, mais pas les deux).

(et encore je n'ai pas implémenter les autres types de structures... l'utilisateur peut donc se retrouver avec 10 structures dont une seule est réellement valide, c-a-d qu'elle contient quelque chose.)

Ma question est, comment proposer à l'utilisateur de ma classe une seule structure (ou objet) qui serait à même de représenter tout les types de IMAGE_OPTIONAL_HEADER ?

De cette façon l'utilisateur n'aura pas à savoir dans un premier temps de quel type est la structure. Bien sûr, s'il veut l'utiliser il faudra qu'il sache de quelle type elle est.

Question similaire :Ce qui me dérange réellement c'est de proposer 10 membres données alors qu'un seul est réellement utile et pertinent, comment arranger cela ?

J'espère avoir été clair

Merci pour votre aide

[Mehdi Feki]

Salut Neitsa,

Pourquoi ne pas heriter de ImageOptionalHeader pour chacun des types 32 64 bits ....

Ensuite tu utilise le pattern Factory pour creer le Header approprié.

[Neitsa]

Bonjour mehdi_tn,

Merci beaucoup pour ta réponse et pour avoir pris le temps d'y réfléchir.

Effectivement, j'avais complètement oublié ce pattern et je pense que c'est exactement ce qu'il me faut !

Merci beaucoup, la question est résolue !