我将在二进制文件中存储 350M 预先计算的 double ，并在我的 dll 启动时将它们加载到内存中。是否有任何内置方法可以并行加载它，或者我应该自己将数据拆分为多个文件并自己处理多个线程？

回答评论:我将在足够强大的机器上运行这个 dll，很可能只在 64 位机器上运行。因为对我的号码的所有访问都将通过属性进行，所以我可以将我的号码存储在多个数组中。

[更新]

谢谢大家的回答!我期待着在不同的盒子上进行大量的基准测试。 关于需求:我想加速一个非常慢的计算，所以我打算预计算一个网格，将它加载到内存中，然后进行插值。

最佳答案

好吧，我做了一个小测试，我肯定会推荐使用内存映射文件。 我创建了一个包含 350M double 值(如前所述的 2.6 GB)的文件，然后测试了将文件映射到内存然后访问任何元素所需的时间。

在我对笔记本电脑(Win7、.Net 4.0、Core2 Duo 2.0 GHz、4GB RAM)的所有测试中，映射文件只用了不到一秒的时间，此时访问任何元素几乎用了 0 毫秒(所有时间)正在验证索引)。 然后我决定遍历所有 350M 个号码，整个过程大约需要 3 分钟(包括分页)，所以如果您需要重复，他们可能是另一种选择。

尽管如此，我还是包装了访问权限，仅出于示例目的，在使用此代码之前您应该检查很多条件，它看起来像这样

public class Storage<T> : IDisposable, IEnumerable<T> where T : struct
{
    MemoryMappedFile mappedFile;
    MemoryMappedViewAccessor accesor;
    long elementSize;
    long numberOfElements;

    public Storage(string filePath)
    {
        if (string.IsNullOrWhiteSpace(filePath))
        {
            throw new ArgumentNullException();
        }

        if (!File.Exists(filePath))
        {
            throw new FileNotFoundException();
        }

        FileInfo info = new FileInfo(filePath);
        mappedFile = MemoryMappedFile.CreateFromFile(filePath);
        accesor = mappedFile.CreateViewAccessor(0, info.Length);
        elementSize = Marshal.SizeOf(typeof(T));
        numberOfElements = info.Length / elementSize;
    }

    public long Length
    {
        get
        {
            return numberOfElements;
        }
    }

    public T this[long index]
    {
        get
        {
            if (index < 0 || index > numberOfElements)
            {
                throw new ArgumentOutOfRangeException();
            }

            T value = default(T);
            accesor.Read<T>(index * elementSize, out value);
            return value;
        }
    }

    public void Dispose()
    {
        if (accesor != null)
        {
            accesor.Dispose();
            accesor = null;
        }

        if (mappedFile != null)
        {
            mappedFile.Dispose();
            mappedFile = null;
        }
    }

    public IEnumerator<T> GetEnumerator()
    {
        T value;
        for (int index = 0; index < numberOfElements; index++)
        {
            value = default(T);
            accesor.Read<T>(index * elementSize, out value);
            yield return value;
        }
    }

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        T value;
        for (int index = 0; index < numberOfElements; index++)
        {
            value = default(T);
            accesor.Read<T>(index * elementSize, out value);
            yield return value;
        }
    }

    public static T[] GetArray(string filePath)
    {
        T[] elements;
        int elementSize;
        long numberOfElements;

        if (string.IsNullOrWhiteSpace(filePath))
        {
            throw new ArgumentNullException();
        }

        if (!File.Exists(filePath))
        {
            throw new FileNotFoundException();
        }

        FileInfo info = new FileInfo(filePath);
        using (MemoryMappedFile mappedFile = MemoryMappedFile.CreateFromFile(filePath))
        {
            using(MemoryMappedViewAccessor accesor = mappedFile.CreateViewAccessor(0, info.Length))
            {
                elementSize = Marshal.SizeOf(typeof(T));
                numberOfElements = info.Length / elementSize;
                elements = new T[numberOfElements];

                if (numberOfElements > int.MaxValue)
                {
                    //you will need to split the array
                }
                else
                {
                    accesor.ReadArray<T>(0, elements, 0, (int)numberOfElements);
                }
            }
        }

        return elements;
    }
}

这是一个如何使用这个类的例子

Stopwatch watch = Stopwatch.StartNew();
using (Storage<double> helper = new Storage<double>("Storage.bin"))
{
    Console.WriteLine("Initialization Time: {0}", watch.ElapsedMilliseconds);

    string item;
    long index;

    Console.Write("Item to show: ");
    while (!string.IsNullOrWhiteSpace((item = Console.ReadLine())))
    {
        if (long.TryParse(item, out index) && index >= 0 && index < helper.Length)
        {
            watch.Reset();
            watch.Start();
            double value = helper[index];
            Console.WriteLine("Access Time: {0}", watch.ElapsedMilliseconds);
            Console.WriteLine("Item: {0}", value);
        }
        else
        {
            Console.Write("Invalid index");
        }

        Console.Write("Item to show: ");
    }
}

更新 我添加了一个静态方法来将文件中的所有数据加载到数组中。显然，这种方法最初需要更多时间(在我的笔记本电脑上需要 1 到 2 分钟)，但之后访问性能就是您对 .Net 的期望。如果您必须经常访问数据，此方法应该很有用。

用法很简单

double[] helper = Storage<double>.GetArray("Storage.bin");

HTH

关于c# - 在C#中将350M数字快速加载到double[]数组中，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/3250192/