Bonjour à tous !
Suite au problème évoqué ici (pour les plus courageux... vous n'êtes cependant pas obligé de "lire" puisque je vais réexposer le probleme) : http://www.csharpfr.com/forum.v2.aspx?ID=538189
j'ai décidé de me tourner vers la liaison tardive.

Rapidemlent, le contexte :
J'ai deux ensembles de classes avec des dépendances entre eux (dans les 2 sens) et j'aimerais créer deux dll différentes pour ces 2 ensembles.
L'une des solutions évoquées dans le topic ci-dessus consiste à utiliser la réflexion et les liaisons tardives pour créer la première dll (après, pour la deuxième, c'est "facile" puisqu'il suffit d'importer la première :))
Le problème est que je ne sais pas trop comment faire cette liaison tardive... J'ai trouvé ici : http://www.c-sharpcorner.com/Code/2003/Oct/LateBindingWithReflection.asp quelque chose qui me paraît très intéressant... cependant ils ont l'air de charger l'assembly à partir d'une dll ... Or c'est cette que je chercher à CREER (donc je ne peux l'avoir sous la main avant de l'avoir créé ^^)

Ce que j'aimerais en fait, c'est savoir s'il serait possible de "compiler et utiliser" un fichier .cs :)
Je pense que si j'arrivais à faire ça, je pourrais m'en sortir avec mes liaisons tardives ^^

Merci d'avance :)

On s'est mal compris ( encore ), quand je parlais de la réflexion c'etait pour appeler une méthode avec "un lien tardif" pas pour créer un assembly dynamiquement. La réflexion permet d'appeler une méthode juste en disposant de son nom ainsi à la compilation ta librarie n'a plus de dépendance avec la seconde, est-ce-que ca semble pouvoir résoudre ton problème ? je remet le petit résumé de l'autre post:

1 ) Charger l'assembly.
2 ) Chercher la méthode dans l'assembly.
3 ) Créer une instance de la classe si la méthode n'est pas static.
4 ) Appeler la méthode.

Voilà un exemple minimaliste de lien tardif pour appeler une méthode:

class App
{
   private const string ASSEMBLY_NAME = "MyLib.dll";
   private const string CLASS_NAME = "MyLib.MyClass";
   private const string METHOD_NAME = "MyMethod";

   [ STAThread ]
   private static void Main( )
   {
      try
      {
         // On Charge l'assembly.
         Assembly assembly = Assembly.LoadFrom( ASSEMBLY_NAME );
         // On obtient la classe.
         Type type = assembly.GetType( CLASS_NAME );
         // On obtient la méthode.
         MethodInfo method = type.GetMethod( METHOD_NAME );
         // On créer l'objet.
         object target = Activator.CreateInstance( type );
         // On appele la méthode.
         string s = ( string )method.Invoke( target, new object[ ] { "Hello World" } );

         /* Autre technique pour appeler la méthode.
         string s = ( string )type.InvokeMember
         (
            METHOD_NAME,
            BindingFlags.InvokeMethod,
            null,
            target,
            new object[ ] { "Hello World" }
         );
         */

         Console.WriteLine( s );
         Console.ReadLine( );

      }
      catch ( Exception ex )
      {
         Console.WriteLine( ex.ToString( ) );
      }
   }
}

la méthode de Lutinore fonctionne parfaitement... malheureusement, le repproche c'est qu'à la compilation de ton appli tu dois connaître le nom de la méthode que tu appelles ainsi que ces paramètres.

Je suis en train de voir pour te faire une source exploitant l'idée des plugins, ca te permet de charger dynamiquement une assembly et de l'appeler sans la connaître... puisqu'elle implémente une interface

---

Sébastien FERRAND
Blog : http://blogs.developpeur.org/sebmafate

oki merci beaucoup ^_^

Cela dit j'ai trouvé ma "solution" qui en fait était vraiment toute conne (mais je pense qu'elle ne marche que dans les cas "simples" où on a pas trop trop de dépendances entre les 2 assembly :
- dans l'assembly présentant le plus petit nombre de dépendances (on appellera cet assembly l'assembly A) vers l'autre assembly (... et celui la l'assembly B), on "commente" toutes ces dépendances, et on compile une DLL A.dll
- On importe la DLL A.dll dans l'assembly B, les dépendances sont donc disponibles, on compile la DLL B.dll
- On importe la DLL B.dll dans l'assembly A, les dépendances sont donc disponibles, on peut décommenter nos lignes et recompiler la DLL A.dll :p

Bon maintenant, si une des méthodes appelées d'une DLL à l'autre vient à changer, faut "s'amuser" à refaire la p'tite manip ci-dessus...
(mais je pense qu'on a le meme problème avec la liaison tardive ^^)

merci a Lutinore : j'avais bien compris que c'était comme ca qu'il fallait procéder (c'est ce qui est décrit dans l'url que j'avais donné si je ne m'abuse) mais je viens de m'apercevoir que ce que je me suis planté lorsque je me suis dit "mais ils utilisent une dll que justement je cherche a créer" : on l'utilise en effet dans le code mais, au départ, c'est vrai qu'elle n'a pas besoin d'exister...

Merci en tous cas :)
et Seb, je reste ouvert a ta solution de plugins =) (si ca ne t'embete pas hein ^^) ... je suis relativement ouverts aux solutions les plus "propres" généralement :)