我将一个字符串解析为DateTime数百万次：
public static CultureInfo ci = CultureInfo.InvariantCulture;
while (!reader.EndOfStream)
{
line = reader.ReadLine();
string[] fields = line.Split(' ');
DateTime newDT = DateTime.ParseExact(fields[0], "yyyyMMddTHHmmssfff", ci);
}
我的探查器强调ParseExact占用了大量时间。是否有任何其他方法/方法可以将字符串解析为更快的DateTime？
关注UP1：
1）我试过了 - 但速度相同
bool OK = DateTime.TryParseExact(fields[0], "yyyyMMddTHHmmssfff", null, System.Globalization.DateTimeStyles.None,out DT);
2）
我尝试编写自己的解析器 - 但这也很慢：
public static DateTime fastParse(ref string s)
{
return new DateTime(int.Parse(s.Substring(0,4)), int.Parse(s.Substring(4,2)),int.Parse(s.Substring(6,2)), int.Parse(s.Substring(9,2)),int.Parse(s.Substring(11,2)),int.Parse(s.Substring(13,2)),int.Parse(s.Substring(15, 3)));
}
关注UP2
我尝试了Master117存储值的建议 - 再说不快 - 也许问题是构造？
public class fastParseData
{
int year;
int mon;
int day;
int hour;
int min;
string previousSlice = "";
public DateTime fastParse(ref string s)
{
if (previousSlice != s.Substring(0, 12))
{
year=int.Parse(s.Substring(0,4));
mon=int.Parse(s.Substring(4,2));
day=int.Parse(s.Substring(6,2));
hour= int.Parse(s.Substring(9,2));
min = int.Parse(s.Substring(11,2));
previousSlice = s.Substring(0, 12);
}
return new DateTime(year, mon, day, hour,min, int.Parse(s.Substring(13, 2)), int.Parse(s.Substring(15, 3)));
}
}
FOLOW UP3
public class fastParseData
{
int year;
int mon;
int day;
int hour;
int min;
string previousSlice = "";
DateTime previousDT;
public DateTime fastParse(ref string s)
{
if (previousSlice != s.Substring(0, 12))
{
year=int.Parse(s.Substring(0,4));
mon=int.Parse(s.Substring(4,2));
day=int.Parse(s.Substring(6,2));
hour= int.Parse(s.Substring(9,2));
min = int.Parse(s.Substring(11,2));
previousSlice = s.Substring(0, 12);
previousDT = new DateTime(year, mon, day, hour,min,0,0);
}
return previousDT.AddMilliseconds((int.Parse(s.Substring(13, 2))*1000)+int.Parse(s.Substring(15, 3)));
}
}
关注UP4
从我的个人资料中，症结似乎是
int.Parse(s.Substring(13, 2))
Parse位比子串更昂贵。
我试过
int.TryParse(s.Substring(13, 2),NumberStyles.None,ci, out secs)
Convert.ToInt32(s.Substring(13, 2));
但是再次 - 速度没有区别。
是否有更快的方法来解析int？
答案 0 :(得分：6)
分割字符串的想法是在正确的轨道上，但子字符串很慢。每当我拆分字符串时，我都会使用字符访问器。 yyyyMMddTHHmmssfff 免责声明：T
public class DateParser1
{
private static System.String DateFormat="yyMMddTHHmmssfff";
public static System.DateTime GetDate(System.String SourceString, int Offset=0) // Offset eliminates need for substring
{
int Year=0;
int Month=0;
int Day=0;
int Hour=0;
int Minute=0;
int Second=0;
int HourOffset=0;
int MS=0;
if(SourceString.Length+Offset<DateFormat.Length) throw new System.Exception(System.String.Format("Date Too Short {0} For {0}",SourceString.Substring(Offset),DateFormat));
for(int i=0;i<DateFormat.Length;i++)
{
System.Char c=SourceString[Offset+i];
switch(DateFormat[i])
{
case 'y':
Year=Year*10+(c-'0');
break;
case 'M':
Month=Month*10+(c-'0');
break;
case 'd':
Day=Day*10+(c-'0');
break;
case 'T':
if(c=='p'||c=='P')
HourOffset=12;
break;
case 'h':
Hour=Hour*10+(c-'0');
if(Hour==12) Hour=0;
break;
case 'H':
Hour=Hour*10+(c-'0');
HourOffset=0;
break;
case 'm':
Minute=Minute*10+(c-'0');
break;
case 's':
Second=Second*10+(c-'0');
break;
case 'f':
MS=MS*10+(c-'0');
break;
}
}
if(Year>30) //Change For Your Business Rules
{
Year+=1900;
}
else
{
Year+=2000;
}
try
{
return new System.DateTime(Year,Month,Day,Hour+HourOffset,Minute,Second,MS);
}
catch(System.Exception)
{
throw new System.Exception(System.String.Format("Error In Date: {0}/{0}/{0} {0}:{0}:{0}.{0} - {0} {0}",Year,Month,Day,Hour+HourOffset,Minute,Second,MS,DateFormat,SourceString.SubString(Offset,DateFormat.Length)));
}
}
}
答案 1 :(得分：2)
您可以编写自己的解析算法，然后将字符串拆分为数组/列表/等等，然后使用Datetime Constructor创建日期时间，
DateTime newDT = DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32);
因为年/月/日不会改变那么快，你可以提供它们，因此可以减少String操作次数。
http://msdn.microsoft.com/de-de/library/vstudio/system.datetime.aspx
一个简单的方法就是存储前8个字母，比如字符串a = fields [0] .slice（0,8）（此刻不知道正确的操作），现在你解析它们并制作ints，但是在下一次运行中你再次对它们进行切片并测试a = new a，如果是这样的话，使用上次的int而不是再次解析它们，当然你需要存储a和整数
因此，现在问题似乎是构造时间你应该尝试添加经过的时间，通过检查你的int是否比之前的addSecond等更高/更低，或者你可以采取你的构造并将值设置为你的新时光。
试试这个：
public class fastParseData
{
int year;
int mon;
int day;
int hour;
int min;
string previousSlice = "";
DateTime previousDT;
public DateTime fastParse(ref string s)
{
if (previousSlice != s.Substring(0, 12))
{
year=int.Parse(s.Substring(0,4));
mon=int.Parse(s.Substring(4,2));
day=int.Parse(s.Substring(6,2));
hour= int.Parse(s.Substring(9,2));
min = int.Parse(s.Substring(11,2));
previousSlice = s.Substring(0, 12);
previousDT = new DateTime(year, mon, day, hour,min,0,0);
}
return previousDT.ParseExact(year, mon, day, hour,min, int.Parse(s.Substring(13, 2)), int.Parse(s.Substring(15, 3));
}
}
这样你只会创建一个DT然后只设置新的时间
答案 2 :(得分：1)
这是用于对框架代码进行基准James's code的代码（参考我的评论）。我在发布模式，.Net 4.5.2,32bit控制台
中运行它static void Main(string[] args)
{
const string date = "2015-04-11T12:45:59";
const string format = "yyyy-MM-ddTHH:mm:ss";
var reference = FrameworkParse(date, format);
var method1 = JamesBarrettParse(date, format);
if (reference != method1)
{
throw new Exception(string.Format("reference date {0} does not match SO date {1}",reference.ToString("s"),method1.ToString("s")));
}
const int iterations = 1000000;
var sw = new Stopwatch();
//FRAMEWORK PARSE
Console.Write("Starting framework parse for {0} iterations...", iterations);
sw.Start();
DateTime dt;
for (var i = 0; i < iterations; i++)
{
dt = FrameworkParse(date, format);
if (dt.Minute != 45)
{
Console.WriteLine("duh");
}
}
sw.Stop();
Console.WriteLine("DONE in {0} millis",sw.ElapsedMilliseconds.ToString("F2",CultureInfo.InvariantCulture));
//James Barrett parse
Console.Write("Starting JB parse for {0} iterations...", iterations);
sw.Restart();
for (var i = 0; i < iterations; i++)
{
dt = JamesBarrettParse(date, format);
if (dt.Minute != 45)
{
Console.WriteLine("duh");
}
}
sw.Stop();
Console.WriteLine("DONE in {0} millis",sw.ElapsedMilliseconds.ToString("F2",CultureInfo.InvariantCulture));
Console.Write("press any key to exit");
Console.ReadKey();
}
private static DateTime FrameworkParse(string s, string format, CultureInfo info = null)
{
var time = DateTime.ParseExact(s, format,
info ?? CultureInfo.InvariantCulture,
DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal);
return time;
}
输出
开始框架解析1000000次迭代...完成2058.00毫秒
开始JB解析1000000次迭代...完成324.00毫秒
按任意键退出
答案 3 :(得分：1)
类似于James Barrett的答复，但我认为速度更快，因为它更直截了当：
假设您的日期格式为yyMMdd。
我发现的最快的转换方法是：
var d = new DateTime(
(s[0] - '0') * 10 + s[1] - '0' + 2000,
(s[2] - '0') * 10 + s[3] - '0',
(s[4] - '0') * 10 + s[5] - '0')
只需根据您选择的日期格式选择索引。如果您需要速度，可能不介意该函数的“非泛型”方式。
此方法大约需要以下时间的10％：
var d = DateTime.ParseExact(s, "yyMMdd", System.Globalization.CultureInfo.InvariantCulture);
答案 4 :(得分：0)
这可能是使用并行化的好地方。 Parallel.ForEach可能是一个很好用的，但你可能想测试其他的并行化方法
private static IEnumerable<string> GetLines(TextReader reader)
{
while (!reader.EndOfStream)
{
yield return reader.ReadLine();
}
}
private static CultureInfo ci = CultureInfo.InvariantCulture;
public static ConcurrentBag ProcessData(TextReader reader)
{
ConcurrentBag <DateTime> results = new ConcurrentBag <DateTime>();
char[] seperators = {' '};
Parallel.ForEach(GetLines(reader), line =>
{
//We only need the first field so limit the split to 2
string[] fields = line.Split(seperators, 2);
results.Enqueue(DateTime.ParseExact(fields[0], "yyyyMMddTHHmmssfff", ci));
});
return results
}
这样做的缺点是你松散了订单，如果这对你来说很重要，那么会有pass in the index from the IEnumerable版本的Parallel.ForEach。您需要存储包含日期的行号（可能是ConcurrentDictionary<long,DateTime>或将Tuple<long,DateTime>存储在包中），然后在稍后对数据进行排序。
答案 5 :(得分：0)
不确定这是否会更快，但您可以将日期字符串转换为long，然后将其按算术分割：
string dateStr = "20131108134701234"; //yyyyMMddHHmmssfff
long dateLong = long.Parse(dateStr);
int f = (int) (dateLong % 1000);
int s = (int) ((dateLong % 100000 - f) / 1000);
int mi = (int) ((dateLong % 10000000 - s - f) / 100000);
int h = (int) ((dateLong % 1000000000 - mi - s - f) / 10000000);
int d = (int) ((dateLong % 100000000000 - h - mi - s - f) / 1000000000);
int mo = (int) ((dateLong % 10000000000000 - d - h - mi - s - f) / 100000000000);
int y = (int) ((dateLong % 100000000000000000 - mo - d - h - mi - s - f) / 10000000000000);
DateTime dateDT = new DateTime(y, mo, d, h, mi, s, f);
（幼稚，未经优化的实施）