List<T> 到 T[] 不复制

Question

我有大量需要提供给 OpenGL 的值类型。如果这能尽快发生，那就太好了。 我现在正在做的事情是这样的：

List<Vertex> VList = new List<Vertex>();
... //Add vertices
Vertex[] VArray;
VList.CopyTo(VArray, VList.Length);
GL.SetData(..., VArray);

这个列表很容易有 10MB 大，所以复制很慢。我可以在不复制的情况下做到这一点，比如以某种方式获取指向 List 内部使用的数组的指针吗？

还是我必须实现自己的 List 类..

编辑：我忘了提到我不知道将添加到列表中的元素数量。

Answer 1

如果您需要重复访问内部数组，最好将访问器存储为委托。

在这个例子中，它是动态方法的委托。第一次调用可能不会很快，但后续调用（在相同类型的 List 上）会快得多。

public static class ListExtensions
{
    static class ArrayAccessor<T>
    {
        public static Func<List<T>, T[]> Getter;

        static ArrayAccessor()
        {
            var dm = new DynamicMethod("get", MethodAttributes.Static | MethodAttributes.Public, CallingConventions.Standard, typeof(T[]), new Type[] { typeof(List<T>) }, typeof(ArrayAccessor<T>), true);
            var il = dm.GetILGenerator();
            il.Emit(OpCodes.Ldarg_0); // Load List<T> argument
            il.Emit(OpCodes.Ldfld, typeof(List<T>).GetField("_items", BindingFlags.NonPublic | BindingFlags.Instance)); // Replace argument by field
            il.Emit(OpCodes.Ret); // Return field
            Getter = (Func<List<T>, T[]>)dm.CreateDelegate(typeof(Func<List<T>, T[]>));
        }
    }

    public static T[] GetInternalArray<T>(this List<T> list)
    {
        return ArrayAccessor<T>.Getter(list);
    }
}

确保包括：

using System.Reflection;
using System.Reflection.Emit;

Answer 2

我不会推荐你想做的事。你为什么首先使用List<T>？如果您能准确地告诉我们您想要创建的数据结构应该具有哪些特征，以及它应该如何与消费 API 交互，我们或许能够为您的问题提供适当的解决方案。

但我会尽力回答问题。

我可以在不复制的情况下做到这一点，例如 以某种方式获得指向数组的指针 List 内部使用？

是的，尽管您将依赖未记录的实现细节。从 NET 4.0 开始，支持数组字段称为 _items。

Vertex[] vertices = (Vertex[]) typeof(List<Vertex>)
                   .GetField("_items", BindingFlags.NonPublic | BindingFlags.Instance)
                   .GetValue(VList);

请注意，这个数组的末尾几乎肯定会有 slack（这就是List<T> 的全部意义），所以这个数组上的array.Length 不会那么有用。需要通过其他方式通知使用数组的 API 数组的“真实”长度（通过告诉它列表的真实 Count 是什么）。

Answer 3

IList<T> 接口并不难做到（好吧，只要 Reflector 是免费的并且可以正常工作，提示提示）。

您可以创建自己的实现并将内部数组公开为公共属性。

Answer 4

与其使用反射来访问List<T> 中的内部数组，如果您只需要添加 的能力，那么我实际上建议您实现自己的可调整大小的数组（喘气！）。 没那么难。

类似：

class ResizableArray<T>
{
    T[] m_array;
    int m_count;

    public ResizableArray(int? initialCapacity = null)
    {
        m_array = new T[initialCapacity ?? 4]; // or whatever
    }

    internal T[] InternalArray { get { return m_array; } }

    public int Count { get { return m_count; } }

    public void Add(T element)
    {
        if (m_count == m_array.Length)
        {
            Array.Resize(ref m_array, m_array.Length * 2);
        }

        m_array[m_count++] = element;
    }
}

然后您可以使用InternalArray 获取内部数组，并使用Count 知道数组中有多少项。

Answer 5

您可以通过反射来做到这一点：

public static T[] GetUnderlyingArray<T>(this List<T> list)
{
    var field = list.GetType().GetField("_items",
        System.Reflection.BindingFlags.Instance |
        System.Reflection.BindingFlags.NonPublic);
    return (T[])field.GetValue(list);
}

编辑：啊，在我测试这个时有人已经说过了..

Answer 6

您可能需要考虑您的处理方法是否错误。如果你发现自己使用反射来做到这一点 - 你已经迷路了。

我可以想出几种方法来解决这个问题，但哪种方法最理想在很大程度上取决于这是否是多线程代码。

让我们假设它不是......

想想数组的特性。每次调用此方法时，都会创建一个 N 长度数组。您的目标是提高性能（这意味着您希望最小化分配和数据副本）。

您能否在编译或运行时提示数组的理想起始大小是多少？我的意思是 - 如果 95% 的时间 N 长度是 100k 或更少......从 100k 项目数组开始。继续使用它，直到遇到数组太小的情况。

当您遇到这种情况时，您可以根据您对程序的理解来决定您要做什么。阵列是否应该增长 10%？它应该增长到字面所需的长度吗？您可以使用现有的数据并继续处理其余数据吗？

随着时间的推移会找到理想的尺寸。您甚至可以让您的程序在每次运行时监控最终大小，并将其用作下次启动时分配的提示（也许这个数组长度取决于环境因素，例如分辨率等）。

换句话说，我的建议是不要使用 List-to-Array 方法，而是预先分配一个数组，将其永久保留，并根据需要进行扩展。

如果您的程序存在线程问题，您显然需要解决这些问题。

Answer 7

您可能能够从通用列表中获取指针，但我不推荐它，它可能不会按照您期望的方式工作（如果有的话）。基本上它意味着获取一个指向对象的指针，而不是像数组这样的内存结构。

我认为你应该反过来做，如果你需要速度，然后在不安全的上下文中使用结构数组指针直接处理字节数组。

背景信息：
“即使与 unsafe 关键字一起使用，也不允许获取托管对象的地址、获取托管对象的大小或声明指向托管类型的指针。” - 来自C#: convert generic pointer to array

MSDN unsafe

Answer 8

由于您使用的是 GL，因此我假设您知道自己在做什么，并跳过所有警告。试试这个，或查看https://stackoverflow.com/a/35588774/194921

  [StructLayout(LayoutKind.Explicit)]
  public struct ConvertHelper<TFrom, TTo>
      where TFrom : class
      where TTo : class {
    [FieldOffset( 0)] public long before;
    [FieldOffset( 8)] public TFrom input;
    [FieldOffset(16)] public TTo output;

    static public TTo Convert(TFrom thing) {
      var helper = new ConvertHelper<TFrom, TTo> { input = thing };
      unsafe {
        long* dangerous = &helper.before;
        dangerous[2] = dangerous[1];  // ie, output = input
      }
      var ret = helper.output;
      helper.input = null;
      helper.output = null;
      return ret;
    }
  }

  class PublicList<T> {
    public T[] _items;
  }

  public static T[] GetBackingArray<T>(this List<T> list) {
    return ConvertHelper<List<T>, PublicList<T>>.Convert(list)._items;
  }