using System;

using System.Linq.Expressions;

​

public class Program

{

    public static void Main()

    {  

        string expressionStringDefault = "(1+Actual)*10%/ABS(1+Target)*72%";

​

        char[] delimiters = new char[] { '(', ')', '+', '/', '*'};

        // Split the expression

        string[] components = expressionStringDefault.Split(delimiters, StringSplitOptions.RemoveEmptyEntries);

        Decimal percentage = 0;

        foreach (var component in components)

        {

            if(component.Contains("%"))

            {

                Console.WriteLine(component.Replace("%",""));

                Decimal a = Convert.ToInt32(component.Replace("%",""));

                Decimal b = Convert.ToDecimal(a/100);

                Console.WriteLine("int b "+b);

                percentage = b;

                expressionStringDefault = expressionStringDefault.Replace(component,percentage.ToString());

                Console.WriteLine(component);

                    Console.WriteLine(expressionStringDefault);

            }

        }

        string expressionString = expressionStringDefault.Replace("ABS","Math.Abs");

        //string expressionString = "(Actual/Math.Abs(Target) * 100)";

        double actual = 100; // Example value for Actual

        double target = 90; // Example value for Target

        double weight = 5;

        Console.WriteLine($"components: {components[5]}");

        double result = Math.Round((EvaluateExpression(expressionString, actual, target) * weight),2);

        Console.WriteLine($"Result: {result}");

    }

​

    static double EvaluateExpression(string expressionString, double actual, double target)

    {

        // Define the parameters

        var actualParam = Expression.Parameter(typeof(double), "Actual");

        var targetParam = Expression.Parameter(typeof(double), "Target");

        // Parse the expression

        var expression = System.Linq.Dynamic.Core.DynamicExpressionParser.ParseLambda(

            new[] { actualParam, targetParam },

            typeof(double),

            expressionString

        );

​

        // Compile the expression into a delegate

        var compiledExpression = (Func<double, double, double>)expression.Compile();

​

        // Invoke the delegate with the actual values

        return compiledExpression(actual, target);

    }

}