Правильний спосіб завантаження методу складання, пошуку класу та виклику ()

Зразок консольної програми.

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();

    }
}

Я хочу динамічно побудувати збірку (.dll), а потім завантажити збірку, створити екземпляр класу та викликати метод Run () цього класу. Чи варто спробувати кинути клас TestRunner на щось? Не впевнений, як типи в одній збірці (динамічний код) знатимуть про мої типи в моїй (статична програма збірки / оболонки). Чи краще просто використовувати кілька рядків коду відображення для виклику Run () лише на об'єкті? Як повинен виглядати цей код?

ОНОВЛЕННЯ: Вільям Едмондсон - див. Коментар

Використовуйте AppDomain

Безпечніше та гнучкіше завантажувати збірку у свою AppDomain .

Отже, замість відповіді, поданої раніше :

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();

Я б запропонував наступне (адаптоване з цієї відповіді на відповідне питання ):

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();

Тепер ви можете розвантажити збірку та мати різні налаштування безпеки.

Якщо вам потрібна ще більша гнучкість та потужність для динамічного завантаження та розвантаження збірок, вам слід поглянути на керовану структуру надбудов (тобто System.AddInпростір імен). Для отримання додаткової інформації дивіться цю статтю про надбудови та розширення на MSDN .

Якщо у вас немає доступу до TestRunnerінформації про тип у викличній збірці (схоже, можливо, у вас немає), ви можете викликати метод таким чином:

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);

Якщо у вас є доступ до IRunnableтипу інтерфейсу, ви можете передати свій екземпляр до цього (а не до TestRunnerтипу, який реалізований у динамічно створеній або завантаженій збірці, так?):

  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();

Я роблю саме те, що ви шукаєте в моєму механізмі правил, який використовує CS-Script для динамічного компілювання, завантаження та запуску C #. Він повинен бути легко перекладений на те, що ви шукаєте, і я наведу приклад. По-перше, код (зачищений):

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;
        }
    }
}

Це візьме інтерфейс типу T, скомпілює файл .cs у збірку, створить екземпляр класу даного типу та вирівняє цей екземплярний клас до інтерфейсу T. По суті, вам просто потрібно переконатися, що екземплярний клас реалізує цей інтерфейс. Я використовую властивості для налаштування та доступу до всього, наприклад:

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; }
}

Наприклад, ви хочете викликати Run (), тому я створив інтерфейс, який визначає метод Run (), наприклад:

public interface ITestRunner
{
    void Run();
}

Потім створіть клас, який його реалізує, ось так:

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

Змініть назву RulesEngine на щось на зразок TestHarness і встановіть свої властивості:

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; }
}

Потім, де б ви не хотіли це зателефонувати, ви можете просто запустити:

ITestRunner testRunner = TestHarnessInterface;

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

Можливо, це чудово підійде для системи плагінів, але мій код як є обмежується завантаженням і запуском одного файлу, оскільки всі наші правила знаходяться в одному вихідному файлі C #. Я думаю, було б досить легко змінити його, щоб просто передати файл типу / джерела для кожного, який ви хотіли запустити. Вам просто потрібно було б перенести код із геттера в метод, який прийняв ці два параметри.

Крім того, використовуйте ваш IRunnable замість ITestRunner.

Вам потрібно буде використовувати відображення, щоб отримати тип "TestRunner". Використовуйте метод Assembly.GetType.

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();
    }
}

Коли ви збираєте свою збірку, ви можете зателефонувати AssemblyBuilder.SetEntryPointі повернути її зAssembly.EntryPoint властивості, щоб викликати її.

Майте на увазі, що ви захочете використовувати цей підпис, і зауважте, що його не потрібно називати Main:

static void Run(string[] args)