C#将两个字符串之间的特定字符串放入列表<；字符串>；

我有一些关于“从两个字符串之间找到特定字符串并进入列表”的问题

我有一根这样的线：

-begin- 
code:[264]
Name:[1] 
Name:[2] 
Name:[3]
-end- 
code:[264]
Name:[1] 
Name:[4] 
code:[264]
Name:[6]
-begin- 
Name:[6] 
code:[264]
Name:[7] 
Name:[8] 
Name:[1]
-end-

我想将字符串“Name:”between“-begin-”to“-end-”拆分为如下列表

list<1>
Name:[1] 
Name:[2] 
Name:[3]
list<2>
Name:[6] 
Name:[7] 
Name:[8]
Name:[1]

我不知道如何拆分字符串“Name:”之后在“-begin-”到“-end-”之间拆分文本

有人能帮我吗

非常感谢。

将把字符串解析为数组子字符串。然后处理子字符串

string[] parseStr = text.Split('\n');

将字符串解析为数组子字符串。然后处理子字符串

string[] parseStr = text.Split('\n');

---

使用枚举数和

yield return

s，您可以实现更干净、更易于维护的代码：

首先，让我们把签名弄对。您需要从输入字符串创建列表集合：

publicstatic IEnumerableprocessText（字符串输入）

looks-right

现在，让我们的生活更轻松。首先，让我们将输入字符串分成几行：

var lines = input.Split(new[] { Environment.NewLine });

现在，让我们遍历这些行，但不要使用

foreach

来执行此操作。让我们更脏一点，直接使用枚举器，原因将在稍后变得更清楚：

