在指针数组中写入和获取元素 .NET 4.7.3

Question

我正在尝试创建一个指针数组，以便能够跟踪对添加到其中的任何非管理对象的引用并对其进行更改，但是当我创建 Int的指针数组时，行为有所不同> 当创建一个 Persons 的指针数组时，什么是非托管的。

    public unsafe struct Person
    {
        public char* name;
        public int age;

        public Person(string name, int age)
        {
            this.name = (char*)Marshal.StringToCoTaskMemAuto(name);
            this.age = age;
        }
    }

添加：

public static unsafe void WriteValueAtPointerArrayIndex<T>(ref T** pointerArray, int index, in T value) where T : unmanaged
    {
        T** ptr = pointerArray;
        fixed (T* ptrValue = &value)
        {
            ptr += index;
            *ptr = ptrValue;

            Console.WriteLine("Address where add: {0}, Value: {1}", (long)ptr, **ptr);
        }
    }

获取：

public static unsafe ref T* GetPointerValueAtPointerArrayIndex<T>(ref T** pointerArray, int index) where T : unmanaged
    {
        T** ptr = pointerArray;
        ptr += index;

        ref T* value = ref *ptr;
        Console.WriteLine("Address to return: {0}, Value {1}", (long)ptr, *value);
        return ref value;
    }

使用方法：

UnsafeList 使用里面的方法并使用以下方法创建内部数组：

 T**_Array = (T**)Marshal.AllocHGlobal(Marshal.SizeOf<T>() * _Capacity);

其中 T：非托管（.NET 4.7.3 的新特性）

        UnsafeList<int> list = new UnsafeList<int>(10);
        list.Add(10);
        list.Add(14);
        list.Add(20);
        list.Add(25);
        list.Add(30);

        for(int i = 0; i < list.Length; i++)
        {
            var v = list[i];
        }

与人一起使用：

        UnsafeList<Person> persons = new UnsafeList<Person>(10);
        Person miguel = new Person("Miguel", 23);
        Person elena = new Person("Elena", 24);
        Person ana = new Person("Ana", 34);
        Person ulises = new Person("Ulises", 23);


        persons.Add(miguel);
        persons.Add(elena);
        persons.Add(ana);
        persons.Add(ulises);

        for (int i = 0; i < persons.Length; i++)
        {
            var v = persons[i];
        }

结果：

• 对于整数：

  Address where add: 2151492103952, Value: 10    
  Address where add: 2151492103960, Value: 14    
  Address where add: 2151492103968, Value: 20    
  Address where add: 2151492103976, Value: 25    
  Address where add: 2151492103984, Value: 30
  

///这里只返回最后添加的但所有地址都正确

    Address to return: 2151492103952, Value 30
    Address to return: 2151492103960, Value 30
    Address to return: 2151492103968, Value 30
    Address to return: 2151492103976, Value 30
    Address to return: 2151492103984, Value 30

• 对于人：

  Address where add: 2151492060192, Value: Miguel, 23
  Address where add: 2151492060200, Value: Elena, 24
  Address where add: 2151492060208, Value: Ana, 34
  Address where add: 2151492060216, Value: Ulises, 23
  
  Address to return: 2151492060192, Value Miguel, 23
  Address to return: 2151492060200, Value Elena, 24
  Address to return: 2151492060208, Value Ana, 34
  Address to return: 2151492060216, Value Ulises, 23
  

为什么使用 Int32 的结果不一致？我是 C# 指针的新手。

Answer 1

嗯嗯发现了问题。你的代码没有任何意义。

fixed (T* ptrValue = &value)

然后

*ptr = ptrValue;

您正在保存所传递数据的地址。如果传递的数据存在于堆栈中，则这是错误。堆栈上的值是瞬态的。你对他们的生命没有太多的控制权。现在... Person 的示例... 您在堆栈上创建了四个Persons。 C# 编译器的生命周期可能会持续到方法结束。因此，您将他们的地址添加到您的UnsafeList<>，然后当您查看UnsafeList<> 时，他们仍然在那里。但是，例如，如果您尝试从方法中使用return，则可能带有Persons 的堆栈将被清除/覆盖，或者至少将不再归您所有。第一个示例（不工作的示例）更糟糕：通过在.Add() 中使用常量，在调用之前将常量压入堆栈，获取该堆栈的地址，然后将常量从中弹出方法结束时的堆栈。然后一个新的常量被压入相同的地址，再次调用该方法，并弹出该常量。所以最后你保存了相同地址的多个副本，这将指向常量的最后一个值。要进行测试，请尝试打印ptrValue！

举一个简单明了的例子：

public static unsafe void Test<T>(in T value) where T : unmanaged
{
    fixed (T* ptr = &value)
    {
        Console.WriteLine($"Ptr: {(IntPtr)ptr}, Value: {value}");
    }
}

然后：

Test(1);
Test(2);
Test(3);
Test(4);
Test(5);

Console.WriteLine();

int a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5;

Test(a1);
Test(a2);
Test(a3);
Test(a4);
Test(a5);

结果：

Ptr: 97774252, Value: 1
Ptr: 97774252, Value: 2
Ptr: 97774252, Value: 3
Ptr: 97774252, Value: 4
Ptr: 97774252, Value: 5

Ptr: 97774340, Value: 1
Ptr: 97774336, Value: 2
Ptr: 97774332, Value: 3
Ptr: 97774328, Value: 4
Ptr: 97774324, Value: 5

如何更正您的代码？甚至不清楚您要做什么，但是您肯定做错了！ :-)

一些未经测试的代码！！我什至没有阅读有关ref 和in 的文档！ :-)

public class RefList<T> 
{
    private T[] _array = new T[16];
    public int Capacity { get => _array.Length; }
    public int Length { get; private set; }

    // TODO Range checks ix >= 0 && ix < Length 
    public ref T this[int ix] { get => ref _array[ix]; }
    public ref T AddEmpty()
    {
        Length++;

        if (Length == _array.Length)
        {
            // This will invalidate all the ref that
            // have been returned until now!
            Array.Resize(ref _array, _array.Length * 2);
        }

        return ref _array[Length - 1];
    }

    public ref T Add(in T value)
    {
        ref T el = ref AddEmpty();

        // Note that value is *copied* to el!
        el = value;

        return ref el;
    }
}

然后

public struct MyStruct
{
    public int A;
}

然后

var rl = new RefList<MyStruct>();
ref var ms = ref rl.AddEmpty();
ms.A = 5;
Console.WriteLine(rl[0].A);
ms = new MyStruct { A = 10 };
Console.WriteLine(rl[0].A);