Как использовать генерацию кода для динамического создания методов C #?

Question

Чтобы определить метод в C, который может вызываться Lua, он должен соответствовать заданной сигнатуре и использовать Lua API для получения параметров и возврата результатов. Я пишу обертку C # для Lua и меня интересует возможность вызывать произвольные методы C #, не заставляя их следовать этим соглашениям. Оборачивая что-то вроде D, можно использовать систему шаблонов для динамического создания этого связующего кода для любого данного метода. Я думал, что это может быть возможно и в C #, но с использованием динамической генерации кода.

API C выглядит примерно так, и сгенерированный код будет манипулировать этим через часть более низкого уровня моей библиотеки, которая P / вызывает библиотеку Lua C.

static int foo (lua_State *L)
{
    int n = lua_gettop(L);    /* number of arguments */
    lua_Number sum = 0;
    int i;
    for (i = 1; i <= n; i++)
    {
        if (!lua_isnumber(L, i)) 
        {
            lua_pushstring(L, "incorrect argument");
            lua_error(L);
        }
        sum += lua_tonumber(L, i);
    }
    lua_pushnumber(L, sum/n);        /* first result */
    lua_pushnumber(L, sum);         /* second result */
    return 2;                   /* number of results */
}

Таким образом, в основном идея состоит в том, чтобы взять метод C #, отразить его параметры и возвращаемые значения, сгенерировать (или извлечь из кэша) метод, который использует Lua API, как описано выше, для передачи этих параметров и возврата этих возвращаемых типов и, наконец, отправки этого метод Луа. Поэтому, когда функция C # вызывается из Lua, она выглядит примерно так: lua -> функция волшебной обертки -> обычная функция C #.

Спасибо.

Answer 1

Если я понимаю, что вы хотите, кажется, у вас есть 2 варианта:

1. используйте CodeDOM для генерации и динамической компиляции кода во время выполнения.
2. испускает реальный исходный код C # и динамически компилирует его в вызываемую сборку во время выполнения.

CodeDom - это какой-то волосатый код очень низкого уровня для написания. Идея в том, что есть объектная модель для языка C #. Вы начинаете с создания экземпляра CodeTypeDeclaration - это сгенерирует тип или класс. Затем вы добавляете свойства и поля - здесь вы, скорее всего, добавите объявления DllImport для ваших функций p / invoke. Затем вы используете разные методы добавления CodeDOM для типа - это будет то место, куда вы вставите сгенерированный метод. Вы можете сделать это публичным, статичным, что угодно.

CodeDOM выглядит так:

System.Type mt= a[0].GetType();

System.CodeDom.CodeTypeDeclaration class1 = new System.CodeDom.CodeTypeDeclaration(mt.Name);
class1.IsClass=true;
class1.TypeAttributes = System.Reflection.TypeAttributes.Public;
class1.Comments.Add(new System.CodeDom.CodeCommentStatement("Wrapper class for " + mt.Name));

System.CodeDom.CodeConstructor ctor;
ctor= new System.CodeDom.CodeConstructor();
ctor.Attributes = System.CodeDom.MemberAttributes.Public;
ctor.Comments.Add(new System.CodeDom.CodeCommentStatement("the null constructor"));
class1.Members.Add(ctor);
ctor.Statements.Add(new System.CodeDom.CodeAssignStatement(new System.CodeDom.CodeVariableReferenceExpression("m_wrapped"), new System.CodeDom.CodeObjectCreateExpression(mt)));

ctor= new System.CodeDom.CodeConstructor();
ctor.Attributes = System.CodeDom.MemberAttributes.Public;
ctor.Comments.Add(new System.CodeDom.CodeCommentStatement("the 'copy' constructor"));
class1.Members.Add(ctor);
ctor.Parameters.Add(new System.CodeDom.CodeParameterDeclarationExpression(mt,"X"));
ctor.Statements.Add(new System.CodeDom.CodeAssignStatement(new System.CodeDom.CodeVariableReferenceExpression("m_wrapped"), new System.CodeDom.CodeVariableReferenceExpression("X")));

// embed a local (private) copy of the wrapped type
System.CodeDom.CodeMemberField field1;
field1= new System.CodeDom.CodeMemberField();
field1.Attributes = System.CodeDom.MemberAttributes.Private;
field1.Name= "m_wrapped";
field1.Type=new System.CodeDom.CodeTypeReference(mt);
class1.Members.Add(field1);

...

это продолжается. и вкл. Как видите, это становится довольно уродливо. Затем вы компилируете его, чего я не показал. Я предполагаю, что вы не захотите использовать этот подход.

---

Я нашел CodeDom довольно хитрым в использовании; вместо этого теперь, когда мне нужны динамически сгенерированные сборки, я испускаю фактический код C # , обычно через шаблоны, в строку в памяти и скомпилирую , что . Это намного проще для моих целей. Компиляция выглядит так:

var cp = new System.CodeDom.Compiler.CompilerParameters {
  ReferencedAssemblies.Add(filesystemLocation), // like /R: option on csc.exe
  GenerateInMemory = true,    // you will get a System.Reflection.Assembly back
  GenerateExecutable = false, // Dll
  IncludeDebugInformation = false,
  CompilerOptions = ""
};

var csharp = new Microsoft.CSharp.CSharpCodeProvider();

// this actually runs csc.exe:
System.CodeDom.Compiler.CompilerResults cr = 
      csharp.CompileAssemblyFromSource(cp, LiteralSource);


// cr.Output contains the output from the command

if (cr.Errors.Count != 0)
{
    // handle errors
}

System.Reflection.Assembly a = cr.CompiledAssembly;

// party on the type here, either via reflection...
System.Type t = a.GetType("TheDynamicallyGeneratedType");

// or via a wellknown interface

В приведенном выше коде LiteralSource содержит исходный код для компиляции. Как я уже сказал, я генерирую это, читая шаблон и заполняя пробелы.

Answer 2

Я не уверен, что правильно интерпретирую ваш вопрос, но вы, возможно, захотите взглянуть на прокси Castle.Dynamic. Это позволяет вам создавать прокси для классов и интерфейсов, а затем перехватывать определенные вызовы методов (что-либо вообще на интерфейсе и что-нибудь виртуальное на реальном классе). Когда вы перехватываете вызов, вы можете просто посмотреть на аргументы и переслать вызов в lua API через P-Invoke. Здесь есть отличный учебник .

Answer 3

Попробуйте заглянуть в T4 . Поскольку он изначально является частью Visual Studio, вы можете использовать систему отражения, чтобы найти все методы в соответствии с вашими вопросами. Выполните поиск в Google, и я уверен, что вы можете найти некоторый пример кода или шаблона людей, использующих отражение с T4, уже для генерации классов или методов-оболочек.

Answer 4

Вы можете представить свой C # как COM, что позволит вызывать все (публичные) методы как внешние приложения.

Или предоставьте одну функцию C #, которая будет вызывать соответствующую другую функцию, возможно, жестко запрограммированную для списка фактических функций в C #, или, возможно, используя отражение. Для параметров может потребоваться массив произвольного размера.