C# 字符串中的子字符串值

我有一个字符串变量，它包含

[l=9；f=0；r=5；p=2]

。可能有多个：

[l=9；f=0；r=5；p=2]，[l=9；f=0；r=6；p=2]

我想得到

元组的
列表
，其中
item1=l的值，item2=r的值，item3=p的值
。最好的方法是什么？

我的代码：

//拆分字符串
var splittedFormattedSeats=Regex.Matches（formatSeats，@“\[.+？\]”）
.Cast（）
.选择（m=>m.Value）
.ToList（）；
IList fullSeat=新列表（）；
foreach（SplittedFormattedSeats中的var SplittedFormattedSeat）
{
...
}

谢谢。
我会采取另一种策略。首先，拆分字符串的子组件

var components = formatSeats.Split(',');

这将为您提供一个字符串数组。这将更有效地解析小字符串块而不是大字符串

然后，您可以使用
Regex
提取值，也可以使用如下简单代码：

foreach(var component in components)
{
    var parts = component.Trim("[]".ToCharArray()).Split(';');

}

var results = from component in components
              let c = component.Trim("[]".ToCharArray())
                               .Split(';')
                               .Select(c=>int.Parse(c.SubString(2))
              select new { l = c[0], f=c[1], r=c[2], p = c[3] };

这将生成匿名类型的枚举

foreach(var x in results)
{
    Console.WriteLine("{0} / {1} / {2} / {3}", x.l, x.f, x.r, x.p);
}

如果您确实需要
元组
，只需将代码更改为：

var results = from component in components
              let c = component.Trim("[]".ToCharArray())
                               .Split(';')
                               .Select(c=>int.Parse(c.SubString(2))
              select new Tuple<int,int,int,int>{ l = c[0], f=c[1], r=c[2], p = c[3] };

最后，如果字符串始终具有这种形式，则可以避免使用正则表达式
 内部字符串的格式是否始终相同？
每个变量（l、f、r&p）是否总是一个位数的值

如果是这样的话，您可以将其子串出来

foreach(var splittedFormatedSeat  in splittedFormatedSeats)
{
    int x, y, z;
    string s = splittedFormatedSeat .ToString();
    if(int.TryParse(s[3].ToString(), out x) &&
       int.TryParse(s[11].ToString(), out y) &&
       int.TryParse(s[15].ToString(), out z))
       fullSeat.Add(new Tuple<int,int,int>(x,y,z));
}

foreach（splittedFormattedSeats中的var splittedFormattedSeat）
{
int x，y，z；
string s=splittedFormattedSeat.ToString（）；
if（int.TryParse（s[3].ToString（），out x）&&
int.TryParse（s[11].ToString（），out y）&&
int.TryParse（s[15].ToString（），out z））
添加（新元组（x，y，z））；
}
string formattedString=“[l=9；f=0；r=5；p=2]，[l=9；f=0；r=6；p=2]”；
var splitString=formattedString.Split（“，”）
.Select（p=>p.Trim（新字符[]{'['，']'，''}））；
列表元组列表=新列表（）；
foreach（splitString中的变量项）
{
int[]finalSplit=item.Split（“；”）.Select（p=>
Convert.ToInt32（p.Substring（p.LastIndexOf（'='））+1.Trim（））
).ToArray（）；
添加（新元组（finalSplit[0]，finalSplit[1]，
最终分裂[2]，最终分裂[3]）；
}

这将拆分l、f、r和p的值，并将它们添加到元组中。
对“f”变量会发生什么情况？@KyorCode:没什么，直接跳过它。“最佳方法”是什么？可读性？演出LINQ的最大使用量？最小代码量？还有别的吗？
public struct MyValue
{
     private readonly int m_L; 
     public int L { get {return m_L; } }

     private readonly int m_F; 
     public int F { get {return m_F; } }

     private readonly int m_R; 
     public int R { get {return m_R; } }

     private readonly int m_P; 
     public int P { get {return m_P; } }

     public MyValue(int l, int f, int r, int p)
     {
         m_L = l;
         m_F = f;
         m_R = r;
         m_P = p;
     }
}
....


var results = from component in components
          let c = component.Trim("[]".ToCharArray())
                           .Split(';')
                           .Select(c=>int.Parse(c.SubString(2))
          select new MyValue(c[0],c[1],c[2],c[3]);

foreach(var splittedFormatedSeat  in splittedFormatedSeats)
{
    int x, y, z;
    string s = splittedFormatedSeat .ToString();
    if(int.TryParse(s[3].ToString(), out x) &&
       int.TryParse(s[11].ToString(), out y) &&
       int.TryParse(s[15].ToString(), out z))
       fullSeat.Add(new Tuple<int,int,int>(x,y,z));
}

        string formattedString = "[l=9;f=0;r=5;p=2],[l=9;f=0;r=6;p=2]";
        var splitString = formattedString.Split(',')
                                    .Select(p => p.Trim(new char[]{'[',']',' '}));

        List<Tuple<int, int, int, int>> tupleList = new List<Tuple<int, int, int, int>>();
        foreach (var item in splitString)
        {
            int[] finalSplit = item.Split(';').Select(p => 
                                                      Convert.ToInt32(p.Substring(p.LastIndexOf('=')+1).Trim())
                                                      ).ToArray();
            tupleList.Add(new Tuple<int, int, int, int>(finalSplit[0], finalSplit[1],
                                    finalSplit[2], finalSplit[3]));
        }