Le moyen le plus efficace pour ajouter des tableaux en C#?

Vous ne pouvez pas ajouter à un tableau réel - de la taille d'un tableau est fixe au moment de la création. Au lieu de cela, utilisez un List<T> qui peuvent grandir comme il faut.

Sinon, conservez une liste de tableaux et de les enchaîner tous que lorsque vous avez saisi tout.

Voir Eric Lippert du blog sur les tableaux pour plus de détails et de compréhension que j'ai pu fournir de façon réaliste 🙂

Je recommande la réponse que l'on trouve ici: Comment concaténer deux tableaux en C#?

par exemple

var z = new int[x.Length + y.Length];
x.CopyTo(z, 0);
y.CopyTo(z, x.Length);

La solution ressemble à beaucoup de plaisir, mais il est possible de concaténer des tableaux en deux états. Lorsque vous êtes à la manipulation de grands tableaux d'octets, je suppose qu'il est inefficace d'utiliser une Liste chaînée pour contenir chaque octet.

Voici un exemple de code pour la lecture des octets à partir d'un flux et d'extension d'un tableau d'octets à la volée:

 byte[] buf = new byte[8192]; 
byte[] résultat = new byte[0]; 
int count = 0; 
faire 
{ 
count = resStream.Read(buf, 0, buf.La longueur); 
if (count != 0) 
{ 
Tableau.Redimensionner(réf résultat, résultat.Longueur + nombre); 
Tableau.Copier(buf, 0, résultat, résultat.Longueur - comte, count); 
} 
} 
while (compteur > 0); //plus de données à lire? 
resStream.Close(); 

Si vous pouvez faire un rapprochement du nombre d'articles qui seront là à la fin, utilisez la surcharge de la Liste constuctor qui prend en compte comme un paramètre. Vous permettra d'économiser cher Liste des duplications. Sinon, vous avez à payer pour cela.

Ici est un produit de classe basée sur ce que Constantin a dit:

class Program
{
static void Main(string[] args)
{
FastConcat<int> i = new FastConcat<int>();
i.Add(new int[] { 0, 1, 2, 3, 4 });
Console.WriteLine(i[0]);
i.Add(new int[] { 5, 6, 7, 8, 9 });
Console.WriteLine(i[4]);
Console.WriteLine("Enumerator:");
foreach (int val in i)
Console.WriteLine(val);
Console.ReadLine();
}
}
class FastConcat<T> : IEnumerable<T>
{
LinkedList<T[]> _items = new LinkedList<T[]>();
int _count;
public int Count
{
get
{
return _count;
}
}
public void Add(T[] items)
{
if (items == null)
return;
if (items.Length == 0)
return;
_items.AddLast(items);
_count += items.Length;
}
private T[] GetItemIndex(int realIndex, out int offset)
{
offset = 0; //Offset that needs to be applied to realIndex.
int currentStart = 0; //Current index start.
foreach (T[] items in _items)
{
currentStart += items.Length;
if (currentStart > realIndex)
return items;
offset = currentStart;
}
return null;
}
public T this[int index]
{
get
{
int offset;
T[] i = GetItemIndex(index, out offset);
return i[index - offset];
}
set
{
int offset;
T[] i = GetItemIndex(index, out offset);
i[index - offset] = value;
}
}
#region IEnumerable<T> Members
public IEnumerator<T> GetEnumerator()
{
foreach (T[] items in _items)
foreach (T item in items)
yield return item;
}
#endregion
#region IEnumerable Members
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
#endregion
}