Ajouter un nouvel élément dans un tableau existant dans c # .net

Comment append un nouvel élément dans un tableau de chaînes existant dans c # .net. Je dois préserver les données existantes.

J’utiliserais une liste si vous avez besoin d’un tableau de taille dynamic:

List ls = new List(); ls.Add("Hello"); 

Cela pourrait être une solution

 Array.Resize(ref array, newsize); array[newsize - 1] = "newvalue" 

Mais pour le tableau de taille dynamic, je préférerais aussi la liste.

Utiliser LINQ:

 arr = (arr ?? Enumerable.Empty()).Concat(new[] { newitem }).ToArray(); 

J’aime utiliser ceci car il s’agit d’une ligne simple et très pratique pour incorporer une instruction switch, une instruction if simple ou passer en argument.

MODIFIER:

Certaines personnes n’aiment pas new[] { newitem } car il crée un petit tableau temporaire à un élément. Voici une version utilisant Enumerable.Repeat qui ne nécessite de créer aucun object (du moins pas en surface). Les iterators .NET créent probablement un tas d’objects de machine à états sous la table.

 arr = (arr ?? Enumerable.Empty()).Concat(Enumerable.Repeat(newitem,1)).ToArray(); 

Et si vous êtes sûr que le tableau n’est jamais null pour commencer, vous pouvez le simplifier pour:

 arr.Concat(Enumerable.Repeat(newitem,1)).ToArray(); 

Notez que si vous souhaitez append des éléments à une collection ordonnée, List est probablement la structure de données souhaitée, et non un tableau avec lequel commencer.

Les tableaux en C # sont immuables , par exemple ssortingng[] , int[] . Cela signifie que vous ne pouvez pas les redimensionner. Vous devez créer un nouveau tableau.

