Hinzufügen von Werten zu einem C # -Array

Wahrscheinlich eine wirklich einfache Sache - ich beginne mit C # und muss einem Array Werte hinzufügen, zum Beispiel:

int[] terms;

for(int runs = 0; runs < 400; runs++)
{
    terms[] = runs;
}

Für diejenigen, die PHP verwendet haben, versuche ich Folgendes in C # zu tun:

$arr = array();
for ($i = 0; $i < 10; $i++) {
    $arr[] = $i;
}

Sie können dies tun -

int[] terms = new int[400];
for (int runs = 0; runs < 400; runs++)
{
    terms[runs] = value;
}

Alternativ können Sie Listen verwenden. Der Vorteil von Listen besteht darin, dass Sie die Arraygröße beim Instanziieren der Liste nicht kennen müssen.

List<int> termsList = new List<int>();
for (int runs = 0; runs < 400; runs++)
{
    termsList.Add(value);
}

// You can convert it back to an array if you would like to
int[] terms = termsList.ToArray();

Bearbeiten: a) for- Schleifen in Liste <T> sind etwas mehr als 2-mal billiger als foreach- Schleifen in Liste <T>, b) Looping auf Array ist ungefähr 2-mal billiger als Looping auf Liste <T>, c) Looping auf Die Verwendung von for für ein Array ist fünfmal billiger als die Schleife auf List <T> mit foreach (was die meisten von uns tun).

Wenn Sie in C # 3 schreiben, können Sie dies mit einem Einzeiler tun:

int[] terms = Enumerable.Range(0, 400).ToArray();

In diesem Code-Snippet wird davon ausgegangen, dass Sie oben in Ihrer Datei eine using-Direktive für System.Linq haben.

Wenn Sie jedoch nach etwas suchen, dessen Größe dynamisch geändert werden kann, wie es bei PHP der Fall ist (ich habe es noch nie gelernt), möchten Sie möglicherweise eine Liste anstelle eines int [] verwenden. . So würde dieser Code aussehen:

List<int> terms = Enumerable.Range(0, 400).ToList();

Beachten Sie jedoch, dass Sie ein 401st-Element nicht einfach hinzufügen können, indem Sie Begriffe [400] auf einen Wert setzen. Sie müssen stattdessen Add () wie folgt aufrufen:

terms.Add(1337);

Mit Linq ‚s Methode Concat macht diese einfache

int[] array = new int[] { 3, 4 };

array = array.Concat(new int[] { 2 }).ToArray();

Ergebnis 3,4,2

Hier finden Sie Antworten zur Verwendung eines Arrays.

C # hat jedoch eine sehr praktische Sache namens System.Collections :)

Sammlungen sind ausgefallene Alternativen zur Verwendung eines Arrays, obwohl viele von ihnen ein Array intern verwenden.

Zum Beispiel hat C # eine Sammlung namens List, die dem PHP-Array sehr ähnlich funktioniert.

using System.Collections.Generic;

// Create a List, and it can only contain integers.
List<int> list = new List<int>();

for (int i = 0; i < 400; i++)
{
   list.Add(i);
}

Die Verwendung einer Liste als Vermittler ist der einfachste Weg, wie andere beschrieben haben. Da Ihre Eingabe jedoch ein Array ist und Sie die Daten nicht nur in einer Liste behalten möchten, sind Sie möglicherweise über die Leistung besorgt.

Die effizienteste Methode besteht wahrscheinlich darin, ein neues Array zuzuweisen und dann Array.Copy oder Array.CopyTo zu verwenden. Dies ist nicht schwer, wenn Sie nur ein Element am Ende der Liste hinzufügen möchten:

public static T[] Add<T>(this T[] target, T item)
{
    if (target == null)
    {
        //TODO: Return null or throw ArgumentNullException;
    }
    T[] result = new T[target.Length + 1];
    target.CopyTo(result, 0);
    result[target.Length] = item;
    return result;
}

