Comment puis-je évaluer le code C# de façon dynamique?

À l'aide de la Roslyn API de script (plus les échantillons ici):

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

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

Vous pouvez également exécuter un morceau de code:

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

De référence et le code qui a été généré dans les courses précédentes:

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

C'est une fonction eval sous c#. Je l'ai utilisé pour convertir des fonctions anonymes (les Expressions Lambda) à partir d'une chaîne.
Source: 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;
}

Tout cela serait certainement le travail. Personnellement, pour ce problème, je serais probablement prendre un peu différente de l'approche. Peut-être quelque chose comme ceci:

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

Lors de l'utilisation de modèles de ce genre, vous devez être attentif à ce que vos données sont stockées par référence et non par valeur. En d'autres termes, ne pas le faire avec les primitives. Vous devez utiliser leur gros ballonnement classe homologues.

J'ai réalisé que ce n'est pas exactement la question, mais la question a été assez bien répondu et j'ai pensé que peut-être une autre approche pourrait aider.

Vous pouvez utiliser la réflexion pour obtenir la propriété et à l'appeler. Quelque chose comme ceci:

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

Qui est, en supposant que l'objet qui a la propriété est appelé "theObject" 🙂

Vous pourriez le faire avec un prototype de la fonction:

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

et ainsi de suite...

J'ai écrit un paquet, SharpByte.Dynamique, afin de simplifier la tâche de compilation et de l'exécution de code dynamique. Le code peut être invoqué à un objet de contexte à l'aide de méthodes d'extension détaillé ici.

Par exemple,

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

renvoie 3;

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

retourne le contexte de l'objet de représentation sous forme de chaîne;

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

d'exécution de ces déclarations comme un script, etc.

Exécutables peut être obtenu facilement à l'aide d'une méthode de fabrique, comme on le voit dans l'exemple ici--tous vous avez besoin est le code source et la liste de tout les paramètres nommés (les jetons sont intégrés à l'aide de triple-support de la notation, comme {{{0}}} afin d'éviter les collisions avec de la ficelle.Format() ainsi que le Guidon comme syntaxes):

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

Chaque objet exécutable (script ou de l'expression) est thread-safe, peut être stockée et réutilisée, prend en charge la journalisation de l'intérieur d'un script, stocke des informations de synchronisation et dernière exception si rencontrées, etc. Il y a aussi une Copie() la méthode compilé sur chacun afin de permettre la création de copies bon marché, c'est à dire à l'aide d'un objet exécutable compilé à partir d'un script ou d'une expression comme modèle pour créer d'autres.

Généraux de l'exécution d'un script compilé ou de la déclaration est relativement faible, à moins d'une microseconde sur du matériel modeste, et déjà compilé des scripts et expressions sont mises en cache pour la réutilisation.

Vous devriez vérifier la Heleonix.La réflexion de la bibliothèque. Il donne des méthodes get/set/invoke membres de façon dynamique, y compris les membres imbriqués, ou si un membre est clairement définie, vous pouvez créer un getter/setter (lambda compilé dans un délégué) qui est plus rapide que la réflexion:

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

Ou si le nombre de propriétés n'est pas sans fin, vous pouvez générer des setters et chache eux (les setters sont rapides car ils sont compilés délégués):

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

Setters peuvent être de type Action<object, object> mais des cas peut être différent au moment de l'exécution, de sorte que vous pouvez créer des listes de poseurs.

la bonne réponse est que vous devez en cache le résultat de garder le mem0ry utilisation faible.

un exemple ressemblerait à ceci

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

et l'ajouter à une Liste

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

enregistrer l'id et l'utiliser dans le code

espère que cette aide