Richtige Methode zum Laden der Assembly, Suchen der Klasse und Aufrufen der Run () -Methode

Beispiel für ein Konsolenprogramm.

class Program
{
    static void Main(string[] args)
    {
        // ... code to build dll ... not written yet ...
        Assembly assembly = Assembly.LoadFile(@"C:\dyn.dll");
        // don't know what or how to cast here
        // looking for a better way to do next 3 lines
        IRunnable r = assembly.CreateInstance("TestRunner");
        if (r == null) throw new Exception("broke");
        r.Run();

    }
}

Ich möchte dynamisch eine Assembly (.dll) erstellen und dann die Assembly laden, eine Klasse instanziieren und die Run () -Methode dieser Klasse aufrufen. Sollte ich versuchen, die TestRunner-Klasse auf etwas zu übertragen? Ich bin mir nicht sicher, wie die Typen in einer Assembly (dynamischer Code) über meine Typen in meiner (statische Assembly / Shell-App) Bescheid wissen würden. Ist es besser, nur ein paar Zeilen Reflektionscode zu verwenden, um Run () nur für ein Objekt aufzurufen? Wie sollte dieser Code aussehen?

UPDATE: William Edmondson - siehe Kommentar

Verwenden Sie eine AppDomain

Es ist sicherer und flexibler, die Baugruppe selbst zu laden AppDomain .

Also anstelle der zuvor gegebenen Antwort :

var asm = Assembly.LoadFile(@"C:\myDll.dll");
var type = asm.GetType("TestRunner");
var runnable = Activator.CreateInstance(type) as IRunnable;
if (runnable == null) throw new Exception("broke");
runnable.Run();

Ich würde Folgendes vorschlagen (angepasst aus dieser Antwort auf eine verwandte Frage ):

var domain = AppDomain.CreateDomain("NewDomainName");
var t = typeof(TypeIWantToLoad);
var runnable = domain.CreateInstanceFromAndUnwrap(@"C:\myDll.dll", t.Name) as IRunnable;
if (runnable == null) throw new Exception("broke");
runnable.Run();

Jetzt können Sie die Baugruppe entladen und verschiedene Sicherheitseinstellungen vornehmen.

Wenn Sie noch mehr Flexibilität und Leistung für das dynamische Laden und Entladen von Assemblys wünschen, sollten Sie sich das Managed Add-Ins Framework (dh den System.AddInNamespace) ansehen . Weitere Informationen finden Sie in diesem Artikel zu Add-Ins und Erweiterbarkeit auf MSDN .

Wenn Sie keinen Zugriff auf die TestRunnerTypinformationen in der aufrufenden Assembly haben (dies scheint nicht der Fall zu sein), können Sie die Methode folgendermaßen aufrufen:

Assembly assembly = Assembly.LoadFile(@"C:\dyn.dll");
Type     type     = assembly.GetType("TestRunner");
var      obj      = Activator.CreateInstance(type);

// Alternately you could get the MethodInfo for the TestRunner.Run method
type.InvokeMember("Run", 
                  BindingFlags.Default | BindingFlags.InvokeMethod, 
                  null,
                  obj,
                  null);

Wenn Sie Zugriff auf den IRunnableSchnittstellentyp haben, können Sie Ihre Instanz in diesen umwandeln (und nicht in den TestRunnerTyp, der in der dynamisch erstellten oder geladenen Assembly implementiert ist, oder?):

  Assembly assembly  = Assembly.LoadFile(@"C:\dyn.dll");
  Type     type      = assembly.GetType("TestRunner");
  IRunnable runnable = Activator.CreateInstance(type) as IRunnable;
  if (runnable == null) throw new Exception("broke");
  runnable.Run();

Ich mache genau das, wonach Sie in meiner Regel-Engine suchen, die verwendet CS-Script zum dynamischen Kompilieren, Laden und Ausführen von C # verwendet. Es sollte leicht in das zu übersetzen sein, wonach Sie suchen, und ich werde ein Beispiel geben. Zuerst der Code (abgespeckte):

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using CSScriptLibrary;

