/// <summary> /// Wraps C# code fragment into auto-generated class (type name <c>DynamicClass</c>), evaluates it and loads the class to the current AppDomain. /// <para>Returns typed <see cref="CSScriptLib.MethodDelegate{T}"/> for class-less style of invoking.</para> /// </summary> /// <typeparam name="T">The delegate return type.</typeparam> /// <example> /// <code> /// var product = CSScript.RoslynEvaluator /// .CreateDelegate<int>(@"int Product(int a, int b) /// { /// return a * b; /// }"); /// /// int result = product(3, 2); /// </code> /// </example> /// <param name="code">The C# code.</param> /// <returns> The instance of a typed <see cref="CSScriptLib.MethodDelegate{T}"/></returns> public MethodDelegate <T> CreateDelegate <T>(string code) { string scriptText = CSScript.WrapMethodToAutoClass(code, true, false); var asm = CompileCode(scriptText); var method = asm.GetTypes() .Where(x => x.GetName().EndsWith("DynamicClass")) .SelectMany(x => x.GetMethods()) .FirstOrDefault(); T invoker(params object[] args) { return((T)method.Invoke(null, args)); } return(invoker); }
/// <summary> /// Wraps C# code fragment into auto-generated class (type name <c>DynamicClass</c>), evaluates it and loads /// the class to the current AppDomain. /// <para> /// After initializing the class instance it is aligned to the interface specified by the parameter <c>T</c>. /// </para> /// </summary> /// <example>The following is the simple example of the interface alignment: /// <code> /// public interface ICalc /// { /// int Sum(int a, int b); /// int Div(int a, int b); /// } /// .... /// ICalc script = CSScript.RoslynEvaluator /// .LoadMethod<ICalc>(@"public int Sum(int a, int b) /// { /// return a + b; /// } /// public int Div(int a, int b) /// { /// return a/b; /// }"); /// int result = script.Div(15, 3); /// </code> /// </example> /// <typeparam name="T">The type of the interface type the script class instance should be aligned to.</typeparam> /// <param name="code">The C# script text.</param> /// <returns>Aligned to the <c>T</c> interface instance of the auto-generated class defined in the script.</returns> public T LoadMethod <T>(string code) where T : class { string scriptText = CSScript.WrapMethodToAutoClass(code, false, false, typeof(T).FullName); return(LoadCode <T>(scriptText)); }
/// <summary> /// Wraps C# code fragment into auto-generated class (type name <c>DynamicClass</c>), evaluates it and loads /// the class to the current AppDomain. /// </summary> /// <example>The following is the simple example of the LoadMethod usage: /// <code> /// dynamic script = CSScript.RoslynEvaluator /// .LoadMethod(@"int Product(int a, int b) /// { /// return a * b; /// }"); /// /// int result = script.Product(3, 2); /// </code> /// </example> /// <param name="code">The C# script text.</param> /// <returns>Instance of the first class defined in the script.</returns> public object LoadMethod(string code) { string scriptText = CSScript.WrapMethodToAutoClass(code, false, false); return(LoadCodeByName(scriptText, $"*.{Globals.DynamicWrapperClassName}")); }
/// <summary> /// Wraps C# code fragment into auto-generated class (type name <c>DynamicClass</c>) and evaluates it. /// <para> /// This method is a logical equivalent of <see cref="CSScriptLib.IEvaluator.CompileCode"/> but is allows you to define /// your script class by specifying class method instead of whole class declaration.</para> /// </summary> /// <example> ///<code> /// dynamic script = CSScript.RoslynEvaluator /// .CompileMethod(@"int Sum(int a, int b) /// { /// return a+b; /// }") /// .CreateObject("*"); /// /// var result = script.Sum(7, 3); /// </code> /// </example> /// <param name="code">The C# code.</param> /// <returns>The compiled assembly.</returns> public Assembly CompileMethod(string code) { string scriptText = CSScript.WrapMethodToAutoClass(code, false, false); return(CompileCode(scriptText)); }