C# Windows Service et Remoting

Question

Je voudrais créer un service Windows qui peut charger plusieurs DLL à partir d'un certain emplacement et les publier en utilisant Remoting sur un port TCP spécifique (disons 9000).

Chaque DLL contient une seule classe qui sera publiée.

Par exemple (Test.dll)

namespace Test 
{ 
    class Service 
    { 
    // methods here 
    } 
} 

Le service devrait publier à l'aide Remoting tcp://<servername>:9000/Test.dll

Je sais comment utiliser Remoting mais je voudrais savoir comment mettre en œuvre le service afin que il peut charger dynamiquement les DLL au démarrage et les décharger lors de l'arrêt.

Peut-il y avoir une autre façon de le faire?

Answer 1

Vous pouvez utiliser les nombreuses méthodes de la classe Assembly pour cela, elles sont chargées dans AppDomain qui sera déchargé avec le service lorsque vous l'arrêtez.

Départ: http://msdn.microsoft.com/en-us/library/system.reflection.assembly.loadfile.aspx

Answer 2

Si vous cherchez une solution robuste, regardez dans MEF, le cadre d'extensibilité géré.

Cependant, si vous voulez juste charger les DLL sous forme de plugins simples, j'ai quelques exemples de code de mon TournamentApi:

/// <summary> 
/// Provides methods to load plugins from external assemblies. 
/// </summary> 
public static class PluginLoader 
{ 
    ... 

    /// <summary> 
    /// Loads the plugins from a specified assembly. 
    /// </summary> 
    /// <param name="assembly">The assembly from which to load.</param> 
    /// <returns>The plugin factories contained in the assembly, if the load was successful; null, otherwise.</returns> 
    public static IEnumerable<IPluginFactory> LoadPlugins(Assembly assembly) 
    { 
     var factories = new List<IPluginFactory>(); 

     try 
     { 
      foreach (var type in assembly.GetTypes()) 
      { 
       IPluginEnumerator instance = null; 

       if (type.GetInterface("IPluginEnumerator") != null) 
       { 
        instance = (IPluginEnumerator)Activator.CreateInstance(type); 
       } 

       if (instance != null) 
       { 
        factories.AddRange(instance.EnumerateFactories()); 
       } 
      } 
     } 
     catch (SecurityException ex) 
     { 
      throw new LoadPluginsFailureException("Loading of plugins failed. Check the inner exception for more details.", ex); 
     } 
     catch (ReflectionTypeLoadException ex) 
     { 
      throw new LoadPluginsFailureException("Loading of plugins failed. Check the inner exception for more details.", ex); 
     } 

     return factories.AsReadOnly(); 
    } 
} 

Cela prend un ensemble chargé et instancier une instance de chaque IPluginEnumerator dans l'assemblée et a il retourner chaque IPluginFactory (Usine abstraite) qu'il prend en charge.

N'hésitez pas à jeter un coup d'œil au code source du projet TournamentApi pour le reste du code.

Answer 3

Vous pouvez facilement charger des assemblages dans le framework .NET. Jetez un oeil à la méthode de charge de la classe d'assemblage pour savoir comment procéder:

http://msdn.microsoft.com/en-us/library/xbe1wdx9%28v=VS.71%29.aspx