将结构引用添加到C＃列表中

Question

Trying to keep my C# code optimized, I found that if I have a list of structure elements, each insertion would be a full copy - something that I would like to avoid.

In C++ I would simply keep a list of pointers and so I was wondering if I can do the same using C#, maybe by having the list as a list of references to the structure. Unfortunately the structure cannot be turned into a class as it is part of the XNA library (Vector3, Matrix, etc...) In any case - how would the format and usage look like if it's possible?

Thanks.

Answer 1

You can't create storeable references to structures in C#, but you could create a reference type wrapper for your value type. That said, the overhead associated with copying the memory is not going to be high for a small structure. Has your profiling shown that this is a problem?

---

Below is an example of a value type wrapped in a reference type. Note that this only works if all access to a particular value is through the wrapping reference type. This violates standard rules of insulation (because of the public field), but this is a bit of a special case.

public sealed class Reference<T>
    where T: struct
{
    public T Value;

    public Reference(T value)
    {
        Value = value;
    }
}

Another thing worth noting is that the Reference wrapper itself can take on the value null, though its contents are non-nullable. You can also add implicit or explicit conversion operators to make this more transparent, if you wish.

Answer 2

No, basically. Options:

• use a class (you've already said you can't)
• box it
• write a class that wraps it (essentially, manual boxing)
• use an array, and access it only directly in the array by index (without copying into a variable); this is then talking directly to the item in the array (no copy)

As an example of the last;

if(arr[idx].X == 20) SomeMethod(ref arr[idx]);

Both the .X, and any usage within SomeMethod, are accessing the value directly in the array, not a copy. This is only possible with vectors (arrays), not lists.

One reason a list of refs to structs isn't possible: it would allow you I store, in the list, the address of a variable on the stack; the array usually outlives the variable on the stack, so that would be ludicrously unsafe

Answer 3

If the structs are made of simple types then you can make an array of pointers. Yes pointers in C# are very useful for cases like yours. There are limitations though. The original structures have to be stored in an Array and not a List<> . Look at the example below compiled with unsafe build flag.

[StructLayout(LayoutKind.Sequential)]
public struct Vec3
{
    public double X, Y, Z;
    public double Mag { get { return Math.Sqrt(X * X + Y * Y + Z * Z); } }
}

public unsafe class Vec3ArrayProxy
{
    Vec3*[] ptr = null; //internal array of pointers

    public Vec3ArrayProxy(Vec3[] array)
    {
        ptr = new Vec3*[array.Length]; //allocate array
        fixed (Vec3* src = array) //src holds pointer from source array
        {
            for (int i = 0; i < array.Length; i++)
            {
                ptr[i] = &src[i]; //take address of i-th element
            }                
        }
    }

    public Vec3ArrayProxy(Vec3ArrayProxy other)
    {
        //just use all the existing pointers
        ptr = (Vec3*[])other.ptr.Clone();
        //or I could say:
        //ptr = other.ptr;
    }
    // Access values with index
    public Vec3 this[int index]
    {
        get { return *ptr[index]; }
        set { *ptr[index] = value; }
    }
    public int Count { get { return ptr.Length; } }
    // Access the array of pointers
    public Vec3*[] PtrArray { get { return ptr; } }
    // Copy the values of original array into new array
    public Vec3[] ToArrayCopy()
    {
        Vec3[] res = new Vec3[ptr.Length];
        for (int i = 0; i < res.Length; i++)
        {
            res[i] = *ptr[i];
        }
        return res;
    }

}


unsafe class Program
{
    static void Main(string[] args)
    {
        const int N = 10; //size of array

        // Allocate array in memory
        Vec3[] array = new Vec3[N];

        // Assign values into array
        for (int i = 0; i < N; i++)
        {
            array[i] = new Vec3() { X = i, Y = 0, Z = 0 };
        }

        //Build proxy to array (with pointers)
        Vec3Array A = new Vec3Array(array);
        // Reference the same pointers as A
        Vec3Array B = new Vec3Array(A); 

        // Change the original array
        array[4].X = -4;

        // Or change via a copy
        A.PtrArray[5]->Y = -5;  

        // Or assign a new value
        B[0] = B[9];            

        // Show contents of array via proxy A
        Console.WriteLine("{0,-6}|{1,6}|{2,6}|{3,6}|{4,6}", 
            "i", "X", "Y", "Z", "Mag");
        for (int i = 0; i < N; i++)
        {
            Console.WriteLine("{0,6}|{1,6:F2}|{2,6:F2}|{3,6:F2}|{4,6:F3}", 
                i + 1, A[i].X, A[i].Y, A[i].Z, A[i].Mag);
        }

    }
}

Sorry for the long code, but I wanted to show all the features of struct pointers. The reason that List<> will not work is because you cannot take a pointer to a list element. If you really really really must use a List<> , then extract the array from the private field _items with the following code:

    static T[] ExtractArray(List<T> list)
    {
        //list.TrimExcess();
        var t = list.GetType();
        var items = t.GetField("_items", 
            BindingFlags.NonPublic | BindingFlags.Instance);
        return items.GetValue(list) as T[];
    }

Crude as it may be, it works and once you have made the reflection on List<> once, you can cache the results in a static field and only call the items.GetValue(list) each time.