Question

我有List<string[]> parsedData。

我有另一个List<string[]> newData = {n, 1, 2, 3}。

parsedData中的字符串似乎以下列方式存储：

1. a b c
2. 1 2 3 
3. 1 2 3

哪个是完美的。当我将newData添加到parsedData时，它就像这样：

1. a b c
2. 1 2 3
3. 1 2 3
4. n 1 2 3

我正在寻找一种方法来转置newData列表，并以类似的方式添加它，但我有问题让它工作。有人可以就这件事情说清楚。

这是我解析parsedData时的代码：

List<string[]> parsedData = new List<string[]>();
        string[] fields;

        try
        {
            TextFieldParser parser = new TextFieldParser(path);
            parser.TextFieldType = FieldType.Delimited;
            parser.SetDelimiters(",");

            while (!parser.EndOfData)
            {
                fields = parser.ReadFields();
                for (int i = 0; i < fields.Length; i++)
                {
                    if (fields[i] == "NaN")
                        fields[i] = null;
                }
                parsedData.Add(fields);
            }

            parser.Close();

        }
        catch (Exception e)
        {
            MessageBox.Show(e.Message);
        }

        return parsedData;

字符串[] newData以这种方式添加到列表中：

List<string[]> newData = new List<string[]>();
        string[] mCol = mean.meanCol(c, parsedData); // function that returns a string[]
        newData.Add(mCol);

然后我想加入上面解释的两个列表，所以它看起来像这样：

a b c n
1 2 3 1
1 2 3 2
1 2 3 3

Answer 1

好的，我假设你有一个看起来像这样的文本文件：

a,b,c
1,2,3
1,2,3

在您阅读/解析之后，您最终得到的内容等于：

List<string[]> parsedData = 
  new List<string[]> 
  { 
    new []{"a", "b", "c"},  
    new []{"1", "2", "3"},  
    new []{"1", "2", "3"}  
  };

然后您希望能够添加以下内容：

List<string[]> newData =
  new List<string[]>
  {
    new []{"n", "1", "2", "3"},  
    new []{"m", "1", "2", "3"},  
    // ... added more new data
  };

好吧，首先newData被“翻转”90°，每个项目的数据点比现有项目多一个（a有1和1，而n有1，2和3）。

所以，即使以理想的方式，你最终也会：

List<string[]> combinedData = 
  new List<string[]> 
  { 
    new []{"a", "b", "c", "n", "m"},  
    new []{"1", "2", "3", "1", "1"},  
    new []{"1", "2", "3", "2", "2"},  
    new []{null, null, null, "3", "3"}  
  };

其次，您使用string[]代替List<string>，因此增长更为复杂。

在任何情况下，List<string[]>都是表达您想要的次优数据结构：具有多个通道名称，并且能够为每个通道名称存储多个测量值。

我建议使用Dictionary<string, List<string>>，其中key是频道名称，value是List<string>，其中包含该频道名称的测量列表

可能有更简单的方法，但从List<string[]>到Dictionary<string, List<string>>的一种方法可能就像：

var transposedData = new Dictionary<string, List<string>>();
var minArrayLength = parsedData.Min(a => a.Length);
for (var index = 0; index < minArrayLength; index++)
{
  string key = null;
  foreach (var array in parsedData)
  {
    if (key == null)
    {
      key = array[index];
      transposedData[key] = new List<string>();
    }
    else
    {
      transposedData[key].Add(array[index]);
    }
  }
}

顺便说一下。不要被var keyword弄糊涂，我喜欢使用它。

在此数据结构中，您可以像这样添加newData：

foreach (var array in newData)
{
  var key = array[0];
  transposedData[key] = new List<string>();

  // skip the key
  for (var index = 1; index < array.Length; index++)
  {
    transposedData[key].Add(array[index]);
  }
}

现在，问题是，你对此感到满意，还是你真的需要List<string[]>？如果是这样，您需要将其转置回来。也许有这样的事情：

// using a list inside for now for easier adding
var backTranspose = new List<List<string>>();

// determine the max number of measurements for a channel name
var maxLength = transposedData.Values.Max(l => l.Count);

// use one more to include key
for (var valueIndex = 0; valueIndex <= maxLength; valueIndex++)
{
  backTranspose.Add(new List<string>());
}

foreach (var kvp in transposedData)
{
  var index = 0;
  backTranspose[index].Add(kvp.Key);

  for (var valueIndex = 0; valueIndex < maxLength; valueIndex++)
  {
    index++;
    if (kvp.Value.Count > valueIndex)
    {
      backTranspose[index].Add(kvp.Value[valueIndex]);
    }
    else
    {
      backTranspose[index].Add(null);
    }
  }
}

// turn the lists back into arrays
parsedData = new List<string[]>();
foreach (var list in backTranspose)
{
  parsedData.Add(list.ToArray());
}

但有一点需要注意，Dictionary没有订购。因此，您最终可能会在不同位置使用频道名称。但是，当然，频道名称和相应的测量数据将具有相同的索引。

Answer 2

您可以使用LINQ和Concat来实现您的目标。

var allData = parsedData.Concat( newData ).ToList();

将string []添加到List <string []> c＃.Net

2 个答案: