Manera de almohorar una matriz para evitar el índice fuera de los límites del error de matriz

Question

Espero tener al menos 183 artículos en mi lista cuando lo consoluntizo, pero a veces el resultado de mis resultados de extracto en los elementos cuentan más bajo que 183. Mi solución actual supuestamente almohadilla la matriz en el caso de que el conteo es menor que183.

if (extractArray.Count() < 183) {
    int arraysize= extractArray.Count();
    var tempArr = new String[183 - arraysize];
    List<string> itemsList = extractArray.ToList<string>();
    itemsList.AddRange(tempArr);
    var values = itemsList.ToArray();
    //-- Process the new array that is now at least 183 in length
}

Pero parece que mi solución no es la mejor.Agradecería cualquier otra solución que pueda ayudar a garantizar que obtenga al menos 183 artículos cada vez que ocurra el extracto, por favor.

Answer 1

La clase base de matriz implementa el cambio de tamaño método

if(extractArray.Length < 183)
    Array.Resize<string>(ref extractArray, 183);

Sin embargo, tenga en cuenta que el cambio de tamaño es problemático para el rendimiento, por lo que este método es útil solo si necesita la matriz por alguna razón.Si puede cambiar a una lista

y, supongo que tiene una matriz unidimensional de cuerdas aquí, por lo que utilizo la propiedad de la longitud para verificar el número efectivo de elementos en la matriz.

Answer 2

Probablemente yo siga las sugerencias de los demás y use una lista.Utilice el constructor "Capacidad" para un rendimiento agregado:

var list = new List<string>(183);

Luego, siempre que obtenga una nueva matriz, haga esto (reemplaza "con el valor que utilice para almohorar la matriz):

list.Clear();
list.AddRange(array);
// logically, you can do this without the if, but it saves an object allocation when the array is full
if (array.Length < 183)
    list.AddRange(Enumerable.Repeat(" ", 183 - array.Length));

De esta manera, la lista siempre está reutilizando la misma matriz interna, reduciendo las asignaciones y la presión de GC.

O, usted podría usar un método de extensión:

public static class ArrayExtensions
{
    public static T ElementOrDefault<T>(this T[] array, int index)
    {
        return ElementOrDefault(array, index, default(T));
    }
    public static T ElementOrDefault<T>(this T[] array, int index, T defaultValue)
    {
        return index < array.Length ? array[index] : defaultValue;
    }
}

luego código como este:

items.Zero = array[0];
items.One = array[1];
//...

se convierte en esto:

items.Zero = array.ElementOrDefault(0);
items.One = array.ElementOrDefault(1);
//...

Finalmente, esta es la idea bastante engorrosa con la que comencé a escribir esta respuesta: podría envolver la matriz en una implementación ilista que está garantizada para tener 183 índices (he omitido la mayoría de las implementaciones de la interfaz para la brevedad):

class ConstantSizeReadOnlyArrayWrapper<T> : IList<T>
{
    private readonly T[] _array;
    private readonly int _constantSize;
    private readonly T _padValue;

    public ConstantSizeReadOnlyArrayWrapper(T[] array, int constantSize, T padValue)
    {
         //parameter validation omitted for brevity
        _array = array;
        _constantSize = constantSize;
        _padValue = padValue;
    }

    private int MissingItemCount
    {
        get { return _constantSize - _array.Length; }
    }

    public IEnumerator<T> GetEnumerator()
    {
        //maybe you don't need to implement this, or maybe just returning _array.GetEnumerator() would suffice.
        return _array.Concat(Enumerable.Repeat(_padValue, MissingItemCount)).GetEnumerator();
    }

    public int Count
    {
        get { return _constantSize; }
    }

    public bool IsReadOnly
    {
        get { return true; }
    }

    public int IndexOf(T item)
    {
        var arrayIndex = Array.IndexOf(_array, item);
        if (arrayIndex < 0 && item.Equals(_padValue))
            return _array.Length;
        return arrayIndex;
    }

    public T this[int index]
    {
        get
        {
            if (index < 0 || index >= _constantSize)
                throw new IndexOutOfRangeException();
            return index < _array.Length ? _array[index] : _padValue;
        }
        set { throw new NotSupportedException(); }
    }
}

ack.

Answer 3

Dado que ha afirmado que debe asegurarse de que haya 183 índices, y que debe presentarlo si no lo hay, sugeriría usar una lista en lugar de una matriz.Puedes hacer algo así como:

while (extractList.Count < 183)
{
     extractList.Add(" "); // just add a space
}

Si tiene que regresar absolutamente a una matriz, puede usar algo similar.

Answer 4

No puedo decir que recomendaría esta solución, ¡pero no dejaré que eso me detendría de publicarlo!¡Si les gusta admitirlo o no, a todos les gustan las soluciones LINQ!

Uso de LINQ, dada una matriz con X Elements en él, puede generar una matriz con elementos exactamente y (183 en su caso) en él como este:

  var items183exactly = extractArray.Length == 183 ? extractArray :
                        extractArray.Take(183)
                                    .Concat(Enumerable.Repeat(string.Empty, Math.Max(0, 183 - extractArray.Length)))
                                    .ToArray();

Si hay menos de 183 elementos, la matriz se acolchará con cadenas vacías.Si hay más de 183 elementos, la matriz se truncará.Si hay exactamente 183 elementos, la matriz se usa como está.

No afirmo que esto es eficiente o que es necesariamente una buena idea.Sin embargo, usa LINQ (¡Yippee!) Y es divertido.