Fatal编程技术网
  • csharp/
  • C# 需要芬奇LINQ（第2部分）

C# 需要芬奇LINQ（第2部分）

c# .net linq c#-4.0 .net-4.0

C# 需要芬奇LINQ（第2部分）,c#,.net,linq,c#-4.0,.net-4.0,C#,.net,Linq,C# 4.0,.net 4.0,我有一个CSV字符串： string data = "G9999999990001800002777107050,G9999999990002777107HMNLAQKPRLLHRAQRWJ010,1,3,29,P,6.74,11.23,07,P,5.25,14.29,08,P,6.89,16.92,2,5,052,U,4.78,31.04,095,O,9.59,27.63,076,P,3.85,16.50,094,P,4.84,18.30,093,O,8.28,26.90,062,P,4.64

我有一个CSV字符串：

string data = "G9999999990001800002777107050,G9999999990002777107HMNLAQKPRLLHRAQRWJ010,1,3,29,P,6.74,11.23,07,P,5.25,14.29,08,P,6.89,16.92,2,5,052,U,4.78,31.04,095,O,9.59,27.63,076,P,3.85,16.50,094,P,4.84,18.30,093,O,8.28,26.90,062,P,4.64,16.00,061,P,2.84,12.87,090,O,7.90,20.83,050,P,3.36,16.59,057,B,12.05,34.46,1,1,111,P,7.26,13.79";
前两个元素是ID

第二个2表示一行和一列，例如第1行和第3列。每个数据块中有4个元素，因此我需要过滤掉12个元素，它们是：
29，P，6.74，11.23，07，P，5.25，14.29，08，P，6.89，16.92

之后，接下来的元素是2和5，例如2行5列。同样，每个数据块有4个元素，所以我需要40个元素，这将导致
052，U，4.78，31.04095，O，9.59，27.63076，P，3.85，16.50094，P，4.84，18.30093，O，8.28，26.90062，P，4.64，16.00061，P，2.84，12.87090，O，7.90，20.83050，P，3.36，16.59057，B，12.05，34.46

接下来的元素是1,1，例如1行1列，因此取4个元素，即
111，p，7.26,13.79

指标（如1,3和2,5和1,1）可能不同，因此CSV长度明显不同。在本例中，这些指标可能有很多套，而不仅仅是3套

我已经开始使用
Aggregate（（x，y）=>x*y）
方法来计算我们需要多少，但我的代码不够动态，无法解释3个以上的指标集

有没有办法找到这些指示器，然后从CSV字符串中的正确位置返回正确数量的元素

请注意：我并没有将自己局限于仅限LINQ的解决方案。我只是觉得可能有内置的方法来处理这个问题。

嗯，伪代码：

read first two IDs
int c = position of second comma
while c <= length of string
    int x = parse number after c
    int y = parse number after x
    set c = position of y + 1
    int[][] m = new int[x][y]
    for (i=0; i<x; i++)
        for (j=0; j<y; j++)
            m[i][j] = parse 4 elements after c
            move c to end of m[i][j]
    add m to list of results

读取前两个ID
int c=第二个逗号的位置
当chmm时，伪代码：


read first two IDs
int c = position of second comma
while c <= length of string
    int x = parse number after c
    int y = parse number after x
    set c = position of y + 1
    int[][] m = new int[x][y]
    for (i=0; i<x; i++)
        for (j=0; j<y; j++)
            m[i][j] = parse 4 elements after c
            move c to end of m[i][j]
    add m to list of results



读取前两个ID
int c=第二个逗号的位置

虽然c我与一位同事进行了协商，并提出了一个可行的解决方案，但我对是否可以改进持开放态度：


 public class Data
        {
            public string Index { get; set; }
            public string Letter { get; set; }
        }

string data = "G9999999990001800002777107050,G9999999990002777107HMNLAQKPRLLHRAQRWJ010,1,3,29,P,6.74,11.23,07,P,5.25,14.29,08,P,6.89,16.92,2,5,052,U,4.78,31.04,095,O,9.59,27.63,076,P,3.85,16.50,094,P,4.84,18.30,093,O,8.28,26.90,062,P,4.64,16.00,061,P,2.84,12.87,090,O,7.90,20.83,050,P,3.36,16.59,057,B,12.05,34.46,1,1,111,P,7.26,13.79";

            var elements = data.Split(',');

            int counter = 1;
            int startIndex = 2;
            int dataBlock=0;
            Dictionary<int, List<Data>> result = new Dictionary<int,List<Data>>();

            while(elements.Length > startIndex)
            {
                dataBlock = int.Parse(elements[startIndex]) * int.Parse(elements[startIndex+1]);
                startIndex +=2;
                for(int i=0;i<dataBlock;i++)
                {
                    Data d = new Data(){Index = elements[startIndex], Letter = elements[startIndex+1]};
                    if (result.ContainsKey(counter))
                        result[counter].Add(d);
                    else
                    {
                        result.Add(counter, new List<Data>());
                        result[counter].Add(d);
                    }

                    startIndex+=4;
                }
                counter++;
            }



