Czy jest możliwe dynamiczne kompilowanie i wykonywanie fragmentów kodu C#?

Question

Zastanawiam się, czy możliwe jest zapisanie fragmentów kodu C# do pliku tekstowego (lub dowolnego strumienia wejściowego), a następnie wykonać je dynamicznie? Zakładając, że to, co mi zostało dostarczone, skompilowałoby dobrze w dowolnym bloku Main(), czy możliwe jest skompilowanie i/lub wykonanie tego kodu? Wolałbym skompilować go ze względu na wydajność.

Przynajmniej mogłem zdefiniować interfejs, że będą wymagane do zrealizowania, wtedy oni zapewnić „sekcja” kodu, który realizowany ten interfejs.

Answer 1

najlepszego rozwiązania w C#/.NET wszystkich statycznych języków jest użycie CodeDOM do takich rzeczy. (Na marginesie, jego drugim głównym celem jest dynamiczne konstruowanie bitów kodu, a nawet całych klas.)

Oto ładny krótki przykład z LukeH's blog, który wykorzystuje trochę LINQ również dla zabawy.

using System; 
using System.Collections.Generic; 
using System.Linq; 
using Microsoft.CSharp; 
using System.CodeDom.Compiler; 

class Program 
{ 
    static void Main(string[] args) 
    { 
     var csc = new CSharpCodeProvider(new Dictionary<string, string>() { { "CompilerVersion", "v3.5" } }); 
     var parameters = new CompilerParameters(new[] { "mscorlib.dll", "System.Core.dll" }, "foo.exe", true); 
     parameters.GenerateExecutable = true; 
     CompilerResults results = csc.CompileAssemblyFromSource(parameters, 
     @"using System.Linq; 
      class Program { 
       public static void Main(string[] args) { 
       var q = from i in Enumerable.Range(1,100) 
          where i % 2 == 0 
          select i; 
       } 
      }"); 
     results.Errors.Cast<CompilerError>().ToList().ForEach(error => Console.WriteLine(error.ErrorText)); 
    } 
} 

Klasa podstawowym znaczeniu tutaj jest CSharpCodeProvider który wykorzystuje kompilator do kompilacji kodu w locie. Jeśli chcesz uruchomić kod, wystarczy trochę refleksji, aby dynamicznie załadować złożenie i wykonać go.

Here to kolejny przykład w języku C#, który (choć nieco mniej zwięzły) dodatkowo pokazuje dokładnie, jak uruchomić skompilowany kod środowiska wykonawczego przy użyciu przestrzeni nazw System.Reflection.

Answer 2

Do kompilacji można po prostu zainicjować połączenie powłoki do kompilatora CSC. Możesz mieć ból głowy próbujący utrzymać swoje ścieżki i przełączniki prosto, ale na pewno można to zrobić.

C# Corner Shell Examples

EDIT: Albo jeszcze lepiej, użyj CodeDOM jak sugeruje Noldorin ...

Answer 3

System.CodeDom.Compiler nazw powinno pomóc. Zobacz this article

Answer 4

Inni już dał dobre odpowiedzi, w jaki sposób generowania kodu w czasie wykonywania tak myślałem, że chciałbym zaadresować akapit drugi. Mam pewne doświadczenie z tym i chcę po prostu podzielić się lekcją, której nauczyłem się z tego doświadczenia.

przynajmniej mogłem zdefiniować interfejs, że będą wymagane do zrealizowania, wtedy oni zapewnić a „sekcja” kod, który realizowany że interfejs.

Możesz mieć problem, jeśli używasz interface jako typu podstawowego. Jeśli dodać jedną nową metodę do interface w przyszłości wszystkie istniejące klasy klienckie dostarczone które implementują interface teraz stają się abstrakcyjne, co oznacza, że ​​nie będzie w stanie skompilować lub instancję klasy klienta dostarczane w czasie wykonywania.

Miałem ten problem, gdy nadszedł czas, aby dodać nową metodę po około 1 roku od wysyłki starego interfejsu i po dystrybucji dużej ilości "starszych" danych, które musiały być obsługiwane. W końcu stworzyłem nowy interfejs, który odziedziczył po starym, ale to podejście utrudniło ładowanie i tworzenie instancji klas dostarczonych przez klienta, ponieważ musiałem sprawdzić, który interfejs był dostępny.

Jednym z rozwiązań, o których myślałem wtedy, było użycie rzeczywistej klasy jako typu podstawowego, takiego jak ten poniżej. Samą klasę można oznaczyć jako abstrakcyjną, ale wszystkie metody powinny być pustymi wirtualnymi metodami (a nie metodami abstrakcyjnymi). Klienci mogą wtedy zastąpić żądane metody i mogę dodać nowe metody do klasy bazowej bez unieważniania istniejącego kodu dostarczonego przez klienta.

public abstract class BaseClass 
{ 
    public virtual void Foo1() { } 
    public virtual bool Foo2() { return false; } 
    ... 
} 

Bez względu na to, czy ten problem dotyczy, należy rozważyć, jak przeprowadzić wersję interfejsu między bazą kodu a kodem dostarczonym przez klienta.

Answer 5

You can compile a piece C# of code into memory and generate assembly bytes z Roslyn. Jest już wspomniany, ale warto tutaj dodać przykład Roslyn. Poniżej znajduje się pełna przykład:

using System; 
using System.Collections.Generic; 
using System.IO; 
using System.Linq; 
using System.Reflection; 
using Microsoft.CodeAnalysis; 
using Microsoft.CodeAnalysis.CSharp; 
using Microsoft.CodeAnalysis.Emit; 

namespace RoslynCompileSample 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(@" 
       using System; 

       namespace RoslynCompileSample 
       { 
        public class Writer 
        { 
         public void Write(string message) 
         { 
          Console.WriteLine(message); 
         } 
        } 
       }"); 

      string assemblyName = Path.GetRandomFileName(); 
      MetadataReference[] references = new MetadataReference[] 
      { 
       MetadataReference.CreateFromFile(typeof(object).Assembly.Location), 
       MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location) 
      }; 