Voici le code pour Array.Resize :

 public static void Resize(ref T[] array, int newSize) { if (newSize < 0) { throw new ArgumentOutOfRangeException("newSize", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum")); } T[] sourceArray = array; if (sourceArray == null) { array = new T[newSize]; } else if (sourceArray.Length != newSize) { T[] destinationArray = new T[newSize]; Copy(sourceArray, 0, destinationArray, 0, (sourceArray.Length > newSize) ? newSize : sourceArray.Length); array = destinationArray; } } 

Comme vous pouvez le voir, il crée un nouveau tableau avec la nouvelle taille, copie le contenu du tableau source et définit la référence au nouveau tableau. L’indice pour ceci est le mot-clé ref pour le premier paramètre.

Il existe des listes qui peuvent allouer dynamicment de nouveaux emplacements pour de nouveaux éléments. C’est par exemple la liste . Celles-ci contiennent des tableaux immuables et les redimensionnent si nécessaire (List n’est pas une implémentation de liste chaînée!). ArrayList est la même chose sans Generics (avec le tableau Object ).

LinkedList est une véritable implémentation de liste chaînée. Malheureusement, vous ne pouvez append que des éléments LinkListNode à la liste. Vous devez donc envelopper vos propres éléments de liste dans ce type de noeud. Je pense que son utilisation est rare.

Très vieille question, mais je voulais quand même append ceci.

Si vous cherchez un one-liner, vous pouvez utiliser le code ci-dessous. Il combine le constructeur de liste qui accepte un énumérable et la syntaxe d’initialisation “new” (depuis la question posée).

 myArray = new List(myArray) { "add this" }.ToArray(); 
  Array.Resize(ref youur_array_name, your_array_name.Length + 1); your_array_name[your_array_name.Length - 1] = "new item"; 

Vous pouvez développer la réponse fournie par @Stephen Chung en utilisant sa logique basée sur LINQ pour créer une méthode d’extension utilisant un type générique.

 public static class CollectionHelper { public static IEnumerable Add(this IEnumerable sequence, T item) { return (sequence ?? Enumerable.Empty()).Concat(new[] { item }); } public static T[] AddRangeToArray(this T[] sequence, T[] items) { return (sequence ?? Enumerable.Empty()).Concat(items).ToArray(); } public static T[] AddToArray(this T[] sequence, T item) { return Add(sequence, item).ToArray(); } } 

Vous pouvez alors l’appeler directement sur le tableau comme ceci.

  public void AddToArray(ssortingng[] options) { // Add one item options = options.AddToArray("New Item"); // Add a options = options.AddRangeToArray(new ssortingng[] { "one", "two", "three" }); // Do stuff... } 

Certes, la méthode AddRangeToArray () semble un peu exagérée puisque vous avez les mêmes fonctionnalités avec Concat () mais de cette manière, le code de fin peut “fonctionner” directement avec le tableau, par opposition à ceci:

 options = options.Concat(new ssortingng[] { "one", "two", "three" }).ToArray(); 

Si vous travaillez beaucoup avec des tableaux et non des listes pour une raison quelconque, cette méthode générique générique de retour typé Add peut aider

  public static T[] Add(T[] array, T item) { T[] returnarray = new T[array.Length + 1]; for (int i = 0; i < array.Length; i++) { returnarray[i] = array[i]; } returnarray[array.Length] = item; return returnarray; } 

Il est préférable de garder Array immuable et de taille fixe.

vous pouvez simuler Add par Extension Method et IEnumerable.Concat()

 public static class ArrayExtensions { public static ssortingng[] Add(this ssortingng[] array, ssortingng item) { return array.Concat(new[] {item}).ToArray(); } } 

Utiliser une liste serait votre meilleure option pour la gestion de la mémoire.

Je suis d’accord avec Ed. C # ne facilite pas la tâche de VB avec ReDim Preserve. Sans collection, vous devrez copier le tableau dans un plus grand.

 ssortingng str = "ssortingng "; List li_str = new List(); for (int k = 0; k < 100; i++ ) li_str.Add(str+k.ToString()); string[] arr_str = li_str.ToArray(); 

Qu’en est-il de l’utilisation d’une méthode d’extension? Par exemple:

 public static IEnumerable Union(this IEnumerable source, TSource item) { return source.Union(new TSource[] { item }); } 

par exemple:

 ssortingng[] sourceArray = new [] { "foo", "bar" } ssortingng additionalItem = "foobar"; ssortingng result = sourceArray.Union(additionalItem); 

Notez que cela imite ce comportement de l’extension Uniion de Linq (utilisée pour combiner deux tableaux dans un nouveau), et nécessite que la bibliothèque Linq fonctionne.

 private static ssortingng[] GetMergedArray(ssortingng[] originalArray, ssortingng[] newArray) { int startIndexForNewArray = originalArray.Length; Array.Resize(ref originalArray, originalArray.Length + newArray.Length); newArray.CopyTo(originalArray, startIndexForNewArray); return originalArray; } 

Pourquoi ne pas essayer avec la classe Ssortingngbuilder . Il a des méthodes telles que .insert et .append. Vous pouvez en savoir plus à ce sujet ici: http://msdn.microsoft.com/en-us/library/2839d5h5(v=vs.71).aspx

Malheureusement, l’utilisation d’une liste ne fonctionnera pas dans toutes les situations. Une liste et un tableau sont en réalité différents et ne sont pas interchangeables à 100%. Cela dépendrait des circonstances si cela pouvait être un travail acceptable.

Puisque cette question n’est pas satisfaite avec la réponse fournie, j’aimerais append cette réponse 🙂

 public class CustomArrayList { private T[] arr; private int count; public int Count { get { return this.count; } } private const int INITIAL_CAPACITY = 4; public CustomArrayList(int capacity = INITIAL_CAPACITY) { this.arr = new T[capacity]; this.count = 0; } public void Add(T item) { GrowIfArrIsFull(); this.arr[this.count] = item; this.count++; } public void Insert(int index, T item) { if (index > this.count || index < 0) { throw new IndexOutOfRangeException( "Invalid index: " + index); } GrowIfArrIsFull(); Array.Copy(this.arr, index, this.arr, index + 1, this.count - index); this.arr[index] = item; this.count++; } private void GrowIfArrIsFull() { if (this.count + 1 > this.arr.Length) { T[] extendedArr = new T[this.arr.Length * 2]; Array.Copy(this.arr, extendedArr, this.count); this.arr = extendedArr; } } } } 

// Donc, si vous avez un tableau existant

// ma solution rapide sera

var tempList = originalArray.ToList ();

tempList.Add (newitem);

// remplace maintenant le tableau original par le nouveau

originalArray = tempList.ToArray ();

Toutes les réponses proposées font la même chose que ce qu’elles disent qu’elles aimeraient éviter, en créant un nouveau tableau et en y ajoutant une nouvelle entrée uniquement avec des frais supplémentaires perdus. LINQ n’est pas magique, la liste de T est un tableau avec un espace tampon avec un espace supplémentaire pour éviter de redimensionner le tableau interne lorsque des éléments sont ajoutés.

Toutes les abstractions doivent résoudre le même problème, créer un tableau sans emplacement vide contenant toutes les valeurs et les renvoyer.

Si vous avez besoin de flexibilité, vous pouvez créer une liste suffisamment grande que vous pouvez utiliser pour réussir. Sinon, utilisez un tableau et partagez cet object thread-safe. En outre, le nouveau Span permet de partager des données sans avoir à copier les listes.

Pour répondre à la question:

 Array.Resize(ref myArray, myArray.Length + 1); data[myArray.Length - 1] = Value;