如何在C＃中截断数组

Question

I mean is it really possible? MSDN says that arrays are fixed-size and the only way to resize is "copy-to-new-place". But maybe it is possible with unsafe/some magic with internal CLR structures, they all are written in C++ where we have a full memory control and can call realloc and so on.

I have no code provided for this question, because I don't even know if it can exist.

---

I'm not talking about Array.Resize methods and so on, because they obviosly do not have needed behaviour.

Assume that we have a standard x86 process with 2GB ram, and I have 1.9GB filled by single array. Then I want to release half of it. So I want to write something like:

MagicClass.ResizeArray(ref arr, n)

And do not get OutOfMemoryException. Array.Resize will try to allocate another gigabyte of RAM and will fail with 1.9+1 > 2GB OutOfMemory.

Answer 1

You can try Array.Resize() :

  int[] myArray = new int[] { 1, 2, 3, 4 };
  int myNewSize = 1;

  Array.Resize(ref myArray, myNewSize);

  // Test: 1
  Console.Write(myArray.Length);

Answer 2

realloc will attempt to do the inplace resize - but it reserves the right to copy the whole thing elsewhere and return a pointer that's completely different.

Pretty much the same outward behaviour is exposed by .NET's List<T> class - which you should be using anyway if you find yourself changing array sizes often. It hides the actual array reference from you so that the change is propagated throughout all of the references to the same list. As you remove items from the end, only the length of the list changes while the inner array stays the same - avoiding the copying.

It doesn't release the memory (you can always do that explicitly with Capacity = XXX , but that makes a new copy of the array), but then again, unless you're working with large arrays, neither does realloc - and if you're working with large arrays, yada, yada - we've been there :)

realloc doesn't really make sense in the kind of memory model .NET has anyway - the heap is continously collected and compacted over time. So if you're trying to use it to avoid the copies when just trimming an array, while also keeping memory usage low... don't bother. At the next heap compaction, the whole memory above your array is going to be moved to fill in the blanks. Even if it were possible to do the realloc , the only benefit you have over simply copying the array is that you would keep your array in the old-living heap - and that isn't necessarily what you want anyway.

Answer 3

Neither array type in BCL supports what you want. That being said - you can implement your own type that would support what you need. It can be backed by standard array, but would implement own Length and indexer properties, that would 'hide' portion of array from you.

public class MyTruncatableArray<T>
{
    private T[] _array;
    private int _length;

    public MyTruncatableArray(int size)
    {
        _array = new T[size];
        _length = size;
    }

    public T this[int index]
    {
        get
        {
            CheckIndex(index, _length);
            return _array[index];
        }
        set
        {
            CheckIndex(index, _length);
            _array[index] = value;
        }
    }

    public int Length
    {
        get { return _length; }
        set
        {
            CheckIndex(value);
            _length = value;
        }
    }

    private void CheckIndex(int index)
    {
        this.CheckIndex(index, _array.Length);
    }

    private void CheckIndex(int index, int maxValue)
    {
        if (index < 0 || index > maxValue)
        {
            throw new ArgumentException("New array length must be positive and lower or equal to original size");
        }
    }
}

It really depend what exactly do need. (Eg do you need to truncate just so that you can easier use it from your code. Or is perf/GC/memory consumption a concern? If the latter is the case - did you perform any measurements that proves standard Array.Resize method unusable for your case?)