SoftCircuits.ExpressionEvaluator 3.0.1

The ID prefix of this package has been reserved for one of the owners of this package by Prefix Reserved
.NET 5.0 .NET Standard 2.0
dotnet add package SoftCircuits.ExpressionEvaluator --version 3.0.1
NuGet\Install-Package SoftCircuits.ExpressionEvaluator -Version 3.0.1
This command is intended to be used within the Package Manager Console in Visual Studio, as it uses the NuGet module's version of Install-Package.
<PackageReference Include="SoftCircuits.ExpressionEvaluator" Version="3.0.1" />
For projects that support PackageReference, copy this XML node into the project file to reference the package.
paket add SoftCircuits.ExpressionEvaluator --version 3.0.1
#r "nuget: SoftCircuits.ExpressionEvaluator, 3.0.1"
#r directive can be used in F# Interactive and Polyglot Notebooks. Copy this into the interactive tool or source code of the script to reference the package.
// Install SoftCircuits.ExpressionEvaluator as a Cake Addin
#addin nuget:?package=SoftCircuits.ExpressionEvaluator&version=3.0.1

// Install SoftCircuits.ExpressionEvaluator as a Cake Tool
#tool nuget:?package=SoftCircuits.ExpressionEvaluator&version=3.0.1

Expression Evaluator

NuGet version (SoftCircuits.ExpressionEvaluator)

Install-Package SoftCircuits.ExpressionEvaluator


ExpressionEvaluator is a .NET library that will evaluate a string expression. It supports custom functions and symbols. Expression operands can include integers, doubles and strings. And operators include +, -, *, /, % (modulus), ^ (power) and & (concatenation).

The library easily integrates with any .NET application. Custom functions and symbols are implemented using the EvaluateFunction and EvaluateSymbol events. These events are raised when ExpressionEvaluator encounters a function or symbol in the expression.

Basic Example

Use the Evaluate() method to evaluate a string expression and return the result.

ExpressionEvaluator eval = new ExpressionEvaluator();
Variable v;

v = eval.Evaluate("2 + 2");        // Returns 4  (Integer)
v = eval.Evaluate("2 + 3 * 5");    // Returns 17 (Integer)
v = eval.Evaluate("(2 + 3) * 5");  // Returns 25 (Integer)

As you can see in the example above, the Evaluate() method returns a Variable. A Variable can hold an integer, double or string value. You can use the Type property to determine its current type, or just call the ToString() method to convert the value to a string. The Variable class includes methods to set its value, convert its value to another type and perform various operations. It also overloads many operators to make it easier to work with.

Expressions may also include string literals. Strings are any text enclosed in either double or single quotes. If the string contains two quotes together, they will be interpreted as a single quote character rather than the end of the string.

ExpressionEvaluator eval = new ExpressionEvaluator();
Variable v;

v = eval.Evaluate("\"2\" & \"2\"");  // Returns 22 (String)
v = eval.Evaluate("'2' & '2'");      // Returns 22 (String)
v = eval.Evaluate("\"2\" + \"2\"");  // Returns 4  (Integer)

Note the concatenation operator (&). This operator converts both operands to a string (if needed) and then concatenates them.

Expression Symbols

This example evaluates an expression with symbols. The EvaluateSymbol event handler defines three symbols ("two", "three", and "five"), and sets the status to SymbolStatus.UndefinedSymbol if the event is raised for an unknown symbol. Setting the status to SymbolStatus.UndefinedSymbol causes an EvaluationException exception to be thrown.

public void Test()
    ExpressionEvaluator eval = new ExpressionEvaluator();
    eval.EvaluateSymbol += Eval_EvaluateSymbol;
    Variable v;

    v = eval.Evaluate("two + two");            // Returns 4  (Integer)
    v = eval.Evaluate("two + three * five");   // Returns 17 (Integer)
    v = eval.Evaluate("(two + three) * five"); // Returns 25 (Integer)

private void Eval_EvaluateSymbol(object sender, SymbolEventArgs e)
    switch (e.Name.ToUpper())
        case "TWO":
        case "THREE":
        case "FIVE":
            e.Status = SymbolStatus.UndefinedSymbol;