      CSharpCompilation compilation = CSharpCompilation.Create(
       assemblyName, 
       syntaxTrees: new[] { syntaxTree }, 
       references: references, 
       options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); 

      using (var ms = new MemoryStream()) 
      { 
       EmitResult result = compilation.Emit(ms); 

       if (!result.Success) 
       { 
        IEnumerable<Diagnostic> failures = result.Diagnostics.Where(diagnostic => 
         diagnostic.IsWarningAsError || 
         diagnostic.Severity == DiagnosticSeverity.Error); 

        foreach (Diagnostic diagnostic in failures) 
        { 
         Console.Error.WriteLine("{0}: {1}", diagnostic.Id, diagnostic.GetMessage()); 
        } 
       } 
       else 
       { 
        ms.Seek(0, SeekOrigin.Begin); 
        Assembly assembly = Assembly.Load(ms.ToArray()); 

        Type type = assembly.GetType("RoslynCompileSample.Writer"); 
        object obj = Activator.CreateInstance(type); 
        type.InvokeMember("Write", 
         BindingFlags.Default | BindingFlags.InvokeMethod, 
         null, 
         obj, 
         new object[] { "Hello World" }); 
       } 
      } 

      Console.ReadLine(); 
     } 
    } 
} 

Answer 6

Znaleziony to użyteczne - zapewnia skompilowany Zgromadzenie odwołuje wszystko, czego obecnie nie odwołuje, ponieważ istnieje duża szansa chciałaś C# jesteś kompilacji używać niektórych klas itp w kodzie że jest to emitujące:

 var refs = AppDomain.CurrentDomain.GetAssemblies(); 
     var refFiles = refs.Where(a => !a.IsDynamic).Select(a => a.Location).ToArray(); 
     var cSharp = (new Microsoft.CSharp.CSharpCodeProvider()).CreateCompiler(); 
     var compileParams = new System.CodeDom.Compiler.CompilerParameters(refFiles); 
     compileParams.GenerateInMemory = true; 
     compileParams.GenerateExecutable = false; 

     var compilerResult = cSharp.CompileAssemblyFromSource(compileParams, code); 
     var asm = compilerResult.CompiledAssembly; 

w moim przypadku było emitujących klasę, którego nazwa została zapisana w ciąg, className, który miał jedną metodę statyczną o nazwie Get() publicznego, który wrócił z rodzaju StoryDataIds. Oto co wywołanie tej metody wygląda następująco:

 var tempType = asm.GetType(className); 
     var ids = (StoryDataIds)tempType.GetMethod("Get").Invoke(null, null);