公共类数据
{
公共字符串索引{get；set；}
公共字符串字母{get；set；}
}
此外，他们还包括10、1、3、29、0、4.84、18.30093、0、8.28、8.28、26.90062、8.28、26.2002、6.84、18.30093、0、8.84、18.84、18.30093、0、8.8、8.28、26.28、26.28、26.26、26.62、26.62、26.62、26.62、8、26.62、8、26.62、8、26.62、8、26.62、8、8、8、8、26.56、26.26、26、8、26、26、26、26.62、8、26、26.62、20、8、8、8、8、8、8、8、8、8、26.60、8、8、8、8、8、8、26.60、8、26、26、26、26、26、26.60、26、26、26、26、26、26、26、第7.46,1,1111页，第7.26,13.79页”；
var元素=data.Split（'，'）；
int计数器=1；
int startIndex=2；
int-dataBlock=0；
字典结果=新字典（）；
while（elements.Length>startIndex）
{
dataBlock=int.Parse（元素[startIndex]）*int.Parse（元素[startIndex+1]）；
startIndex+=2；

对于（int i=0；i我与一位同事进行了协商，并提出了一个可行的解决方案，但我对是否可以改进持开放态度：


 public class Data
        {
            public string Index { get; set; }
            public string Letter { get; set; }
        }

string data = "G9999999990001800002777107050,G9999999990002777107HMNLAQKPRLLHRAQRWJ010,1,3,29,P,6.74,11.23,07,P,5.25,14.29,08,P,6.89,16.92,2,5,052,U,4.78,31.04,095,O,9.59,27.63,076,P,3.85,16.50,094,P,4.84,18.30,093,O,8.28,26.90,062,P,4.64,16.00,061,P,2.84,12.87,090,O,7.90,20.83,050,P,3.36,16.59,057,B,12.05,34.46,1,1,111,P,7.26,13.79";

            var elements = data.Split(',');

            int counter = 1;
            int startIndex = 2;
            int dataBlock=0;
            Dictionary<int, List<Data>> result = new Dictionary<int,List<Data>>();

            while(elements.Length > startIndex)
            {
                dataBlock = int.Parse(elements[startIndex]) * int.Parse(elements[startIndex+1]);
                startIndex +=2;
                for(int i=0;i<dataBlock;i++)
                {
                    Data d = new Data(){Index = elements[startIndex], Letter = elements[startIndex+1]};
                    if (result.ContainsKey(counter))
                        result[counter].Add(d);
                    else
                    {
                        result.Add(counter, new List<Data>());
                        result[counter].Add(d);
                    }

                    startIndex+=4;
                }
                counter++;
            }



公共类数据
{
公共字符串索引{get；set；}
公共字符串字母{get；set；}
}
此外，他们还包括10、1、3、29、0、4.84、18.30093、0、8.28、8.28、26.90062、8.28、26.2002、6.84、18.30093、0、8.84、18.84、18.30093、0、8.8、8.28、26.28、26.28、26.26、26.62、26.62、26.62、26.62、8、26.62、8、26.62、8、26.62、8、26.62、8、8、8、8、26.56、26.26、26、8、26、26、26、26.62、8、26、26.62、20、8、8、8、8、8、8、8、8、8、26.60、8、8、8、8、8、8、26.60、8、26、26、26、26、26、26.60、26、26、26、26、26、26、26、第7.46,1,1111页，第7.26,13.79页”；
var元素=data.Split（'，'）；
int计数器=1；
int startIndex=2；
int-dataBlock=0；
字典结果=新字典（）；
while（elements.Length>startIndex）
{
dataBlock=int.Parse（元素[startIndex]）*int.Parse（元素[startIndex+1]）；
startIndex+=2；

对于（int i=0；我为什么你要用Linq解决这个解析问题。你难道不知道人们在Linq存在之前解析的很好吗？是的，这一点很公平。我只是觉得这可能更容易。我不想要一个定义的Linq解决方案。不管怎样。在这种情况下，你基本上是在发布“给我代码”问题。这应该是关闭的。这在我看来并不是一个LINQ问题。在这种情况下，将此字符串读入您创建的对象结构中可能会更容易，以便更容易使用。因为字符串的长度是动态的，我不确定如何才能在对象中公开相关属性为什么您要尝试用Linq解决这个解析问题。你难道不知道人们在Linq存在之前解析得很好吗？是的，这一点很公平。我只是觉得这可能更容易。我不想要一个定义的Linq解决方案。不管什么都行。在这种情况下，你基本上是在发布“给我代码”问题。这应该是关闭的。这在我看来并不是一个LINQ问题。在这种情况下，将此字符串读入您创建的对象结构可能会更容易，以便更容易使用。因为字符串的长度是动态的，我不确定如何在objectFirst thing中公开相关属性ind使用的是split，但是如果字符串长度较大，则会很耗时，因为字符串是不可变的，需要占用太多内存（如果字符串大小较大，同样如此）。首先想到的是使用split，但是如果字符串长度较大，则会很耗时，因为字符串是不可变的，需要占用太多内存（如果字符串大小较大，同样如此）。