FSharp.Data CsvProvider 性能
FSharp.Data CsvProvider performance
我有一个包含 6 列和 678,552 行的 csv 文件。不幸的是，我不能分享任何数据样本，但类型很简单：int64、int64、date、date、string、string 等等没有缺失值。
使用 read.table 将此数据加载到 R 中的数据框中的时间：~ 3 秒。
在 F# 中使用 CsvFile.Load 加载此数据的时间：~ 3 秒。
在 F# 中将此数据加载到 Deedle 数据帧中的时间：~ 7 秒。
添加 inferTypes=false 并为 Deedle 的 Frame.ReadCsv 提供架构可将时间缩短至约 3 秒
在 F# 中使用 CsvProvider 加载此数据的时间：~ 5 分钟。
这 5 分钟甚至是在我在 Schema 参数中定义类型之后，大概消除了 F# 用来推断它们的时间。
我知道类型提供程序需要比 R 或 CsvFile.Load 做更多的工作才能将数据解析为正确的数据类型，但我对 x100 的速度损失感到惊讶。更令人困惑的是 Deedle 加载数据所花费的时间，因为它还需要推断类型并进行适当的转换、按系列进行组织等。实际上我本以为 Deedle 比 CsvProvider 花费的时间更长。
在 this issue 中，CsvProvider 的糟糕性能是由大量列引起的，这不是我的情况。
我想知道我是否做错了什么，或者是否有任何方法可以加快速度。
澄清一下：创建提供程序几乎是瞬间完成的。当我强制生成序列由 Seq.length df.Rows 实现时，fsharpi 提示需要 ~ 5 分钟到 return。
我在 linux 系统上，F# v4.1 on mono v4.6.1。
这是 CsvProvider 的代码
let [<Literal>] SEP = "|"
let [<Literal>] CULTURE = "sv-SE"
let [<Literal>] DATAFILE = dataroot + "all_diagnoses.csv"
type DiagnosesProvider = CsvProvider<DATAFILE, Separators=SEP, Culture=CULTURE>
let diagnoses = DiagnosesProvider()
编辑 1:
我添加了 Deedle 将数据加载到框架中所需的时间。
编辑2：
如果 inferTypes=false 并提供了架构，则添加了 Deedle 花费的时间。
此外，按照评论中的建议在 CsvProvider 中提供 CacheRows=false 对加载时间没有明显影响。
编辑3：
好的，我们正在取得进展。由于某些特殊原因，似乎 Culture 是罪魁祸首。如果我省略此参数，CsvProvider 会在大约 7 秒内加载数据。我不确定是什么原因造成的。我系统的语言环境是 en_US。然而，数据来自瑞典语言环境中的 SQL 服务器，其中十进制数字由“，”而不是“.”分隔。这个特定的数据集没有任何小数，所以我可以完全省略 Culture。然而，另一组有 2 个小数列和超过 1,000,000 行。我的下一个任务是在我目前没有可用的 Windows 系统上对此进行测试。
编辑4：
问题似乎解决了，但我仍然不明白是什么原因造成的。如果我通过以下方式改变文化 "globally"：
System.Globalization.CultureInfo.DefaultThreadCurrentCulture = CultureInfo("sv-SE")
System.Threading.Thread.CurrentThread.CurrentCulture = CultureInfo("sv-SE")
然后从 CsvProvider 中删除 Culture="sv-SE" 参数，加载时间减少到 6 秒左右，小数被正确解析。我将此打开，以防有人可以对此行为做出解释。
我正在尝试重现您遇到的问题，因为您无法共享我尝试生成一些测试数据的数据。但是，在我的机器 (.NET 4.6.2 F#4.1) 上，我没有看到它需要几分钟，它需要几秒钟。
也许您可以尝试查看我的示例应用程序在您的设置中的表现，我们可以从中进行工作？
open System
open System.Diagnostics
open System.IO
let clock =
let sw = Stopwatch ()
sw.Start ()
fun () ->
sw.ElapsedMilliseconds
let time a =
let before = clock ()
let v = a ()
let after = clock ()
after - before, v
let generateDataSet () =
let random = Random 19740531
let firstDate = DateTime(1970, 1, 1)
let randomInt () = random.Next () |> int64 |> (+) 10000000000L |> string
let randomDate () = (firstDate + (random.Next () |> float |> TimeSpan.FromSeconds)).ToString("s")
let randomString () =
let inline valid ch =
match ch with
| '"'
| '\' -> ' '
| _ -> ch
let c = random.Next () % 16
let g i =
if i = 0 || i = c + 1 then '"'
else 32 + random.Next() % (127 - 32) |> char |> valid
Array.init (c + 2) g |> String
let columns =
[|
"Id" , randomInt
"ForeignId" , randomInt
"BirthDate" , randomDate
"OtherDate" , randomDate
"FirstName" , randomString
"LastName" , randomString
|]
use sw = new StreamWriter ("perf.csv")
let headers = columns |> Array.map fst |> String.concat ";"
sw.WriteLine headers
for i = 0 to 700000 do
let values = columns |> Array.map (fun (_, f) -> f ()) |> String.concat ";"
sw.WriteLine values
open FSharp.Data
[<Literal>]
let sample = """Id;ForeignId;BirthDate;OtherDate;FirstName;LastName
11795679844;10287417237;2028-09-14T20:33:17;1993-07-21T17:03:25;",xS@ %aY)N*})Z";"ZP~;"
11127366946;11466785219;2028-02-22T08:39:57;2026-01-24T05:07:53;"H-/QA(";"g8}J?k~"
"""
type PerfFile = CsvProvider<sample, ";">
let readDataWithTp () =
use streamReader = new StreamReader ("perf.csv")
let csvFile = PerfFile.Load streamReader
let length = csvFile.Rows |> Seq.length
printfn "%A" length
[<EntryPoint>]
let main argv =
Environment.CurrentDirectory <- AppDomain.CurrentDomain.BaseDirectory
printfn "Generating dataset..."
let ms, _ = time generateDataSet
printfn " took %d ms" ms
printfn "Reading dataset..."
let ms, _ = time readDataWithTp
printfn " took %d ms" ms
0
性能数据（我桌面上的 .NET462）：
Generating dataset...
took 2162 ms
Reading dataset...
took 6156 ms
性能数据（我的 Macbook Pro 上的 Mono 4.6.2）：
Generating dataset...
took 4432 ms
Reading dataset...
took 8304 ms
更新
事实证明，向 CsvProvider 明确指定 Culture 似乎会大大降低性能。它可以是任何文化，不仅仅是 sv-SE 但为什么？
如果检查提供程序为快速和慢速情况生成的代码，就会注意到不同之处：
快
internal sealed class csvFile@78
{
internal System.Tuple<long, long, System.DateTime, System.DateTime, string, string> Invoke(object arg1, string[] arg2)
{
Microsoft.FSharp.Core.FSharpOption<string> fSharpOption = TextConversions.AsString(arg2[0]);
long arg_C9_0 = TextRuntime.GetNonOptionalValue<long>("Id", TextRuntime.ConvertInteger64("", fSharpOption), fSharpOption);
fSharpOption = TextConversions.AsString(arg2[1]);
long arg_C9_1 = TextRuntime.GetNonOptionalValue<long>("ForeignId", TextRuntime.ConvertInteger64("", fSharpOption), fSharpOption);
fSharpOption = TextConversions.AsString(arg2[2]);
System.DateTime arg_C9_2 = TextRuntime.GetNonOptionalValue<System.DateTime>("BirthDate", TextRuntime.ConvertDateTime("", fSharpOption), fSharpOption);
fSharpOption = TextConversions.AsString(arg2[3]);
System.DateTime arg_C9_3 = TextRuntime.GetNonOptionalValue<System.DateTime>("OtherDate", TextRuntime.ConvertDateTime("", fSharpOption), fSharpOption);
fSharpOption = TextConversions.AsString(arg2[4]);
string arg_C9_4 = TextRuntime.GetNonOptionalValue<string>("FirstName", TextRuntime.ConvertString(fSharpOption), fSharpOption);
fSharpOption = TextConversions.AsString(arg2[5]);
return new System.Tuple<long, long, System.DateTime, System.DateTime, string, string>(arg_C9_0, arg_C9_1, arg_C9_2, arg_C9_3, arg_C9_4, TextRuntime.GetNonOptionalValue<string>("LastName", TextRuntime.ConvertString(fSharpOption), fSharpOption));
}
}
慢
internal sealed class csvFile@78
{
internal System.Tuple<long, long, System.DateTime, System.DateTime, string, string> Invoke(object arg1, string[] arg2)
{
Microsoft.FSharp.Core.FSharpOption<string> fSharpOption = TextConversions.AsString(arg2[0]);
long arg_C9_0 = TextRuntime.GetNonOptionalValue<long>("Id", TextRuntime.ConvertInteger64("sv-SE", fSharpOption), fSharpOption);
fSharpOption = TextConversions.AsString(arg2[1]);
long arg_C9_1 = TextRuntime.GetNonOptionalValue<long>("ForeignId", TextRuntime.ConvertInteger64("sv-SE", fSharpOption), fSharpOption);
fSharpOption = TextConversions.AsString(arg2[2]);
System.DateTime arg_C9_2 = TextRuntime.GetNonOptionalValue<System.DateTime>("BirthDate", TextRuntime.ConvertDateTime("sv-SE", fSharpOption), fSharpOption);
fSharpOption = TextConversions.AsString(arg2[3]);
System.DateTime arg_C9_3 = TextRuntime.GetNonOptionalValue<System.DateTime>("OtherDate", TextRuntime.ConvertDateTime("sv-SE", fSharpOption), fSharpOption);
fSharpOption = TextConversions.AsString(arg2[4]);
string arg_C9_4 = TextRuntime.GetNonOptionalValue<string>("FirstName", TextRuntime.ConvertString(fSharpOption), fSharpOption);
fSharpOption = TextConversions.AsString(arg2[5]);
return new System.Tuple<long, long, System.DateTime, System.DateTime, string, string>(arg_C9_0, arg_C9_1, arg_C9_2, arg_C9_3, arg_C9_4, TextRuntime.GetNonOptionalValue<string>("LastName", TextRuntime.ConvertString(fSharpOption), fSharpOption));
}
}
更具体的区别是：
// Fast
TextRuntime.ConvertDateTime("", fSharpOption), fSharpOption)
// Slow
TextRuntime.ConvertDateTime("sv-SE", fSharpOption), fSharpOption)
当我们指定一种文化时，它会传递给 ConvertDateTime，后者将其转发给 GetCulture
static member GetCulture(cultureStr) =
if String.IsNullOrWhiteSpace cultureStr
then CultureInfo.InvariantCulture
else CultureInfo cultureStr
这意味着对于默认情况我们使用 CultureInfo.InvariantCulture 但对于每个字段和行的任何其他情况我们正在创建一个 CultureInfo 对象。缓存可以完成，但事实并非如此。创建过程本身似乎并没有花费太多时间，但是当我们每次解析一个新的 CultureInfo 对象时会发生一些事情。
在FSharp.Data中解析DateTime本质上就是这样
let dateTimeStyles = DateTimeStyles.AllowWhiteSpaces ||| DateTimeStyles.RoundtripKind
match DateTime.TryParse(text, cultureInfo, dateTimeStyles) with
所以让我们做一个性能测试，我们使用一个缓存的 CultureInfo 对象和另一个我们每次创建一个的对象。
open System
open System.Diagnostics
open System.Globalization
let clock =
let sw = Stopwatch ()
sw.Start ()
fun () ->
sw.ElapsedMilliseconds
let time a =
let before = clock ()
let v = a ()
let after = clock ()
after - before, v
let perfTest c cf () =
let dateTimeStyles = DateTimeStyles.AllowWhiteSpaces ||| DateTimeStyles.RoundtripKind
let text = DateTime.Now.ToString ("", cf ())
for i = 1 to c do
let culture = cf ()
DateTime.TryParse(text, culture, dateTimeStyles) |> ignore
[<EntryPoint>]
let main argv =
Environment.CurrentDirectory <- AppDomain.CurrentDomain.BaseDirectory
let ct = "sv-SE"
let cct = CultureInfo ct
let count = 10000
printfn "Using cached CultureInfo object..."
let ms, _ = time (perfTest count (fun () -> cct))
printfn " took %d ms" ms
printfn "Using fresh CultureInfo object..."
let ms, _ = time (perfTest count (fun () -> CultureInfo ct))
printfn " took %d ms" ms
0
.NET 4.6.2 F#4.1 上的性能数据：
Using cached CultureInfo object...
took 16 ms
Using fresh CultureInfo object...
took 5328 ms
所以似乎在 FSharp.Data 中缓存 CultureInfo 对象应该会在指定区域性时显着提高 CsvProvider 性能。
问题是由于 CsvProvider 没有记忆显式设置 Culture。 this 拉取请求解决了该问题。
我有一个包含 6 列和 678,552 行的 csv 文件。不幸的是，我不能分享任何数据样本，但类型很简单：int64、int64、date、date、string、string 等等没有缺失值。
使用 read.table 将此数据加载到 R 中的数据框中的时间：~ 3 秒。
在 F# 中使用 CsvFile.Load 加载此数据的时间：~ 3 秒。
在 F# 中将此数据加载到 Deedle 数据帧中的时间：~ 7 秒。
添加 inferTypes=false 并为 Deedle 的 Frame.ReadCsv 提供架构可将时间缩短至约 3 秒
在 F# 中使用 CsvProvider 加载此数据的时间：~ 5 分钟。
这 5 分钟甚至是在我在 Schema 参数中定义类型之后，大概消除了 F# 用来推断它们的时间。
我知道类型提供程序需要比 R 或 CsvFile.Load 做更多的工作才能将数据解析为正确的数据类型，但我对 x100 的速度损失感到惊讶。更令人困惑的是 Deedle 加载数据所花费的时间，因为它还需要推断类型并进行适当的转换、按系列进行组织等。实际上我本以为 Deedle 比 CsvProvider 花费的时间更长。
在 this issue 中，CsvProvider 的糟糕性能是由大量列引起的，这不是我的情况。
我想知道我是否做错了什么，或者是否有任何方法可以加快速度。
澄清一下：创建提供程序几乎是瞬间完成的。当我强制生成序列由 Seq.length df.Rows 实现时，fsharpi 提示需要 ~ 5 分钟到 return。
我在 linux 系统上，F# v4.1 on mono v4.6.1。
这是 CsvProvider 的代码
let [<Literal>] SEP = "|"
let [<Literal>] CULTURE = "sv-SE"
let [<Literal>] DATAFILE = dataroot + "all_diagnoses.csv"
type DiagnosesProvider = CsvProvider<DATAFILE, Separators=SEP, Culture=CULTURE>
let diagnoses = DiagnosesProvider()
编辑 1: 我添加了 Deedle 将数据加载到框架中所需的时间。
编辑2：
如果 inferTypes=false 并提供了架构，则添加了 Deedle 花费的时间。
此外，按照评论中的建议在 CsvProvider 中提供 CacheRows=false 对加载时间没有明显影响。
编辑3：
好的，我们正在取得进展。由于某些特殊原因，似乎 Culture 是罪魁祸首。如果我省略此参数，CsvProvider 会在大约 7 秒内加载数据。我不确定是什么原因造成的。我系统的语言环境是 en_US。然而，数据来自瑞典语言环境中的 SQL 服务器，其中十进制数字由“，”而不是“.”分隔。这个特定的数据集没有任何小数，所以我可以完全省略 Culture。然而，另一组有 2 个小数列和超过 1,000,000 行。我的下一个任务是在我目前没有可用的 Windows 系统上对此进行测试。
编辑4： 问题似乎解决了，但我仍然不明白是什么原因造成的。如果我通过以下方式改变文化 "globally"：
System.Globalization.CultureInfo.DefaultThreadCurrentCulture = CultureInfo("sv-SE")
System.Threading.Thread.CurrentThread.CurrentCulture = CultureInfo("sv-SE")
然后从 CsvProvider 中删除 Culture="sv-SE" 参数，加载时间减少到 6 秒左右，小数被正确解析。我将此打开，以防有人可以对此行为做出解释。
我正在尝试重现您遇到的问题，因为您无法共享我尝试生成一些测试数据的数据。但是，在我的机器 (.NET 4.6.2 F#4.1) 上，我没有看到它需要几分钟，它需要几秒钟。
也许您可以尝试查看我的示例应用程序在您的设置中的表现，我们可以从中进行工作？
open System
open System.Diagnostics
open System.IO
let clock =
let sw = Stopwatch ()
sw.Start ()
fun () ->
sw.ElapsedMilliseconds
let time a =
let before = clock ()
let v = a ()
let after = clock ()
after - before, v
let generateDataSet () =
let random = Random 19740531
let firstDate = DateTime(1970, 1, 1)
let randomInt () = random.Next () |> int64 |> (+) 10000000000L |> string
let randomDate () = (firstDate + (random.Next () |> float |> TimeSpan.FromSeconds)).ToString("s")
let randomString () =
let inline valid ch =
match ch with
| '"'
| '\' -> ' '
| _ -> ch
let c = random.Next () % 16
let g i =
if i = 0 || i = c + 1 then '"'
else 32 + random.Next() % (127 - 32) |> char |> valid
Array.init (c + 2) g |> String
let columns =
[|
"Id" , randomInt
"ForeignId" , randomInt
"BirthDate" , randomDate
"OtherDate" , randomDate
"FirstName" , randomString
"LastName" , randomString
|]
use sw = new StreamWriter ("perf.csv")
let headers = columns |> Array.map fst |> String.concat ";"
sw.WriteLine headers
for i = 0 to 700000 do
let values = columns |> Array.map (fun (_, f) -> f ()) |> String.concat ";"
sw.WriteLine values
open FSharp.Data
[<Literal>]
let sample = """Id;ForeignId;BirthDate;OtherDate;FirstName;LastName
11795679844;10287417237;2028-09-14T20:33:17;1993-07-21T17:03:25;",xS@ %aY)N*})Z";"ZP~;"
11127366946;11466785219;2028-02-22T08:39:57;2026-01-24T05:07:53;"H-/QA(";"g8}J?k~"
"""
type PerfFile = CsvProvider<sample, ";">
let readDataWithTp () =
use streamReader = new StreamReader ("perf.csv")
let csvFile = PerfFile.Load streamReader
let length = csvFile.Rows |> Seq.length
printfn "%A" length
[<EntryPoint>]
let main argv =
Environment.CurrentDirectory <- AppDomain.CurrentDomain.BaseDirectory
printfn "Generating dataset..."
let ms, _ = time generateDataSet
printfn " took %d ms" ms
printfn "Reading dataset..."
let ms, _ = time readDataWithTp
printfn " took %d ms" ms
0
性能数据（我桌面上的 .NET462）：
Generating dataset...
took 2162 ms
Reading dataset...
took 6156 ms
性能数据（我的 Macbook Pro 上的 Mono 4.6.2）：
Generating dataset...
took 4432 ms
Reading dataset...
took 8304 ms
更新
事实证明，向 CsvProvider 明确指定 Culture 似乎会大大降低性能。它可以是任何文化，不仅仅是 sv-SE 但为什么？
如果检查提供程序为快速和慢速情况生成的代码，就会注意到不同之处：
快
internal sealed class csvFile@78
{
internal System.Tuple<long, long, System.DateTime, System.DateTime, string, string> Invoke(object arg1, string[] arg2)
{
Microsoft.FSharp.Core.FSharpOption<string> fSharpOption = TextConversions.AsString(arg2[0]);
long arg_C9_0 = TextRuntime.GetNonOptionalValue<long>("Id", TextRuntime.ConvertInteger64("", fSharpOption), fSharpOption);
fSharpOption = TextConversions.AsString(arg2[1]);
long arg_C9_1 = TextRuntime.GetNonOptionalValue<long>("ForeignId", TextRuntime.ConvertInteger64("", fSharpOption), fSharpOption);
fSharpOption = TextConversions.AsString(arg2[2]);
System.DateTime arg_C9_2 = TextRuntime.GetNonOptionalValue<System.DateTime>("BirthDate", TextRuntime.ConvertDateTime("", fSharpOption), fSharpOption);
fSharpOption = TextConversions.AsString(arg2[3]);
System.DateTime arg_C9_3 = TextRuntime.GetNonOptionalValue<System.DateTime>("OtherDate", TextRuntime.ConvertDateTime("", fSharpOption), fSharpOption);
fSharpOption = TextConversions.AsString(arg2[4]);
string arg_C9_4 = TextRuntime.GetNonOptionalValue<string>("FirstName", TextRuntime.ConvertString(fSharpOption), fSharpOption);
fSharpOption = TextConversions.AsString(arg2[5]);
return new System.Tuple<long, long, System.DateTime, System.DateTime, string, string>(arg_C9_0, arg_C9_1, arg_C9_2, arg_C9_3, arg_C9_4, TextRuntime.GetNonOptionalValue<string>("LastName", TextRuntime.ConvertString(fSharpOption), fSharpOption));
}
}
慢
internal sealed class csvFile@78
{
internal System.Tuple<long, long, System.DateTime, System.DateTime, string, string> Invoke(object arg1, string[] arg2)
{
Microsoft.FSharp.Core.FSharpOption<string> fSharpOption = TextConversions.AsString(arg2[0]);
long arg_C9_0 = TextRuntime.GetNonOptionalValue<long>("Id", TextRuntime.ConvertInteger64("sv-SE", fSharpOption), fSharpOption);
fSharpOption = TextConversions.AsString(arg2[1]);
long arg_C9_1 = TextRuntime.GetNonOptionalValue<long>("ForeignId", TextRuntime.ConvertInteger64("sv-SE", fSharpOption), fSharpOption);
fSharpOption = TextConversions.AsString(arg2[2]);
System.DateTime arg_C9_2 = TextRuntime.GetNonOptionalValue<System.DateTime>("BirthDate", TextRuntime.ConvertDateTime("sv-SE", fSharpOption), fSharpOption);
fSharpOption = TextConversions.AsString(arg2[3]);
System.DateTime arg_C9_3 = TextRuntime.GetNonOptionalValue<System.DateTime>("OtherDate", TextRuntime.ConvertDateTime("sv-SE", fSharpOption), fSharpOption);
fSharpOption = TextConversions.AsString(arg2[4]);
string arg_C9_4 = TextRuntime.GetNonOptionalValue<string>("FirstName", TextRuntime.ConvertString(fSharpOption), fSharpOption);
fSharpOption = TextConversions.AsString(arg2[5]);
return new System.Tuple<long, long, System.DateTime, System.DateTime, string, string>(arg_C9_0, arg_C9_1, arg_C9_2, arg_C9_3, arg_C9_4, TextRuntime.GetNonOptionalValue<string>("LastName", TextRuntime.ConvertString(fSharpOption), fSharpOption));
}
}
更具体的区别是：
// Fast
TextRuntime.ConvertDateTime("", fSharpOption), fSharpOption)
// Slow
TextRuntime.ConvertDateTime("sv-SE", fSharpOption), fSharpOption)
当我们指定一种文化时，它会传递给 ConvertDateTime，后者将其转发给 GetCulture
static member GetCulture(cultureStr) =
if String.IsNullOrWhiteSpace cultureStr
then CultureInfo.InvariantCulture
else CultureInfo cultureStr
这意味着对于默认情况我们使用 CultureInfo.InvariantCulture 但对于每个字段和行的任何其他情况我们正在创建一个 CultureInfo 对象。缓存可以完成，但事实并非如此。创建过程本身似乎并没有花费太多时间，但是当我们每次解析一个新的 CultureInfo 对象时会发生一些事情。
在FSharp.Data中解析DateTime本质上就是这样
let dateTimeStyles = DateTimeStyles.AllowWhiteSpaces ||| DateTimeStyles.RoundtripKind
match DateTime.TryParse(text, cultureInfo, dateTimeStyles) with
所以让我们做一个性能测试，我们使用一个缓存的 CultureInfo 对象和另一个我们每次创建一个的对象。
open System
open System.Diagnostics
open System.Globalization
let clock =
let sw = Stopwatch ()
sw.Start ()
fun () ->
sw.ElapsedMilliseconds
let time a =
let before = clock ()
let v = a ()
let after = clock ()
after - before, v
let perfTest c cf () =
let dateTimeStyles = DateTimeStyles.AllowWhiteSpaces ||| DateTimeStyles.RoundtripKind
let text = DateTime.Now.ToString ("", cf ())
for i = 1 to c do
let culture = cf ()
DateTime.TryParse(text, culture, dateTimeStyles) |> ignore
[<EntryPoint>]
let main argv =
Environment.CurrentDirectory <- AppDomain.CurrentDomain.BaseDirectory
let ct = "sv-SE"
let cct = CultureInfo ct
let count = 10000
printfn "Using cached CultureInfo object..."
let ms, _ = time (perfTest count (fun () -> cct))
printfn " took %d ms" ms
printfn "Using fresh CultureInfo object..."
let ms, _ = time (perfTest count (fun () -> CultureInfo ct))
printfn " took %d ms" ms
0
.NET 4.6.2 F#4.1 上的性能数据：
Using cached CultureInfo object...
took 16 ms
Using fresh CultureInfo object...
took 5328 ms
所以似乎在 FSharp.Data 中缓存 CultureInfo 对象应该会在指定区域性时显着提高 CsvProvider 性能。
问题是由于 CsvProvider 没有记忆显式设置 Culture。 this 拉取请求解决了该问题。