Discussion :

[funkydata]

Salut,
je suis en train (enfin j'essaye plutôt ) de faire une fonction de chargement générique. Ce que je veux obtenir est la chose suivante :

Code :

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

MonType MarVar = Import.Load<MonType>(MonFichier);

La fonction "Load" utilise des "codecs" pour charger convenablement les différents types de variables. Ces codecs possèdent une propriété "Type" indiquant quel type d'objet il est destiné à importer. Donc dans ce cas présent la fonction "Load" va chercher le "codec" destiné à charger les objets de type "MonType" puis retourner un "object" qui sera le resultat de l'importation.

1er problème : y-a-t'il un moyen d'éviter de faire un cast explicite de l'objet retourné ? actuellement je suis obligé de faire ceci pour que cela fonctionne :

Code :

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

MonType MarVar = (MonType)Import.Load<MonType>(MonFichier);

2ème problème : En prenant le même exemple, je dois dans certains cas lier le codec à une interface ou une classe abstraite :

Code :

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

1
2
MonType1 : MonInterface
MonType2 : MonInterface

Le codec est ici fait pour charger un objet "MonInterface". Comment dans ce cas tester si "MonType1" est bien un objet hérité de l'interface "MonInterface" afin que la fonction "Load" affecte bien le chargement de cet objet au bon codec ?

Voilà j'espère avoir été clair, c'est pas vraiment facile à expliquer

[StormimOn]

Pour le 1er problème, si j'ai bien compris, procède ainsi

Code :

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

1
2
public T Load<T> (T item) 
{ return item; }

Pour le 2ème problème c'est possible en contraignant le type du paramètre au niveau de la dérivation

Code :

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

1
2
public void Load<T> (T item) where T : ICloneable
{ ... }

Une erreur sera levée à la compilation si T n'implémente pas ICloneable. Très pratique le cas échéant

[funkydata]

J'ai résolu le premier problème... tu m'as mis sur la voie. Je ne sais pas pourquoi je n'y avais pas penser avant

Code :

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

1
2
3
4
5
6
 
public T Load<T>(string Filename)
{
      ....
      return (T)ImportCodecs[CodecIndex].Import(Filename);
}

Par contre pour le second problème il est certain que de contraindre le type aurait été le plus simple malheuresement dans mon cas ce n'est pas possible dans la mesure ou je ne connais pas à l'avance les types supportés par les codecs ni même si les objets sont ou non susceptibles d'être interfacés. Du coup tout doit se passer dans le runtime.
Alors, j'ai trouvé une méthode pour faire ce que je veux mais je ne pense pas que ca soit trés propre ... mais ca fonctionne.

L'appel dans la fonction Load<T> :

Code :

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

int CodecIndex = GetCodecIndex(typeof(T));

La fonction :

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
 
private int GetCodecIndex(Type ThisType)
{
    // Scan de tous les codecs
    for (int i = 0; i < ImportCodecs.Count; i++)
    {
        // Si le codec est affecté à un type interface...
        if (ImportCodecs[i].Type.IsInterface)
        {
            // On scan toutes les interfaces du type à tester
            Type[] Interfaces = ThisType.GetInterfaces();
            for (int j = 0; j < Interfaces.Length; j++)
                if (Interfaces[j] == ImportCodecs[i].Type)
                    return i; // Trouvé !
        }
        // ...sinon le type assigné au codec doit être le même que celui de l'objet à créer
        else if (ImportCodecs[i].Type == ThisType)
            return i; // Trouvé
    }
 
    // Pas trouvé !
    return -1;
}

Voilà si quelqu'un à une méthode plus propre je prends