Question

所以这是我的插件/外部对象

namespace Outer
{
    interface IMonster
    {
        String GetName();
    }
    interface IPlugin
    {
        String GetGameVersion();
        long GetPureTime();
        IMonster GetMonster(int iEntityIndex);
    }

    abstract class TheHack
    {
        public abstract void OnEnabled(IPlugin pluginInterface);
        public abstract void OnDisabled();
    }

    class Plugin : TheHack
    {
        public override void OnEnabled(IPlugin pluginInterface)
        {
            Console.WriteLine(pluginInterface.GetMonster(0).GetName());
        }

        public override void OnDisabled()
        {
            Console.WriteLine("Plugin disabled");
        }
    }
}

这是我的内部代码，它抓取插件程序集，创建一个新的Outer类实例并执行它，并将我的内部代码中的全局插件对象传递给类实例。

namespace Inner
{
    interface IMonster
    {
        String GetName();
    }
    interface IPlugin
    {
        String GetGameVersion();
        long GetPureTime();
        IMonster GetMonster(int iEntityIndex);
    }
    abstract class TheHack
    {
        public abstract void OnEnabled(IPlugin pluginInterface);
        public abstract void OnDisabled();
    }
    class ImplMonster : IMonster
    {
        public String GetName()
        {
            return "A cute cat";
        }
    }
    class Impl: IPlugin
    {
        public String GetGameVersion()
        {
            return "-1";
        }

        public long GetPureTime()
        {
            return DateTime.Now.Ticks;
        }

        public IMonster GetMonster(int iEntityIndex)
        {
            return new ImplMonster();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
           var tp = Assembly.Load("plugin.dll").GetType("Outer.Plugin");
           if (tp != null)
           {
               var cls = Activator.CreateInstance(tp);

               MethodInfo mi = tp.GetMethod("OnEnabled", new[] {typeof (IPlugin)});

               if (mi != null && tp.IsSubclassOf(typeof (TheHack)))
               {
                  mi.Invoke(cls, new[] {new Implementation()});
               }
            }
            Console.ReadLine();
        }
    }
}

但是当我调试这些代码时，控制台上没有结果，所以我决定取消空保护代码，但调试器告诉我内部的对象不能应用于外部，但是它们扩展，实现了相同的类，相同的结构，但调试器只是告诉我它无法运行。

为什么会发生这种情况，以及如何忽略/绕过检查，因为我想制作一个插件系统，在那里我可以操纵纯虚方法在C ++中实现这一点，但在C＃中，没有相同的相关（在C＃中没有纯虚函数，思想抽象函数类似但类型安全，我不能通过内存地址，因为我没有运行不安全的代码）也没有任何类似的方法来执行此操作。

Answer 1

看起来你已经定义了两种类型：一次在插件中，一次在主可执行文件中。这是进入其他一些环境的唯一方法，但它不适用于C＃。即使类型具有完全相同的命名空间和完全相同的名称，如果它们来自不同的程序集，它们也是不同的类型。

您应该做的是在主可执行文件中定义仅的基本类型。在插件中，添加对主可执行文件的引用，您将能够引用主可执行文件的公共类型并从中派生。

如何通过使用相同的东西调用函数，但在其他地方，usingReflection？

1 个答案: