我是一名新手，对C#不是很熟悉。我有一个用户输入的字符串（希望是有效的）。
这个字符串将组成多个信息部分和子部分。
例如：
1-7 will //represent values 1 2 3 4 5 6 7
3:.25:7 //will be the numbers contained between 3 and 7 in increments of .25
// (3 3.25 3.5 3.75 4 ... 6.75 7)
1,4,5 //will represent values 1 4 5
1-7;3:.25:10;1,5,9;4-7
由于上述有4个“数据集”，因此我应该创建4个包含值的新数组。如果我有n个“数据集”，我应该创建n个新数组。
稍后，我想以嵌套方式迭代所有组合的数组。
如果可能（不是必需的），还可以进行以下表示形式的混合：
1-7,9,16:2:20;
我希望我的例子能够清晰地表达我的意思。
谢谢！
嗯，在这里可能会有一个聪明的正则表达式答案，但我会尝试使用我最喜欢的string.Split()函数。
作为第一步，您可以在“;”上拆分输入字符串。
string[] datasets = inputString.Split(';');
就你最后提到的那一点而言，逗号“，”似乎做的更多或更少是一样的，你可以将其与Split(';', ',')合并或保持分开。
string[] parts = datasets[i].Split(',');
string.IndexOf() 进行检测。string[] rangeParts = parts[j].Split('-');
string[] steppedParts = parts[j].Split(':');
结果应分别具有长度2和3。
然后应使用TryParse()检查生成的字符串，并由于使用了标点符号，最好修复Culture：
bool valid = double.TryParse(parts[k],
System.Globalization.NumberStyles.AllowDecimalPoint,
System.Globalization.CultureInfo.InvariantCulture, out value);
我建议使用正则表达式。首先，我会使用以下表达式将其分成几个部分。
^((?<section>[^;]+)(;|$))+
^((?<subsection>[^,]+)(,|$))+
(?<value>^[0-9]+$)|
(?<range>^[0-9]+-[0-9]+$)|
(?<rangewithstep>^[0-9]+:\.[0-9]+:[0-9]+$)
^(?<start>[0-9]+)-(?<end>[0-9]+)$
^(?<start>[0-9]+):(?<step>\.[0-9]+):(?<end>[0-9]+)$
using System;
using System.Text.RegularExpressions;
using System.Globalization;
namespace RangeParser
{
class Program
{
static void Main(string[] args)
{
String input = "1-7,9,16:2:20;1-7; 3:.75 : 10;1,5,9;4-7";
Match sections = (new Regex(@"^((?<section>[^;]+)(;|$))+")).Match(input.Replace(" ", ""));
foreach (Capture section in sections.Groups["section"].Captures)
{
Console.Write("Section ");
Match subsections = (new Regex(@"^((?<subsection>[^,]+)(,|$))+")).Match(section.Value);
foreach (Capture subsection in subsections.Groups["subsection"].Captures)
{
Match subsectionparts = (new Regex(@"^(?<start>[0-9]*\.?[0-9]+)(((:(?<step>[0-9]*\.?[0-9]+):)|-)(?<end>[0-9]*\.?[0-9]+))?$")).Match(subsection.Value);
if (subsectionparts.Groups["start"].Length > 0)
{
Decimal start = Decimal.Parse(subsectionparts.Groups["start"].Value, CultureInfo.InvariantCulture);
Decimal end = start;
Decimal step = 1;
if (subsectionparts.Groups["end"].Length > 0)
{
end = Decimal.Parse(subsectionparts.Groups["end"].Value, CultureInfo.InvariantCulture);
if (subsectionparts.Groups["step"].Length > 0)
{
step = Decimal.Parse(subsectionparts.Groups["step"].Value, CultureInfo.InvariantCulture);
}
}
Decimal current = start;
while (current <= end)
{
Console.Write(String.Format("{0} ", current));
current += step;
}
}
}
Console.WriteLine();
}
Console.ReadLine();
}
}
}
更新
修改以允许类似于“1.5:0.2:3.6”的内容。
更新
为什么要使用十进制而不是单精度或双精度？
输入中的数字是十进制数，不能被单精度或双精度精确表示，因为它们使用基于2的表示。例如，0.1由单精度值0.100000001490116119384765625表示。
Single x = 0.0F;
for (int i = 0; i < 8; i++)
{
x += 0.1F;
}
Console.WriteLine(x);
这个程序只需8次迭代即可输出0.8000001。1000次迭代后，误差增长到0.00095，显示为99.99905而不是100.0，在一百万次迭代后，结果为100,958.3而不是100,000。
对于十进制数没有这样的错误，因为十进制使用基数10表示，并且能够精确表示类似于0.1的十进制数字。
var results = ParseExpression("1-7;3:.25:10;1,5,9;4-7");
private static List<List<float>> ParseExpression(string expression)
{
// "x-y" is the same as "x:1:y" so simplify the expression...
expression = expression.Replace("-", ":1:");
var results = new List<List<float>>();
foreach (var part in expression.Split(';'))
results.Add(ParseSubExpression(part));
return results;
}
private static List<float> ParseSubExpression(string part)
{
var results = new List<float>();
// If this is a set of numbers...
if (part.IndexOf(',') != -1)
// Then add each member of the set...
foreach (string a in part.Split(','))
results.AddRange(ParseSubExpression(a));
// If this is a range that needs to be computed...
else if (part.IndexOf(":") != -1)
{
// Parse out the range parameters...
var parts = part.Split(':');
var start = float.Parse(parts[0]);
var increment = float.Parse(parts[1]);
var end = float.Parse(parts[2]);
// Evaluate the range...
for (var i = start; i <= end; i += increment)
results.Add(i);
}
else
results.Add(float.Parse(part));
return results;
}
List<List<Decimal>>。019.;,-:!
FormatException: "!,"
FormatException: ","
FormatException: "1,"
FormatException: "!"
FormatException: ";9"
FormatException: "::"
FormatException: "!.999009"
FormatException: "!.0!99!9"
FormatException: "0,9.90:!!,,,!,,,,,,!,,,0!!!9,!"
FormatException: ""
FormatException: "-99,9"
FormatException: "1,9,,,!,,,,,,9,,,9,1,!9,,,,!,!"
FormatException: "!:,"
FormatException: "!9!:.!!,!!!."
FormatException: "!:"
IndexOutOfRangeException: "1:9"
FormatException: "09..::!"
FormatException: "9,0..:!.!,,,!,,,,,,!,,,!!-,!,!"
OverflowException: "99999999999999999999999999999999999999999999"
FormatException: "!."
FormatException: "999909!!"
FormatException: "-"
FormatException: "9,9:9:999,,,9,,,,,,!,,,!9!!!,!"
FormatException: "!9,"
FormatException: "!.09!!0!"
FormatException: "9-;"
FormatException: ":"
FormatException: "!.!9!9!!"
NullReferenceException: null
FormatException: ":,"
FormatException: "!!"
FormatException: "9;"
ParseExpression(string) 100,00% 10/10 blocks
ParseSubExpression(string) 96,15% 25/26 blocks
ParseExpressionRegex(string) 95,06% 77/81 blocks
ParseExpressionRegexSingle(string) 94,87% 74/78 blocks
C# 中没有解析范围的约定，因此您可以自由地进行任何最合理的操作。
但是，您可能希望从数学中的区间表示法派生出您的符号。
[2,4] - numbers between 2 and 4
(0,7] - numbers between 0 and 7, but not including 0
好的，当我使用Hank的前两个部分（假设数据集中有一个逗号）拆分字符串时
然后我可以用剩余的信息填充数组。
对于用“-”分隔的部分，我会取“-”之前的值，并从那里开始进行循环，直到“-”之后的值。
对于用“:”分隔的部分，我做的几乎是一样的事情，除了在for循环更新时不是i++增量，而是i+=（中间值）。
要解析出“-”或“：”字符之前和之后的值，我只需再次拆分并知道数组中哪些索引对应什么。
谢谢,
我明天会更新我的最终解决方案。
如果Henk Holterman想要根据我上面说的内容（解析其他部分的描述）更新他的解决方案，我会在我的主页上投票支持。由于某种原因，他们在这里阻止了OpenID。
顺便说一句：我不明白为什么他们不让我作为访客接受解决方案，即使我提供了正确的电子邮件地址，我也应该能够接受解决方案，对吧？
首先，通过分号将字符串拆分为单独的集合。然后，通过逗号将每个集合拆分为集合中的单独数字或范围。
现在您拥有的字符串可以是以下之一：
一个单独的数字，例如42
一系列数字，例如1-7
步进范围，例如1:.5:7
您可以通过检查字符串是否包含连字符或冒号来识别第二个和第三个。然后，您将拆分这些字符串并进行一些循环以将数字添加到集合中。
通过像这样在同一级别处理数字和范围，它们可以按照您想要的方式混合。
一些提示：
使用double.TryParse解析数字。使用CultureInfo.InvariantCulture作为格式提供程序，它使用句点作为小数分隔符。
您可以使用List<double>来保存每个集合的数字。最终结果可以是列表数组，或者如果您想要数组数组，则可以使用ToArray方法创建数组。