如何在复杂数据类型上创建表达式树

Question

我必须承认，我对 C# 中的表达式树完全陌生，但目前有必要习惯它。我的问题是我有两个包含数组的数据类型。因此，我创建了一个名为 IArray<> 的接口。

    /// <summary>
    /// Interface for all classes that provide a list of IArrayData
    /// </summary>
    public interface IArray<ElementDataType>
        where ElementDataType : struct
    {
        /// <summary>
        /// Returns a single data out fo the array container.
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        IArrayData<ElementDataType> GetElementData(int index);

        /// <summary>
        /// Returns the amount of ArrayData.
        /// </summary>
        int Count
        {
            get;
        }

        /// <summary>
        /// Returns the size of a single dataset in number of elements
        /// (not in bytes!).
        /// </summary>
        /// <returns></returns>
        int GetDataSize();

        /// <summary>
        /// Creates a copy of the array data provider, by copying the metainformation, but not the
        /// contents.
        /// </summary>
        /// <returns></returns>
        IArray<ElementDataType> CloneStub();
    }

IArrayData 定义如下：

   /// <summary>
    /// DataProvider that provides the internal data as an array.
    /// </summary>
    /// <typeparam name="NativeDataType"></typeparam>
    public interface IArrayData<NativeDataType> where NativeDataType : struct
    {
        /// <summary>
        /// Returns the data in an arbitrary format.
        /// The implementor must take care of an appropriate cast.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        T[] GetData<T>() where T : struct;

        /// <summary>
        /// Returns the data as float[].
        /// </summary>
        /// <returns></returns>
        float[] GetData();

        /// <summary>
        /// Sets the data in an arbitrary format.
        /// The implementor must take care of an appropriate cast.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="data_in"></param>
        void SetData<T>(T[] data_in) where T : struct;

        /// <summary>
        /// Sets the data as float[].
        /// </summary>
        /// <param name="data_in"></param>
        void SetData(float[] data_in);
    }

有两种类型实现该接口。对于大多数数据，我必须对数据执行数学运算。目前我已经创建了自己的表达式评估器，但我很想使用表达式树，因为在我看来它更灵活。我如何在给定的接口上实现像+、-这样的数学运算？

我拥有的一种类型是我所说的 VoxelVolume，它用于存储 3D 图像数据块。 VoxelVolume 实现 IArray：

public abstract class VoxelVolume : IArray<float>
{
}

假设我有 3 个 VoxelVolume A、B 和 C。现在我想执行一个操作：

VoxelVolume D = (A + B) * C;

目前我正在使用运算符重载来执行此操作，并且效果很好。唯一的问题是，表达式是逐个操作求值的，表达式越长，花费的时间和内存就越多。我更愿意将操作合并为一个步骤。这就是我当前的实现所做的

public static IArray<float> AddMul(IArray<float> A, IArray<float> B, IArray<float> C)
{
    IArray<float> Result = A.CloneStub();

    int L = A.Count;
    int N = A.GetDataSize();

    for (int l = 0; l < L; l++)
    {
        float[] a = A.GetElementData(l).GetData();
        float[] b = B.GetElementData(l).GetData();
        float[] c = C.GetElementData(l).GetData();
        float[] d = new float[a.Length];

        for (int n = 0; n < N; n++)
        {
            d[n] = (a[n] + b[n]) * c[n];
        }

        Result.GetElementData(l).SetData(d);
    }

    return Result;
}

，但正如您可能认识到的那样，我必须为所有不同的操作输入很多内容 +、-、*、/ 等等。出于这个原因，我希望有一种更通用和灵活的方法来执行此操作。

谢谢 马丁

Answer 1

在您的示例中，我假设在标准代码中运行 GetData() 调用是合理的，尽管由于我们可能不知道“深度”，所以我们可以简化为锯齿状数组（矩形阵列也可以工作，但在所有方面都更难使用，所以我们不要这样做）。因此，假设我们有一个锯齿状数组，而不是 a、b、c（尽管我们假设答案为 d > 很简单）。因此，我们实际上需要构建：

= ((jagged[0])[n] + (jagged[1])[n]) * (jagged[2])[n]

即作为一棵树：

= *( +((jagged[0])[n], (jagged[1])[n]), (jagged[2])[n])

因此我们可以构建一个表达式（并评估），通过：

var data = Expression.Parameter(typeof (float[][]));
var n = Expression.Parameter(typeof (int));

var body = 
    Expression.Multiply( // *
        Expression.Add( // +
            Expression.ArrayIndex(
                Expression.ArrayIndex(data, Expression.Constant(0)), n), // a[n]
            Expression.ArrayIndex(
                Expression.ArrayIndex(data, Expression.Constant(1)), n) // b[n]
            ),
        Expression.ArrayIndex(
            Expression.ArrayIndex(data, Expression.Constant(2)), n)  // c[n]
    );
var func = Expression.Lambda<Func<float[][], int, float>>(body, data, n).Compile();


// here, a===jagged[0], b===jagged[1], c===jagged[2]
float[][] jagged = new[] { new[] { 1F, 2F }, new[] { 3F, 4F }, new[] { 5F, 6F } };
for(int i = 0; i < 2; i++)
{
    Console.WriteLine("{0}: {1}", i, func(jagged, i));
}

显然，您的实际代码需要解析您的输入表达式并构建一个类似的树灵活地；但这应该足以说明一般方法。