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

Question

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

Answer 1

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

Answer 2

¿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

Answer 3

¿Qué hay de usar un método de extensión? Por ejemplo:

public static IEnumerable<TSource> Union<TSource>(this IEnumerable<TSource> 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.

Answer 4

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

Answer 5

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

public class CustomArrayList<T> 
 {  
   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;  
    } 
  }
 }
}

Answer 6

Esa podría ser una solución;

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

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

Answer 7

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.

Answer 8

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.

Answer 9

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 sintaxis de inicializador enumerable y la inicial (desde la pregunta planteada).

myArray = new List<string>(myArray) { "add this" }.ToArray();

Answer 10

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<T> Add<T>(this IEnumerable<T> sequence, T item)
    {
        return (sequence ?? Enumerable.Empty<T>()).Concat(new[] { item });
    }

    public static T[] AddRangeToArray<T>(this T[] sequence, T[] items)
    {
        return (sequence ?? Enumerable.Empty<T>()).Concat(items).ToArray();
    }

    public static T[] AddToArray<T>(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();

Answer 11

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

Answer 12

Usando LINQ:

arr = (arr ?? Enumerable.Empty<string>()).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<string>()).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.

Answer 13

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

Answer 14

Usaría una lista si necesitas una matriz de tamaño dinámico:

List<string> ls = new List<string>();
ls.Add("Hello");

Answer 15

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<T>(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 <T> . Estos contienen arreglos inmutables y los cambian de tamaño cuando es necesario (¡List <T> no es una implementación de lista enlazada!). ArrayList es lo mismo sin genéricos (con matriz de objetos ).

LinkedList <T> es una implementación de lista vinculada real. Desafortunadamente, puede agregar solo elementos LinkListNode <T> 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.

Answer 16

 Array.Resize(ref youur_array_name, your_array_name.Length + 1);
 your_array_name[your_array_name.Length - 1] = "new item";

Answer 17

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

Answer 18

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