Agregue un nuevo elemento en la matriz existente en c # .net

Cómo agregar un nuevo elemento en una matriz existente en c # .net. Necesito preservar los datos existentes.

Usaría una lista si necesitas una matriz de tamaño dynamic:

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

Esa podría ser una solución;

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

Pero para una matriz de tamaño dynamic, preferiría una lista también.

Usando LINQ:

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

Me gusta usar esto ya que es un trazador de líneas único y muy conveniente para incrustar en una instrucción de conmutación, una instrucción if simple o pasar como argumento.

EDITAR:

A algunas personas no les gusta new[] { newitem } porque crea una matriz temporal pequeña de un elemento. Aquí hay una versión que usa Enumerable.Repeat que no requiere crear ningún objeto (al menos no en la superficie: los iteradores .NET probablemente crean un grupo de objetos de máquina de estado debajo de la tabla).

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

Y si está seguro de que la matriz nunca es null para empezar, puede simplificarla para:

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

Tenga en cuenta que si desea agregar elementos a una colección ordenada, List es probablemente la estructura de datos que desea, no una matriz para comenzar.

Las matrices en C # son inmutables , por ejemplo, string[] , int[] . Eso significa que no puedes redimensionarlos. Necesitas crear una nueva matriz.

Aquí está el código para 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; } } 

Como puede ver, crea una nueva matriz con el nuevo tamaño, copia el contenido de la matriz fuente y establece la referencia a la nueva matriz. La sugerencia para esto es la palabra clave ref para el primer parámetro.

Hay listas que pueden asignar dinámicamente nuevos espacios para nuevos elementos. Esto es, por ejemplo, List . Estos contienen arreglos inmutables y los cambian de tamaño cuando es necesario (¡List no es una implementación de lista enlazada!). ArrayList es lo mismo sin generics (con matriz de objetos ).

LinkedList es una implementación de lista vinculada real. Desafortunadamente, puede agregar solo elementos LinkListNode a la lista, por lo que debe ajustar sus propios elementos de lista en este tipo de nodo. Creo que su uso es poco común.

Pregunta muy vieja, pero aún quería agregar esto.

Si está buscando un trazador de líneas único, puede usar el siguiente código. Combina el constructor de lista que acepta una syntax de inicializador enumerable y la inicial (desde la pregunta planteada).

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

Puede expandir la respuesta proporcionada por @Stephen Chung utilizando su lógica basada en LINQ para crear un método de extensión usando un tipo genérico.

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

A continuación, puede llamarlo directamente en la matriz de esta manera.

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

Es cierto que el método AddRangeToArray () parece un poco exagerado ya que tiene la misma funcionalidad con Concat () pero de esta manera el código final puede “trabajar” directamente con el conjunto, a diferencia de esto:

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

Si trabaja mucho con matrices y listas por alguna razón, este método genérico de devolución genérica puede ayudar

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

Es mejor mantener Array inmutable y de tamaño fijo.

puede simular Add por Extension Method e IEnumerable.Concat()

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

Usar una lista sería su mejor opción para la administración de la memoria.

Estoy de acuerdo con Ed. C # no lo hace tan fácil como lo hace VB con ReDim Preserve. Sin una colección, tendrás que copiar la matriz en una más grande.

 string str = "string "; 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é hay de usar un método de extensión? Por ejemplo:

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

por ejemplo:

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

Tenga en cuenta que esto imita este comportamiento de la extensión Uniion de Linq (utilizada para combinar dos matrices en una nueva), y requería que la biblioteca Linq funcionara.

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

¿Por qué no probar utilizando la clase Stringbuilder ? Tiene métodos como .insert y .append. Puede leer más sobre esto aquí: http://msdn.microsoft.com/en-us/library/2839d5h5(v=vs.71).aspx

Lamentablemente, usar una lista no funcionará en todas las situaciones. Una lista y una matriz son realmente diferentes y no son 100% intercambiables. Dependería de las circunstancias si esto fuera una solución aceptable.

Dado que esta pregunta no está satisfecha con la respuesta proporcionada, me gustaría agregar esta respuesta 🙂

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

// Entonces, si tienes una matriz existente

// mi solución rápida será

var tempList = originalArray.ToList ();

tempList.Add (newitem);

// ahora solo reemplaza la matriz original con la nueva

originalArray = tempList.ToArray ();

Todas las respuestas propuestas hacen lo mismo que lo que dicen que les gustaría evitar, creando una nueva matriz y agregando una nueva entrada solo con la pérdida de más sobrecarga. LINQ no es mágico, la lista de T es una matriz con un espacio de memoria intermedia con algo de espacio adicional para evitar el cambio de tamaño de la matriz interna cuando se agregan elementos.

Todas las abstracciones tienen que resolver el mismo problema, crear una matriz sin espacios vacíos que contengan todos los valores y devolverlos.

Si necesita la flexibilidad y puede crear una lista suficientemente grande que puede usar para aprobar, hágalo. de lo contrario, use una matriz y comparta ese objeto seguro para subprocesos. Además, el nuevo Span ayuda a compartir datos sin tener que copiar las listas.

Para responder la pregunta:

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