Discussion :

[Lemontree]

J'ai besoin de faire une application modulaire dont un des module stocke ses propriétés dans le app.config. J'ai créé une dll contenant ce fameux module. Il contient uniquement une classe héritant de ConfigurationSection et implémentant une interface générique de mon cru (ICanalGenerique).

Le noyau implémentant les modules n'a connaissance que de mon interface générique, les dll étant gérées par pluggin. J'utilise donc la reflection pour instancier ma classe contenue dans la dll.

J'ai fait un test direct de ma dll sans passer par la reflection et mon objet charge bien ses propriétés depuis le app.config, en utilisant ce 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
19
using System;
using System.Linq;
using System.Configuration;
using System.IO;
using Copilote.CanalUNC;
using Copilote.CanalGenerique;
 
namespace ConsoleApplication1
{
  class Program
  {
    static void Main()
    {
      CanalUNC section = (CanalUNC)ConfigurationManager.GetSection("CanalUNC");
      Console.WriteLine("{0} ; {1}", section.DirectoryAsc, section.DirectoryAscSave);
      Console.ReadLine();
    }
  }
}

Par contre, je ne trouve pas de moyen pour le faire via la reflection ; mon code dans ce cas :

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
using System;
using System.Collections.Specialized;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Copilote.GestionLog;
using Copilote.CanalGenerique;
using System.IO;
using System.Reflection;
using System.Configuration;
 
namespace TestEchanges
{
 class Program
 {
  static void Main(string[] args)
  {
   LogSingleton.Instance.IsChronodate = true;
   LogSingleton.Instance.AddEntry(null, new LogEventArgs(TypeLog.Noyau, TypeErreur.Information, "Démarrage de l'application."));
   NameValueCollection appSettings = ConfigurationManager.AppSettings;
   NameValueCollection configSettings = null;
   for (int i = 0; i < appSettings.Count; i++)
   {
    if (appSettings.GetKey(i) == "Config")
     configSettings = (NameValueCollection)ConfigurationManager.GetSection(appSettings[appSettings.GetKey(i)]);
   }
   Assembly monAssembly = Assembly.LoadFrom(Path.Combine(Environment.CurrentDirectory, configSettings["Canal"]));
   // Introspection des types
   ICanalGenerique monCanal;
   foreach (Type type in monAssembly.GetTypes())
   {
    if (type.GetInterface(typeof(ICanalGenerique).FullName) != null)
    {
     // Un type correspond, création d'un objet
     monCanal = (ICanalGenerique)Activator.CreateInstance(type, ConfigurationManager.GetSection("CanalUNC"));
     // Liaison de l'événement à la fonction de traçage
     monCanal.RaiseLogEvent += LogSingleton.Instance.AddEntry;
 
     // Tentative de lecture
     MemoryStream monStream = new MemoryStream();
     monCanal.GetData(ref monStream);
 
     byte[] byteArray = new byte[monStream.Length];
     var count = monStream.Read(byteArray, 0, (int)monStream.Length);
 
     Console.WriteLine(Encoding.Default.GetString(byteArray));
    }
   }
 
   // On attend...
   Console.ReadLine();
  }
 }
}

Qu'est ce que je fait de travers ?

Merci d'avance !

[Lemontree]

J'ai contourné mon problème en partant d'un objet déclaré en ConfigurationSection et en appelant mes méthodes interfacées via le InvokeMember...

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
// Introspection des types
      foreach (Type monType in canalAssembly.GetTypes())
      {
        // Si la classe présente dans l'assembly implémente une ICanalGenerique, il s'agit d'un canal
        if (monType.GetInterface(typeof(ICanalGenerique).FullName) != null)
        {
          // On part du principe que tout objet géré par le noyau hérite de ConfigurationSection, ce qui permet de sauvegarder les propriétés dans le app.config
          ConfigurationSection monCanal = null;
          // Un type correspond, création d'un objet
          monCanal = (ConfigurationSection)Activator.CreateInstance(monType);
          // On lui colle la section du app.config correspondante
          monCanal = (ConfigurationSection)ConfigurationManager.GetSection(monType.Name);
 
          try
          {
            // Liaison de l'événement à la fonction de traçage
            // On fait un appel du style monCanal.RaiseLogEvent += LogSingleton.Instance.AddEntry; mais en utilisant la reflection
            // On récupère un pointeur sur l'événement
            EventInfo evClick = monType.GetEvent("RaiseLogEvent");
            // Puis son type
            Type tDelegate = evClick.EventHandlerType;
            // On fabrique un handler sur la fonction à lier
            MethodInfo myHandler = typeof(GestionLog).GetMethod("AddEntry", BindingFlags.Public | BindingFlags.Instance);
            // On crée le délégué sur la fonction à lier
            Delegate d = Delegate.CreateDelegate(tDelegate, GestionLog.Instance, myHandler);
            // On récupère le pointeur sur la fonction
            MethodInfo addHandler = evClick.GetAddMethod();
            // Par reflection, on lie le bazard
            addHandler.Invoke(monCanal, new Object[] { d });
          }
          catch
          {
            GestionLog.Instance.AddEntry(null, new LogEventArgs(TypeLog.Noyau, TypeErreur.Information, "Erreur de liaison du Log au Canal."));
          }
 
          // Tentative de lecture
          monStream = new MemoryStream();
          // Puisqu'on sait qu'il s'agit d'un canal, l'objet doit avoir la methode 'GetData'
          // On fait un appel du style monCanal.GetData(ref monStream); mais en utilisant la reflection
          bool Result = false;
          try
          {
            Result = (bool)monCanal.GetType().InvokeMember("GetData", BindingFlags.Default | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.InvokeMethod, null, monCanal, new object[] { monStream });
          }
          catch (MissingMethodException mme)
          {
            // Dans le cas ou la méthode n'est pas un membre de ce type ...
            Console.WriteLine("Méthode 'GetData' introuvable : " + mme.Message);
          }

Et c'est opérationnel...