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