using (var enumerator = lines.GetEnumerator())
{
    while (enumerator.MoveNext()
    {
    }
}

好的，现在我们只需要找到每个子列表的开头并相应地构建它。这很简单：

while (enumerator.MoveNext()
{
    if (enumerator.Current == "-begin-"
        yield return createSubList(enumerator).ToList();
}

现在你明白我为什么直接使用枚举器了。这样，我可以调用另一个方法，轻松跟踪输入文本中的位置：

static IEnumerable<string> createSubList(IEnumerator<string> enumerator)
{
    while (enumerator.MoveNext()
    {
        if (enumerator.Current == "-end-")
        {
            yield break;
        }

        if (!enumerator.Current.StartsWith(...whatever strings you want to ignore))
        {
            yield return enumerator.Current;
        }      
    }
}

静态IEnumerable createSubList（IEnumerator枚举器）
{
while（枚举数.MoveNext（）
{
如果（enumerator.Current==“-end-”）
{
屈服断裂；
}
如果（！enumerator.Current.StartsWith（…任何要忽略的字符串））
{
产生返回枚举数。当前；
}      
}
}

我们完成了！让我们一起来：

public IEnumerable<IList<string>> ProcessText(string input)
{
    var lines = input.Split(new[] { Environment.NewLine });

    using (var enumerator = lines.GetEnumerator())
    {
        while (enumerator.MoveNext()
        {
            if (enumerator.Current == "-begin-"
                yield return createSubList(enumerator).ToList();
        }
    }
}

private static IEnumerable<string> createSubList(IEnumerator<string> enumerator)
{
    while (enumerator.MoveNext()
    {
        if (enumerator.Current == "-end-")
        {
            yield break;
        }

        if (!enumerator.Current.StartsWith(...whatever strings you want to ignore))
        {
            yield return enumerator.Current;
        }      
    }
}

public IEnumerable ProcessText（字符串输入）
{
var lines=input.Split（new[]{Environment.NewLine}）；
使用（var enumerator=lines.GetEnumerator（））
{
while（枚举数.MoveNext（）
{
如果（enumerator.Current==“-开始--”
返回createSubList（枚举器）.ToList（）；
}
}
}
私有静态IEnumerable createSubList（IEnumerator枚举器）
{
while（枚举数.MoveNext（）
{
如果（enumerator.Current==“-end-”）
{
屈服断裂；
}
如果（！enumerator.Current.StartsWith（…任何要忽略的字符串））
{
产生返回枚举数。当前；
}      
}
}

您可以利用枚举数和

产生返回来实现更干净、更易于维护的代码

s:

首先，让我们正确地获取签名。您需要从输入字符串创建一个列表集合：

publicstatic IEnumerableprocessText（字符串输入）

看起来很正确

现在，让我们的生活更轻松。首先，让我们将输入字符串拆分为几行：

var lines = input.Split(new[] { Environment.NewLine });

现在，让我们遍历这些行，但不要使用

foreach

来执行此操作。让我们更脏一点，直接使用枚举器，原因将在稍后变得更清楚：

using (var enumerator = lines.GetEnumerator())
{
    while (enumerator.MoveNext()
    {
    }
}

好的，现在我们只需要找到每个子列表的开头并相应地构建它。这很简单：

while (enumerator.MoveNext()
{
    if (enumerator.Current == "-begin-"
        yield return createSubList(enumerator).ToList();
}

现在你明白我为什么直接使用枚举器了。这样我可以调用另一个方法，轻松跟踪我们在输入文本中的位置：

static IEnumerable<string> createSubList(IEnumerator<string> enumerator)
{
    while (enumerator.MoveNext()
    {
        if (enumerator.Current == "-end-")
        {
            yield break;
        }

        if (!enumerator.Current.StartsWith(...whatever strings you want to ignore))
        {
            yield return enumerator.Current;
        }      
    }
}

静态IEnumerable createSubList（IEnumerator枚举器）
{
while（枚举数.MoveNext（）
{
如果（enumerator.Current==“-end-”）
{
屈服断裂；
}
如果（！enumerator.Current.StartsWith（…任何要忽略的字符串））
{
产生返回枚举数。当前；
}      
}
}

我们完成了！让我们一起来：

public IEnumerable<IList<string>> ProcessText(string input)
{
    var lines = input.Split(new[] { Environment.NewLine });

    using (var enumerator = lines.GetEnumerator())
    {
        while (enumerator.MoveNext()
        {
            if (enumerator.Current == "-begin-"
                yield return createSubList(enumerator).ToList();
        }
    }
}

private static IEnumerable<string> createSubList(IEnumerator<string> enumerator)
{
    while (enumerator.MoveNext()
    {
        if (enumerator.Current == "-end-")
        {
            yield break;
        }

        if (!enumerator.Current.StartsWith(...whatever strings you want to ignore))
        {
            yield return enumerator.Current;
        }      
    }
}

public IEnumerable ProcessText（字符串输入）
{
var lines=input.Split（new[]{Environment.NewLine}）；
使用（var enumerator=lines.GetEnumerator（））
{
while（枚举数.MoveNext（）
{
如果（enumerator.Current==“-开始--”
返回createSubList（枚举器）.ToList（）；
}
}
}
私有静态IEnumerable createSubList（IEnumerator枚举器）
{
while（枚举数.MoveNext（）
{
如果（enumerator.Current==“-end-”）
{
屈服断裂；
}
如果（！enumerator.Current.StartsWith（…任何要忽略的字符串））
{
产生返回枚举数。当前；
}      
}
}

您的尝试离可行的解决方案不远。
我手边只有手机，所以我不能给你测试过的代码。但我的建议如下：

• 您似乎需要一个字符串列表数组。创建一个字符串列表，因为您不知道数组将变得多大。您可以很容易地从最后的列表中获得一个数组
• 你需要一个循环，你已经有了
• 在循环中，找到开始和结束。您几乎已经完成了。您应该搜索

  -begin-

  和

  -end-

• 在

  -begin-

  和

  -end-

  之间获取所需的数据，并在内部（嵌套）循环中进行处理

嵌套循环：

• 创建一个字符串列表
• 获取数据，以与外部循环相同的方式搜索开始<代码>名称和结束<代码>]
• 将找到的元素添加到列表中

嵌套循环后，仍在外部循环内：

• 将刚才填写的字符串列表添加到字符串列表中

外环的末端

---

记住对外循环使用有效的条件。在您的示例中，您从未设置“位置”。

您的尝试离有效解决方案不远。
我手边只有手机，所以我不能给你测试过的代码。但我的建议如下：

• 您似乎需要一个列表数组