Auf Wunsch kann ich auch eine Code-Code für eine Insert-Erweiterungsmethode eingeben, die einen Zielindex als Eingabe verwendet. Es ist etwas komplizierter und verwendet die statische Methode Array.Copy 1-2 mal.

Basierend auf der Antwort von Thracx (ich habe nicht genug Punkte, um zu antworten):

public static T[] Add<T>(this T[] target, params T[] items)
    {
        // Validate the parameters
        if (target == null) {
            target = new T[] { };
        }
        if (items== null) {
            items = new T[] { };
        }

        // Join the arrays
        T[] result = new T[target.Length + items.Length];
        target.CopyTo(result, 0);
        items.CopyTo(result, target.Length);
        return result;
    }

Auf diese Weise können Sie dem Array mehr als nur ein Element hinzufügen oder einfach ein Array als Parameter übergeben, um zwei Arrays zu verbinden.

Sie müssen zuerst das Array zuweisen:

int [] terms = new int[400]; // allocate an array of 400 ints
for(int runs = 0; runs < terms.Length; runs++) // Use Length property rather than the 400 magic number again
{
    terms[runs] = value;
}

int ArraySize = 400;

int[] terms = new int[ArraySize];


for(int runs = 0; runs < ArraySize; runs++)
{

    terms[runs] = runs;

}

So würde ich es codieren.

C # -Arrays haben eine feste Länge und sind immer indiziert. Gehen Sie mit Mottis Lösung:

int [] terms = new int[400];
for(int runs = 0; runs < 400; runs++)
{
    terms[runs] = value;
}

Beachten Sie, dass dieses Array ein dichtes Array ist, ein zusammenhängender Block von 400 Bytes, in dem Sie Dinge ablegen können. Wenn Sie ein Array mit dynamischer Größe wünschen, verwenden Sie eine Liste <int>.

List<int> terms = new List<int>();
for(int runs = 0; runs < 400; runs ++)
{
    terms.Add(runs);
}

Weder int [] noch List <int> ist ein assoziatives Array - das wäre ein Wörterbuch <> in C #. Sowohl Arrays als auch Listen sind dicht.

int[] terms = new int[10]; //create 10 empty index in array terms

//fill value = 400 for every index (run) in the array
//terms.Length is the total length of the array, it is equal to 10 in this case 
for (int run = 0; run < terms.Length; run++) 
{
    terms[run] = 400;
}

//print value from each of the index
for (int run = 0; run < terms.Length; run++)
{
    Console.WriteLine("Value in index {0}:\t{1}",run, terms[run]);
}

Console.ReadLine();

