Wie kann ich auswerten C# code dynamisch?

Verwendung des Roslyn-scripting-API (mehr samples hier):

//add NuGet package 'Microsoft.CodeAnalysis.Scripting'
using Microsoft.CodeAnalysis.CSharp.Scripting;

await CSharpScript.EvaluateAsync("System.Math.Pow(2, 4)") //returns 16

Können Sie auch jedes Stück code:

var script = await CSharpScript.RunAsync(@"
                class MyClass
                { 
                    public void Print() => System.Console.WriteLine(1);
                }")

- Und Referenz-code, der generiert wurde, in früheren Auflagen:

await script.ContinueWithAsync("new MyClass().Print();");

InformationsquelleAutor Eli Arbel

Dies ist eine Funktion eval unter c#. Ich benutzte es, um zu konvertieren anonyme Funktionen (Lambda-Ausdrücke) aus einem string.
Quelle: http://www.codeproject.com/KB/cs/evalcscode.aspx

public static object Eval(string sCSCode) {

  CSharpCodeProvider c = new CSharpCodeProvider();
  ICodeCompiler icc = c.CreateCompiler();
  CompilerParameters cp = new CompilerParameters();

  cp.ReferencedAssemblies.Add("system.dll");
  cp.ReferencedAssemblies.Add("system.xml.dll");
  cp.ReferencedAssemblies.Add("system.data.dll");
  cp.ReferencedAssemblies.Add("system.windows.forms.dll");
  cp.ReferencedAssemblies.Add("system.drawing.dll");

  cp.CompilerOptions = "/t:library";
  cp.GenerateInMemory = true;

  StringBuilder sb = new StringBuilder("");
  sb.Append("using System;\n" );
  sb.Append("using System.Xml;\n");
  sb.Append("using System.Data;\n");
  sb.Append("using System.Data.SqlClient;\n");
  sb.Append("using System.Windows.Forms;\n");
  sb.Append("using System.Drawing;\n");

  sb.Append("namespace CSCodeEvaler{ \n");
  sb.Append("public class CSCodeEvaler{ \n");
  sb.Append("public object EvalCode(){\n");
  sb.Append("return "+sCSCode+"; \n");
  sb.Append("} \n");
  sb.Append("} \n");
  sb.Append("}\n");

  CompilerResults cr = icc.CompileAssemblyFromSource(cp, sb.ToString());
  if( cr.Errors.Count > 0 ){
      MessageBox.Show("ERROR: " + cr.Errors[0].ErrorText, 
         "Error evaluating cs code", MessageBoxButtons.OK, 
         MessageBoxIcon.Error );
      return null;
  }

  System.Reflection.Assembly a = cr.CompiledAssembly;
  object o = a.CreateInstance("CSCodeEvaler.CSCodeEvaler");

  Type t = o.GetType();
  MethodInfo mi = t.GetMethod("EvalCode");

  object s = mi.Invoke(o, null);
  return s;

}

InformationsquelleAutor Largo

All das würde auf jeden Fall funktionieren. Persönlich, für das spezielle problem, ich würde wahrscheinlich ein wenig anders Vorgehen. Vielleicht so etwas wie dieses:

class MyClass {
  public Point point1, point2, point3;

  private Point[] points;

  public MyClass() {
    //...
    this.points = new Point[] {point1, point2, point3};
  }

  public void DoSomethingWith(int i) {
    Point target = this.points[i+1];
    //do stuff to target
  }
}

Bei der Verwendung von mustern wie diesem, Sie müssen vorsichtig sein, dass Ihre Daten gespeichert werden, per Referenz und nicht als Wert. In anderen Worten, tun Sie das nicht mit primitiven. Verwenden Sie Ihre großen aufgeblähten Klasse Kollegen.

Erkannte ich, dass das nicht ganz die Frage, aber wurde die Frage ziemlich gut beantwortet, und ich dachte vielleicht ein anderer Ansatz könnte helfen.

InformationsquelleAutor MojoFilter

Können Sie verwenden Sie reflektion, um die Eigenschaft und rufen Sie die Vervollständigung auf. So etwas wie dieses:

object result = theObject.GetType().GetProperty("Property" + i).GetValue(theObject, null);

Ist, vorausgesetzt, das Objekt, das die Eigenschaft hat, wird als "theObject" 🙂

InformationsquelleAutor David Wengier

Könnte man es machen, mit einem Prototyp-Funktion:

void something(int i, string P1) {
    something(i, P1, String.Empty);
}

void something(int i, string P1, string P2) {
    something(i, P1, P2, String.Empty);
}

void something(int i, string P1, string P2, string P3) {
    something(i, P1, P2, P3, String.Empty);
}

und so weiter...

InformationsquelleAutor GateKiller

Ich geschrieben habe, ein Paket, SharpByte.Dynamische, um die Aufgabe zu vereinfachen kompilieren und ausführen von code dynamisch. Der code aufgerufen werden können, die auf jedem Kontext-Objekt mit Erweiterung Methoden wie im weiteren beschrieben hier.

Beispielsweise

someObject.Evaluate<int>("6 /{{{0}}}", 3))

