Question

我必须承认，我对C＃中的表达树绝对不熟悉，但目前有必要习惯它。我的问题是我有两个包含数组数组的DataType。出于这个原因，我创建了一个名为IArray＆lt;＆gt;

的接口

    /// <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个VoxelVolumes 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矩形阵列也可以工作，但在所有点都很难处理，所以我们不要这样做。因此，假设我们有一个锯齿状数组而不是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));
}

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

如何在复杂数据类型上执行表达式树

1 个答案: