Fügen Sie ein neues Element in ein vorhandenes Array in c # .net ein

Wie füge ich ein neues Element in ein vorhandenes String-Array in C # .net ein?

Ich muss die vorhandenen Daten beibehalten.

Ich würde eine Liste verwenden, wenn Sie ein Array mit dynamischer Größe benötigen:

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

Das könnte eine Lösung sein;

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

Aber für ein Array mit dynamischer Größe würde ich auch eine Liste bevorzugen.

Verwenden von LINQ:

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

Ich verwende dies gerne, da es ein Einzeiler ist und sehr praktisch ist, um es in eine switch-Anweisung, eine einfache if-Anweisung oder eine Übergabe als Argument einzubetten.

BEARBEITEN:

Einige Leute mögen es nicht, new[] { newitem }weil es ein kleines temporäres Array mit einem Element erstellt. Hier ist eine Version Enumerable.Repeat, bei der kein Objekt erstellt werden muss (zumindest nicht auf der Oberfläche - .NET-Iteratoren erstellen wahrscheinlich eine Reihe von Zustandsmaschinenobjekten unter der Tabelle).

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

Und wenn Sie sicher sind, dass das Array niemals nullbeginnen soll, können Sie es vereinfachen, um:

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

Beachten Sie, dass, wenn Sie einer geordneten Sammlung Elemente hinzufügen möchten, dies Listwahrscheinlich die gewünschte Datenstruktur ist und nicht zunächst ein Array.

Sehr alte Frage, wollte diese aber noch hinzufügen.

Wenn Sie nach einem Einzeiler suchen, können Sie den folgenden Code verwenden. Es kombiniert den Listenkonstruktor, der eine Aufzählung akzeptiert, und die "neue" (seit der Frage aufgeworfene) Initialisierersyntax.

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

Arrays in C # sind unveränderlich , zum Beispiel string[], int[]. Das bedeutet, dass Sie die Größe nicht ändern können. Sie müssen ein brandneues Array erstellen.

Hier ist der Code für 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;
    }
}

Wie Sie sehen, wird ein neues Array mit der neuen Größe erstellt, der Inhalt des Quellarrays kopiert und der Verweis auf das neue Array festgelegt. Der Hinweis hierfür ist das Schlüsselwort ref für den ersten Parameter.

Es gibt Listen, die neue Slots dynamisch für neue Elemente zuweisen können. Dies ist zB List <T> . Diese enthalten unveränderliche Arrays und ändern deren Größe bei Bedarf (List <T> ist keine Implementierung einer verknüpften Liste!). ArrayList ist dasselbe ohne Generics (mit Object- Array).

LinkedList <T> ist eine echte Implementierung einer verknüpften Liste. Leider können Sie der Liste nur LinkListNode <T> -Elemente hinzufügen, sodass Sie Ihre eigenen Listenelemente in diesen Knotentyp einschließen müssen. Ich denke, seine Verwendung ist ungewöhnlich.

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

Sie können die Antwort von @Stephen Chung erweitern, indem Sie seine LINQ-basierte Logik verwenden, um eine Erweiterungsmethode mit einem generischen Typ zu erstellen.

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

}

Sie können es dann direkt auf dem Array aufrufen.

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

Zugegeben, die AddRangeToArray () -Methode scheint etwas übertrieben, da Sie mit Concat () dieselbe Funktionalität haben, aber auf diese Weise kann der Endcode direkt mit dem Array "arbeiten", im Gegensatz dazu:

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

Es ist besser, das Array unveränderlich und fest zu halten.

Sie können Addmit Extension Methodund simulierenIEnumerable.Concat()

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

Wenn Sie aus irgendeinem Grund viel mit Arrays und nicht mit Listen arbeiten, kann diese generische generische Rückgabemethode Addhilfreich sein

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

Alle vorgeschlagenen Antworten machen dasselbe wie das, was sie vermeiden möchten, erstellen ein neues Array und fügen einen neuen Eintrag hinzu, nur mit mehr Overhead verloren. LINQ ist keine Zauberei. Die Liste von T ist ein Array mit einem Pufferbereich mit zusätzlichem Speicherplatz, um zu vermeiden, dass die Größe des inneren Arrays beim Hinzufügen von Elementen geändert wird.

Alle Abstraktionen müssen das gleiche Problem lösen, ein Array ohne leere Slots erstellen, die alle Werte enthalten, und diese zurückgeben.

Wenn Sie die Flexibilität benötigen und eine ausreichend große Liste erstellen können, die Sie zum Übergeben verwenden können, tun Sie dies. Verwenden Sie andernfalls ein Array und geben Sie das threadsichere Objekt frei. Mit dem neuen Span können Sie auch Daten gemeinsam nutzen, ohne die Listen kopieren zu müssen.

Um die Frage zu beantworten:

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

Wenn Sie also ein vorhandenes Array haben, ist meine schnelle Lösung

var tempList = originalArray.ToList();
tempList.Add(newitem);

Ersetzen Sie jetzt einfach das ursprüngliche Array durch das neue

originalArray = tempList.ToArray();

Eine neue Append<TSource>Methode wurde hinzugefügtIEnumerable<TSource>Seit .NET Framework 4.7.1 und .NET Core 1.0 wurde .

So verwenden Sie es:

var numbers = new [] { "one", "two", "three" };
numbers = numbers.Append("four").ToArray();
Console.WriteLine(string.Join(", ", numbers)); // one, two, three, four

Beachten Sie, dass Sie Prepend<TSource>stattdessen die neue Methode verwenden können, wenn Sie das Element am Anfang des Arrays hinzufügen möchten .

Die Verwendung einer Liste ist die beste Option für die Speicherverwaltung.

Was ist mit einer Erweiterungsmethode? Zum Beispiel:

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

zum Beispiel:

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

Beachten Sie, dass dies das Verhalten der Uniion-Erweiterung von Linq nachahmt (mit der zwei Arrays zu einem neuen kombiniert werden), und dass die Linq-Bibliothek funktionieren muss.

Ich stimme Ed zu. C # macht dies nicht so einfach wie VB mit ReDim Preserve. Ohne eine Sammlung müssen Sie das Array in ein größeres kopieren.

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

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

Probieren Sie die Stringbuilder- Klasse aus. Es hat Methoden wie .insert und .append. Weitere Informationen finden Sie hier: http://msdn.microsoft.com/en-us/library/2839d5h5(v=vs.71).aspx

Leider funktioniert die Verwendung einer Liste nicht in allen Situationen. Eine Liste und ein Array unterscheiden sich tatsächlich und sind nicht zu 100% austauschbar. Es würde von den Umständen abhängen, ob dies eine akzeptable Lösung wäre.

Da diese Frage mit der angegebenen Antwort nicht zufrieden ist, möchte ich diese Antwort hinzufügen :)

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