gibt 3;

someObject.Evaluate("this.ToString()"))

gibt die Kontext-Objekts string-Darstellung;

someObject.Execute(@
"Console.WriteLine(""Hello, world!"");
Console.WriteLine(""This demonstrates running a simple script"");
");

läuft diese Anweisungen als Skript, etc.

Ausführbaren Dateien bekommen kann leicht über eine factory-Methode, wie im Beispiel hier--alles, was Sie brauchen, ist der source code und die Liste der erwarteten benannte Parameter (Token eingebettet sind mittels triple-Klammer-notation, wie {{{0}}}, zur Vermeidung von Kollisionen mit string.Format () - sowie LENKER-ähnliche Syntax):

IExecutable executable = ExecutableFactory.Default.GetExecutable(executableType, sourceCode, parameterNames, addedNamespaces);

Jedes ausführbare Objekt (Skript oder Ausdruck) thread-sicher ist, können gespeichert und wiederverwendet, Protokollierung unterstützt von einem Skript, speichert timing-Informationen und Letzte Ausnahme, wenn Sie Ihr begegnen, usw. Es gibt auch eine Copy () - Methode kompiliert, der auf jedem zu erlauben das erstellen von Billig-Kopien, d.h. durch ein ausführbares Objekt zusammengestellt aus einem Skript oder Ausdruck, der als Vorlage zum erstellen anderer.

Overhead die Ausführung einer bereits kompilierten Skript oder eine Anweisung ist relativ gering, auch unter einer Mikrosekunde auf bescheidene hardware, und bereits kompilierten Skripte und Ausdrücke werden im Cache für die Wiederverwendung.

InformationsquelleAutor Iucounu

Könnten Sie überprüfen die Heleonix.Reflexion Bibliothek. Es stellt Methoden get - /set - /invoke-Mitglieder, die dynamisch, einschließlich verschachtelter Mitglieder, oder wenn ein Mitglied klar definiert ist, können Sie erstellen, getter/setter (lambda zusammengestellt, in ein Delegierter), die ist schneller als die Reflexion:

var success = Reflector.Set(instance, null, $"Property{i}", value);

Oder wenn die Anzahl der Eigenschaften ist nicht endlos, Sie können generieren setter und chache (setter sind schneller, da Sie kompiliert sind Delegierte):

var setter = Reflector.CreateSetter<object, object>($"Property{i}", typeof(type which contains "Property"+i));
setter(instance, value);

Setter kann der Typ Action<object, object> aber Instanzen können unterschiedlich sein, zur Laufzeit, so können Sie Listen erstellen, setter.

InformationsquelleAutor Hennadii Lutsyshyn

die richtige Antwort ist, dass Sie brauchen, um cache aller das Ergebnis zu halten, die mem0ry Nutzung gering.

einem Beispiel würde das wie folgt Aussehen

TypeOf(Evaluate)
{
"1+1":2;
"1+2":3;
"1+3":5;
....
"2-5":-3;
"0+0":1
} 

und hinzufügen zu einer Liste

List<string> results = new List<string>();
for() results.Add(result);

speichern der id und verwenden Sie es in den code

hoffe, das hilft

InformationsquelleAutor roft