/*Ausgabe:

Wert im Index 0: 400
Wert im Index 1: 400
Wert im Index 2: 400
Wert im Index 3: 400
Wert im Index 4: 400
Wert im Index 5: 400
Wert im Index 6: 400
Wert im Index 7: 400
Wert in Index 8: 400
Wert in Index 9: 400
* /

Sie können einem Array nicht einfach ein Element hinzufügen. Sie können das Element an einer bestimmten Position wie unten beschrieben festlegen. Ich empfehle jedoch, stattdessen ein List<int>oder ein zu Collection<int>verwenden und es zu verwenden, ToArray()wenn Sie es in ein Array konvertieren müssen.

Wenn Sie wirklich ein Array benötigen, ist das Folgende wahrscheinlich das einfachste:

using System.Collections.Generic;

// Create a List, and it can only contain integers.
List<int> list = new List<int>();

for (int i = 0; i < 400; i++)
{
   list.Add(i);
}

int [] terms = list.ToArray();

Ich werde dies für eine andere Variante hinzufügen. Ich bevorzuge diese Art von funktionalen Codierungslinien mehr.

Enumerable.Range(0, 400).Select(x => x).ToArray();

Wenn Sie die Größe des Arrays nicht kennen oder bereits ein vorhandenes Array haben, das Sie hinzufügen. Sie können dies auf zwei Arten tun. Das erste ist die Verwendung eines Generikums List<T>: Dazu müssen Sie das Array in ein konvertieren var termsList = terms.ToList();und die Add-Methode verwenden. Wenn Sie fertig sind, verwenden Sie die var terms = termsList.ToArray();Methode, um zurück in ein Array zu konvertieren.

var terms = default(int[]);
var termsList = terms == null ? new List<int>() : terms.ToList();

for(var i = 0; i < 400; i++)
    termsList.Add(i);

terms = termsList.ToArray();

Die zweite Möglichkeit besteht darin, die Größe des aktuellen Arrays zu ändern:

var terms = default(int[]);

for(var i = 0; i < 400; i++)
{
    if(terms == null)
        terms = new int[1];
    else    
        Array.Resize<int>(ref terms, terms.Length + 1);

    terms[terms.Length - 1] = i;
}

Wenn Sie .NET 3.5 verwenden Array.Add(...);

Mit beiden können Sie dies dynamisch tun. Wenn Sie viele Elemente hinzufügen, verwenden Sie einfach a List<T>. Wenn es sich nur um ein paar Elemente handelt, hat es eine bessere Leistung bei der Größenänderung des Arrays. Dies liegt daran, dass Sie beim Erstellen des List<T>Objekts mehr Treffer erzielen .

Zeiten in Zecken:

3 Artikel

Array-Größenänderungszeit: 6

Liste Hinzufügen Zeit: 16

400 Artikel

Array-Größenänderungszeit: 305

Liste Add Time: 20

Nur ein anderer Ansatz:

int runs = 0; 
bool batting = true; 
string scorecard;

while (batting = runs < 400)
    scorecard += "!" + runs++;

return scorecard.Split("!");

Ein Ansatz besteht darin, ein Array über LINQ zu füllen

Wenn Sie ein Array mit einem Element füllen möchten, können Sie einfach schreiben

string[] arrayToBeFilled;
arrayToBeFilled= arrayToBeFilled.Append("str").ToArray();

Wenn Sie ein Array mit mehreren Elementen füllen möchten, können Sie den vorherigen Code in einer Schleife verwenden

//the array you want to fill values in
string[] arrayToBeFilled;
//list of values that you want to fill inside an array
List<string> listToFill = new List<string> { "a1", "a2", "a3" };
//looping through list to start filling the array

foreach (string str in listToFill){
// here are the LINQ extensions
arrayToBeFilled= arrayToBeFilled.Append(str).ToArray();
}

int[] terms = new int[400];

for(int runs = 0; runs < 400; runs++)
{
    terms[runs] = value;
}

         static void Main(string[] args)
        {
            int[] arrayname = new int[5];/*arrayname is an array of 5 integer [5] mean in array [0],[1],[2],[3],[4],[5] because array starts with zero*/
            int i, j;


          /*initialize elements of array arrayname*/
            for (i = 0; i < 5; i++)
            {
                arrayname[i] = i + 100;
            }

             /*output each array element value*/
            for (j = 0; j < 5; j++)
            {
                Console.WriteLine("Element and output value [{0}]={1}",j,arrayname[j]);
            }
            Console.ReadKey();/*Obtains the next character or function key pressed by the user.
                                The pressed key is displayed in the console window.*/
        }

            /*arrayname is an array of 5 integer*/
            int[] arrayname = new int[5];
            int i, j;
            /*initialize elements of array arrayname*/
            for (i = 0; i < 5; i++)
            {
                arrayname[i] = i + 100;
            }

Hinzufügen der Listenwerte zum Zeichenfolgenarray mithilfe von C # ohne Verwendung der ToArray () -Methode

        List<string> list = new List<string>();
        list.Add("one");
        list.Add("two");
        list.Add("three");
        list.Add("four");
        list.Add("five");
        string[] values = new string[list.Count];//assigning the count for array
        for(int i=0;i<list.Count;i++)
        {
            values[i] = list[i].ToString();
        }

Die Ausgabe des Wertearrays enthält:

einer

zwei

drei

vier

fünf