Maneira de preencher uma matriz para evitar índice fora dos limites do erro da matriz

Question

Espero ter pelo menos 183 itens em minha lista quando a consultar, mas às vezes o resultado da minha extração resulta em uma contagem de itens inferior a 183.Minha correção atual supostamente preenche a matriz caso a contagem seja menor que 183.

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
}

Mas parece que minha solução não é a melhor.Eu apreciaria qualquer outra solução que pudesse ajudar a garantir que eu receba pelo menos 183 itens sempre que a extração acontecer, por favor.

Answer 1

A classe base Array implementa o Redimensionar método

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

No entanto, lembre-se de que o redimensionamento é problemático para o desempenho; portanto, esse método será útil apenas se você precisar do array por algum motivo.Se você puder mudar para uma lista

E suponho que você tenha um array unidimensional de strings aqui, então uso a propriedade Length para verificar o número efetivo de itens no array.

Answer 2

Provavelmente seguiria as sugestões de outras pessoas e usaria uma lista.Use o construtor "capacity" para obter desempenho adicional:

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

Então, sempre que você obtiver um novo array, faça o seguinte (substitua " " por qualquer valor usado para preencher o array):

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));

Dessa forma, a lista sempre reutiliza o mesmo array interno, reduzindo as alocações e a pressão do GC.

Ou você pode usar um método de extensão:

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;
    }
}

Então codifique assim:

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

Torna-se isto:

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

Finalmente, esta é a ideia bastante complicada com a qual comecei a escrever esta resposta:Você pode agrupar a matriz em uma implementação IList com garantia de 183 índices (omiti a maioria das implementações de membros da interface por questões de brevidade):

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(); }
    }
}

Aceito.

Answer 3

Como você declarou que precisa garantir que haja 183 índices e que precisa preenchê-los se não houver, sugiro usar uma lista em vez de uma matriz.Você pode fazer algo como:

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

Se você ABSOLUTAMENTE precisar voltar para um array, poderá usar algo semelhante.

Answer 4

Não posso dizer que recomendaria esta solução, mas não deixarei que isso me impeça de publicá-la!Quer gostem de admitir ou não, todo mundo gosta de soluções linq!

Usando o linq, dado um array com X elementos, você pode gerar um array com exatamente Y (183 no seu caso) elementos como este:

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

Se houver menos de 183 elementos, o array será preenchido com strings vazias.Se houver mais de 183 elementos, o array será truncado.Se houver exatamente 183 elementos, o array será usado como está.

Não afirmo que isso seja eficiente ou que seja necessariamente uma boa ideia.No entanto, ele usa linq (yippee!) e é divertido.