将C#交错数组转换为数组，然后再转换回来

我目前有一个锯齿状数组

Class[][]]

，我想将其序列化为一个普通的

Class[]

数组，然后在反序列化后转换回

Class[][][]

数组。有可能在这两种方式之间转换吗？尺寸是恒定的。

我不这么认为

如果它是一个类[，]多维数组，您可能已经能够做到这一点，但每个数组可能具有不同的长度这一事实将永远是一个绊脚石

假设您将if序列化为一个类[]+另一个类以提供原始维度，那么您将是金色的。

我不这么认为，Rory

如果它是一个类[，]多维数组，您可能已经能够做到这一点，但每个数组可能具有不同的长度这一事实将永远是一个绊脚石

---

假设您将if序列化为类[]+另一个类以提供原始维度，那么您将是金色的。

这就是如何将if展平为一维结构的方法：

var jagged = new object[][][];
var flattened = jagged.SelectMany(inner => inner.SelectMany(innerInner => innerInner)).ToArray();

---

至于回到多维-这将完全取决于您试图实现什么/数据代表什么

这就是如何将其扁平化为一维结构：

var jagged = new object[][][];
var flattened = jagged.SelectMany(inner => inner.SelectMany(innerInner => innerInner)).ToArray();

---

至于返回多维-这将完全取决于您试图实现什么/数据代表什么

如果您不介意序列化平坦数组和整数数组，可以使用以下方法：

public static int[] JaggedSizes<T>(this T[][][] topArray)
{
    List<int> rtn = new List<int>();
    rtn.Add(topArray.Length);
    for (int i = 0; i < topArray.Length; i++)
    {
        var midArray = topArray[i];
        rtn.Add(midArray.Length);
        for (int j = 0; j < midArray.Length; j++)
        {
            var botArray = midArray[j];
            rtn.Add(botArray.Length);
        }
    }
    return rtn.ToArray();
}

// Thanks @Dave Bish
public static T[] ToFlat<T>(this T[][][] jagged)
{
    return jagged.SelectMany(inner => 
        inner.SelectMany(innerInner => innerInner)).ToArray(); 
}

public static T[][][] FromFlatWithSizes<T>(this T[] flat, int[] sizes)
{
    int inPtr = 0;
    int sPtr = 0;
    int topSize = sizes[sPtr++];
    T[][][] rtn = new T[topSize][][];
    for (int i = 0; i < topSize; i++)
    {
        int midSize = sizes[sPtr++];
        T[][] mid = new T[midSize][];
        rtn[i] = mid;
        for (int j = 0; j < midSize; j++)
        {
            int botSize = sizes[sPtr++];
            T[] bot = new T[botSize];
            mid[j] = bot;
            for (int k = 0; k < botSize; k++)
            {
                bot[k] = flat[inPtr++];
            }
        }
    }
    return rtn;
}

publicstaticint[]JaggedSizes（这个T[]topArray）
{
List rtn=新列表（）；
rtn.Add（topArray.Length）；
for（int i=0；i
SelectMany（innerInner=>innerInner））.ToArray（）；
}
公共静态T[][]FromFlatWithSizes（此T[]平面，int[]大小）
{
int inPtr=0；
int-sPtr=0；
int topSize=尺寸[sPtr++]；
T[][]rtn=新的T[topSize][]；
对于（int i=0；i

如果您不介意序列化展平数组和整数数组，可以使用以下方法：

public static int[] JaggedSizes<T>(this T[][][] topArray)
{
    List<int> rtn = new List<int>();
    rtn.Add(topArray.Length);
    for (int i = 0; i < topArray.Length; i++)
    {
        var midArray = topArray[i];
        rtn.Add(midArray.Length);
        for (int j = 0; j < midArray.Length; j++)
        {
            var botArray = midArray[j];
            rtn.Add(botArray.Length);
        }
    }
    return rtn.ToArray();
}

// Thanks @Dave Bish
public static T[] ToFlat<T>(this T[][][] jagged)
{
    return jagged.SelectMany(inner => 
        inner.SelectMany(innerInner => innerInner)).ToArray(); 
}

public static T[][][] FromFlatWithSizes<T>(this T[] flat, int[] sizes)
{
    int inPtr = 0;
    int sPtr = 0;
    int topSize = sizes[sPtr++];
    T[][][] rtn = new T[topSize][][];
    for (int i = 0; i < topSize; i++)
    {
        int midSize = sizes[sPtr++];
        T[][] mid = new T[midSize][];
        rtn[i] = mid;
        for (int j = 0; j < midSize; j++)
        {
            int botSize = sizes[sPtr++];
            T[] bot = new T[botSize];
            mid[j] = bot;
            for (int k = 0; k < botSize; k++)
            {
                bot[k] = flat[inPtr++];
            }
        }
    }
    return rtn;
}

publicstaticint[]JaggedSizes（这个T[]topArray）
{
List rtn=新列表（）；
rtn.Add（topArray.Length）；
for（int i=0；i
SelectMany（innerInner=>innerInner））.ToArray（）；
}
公共静态T[][]FromFlatWithSizes（此T[]平面，int[]大小）
{
int inPtr=0；
int-sPtr=0；
int topSize=尺寸[sPtr++]；
T[][]rtn=新的T[topSize][]；
对于（int i=0；i

如果你想重建原始结构，你需要以某种方式记住参差不齐的“位”的各种大小。当然……这是可能的。我不确定你想这样做的原因是什么，如果你想以你想要的方式将它序列化（在这种情况下，你想将它存储为锯齿状数组），会容易得多。@Ramhound当我尝试序列化锯齿状数组时，我使用的mono的实现变得混乱，但是平面阵列似乎没有问题刚刚看到你的编辑-如果尺寸是恒定的，为什么不使用

[，]

来代替呢？如果你想重建原始结构，你需要记住参差不齐的“位”的各种大小。当然……这是可能的。我不确定你想这样做的原因是什么，如果你想以你想要的方式将它序列化（在这种情况下，你想将它存储为锯齿状数组），会容易得多。@Ramhound当我尝试序列化锯齿状数组时，我使用的mono的实现变得混乱，但是平面阵列似乎没有问题刚刚看到你的编辑-如果尺寸是恒定的，为什么不使用

[，]

来代替呢？我认为

=>innerInner.SelectMany（）

需要是

=>innerInner

+1来提及“返回”，以及它是如何完全依赖的。我认为

=>innerInnerInner.SelectMany（）

只需要

=>innerInner

+1就可以提到“返回”，以及它是如何完全依赖的。