🚀 go-pugleaf

1. Uzycie jakiegos języka skryptowego(np IronPython)
2. Napisanie wlasnego parsera wyrazen.
3. w frameworku 4 mozna np tak:


namespace ScriptingInterface
{
    public interface IScriptType
    {
        dynamic RunScript(dynamic _);
    }

    public class ScriptProvider
    {
        ScriptProvider(string code)
        {
            Assembly compiledScript = CompileCode(@"
                using System;
                using ScriptingInterface;
                using System.ComponentModel.Composition;
                [Export(typeof(IScriptType))]
                public class ScriptType : IScriptType
                {
                    public dynamic RunScript(dynamic _)
                    {
                        return " + code + @";
                    }
                }");
            AggregateCatalog catalog = new AggregateCatalog();
            catalog.Catalogs.Add(new
AssemblyCatalog( compiledScript));
            CompositionContainer _container = new
CompositionContainer(catalog);
            _container.SatisfyImportsOnce(this);
        }

        static Assembly CompileCode(string code)
        {
            Microsoft.CSharp.CSharpCodeProvider csProvider = new
Microsoft.CSharp.CSharpCodeProvider();
            CompilerParameters options = new CompilerParameters();
            options.GenerateExecutable = false;
            options.GenerateInMemory = true;
            options.ReferencedAssemblies.Add("System.Core.dll");
            options.ReferencedAssemblies.Add("Microsoft.CSharp.dll");
 
options.ReferencedAssemblies.Add("System.ComponentModel.Composition.dll");
 
options.ReferencedAssemblies.Add(Assembly.GetExecutingAssembly().Location);
            CompilerResults result;
            result = csProvider.CompileAssemblyFromSource(options,
code);
            if (result.Errors.HasErrors)
            {
                throw new Exception(result.Errors[0].ErrorText);
            }
            return result.CompiledAssembly;
        }

        [Import]
        IScriptType Script { get; set; }

        public static dynamic RunScript(string code, dynamic param)
        {
            return new
ScriptingInterface.ScriptProvider(code).Script.RunScript(param);
        }
    }
}


i wywolanie

        private void button1_Click(object sender, EventArgs e)
        {
            dynamic param = new ExpandoObject();
            param.iIle = 2;
            param.dNorma = 2.55M;
            param.dCena = 120.57M;
            param.dWsp = 0.2M;
            try
            {
 
MessageBox.Show(ScriptingInterface.ScriptProvider.RunScript(textBox1.Text,
param).ToString());
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

mankamentem tego rozwiazania jest to ze wyrazenie musi wygladac tak:

_.iIle * _.dNorma * _.dCena * (1 + _.dWsp)