Expression Functions

The next example defines two custom functions ("add" and "multiply"). The EvaluateFunction event handler sets the status to FunctionStatus.UndefinedFunction if the function name is not supported. In addition, it sets the status to FunctionStatus.WrongParameterCount if the number of arguments passed is not valid for the function. Setting the status to FunctionStatus.UndefinedFunction or FunctionStatus.WrongParameterCount causes an EvaluationException exception to be thrown.

void Test()
    ExpressionEvaluator eval = new ExpressionEvaluator();
    eval.EvaluateFunction += Eval_EvaluateFunction;
    Variable v;

    v = eval.Evaluate("add(2, 2)");               // Returns 4  (Integer)
    v = eval.Evaluate("2 + multiply(3, 5)");      // Returns 17 (Integer)
    v = eval.Evaluate("multiply(add(2, 3), 5)");  // Returns 25 (Integer)

private void Eval_EvaluateFunction(object sender, FunctionEventArgs e)
    switch (e.Name.ToUpper())
        case "ADD":
            if (e.Parameters.Length == 2)
                e.Result.SetValue(e.Parameters[0] + e.Parameters[1]);
                e.Status = FunctionStatus.WrongParameterCount;
        case "MULTIPLY":
            if (e.Parameters.Length == 2)
                e.Result.SetValue(e.Parameters[0] * e.Parameters[1]);
                e.Status = FunctionStatus.WrongParameterCount;
            e.Status = FunctionStatus.UndefinedFunction;

As the example above demonstrates, expressions can include nested functions (functions that are passed the result of another function or expression).

Additional Information

This code was derived from the article A C# Expression Evaluator.

Product Compatible and additional computed target framework versions.
.NET net5.0 is compatible.  net5.0-windows was computed.  net6.0 is compatible.  net6.0-android was computed.  net6.0-ios was computed.  net6.0-maccatalyst was computed.  net6.0-macos was computed.  net6.0-tvos was computed.  net6.0-windows was computed.  net7.0 was computed.  net7.0-android was computed.  net7.0-ios was computed.  net7.0-maccatalyst was computed.  net7.0-macos was computed.  net7.0-tvos was computed.  net7.0-windows was computed. 
.NET Core netcoreapp2.0 was computed.  netcoreapp2.1 was computed.  netcoreapp2.2 was computed.  netcoreapp3.0 was computed.  netcoreapp3.1 was computed. 
.NET Standard netstandard2.0 is compatible.  netstandard2.1 was computed. 
.NET Framework net461 was computed.  net462 was computed.  net463 was computed.  net47 was computed.  net471 was computed.  net472 was computed.  net48 was computed.  net481 was computed. 
MonoAndroid monoandroid was computed. 
MonoMac monomac was computed. 
MonoTouch monotouch was computed. 
Tizen tizen40 was computed.  tizen60 was computed. 
Xamarin.iOS xamarinios was computed. 
Xamarin.Mac xamarinmac was computed. 
Xamarin.TVOS xamarintvos was computed. 
Xamarin.WatchOS xamarinwatchos was computed. 
Compatible target framework(s)
Additional computed target framework(s)
Learn more about Target Frameworks and .NET Standard.

NuGet packages

This package is not used by any NuGet packages.

GitHub repositories

This package is not used by any popular GitHub repositories.

Version Downloads Last updated
3.0.1 1,743 5/20/2022
3.0.0 1,455 2/21/2021
2.1.0 581 4/10/2020
2.0.9 413 4/8/2020
2.0.8 393 4/8/2020
2.0.7 420 4/8/2020
2.0.6 425 4/7/2020
2.0.5 391 4/6/2020
2.0.4 434 4/5/2020
2.0.3 462 4/4/2020
2.0.2 457 4/2/2020
2.0.1 463 3/4/2020
2.0.0 509 3/4/2020
1.0.1 519 8/5/2019
1.0.0 457 7/7/2019

Added support for .NET 6.0; minor code tweaks.