# An evaluator for simple script evaluation
**Date:** 2016-05-01
**Author:** Kees C. Bakker
**Categories:** .NET / C#, .NET Framework / C#, KeesTalksTech Utility Pack, Projects
**Original:** https://keestalkstech.com/an-evaluator-for-simple-script-evaluation/
---
In a previous blog I explored [how to create a dynamic compiler](/2016/05/how-to-add-dynamic-compilation-to-your-projects/). In this blog I'll explore how to create an evaluator that aids in the compilation of classes. It will take care of the ceremony needed to wrap the code into a class, compile it and retrieve the result.
## The Evaluator class
The basic idea is to feed the evaluator the code and to execute it by calling `Run`. I've added some comments to the class to explain how it works.
```cs
using KeesTalksTech.Utilities.Compilation;
using System;
using System.Collections.Generic;
///
/// The evaluator aids in the compilation of classes. It will take care
/// of the ceremony needed to wrap the code into a class, compile it and retrieve the result.
///
public class Evaluator : IEvaluator
{
private readonly ICompiler _compiler;
private readonly Type _producerType = typeof(IProducer);
///
/// Initializes a new instance of the class.
///
/// The compiler.
public Evaluator(ICompiler compiler) : this(compiler, null)
{
}
///
/// Initializes a new instance of the class. This constructor can be
/// used by classes that inherit the compiler to change the base type of the compiled
/// producer class.
///
/// The compiler.
/// Type of the producer.
protected Evaluator(ICompiler compiler, Type producerType = null)
{
if (compiler == null)
{
throw new ArgumentNullException(nameof(compiler));
}
_compiler = compiler;
if (producerType != null && this._producerType != producerType)
{
if (!typeof(IProducer).IsAssignableFrom(producerType))
{
throw new NotSupportedException("The baseType parameter needs to be an implementation of IProducer.");
}
this._producerType = producerType;
AssemblyLocations.Add(producerType.Assembly.Location);
}
Usings.Add("System");
AssemblyLocations.Add(typeof(object).Assembly.Location);
AssemblyLocations.Add(typeof(IProducer).Assembly.Location);
}
///
/// Some definitions might live in a different assembly that
/// needs to be referenced in order to compile the DLL.
///
public List AssemblyLocations { get; } = new List();
///
/// Adds usings to the code - this makes it easier to create
/// scripts because objects can be used by their name instead
/// of their full name.
///
///
/// The usings.
///
public List Usings { get; } = new List();
///
/// Generates the class en compiles it into a producer.
///
/// The code.
/// The producer.
public IProducer CreateProducer(string code)
{
var args = new CompilerInstructions();
args.ClassName = "_" + Guid.NewGuid().ToString("N");
args.Code = @"<>
public class <>: <>
{
public <> object Run()
{
<>;
return null;
}
}";
args.Code = args.Code.Replace("<>", args.ClassName);
args.Code = args.Code.Replace("<>", FixFullName(_producerType));
args.Code = args.Code.Replace("<>", code);
args.AssemblyLocations.AddRange(this.AssemblyLocations);
if (Usings.Count > 0)
{
string usings = "using " + String.Join(";\nusing ", Usings) + ";";
args.Code = args.Code.Replace("<>", usings);
}
else
{
args.Code = args.Code.Replace("<>", "");
}
if (_producerType.IsClass)
{
args.Code = args.Code.Replace("<>", "override");
}
else
{
args.Code = args.Code.Replace("<>", "");
}
return _compiler.CompileAndCreateObject(args);
}
///
/// Runs the specified code.
///
/// The code.
/// The result.
public object Run(string code)
{
var producer = CreateProducer(code);
return producer.Run();
}
///
/// Fixes the full name.
///
/// The type.
/// The full name.
private string FixFullName(Type type)
{
return type.FullName.Replace("+", ".");
}
}
```
A script doesn't have to produce anything, that's why the generated class returns null by default. If the specified script does not have to have a return. The script also adds an extra ';' to the script.
## Hello world script
So let's create a small script that prints Hello World! 10 times:
```cs
var compiler = new CodeDomCompiler();
var evaluator = new Evaluator(compiler);
for (var i = 1; i <= 10; i++)
{
var script = "Console.WriteLine(\"" + i.ToString("00") + ": Hello world!\");";
evaluator.Run(script);
}
```
The following example shows how to return a string and print it:
```cs
var compiler = new CodeDomCompiler();
var evaluator = new Evaluator(compiler);
for (var i = 1; i <= 10; i++)
{
var script = "return \"" + i.ToString("00") + ": Hello world!\";";
var result = evaluator.Run(script);
Console.WriteLine(result);
}
```
## Evaluation with a special class
What if you want to interact with the object that was compiled? That's possible. First create a generic evaluator:
```cs
using KeesTalksTech.Utilities.Compilation;
///
/// Evaluator that will generate sripts with a certain base type.
///
/// The base type of the classes that will be generated by the evaluator.
///
public class Evaluator : Evaluator where BaseType : class, IProducer
{
///
/// Initializes a new instance of the class.
///
/// The compiler.
public Evaluator(ICompiler compiler) : base(compiler, typeof(BaseType))
{
}
///
/// Creates the producer.
///
/// The code.
/// The producer.
public new BaseType CreateProducer(string code)
{
return (BaseType)base.CreateProducer(code);
}
}
```
Next create an abstract class that defines the interaction. This class needs to implement `IProducer`:
```cs
public abstract class MyProducer : IProducer
{
public int Counter { get; set; }
public string Message { get; set; }
public abstract object Run();
}
```
Let's see it in action:
```cs
var compiler = new CodeDomCompiler();
var evaluator = new Evaluator(compiler);
var script = @"
var s = Counter.ToString(""0000"");
s += "" "" + Message;
Console.WriteLine(s);
";
var obj = evaluator.CreateProducer(script);
obj.Message = "Hello World!";
obj.Counter = 1;
for (var i = 0; i <= 10; i++)
{
obj.Run();
obj.Counter *= 2;
}
```
So that's it. Happy coding!