namespace RulesEngine
{
    /// <summary>
    /// Make sure <typeparamref name="T"/> is an interface, not just any type of class.
    /// 
    /// Should be enforced by the compiler, but just in case it's not, here's your warning.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class RulesEngine<T> where T : class
    {
        public RulesEngine(string rulesScriptFileName, string classToInstantiate)
            : this()
        {
            if (rulesScriptFileName == null) throw new ArgumentNullException("rulesScriptFileName");
            if (classToInstantiate == null) throw new ArgumentNullException("classToInstantiate");

            if (!File.Exists(rulesScriptFileName))
            {
                throw new FileNotFoundException("Unable to find rules script", rulesScriptFileName);
            }

            RulesScriptFileName = rulesScriptFileName;
            ClassToInstantiate = classToInstantiate;

            LoadRules();
        }

        public T @Interface;

        public string RulesScriptFileName { get; private set; }
        public string ClassToInstantiate { get; private set; }
        public DateTime RulesLastModified { get; private set; }

        private RulesEngine()
        {
            @Interface = null;
        }

        private void LoadRules()
        {
            if (!File.Exists(RulesScriptFileName))
            {
                throw new FileNotFoundException("Unable to find rules script", RulesScriptFileName);
            }

            FileInfo file = new FileInfo(RulesScriptFileName);

            DateTime lastModified = file.LastWriteTime;

            if (lastModified == RulesLastModified)
            {
                // No need to load the same rules twice.
                return;
            }

            string rulesScript = File.ReadAllText(RulesScriptFileName);

            Assembly compiledAssembly = CSScript.LoadCode(rulesScript, null, true);

            @Interface = compiledAssembly.CreateInstance(ClassToInstantiate).AlignToInterface<T>();

            RulesLastModified = lastModified;
        }
    }
}

Dies nimmt eine Schnittstelle vom Typ T, kompiliert eine CS-Datei in eine Assembly, instanziiert eine Klasse eines bestimmten Typs und richtet diese instanziierte Klasse an der T-Schnittstelle aus. Grundsätzlich müssen Sie nur sicherstellen, dass die instanziierte Klasse diese Schnittstelle implementiert. Ich benutze Eigenschaften, um alles einzurichten und darauf zuzugreifen, wie folgt:

private RulesEngine<IRulesEngine> rulesEngine;

public RulesEngine<IRulesEngine> RulesEngine
{
    get
    {
        if (null == rulesEngine)
        {
            string rulesPath = Path.Combine(Application.StartupPath, "Rules.cs");

            rulesEngine = new RulesEngine<IRulesEngine>(rulesPath, typeof(Rules).FullName);
        }

        return rulesEngine;
    }
}

public IRulesEngine RulesEngineInterface
{
    get { return RulesEngine.Interface; }
}

In Ihrem Beispiel möchten Sie Run () aufrufen, daher würde ich eine Schnittstelle erstellen, die die Run () -Methode wie folgt definiert:

public interface ITestRunner
{
    void Run();
}

Erstellen Sie dann eine Klasse, die sie wie folgt implementiert:

public class TestRunner : ITestRunner
{
    public void Run()
    {
        // implementation goes here
    }
}

Ändern Sie den Namen von RulesEngine in TestHarness und legen Sie Ihre Eigenschaften fest:

private TestHarness<ITestRunner> testHarness;

public TestHarness<ITestRunner> TestHarness
{
    get
    {
        if (null == testHarness)
        {
            string sourcePath = Path.Combine(Application.StartupPath, "TestRunner.cs");

            testHarness = new TestHarness<ITestRunner>(sourcePath , typeof(TestRunner).FullName);
        }

        return testHarness;
    }
}

public ITestRunner TestHarnessInterface
{
    get { return TestHarness.Interface; }
}

Dann können Sie überall dort, wo Sie es aufrufen möchten, einfach Folgendes ausführen:

ITestRunner testRunner = TestHarnessInterface;

if (null != testRunner)
{
    testRunner.Run();
}

Es würde wahrscheinlich gut für ein Plugin-System funktionieren, aber mein Code ist so wie er ist auf das Laden und Ausführen einer Datei beschränkt, da sich alle unsere Regeln in einer C # -Quelldatei befinden. Ich würde denken, dass es ziemlich einfach wäre, es so zu ändern, dass nur die Typ- / Quelldatei für jede Datei übergeben wird, die Sie ausführen möchten. Sie müssten nur den Code aus dem Getter in eine Methode verschieben, die diese beiden Parameter verwendet.

Verwenden Sie Ihr IRunnable auch anstelle von ITestRunner.

Sie müssen Reflection verwenden, um den Typ "TestRunner" zu erhalten. Verwenden Sie die Assembly.GetType-Methode.

class Program
{
    static void Main(string[] args)
    {
        Assembly assembly = Assembly.LoadFile(@"C:\dyn.dll");
        Type type = assembly.GetType("TestRunner");
        var obj = (TestRunner)Activator.CreateInstance(type);
        obj.Run();
    }
}

Wenn Sie Ihre Assembly erstellen, können Sie sie aufrufen AssemblyBuilder.SetEntryPointund dann von der Assembly.EntryPointEigenschaft zurückholen , um sie aufzurufen.

Denken Sie daran, dass Sie diese Signatur verwenden möchten, und beachten Sie, dass sie nicht benannt werden muss Main:

static void Run(string[] args)