Ajout de valeurs à un tableau C #

Probablement très simple - je commence avec C # et j'ai besoin d'ajouter des valeurs à un tableau, par exemple:

int[] terms;

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

Pour ceux qui ont utilisé PHP, voici ce que j'essaie de faire en C #:

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

Vous pouvez le faire de cette façon -

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

Alternativement, vous pouvez utiliser des listes - l'avantage avec les listes étant, vous n'avez pas besoin de connaître la taille du tableau lors de l'instanciation de la liste.

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

Edit: a) pour les boucles sur la liste <T> sont un peu plus de 2 fois moins cher que pour les boucles pour chaque sur la liste <T>, b) la boucle sur le tableau est environ 2 fois moins cher que la boucle sur la liste <T>, c) la boucle sur tableau utilisant for est 5 fois moins cher que de boucler sur List <T> en utilisant foreach (ce que la plupart d'entre nous font).

Si vous écrivez en C # 3, vous pouvez le faire avec une seule ligne:

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

Cet extrait de code suppose que vous avez une directive using pour System.Linq en haut de votre fichier.

D'un autre côté, si vous cherchez quelque chose qui peut être redimensionné dynamiquement, comme cela semble être le cas pour PHP (je ne l'ai jamais réellement appris), alors vous voudrez peut-être utiliser une liste au lieu d'un int [] . Voici à quoi ressemblerait ce code:

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

Notez cependant que vous ne pouvez pas simplement ajouter un 401e élément en définissant les termes [400] sur une valeur. Vous devriez plutôt appeler Add (), comme ceci:

terms.Add(1337);

L'utilisation de la méthode de Linq Concat rend cela simple

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

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

résultat 3,4,2

Des réponses sur la façon de le faire en utilisant un tableau sont fournies ici.

Cependant, C # a une chose très pratique appelée System.Collections :)

Les collections sont de fantastiques alternatives à l'utilisation d'un tableau, bien que beaucoup d'entre elles utilisent un tableau en interne.

Par exemple, C # possède une collection appelée List qui fonctionne de manière très similaire au tableau PHP.

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

Utiliser une liste comme intermédiaire est le moyen le plus simple, comme d'autres l'ont décrit, mais comme votre entrée est un tableau et que vous ne voulez pas simplement conserver les données dans une liste, je suppose que vous pourriez être préoccupé par les performances.

La méthode la plus efficace consiste probablement à allouer un nouveau tableau, puis à utiliser Array.Copy ou Array.CopyTo. Ce n'est pas difficile si vous souhaitez simplement ajouter un élément à la fin de la liste:

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

Je peux également poster du code pour une méthode d'extension d'insertion qui prend un index de destination en entrée, si vous le souhaitez. C'est un peu plus compliqué et utilise la méthode statique Array.Copy 1-2 fois.

Basé sur la réponse de Thracx (je n'ai pas assez de points pour répondre):

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

Cela permet d'ajouter plus d'un élément au tableau ou simplement de passer un tableau en paramètre pour joindre deux tableaux.

Vous devez d'abord allouer le tableau:

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;

}

Ce serait ainsi que je le coderais.

Les tableaux C # sont de longueur fixe et toujours indexés. Optez pour la solution de Motti:

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

Notez que ce tableau est un tableau dense, un bloc contigu de 400 octets où vous pouvez déposer des objets. Si vous voulez un tableau de taille dynamique, utilisez un List <int>.

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

Ni int [] ni List <int> n'est un tableau associatif - ce serait un Dictionary <> en C #. Les tableaux et les listes sont denses.

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

/*Production:

Valeur dans l'index 0: 400
Valeur dans l'index 1: 400
Valeur dans l'index 2: 400
Valeur dans l'index 3: 400
Valeur dans l'index 4: 400
Valeur dans l'index 5: 400
Valeur dans l'index 6: 400
Valeur dans l'index 7: 400
Valeur dans index 8: 400
Valeur dans l'index 9: 400
* /

Vous ne pouvez pas simplement ajouter un élément à un tableau facilement. Vous pouvez définir l'élément à une position donnée comme décrit dans le texte tombé888 , mais je recommande d'utiliser un List<int>ou un à la Collection<int>place et à utiliser ToArray()si vous en avez besoin converti en tableau.

Si vous avez vraiment besoin d'un tableau, les problèmes suivants sont les plus simples:

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

J'ajouterai ceci pour une autre variante. Je préfère davantage ce type de lignes de codage fonctionnelles.

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

Si vous ne connaissez pas la taille du tableau ou si vous avez déjà un tableau existant auquel vous ajoutez. Vous pouvez vous y prendre de deux manières. La première consiste à utiliser un générique List<T>: pour ce faire, vous souhaiterez convertir le tableau en a var termsList = terms.ToList();et utiliser la méthode Add. Ensuite, lorsque vous avez terminé, utilisez la var terms = termsList.ToArray();méthode pour reconvertir en tableau.

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

La deuxième façon consiste à redimensionner le tableau actuel:

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

Si vous utilisez .NET 3.5 Array.Add(...);

Les deux vous permettront de le faire de manière dynamique. Si vous allez ajouter de nombreux éléments, utilisez simplement a List<T>. S'il ne s'agit que de quelques éléments, les performances de redimensionnement du tableau seront meilleures. C'est parce que vous prenez plus de succès pour créer leList<T> objet.

Temps en tiques:

3 éléments

Temps de redimensionnement du tableau: 6

Temps d'ajout de liste: 16

400 éléments

Temps de redimensionnement de la baie: 305

Temps d'ajout de liste: 20

Juste une approche différente:

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

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

return scorecard.Split("!");

une approche consiste à remplir un tableau via LINQ

si vous voulez remplir un tableau avec un élément, vous pouvez simplement écrire

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

en outre, si vous souhaitez remplir un tableau avec plusieurs éléments, vous pouvez utiliser le code précédent dans une boucle

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

Pour ajouter les valeurs de liste au tableau de chaînes à l'aide de C # sans utiliser la méthode ToArray ()

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

La sortie du tableau de valeurs contient:

une

deux

Trois

quatre

cinq