如何在C#中实现NumPy风格的多维数组切片？

Great question! C# doesn’t have native support for NumPy-style slicing like Python does, but we can build solutions both for your specific use case and a more flexible, dynamic approach that handles arbitrary slicing scenarios.

Manual Slicing for Your Specific Case #

For your exact example (arr[2:4, 0, :2, :]), we can manually create the target 3D array and copy elements by mapping indices between the original 4D array and the sliced 3D array. This is the fastest approach since it avoids any reflection or dynamic logic.

Here’s how to do it:

// Initialize your original 4D array
int[,,,] arr = new int[5, 6, 7, 8];
// Populate arr with values as needed

// Create the target 3D array: dimensions are (4-2) x (2-0) x 8 → 2x2x8
int[,,] mySlice = new int[2, 2, 8];

// Copy elements from the original array to the slice
for (int i = 0; i < 2; i++)
{
    // Original first dimension: 2 → 3 (since 2:4 is exclusive of 4)
    int originalDim1 = 2 + i;
    
    for (int j = 0; j < 2; j++)
    {
        // Original third dimension: 0 → 1 (since :2 is exclusive of 2)
        int originalDim3 = j;
        
        for (int k = 0; k < 8; k++)
        {
            // Original second dimension is fixed at 0; fourth dimension is all elements
            mySlice[i, j, k] = arr[originalDim1, 0, originalDim3, k];
        }
    }
}

Dynamic, General-Purpose Slicing #

If you need to handle arbitrary slicing (different ranges, single indices that reduce dimensionality, etc.), we can build a reusable utility with slice specifications. This mimics NumPy’s flexibility, including support for full ranges (:), single indices, and start/end ranges.

Step 1: Define Slice Specifications #

First, create a class to represent how each dimension should be sliced:

public enum SliceType
{
    All,       // Corresponds to ":" in NumPy
    SingleIndex, // Corresponds to a single number like "0"
    Range      // Corresponds to "start:end" like "2:4"
}

public class SliceSpec
{
    public SliceType Type { get; set; }
    public int? Start { get; set; }
    public int? End { get; set; }
    public int? Index { get; set; }

    // Helper methods for easy slice creation
    public static SliceSpec All() => new SliceSpec { Type = SliceType.All };
    public static SliceSpec Index(int idx) => new SliceSpec { Type = SliceType.SingleIndex, Index = idx };
    public static SliceSpec Range(int start, int end) => new SliceSpec { Type = SliceType.Range, Start = start, End = end };
}

Step 2: Build the Slicing Utility #

Create an extension method to handle slicing for any multidimensional array:

public static class ArraySlicer
{
    public static Array Slice(this Array source, params SliceSpec[] slices)
    {
        if (source.Rank != slices.Length)
            throw new ArgumentException("Number of slice specs must match the array's rank.");

        // Calculate target dimensions and collect slice details
        List<int> targetDimensions = new List<int>();
        List<(int start, int end, bool isSingleIndex)> sliceDetails = new List<(int, int, bool)>();

        for (int dim = 0; dim < source.Rank; dim++)
        {
            int dimLength = source.GetLength(dim);
            var slice = slices[dim];

            switch (slice.Type)
            {
                case SliceType.All:
                    sliceDetails.Add((0, dimLength, false));
                    targetDimensions.Add(dimLength);
                    break;
                case SliceType.SingleIndex:
                    int idx = slice.Index.Value;
                    if (idx < 0 || idx >= dimLength)
                        throw new IndexOutOfRangeException($"Index {idx} is out of bounds for dimension {dim}.");
                    sliceDetails.Add((idx, idx + 1, true));
                    // Single indices remove that dimension from the target array
                    break;
                case SliceType.Range:
                    int start = slice.Start.Value;
                    int end = slice.End.Value;
                    // Handle negative indices (like NumPy: -1 means last element)
                    start = start < 0 ? dimLength + start : start;
                    end = end < 0 ? dimLength + end : end;
                    // Clamp values to valid range
                    start = Math.Clamp(start, 0, dimLength);
                    end = Math.Clamp(end, 0, dimLength);
                    
                    if (start >= end)
                        throw new ArgumentException("Range start must be less than end.");
                    
                    sliceDetails.Add((start, end, false));
                    targetDimensions.Add(end - start);
                    break;
                default:
                    throw new NotImplementedException("Unsupported slice type.");
            }
        }

        // Create the target array
        Type elementType = source.GetType().GetElementType();
        Array targetArray = Array.CreateInstance(elementType, targetDimensions.ToArray());

        // Recursively copy elements from source to target
        CopyElements(source, targetArray, sliceDetails, new int[source.Rank], new int[targetDimensions.Count], 0);

        return targetArray;
    }

    private static void CopyElements(Array source, Array target, List<(int start, int end, bool isSingle)> sliceDetails, int[] sourceIndices, int[] targetIndices, int currentDim)
    {
        if (currentDim == source.Rank)
        {
            // Copy the element to the target array
            target.SetValue(source.GetValue(sourceIndices), targetIndices);
            return;
        }

        var (start, end, isSingle) = sliceDetails[currentDim];
        int targetIndex = 0;

        for (int i = start; i < end; i++)
        {
            sourceIndices[currentDim] = i;
            if (!isSingle)
            {
                targetIndices[currentDim] = targetIndex;
                targetIndex++;
            }

            // Recurse to the next dimension
            CopyElements(source, target, sliceDetails, sourceIndices, targetIndices, currentDim + 1);
        }
    }
}

Step 3: Use the Slicer for Your Example #

Now you can replicate your NumPy-style slice with just a few lines:

int[,,,] arr = new int[5, 6, 7, 8];
// Populate arr with values as needed

// Define your slices: 2:4, 0, :2, :
var slices = new[]
{
    SliceSpec.Range(2, 4),
    SliceSpec.Index(0),
    SliceSpec.Range(0, 2),
    SliceSpec.All()
};

// Perform slicing and cast to the target 3D array type
int[,,] mySlice = (int[,,])arr.Slice(slices);

Notes on Performance & Alternatives #

• Performance: The manual slicing approach is fastest since it avoids reflection and recursion. Use this if you only need to handle a specific slicing pattern.
• Flexibility: The dynamic slicer works for any multidimensional array and supports most NumPy-style slicing features (including negative indices).
• Third-Party Libraries: If you don’t want to roll your own solution, libraries like MathNet.Numerics or TensorFlow.NET offer array slicing capabilities similar to NumPy.

内容的提问来源于stack exchange，提问作者Gulzar