在运行时创建一个可以计算的表达式。

我有一个产品列表，需要创建可以持久化、检索和执行的表达式树。这是为客户端计算构建器而设计的。

我对表达式还不太熟悉，虽然我已经阅读了相当多的文档，但学习曲线有点陡峭。我想要的是能够先积累PropertyExpression和Operand对。以下是我目前的进展，不确定是否正确地构建了它。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
namespace ConsoleApplication1
{
    public enum ProductType { Perishable, Fixed, Miscellaneous }
    public enum OperandType { Addition, Subtraction, Multiplication, Division }
    public class Product
    {
        public string Name { get; set; }
        public ProductType Type { get; set; }
        public float Price { get; set; }
    }
    public class Configuration
    {
        public Dictionary Dictionary { get; set; }
    }
    public class Operand
    {
        public OperandType Type { get; set; }
    }
    public class CalculationPair
        where TEntityType : class
        where TProperty : struct
    {
        public ValueTypeProperty Left { get; set; }
        public Operand Operand { get; set; }
        public ValueTypeProperty Right { get; set; }
        // How to specify TResult as an [out] parameter?
        public TResult Calculate()
            where TResult : struct
        {
            TResult result = default(TResult);
            if (this.Operand.Type == OperandType.Multiplication)
            {
                // How to execute the expression?
                //result = this.Left * this.Right;
            }
            return result;
        }
    }
    public class ValueTypeProperty
        where TEntityType : class
        where TProperty : struct
    {
        public string Name { get; set; }
        public Expression> PropertyExpression { get; set; }
    }
    public class ProductPriceProperty :
        ValueTypeProperty
    {
    }
    public static class Program
    {
        public static void Main()
        {
            Configuration config = new Configuration();
            List products = new List();
            config.Dictionary.Add("ExportFactor", 80);
            config.Dictionary.Add("ChannelMargin", 100);
            products.Add(new Product() { Name = "1", Type = ProductType.Fixed, Price = 10 });
            products.Add(new Product() { Name = "2", Type = ProductType.Miscellaneous, Price = 20 });
            products.Add(new Product() { Name = "3", Type = ProductType.Perishable, Price = 30 });
            foreach (var product in products)
            {
                if (product.Type == ProductType.Fixed)
                {
                    CalculationPair calculation = new CalculationPair()
                    {
                        Left = new ProductPriceProperty() { Name = "Product Price", PropertyExpression = (entity => entity.Price) },
                        Operand = new Operand() { Type = OperandType.Multiplication },
                        Right = new ProductPriceProperty() { Name = "ExportFactor", PropertyExpression = (entity => config.Dictionary["ExportFactor"]) },
                    };
                    // Calculation needs to be persisted to be retrieved later.
                    // ???!
                    // Once calculation has been reconstructed from the persistence layer, it needs to be executed.
                    product.Price = calculation.Calculate();
                }
            }
        }
    }
}

更新：以下是我在优先顺序上遇到的问题：

- 如何在`CalculationPair.Calculate()`函数中执行表达式？

- 如何在`CalculationPair.Calculate()`函数中将TResult指定为[out]参数？

- 如何持久化计算表达式并在以后检索它？