असेंबली लोड करने का सही तरीका, क्लास और कॉल रन () विधि का पता लगाएं

Question 1

नमूना सांत्वना कार्यक्रम।

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) का निर्माण करना चाहता हूं, और फिर असेंबली को लोड करता हूं, एक क्लास को इंस्टेंट करता हूं, और उस क्लास की रन () विधि को कॉल करता हूं। क्या मुझे TestRunner क्लास को कुछ करने की कोशिश करनी चाहिए? यह निश्चित नहीं है कि एक विधानसभा (डायनामिक कोड) के प्रकारों को मेरे (स्टेटिक असेंबली / शेल ऐप) में मेरे प्रकारों के बारे में कैसे पता चलेगा। क्या सिर्फ एक वस्तु पर रन () कॉल करने के लिए प्रतिबिंब कोड की कुछ पंक्तियों का उपयोग करना बेहतर है? उस कोड को कैसा दिखना चाहिए?

अद्यतन: विलियम एडमंडसन - टिप्पणी देखें

Question 2

एक 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 पर ऐड-इन्स और एक्स्टेंसिबिलिटी पर यह लेख देखें ।

Question 3

यदि आपके पास 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();

Question 4

मैं बिल्कुल वही कर रहा हूं जो आप मेरे नियम इंजन में देख रहे हैं, जो गतिशील रूप से संकलन, लोड करने और C # चलाने के लिए CS-Script का उपयोग करता है। यह आसानी से अनुवाद योग्य होना चाहिए कि आप क्या खोज रहे हैं, और मैं एक उदाहरण दूंगा। सबसे पहले, कोड (छीन लिया गया):

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

अपने उदाहरण के लिए, आप रन () को कॉल करना चाहते हैं, इसलिए मैं एक इंटरफ़ेस बनाऊंगा जो रन () विधि को परिभाषित करता है, जैसे:

public interface ITestRunner
{
    void Run();
}

फिर एक वर्ग बनाएं जो इसे लागू करता है, जैसे:

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

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

यह शायद एक प्लगइन सिस्टम के लिए बहुत अच्छा काम करेगा, लेकिन जैसा कि मेरा कोड एक फ़ाइल लोड करने और चलाने तक सीमित है, क्योंकि हमारे सभी नियम एक सी # स्रोत फ़ाइल में हैं। मुझे लगता है कि इसे संशोधित करना बहुत आसान होगा, बस इसे टाइप / सोर्स फाइल में पास करना होगा हर एक के लिए जिसे आप चलाना चाहते थे। आपको बस कोड को गेट्टर से एक विधि में स्थानांतरित करना होगा जो उन दो मापदंडों को ले गया।

इसके अलावा, ITestRunner के स्थान पर अपने IRunnable का उपयोग करें।

Question 5

आपको "TestRunner" प्रकार प्राप्त करने के लिए प्रतिबिंब का उपयोग करने की आवश्यकता होगी। असेंबली का उपयोग करें। गेट टाइप विधि।

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

Question 6

जब आप अपना असेंबली बनाते हैं, तो आप कॉल कर सकते हैं AssemblyBuilder.SetEntryPoint, और फिर इसे वापस लाने के लिए इसे Assembly.EntryPointसंपत्ति से वापस ले सकते हैं।

ध्यान रखें कि आप इस हस्ताक्षर का उपयोग करना चाहते हैं, और ध्यान दें कि इसका नाम नहीं है Main:

static void Run(string[] args)