Добавление значений в массив C#

Сначала вам нужно выделить массив:

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[] terms = new int[400];

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

int ArraySize = 400;

int[] terms = new int[ArraySize];


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

    terms[runs] = runs;

}

Вот как бы я это закодировал.

Вы не можете просто добавить элемент в массив. Вы можете установить элемент в заданной позиции как обрисованный упавший888, но я рекомендую вместо этого использовать List<int> или Collection<int> и использовать ToArray(), если вам нужно преобразовать его в массив.

Можно так сделать -

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

В качестве альтернативы вы можете использовать списки - преимущество списков в том, что вам не нужно знать размер массива при создании экземпляра списка.

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

Редактировать:a) Циклы для в List <T> чуть более чем в 2 раза дешевле, чем циклы для каждого в List <T>, б) Цикл по массиву примерно в 2 раза дешевле, чем цикл по List <T>, в) Цикл по массиву с использованием для в 5 раз дешевле, чем цикл по List <T> с использованием для каждого (что большинство из нас делает).

Массивы C# имеют фиксированную длину и всегда индексируются. Пойдите с решением Мотти:

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

Обратите внимание, что этот массив представляет собой плотный массив, непрерывный блок размером 400 байт, в который вы можете бросать вещи. Если вам нужен массив с динамическим размером, используйте List <int>.

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

Ни int [], ни List <int> не являются ассоциативными массивами - это было бы Dictionary <> в C#. И массивы, и списки плотные.

Здесь приведены ответы о том, как это сделать с использованием массива.

Однако в C# есть очень удобная штука под названием System.Collections :)

Коллекции - это прекрасная альтернатива использованию массива, хотя многие из них используют массив внутри.

Например, в C# есть коллекция под названием List, которая по своим функциям очень похожа на массив 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);
}

Если вы пишете на C# 3, вы можете сделать это с помощью однострочника:

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

Этот фрагмент кода предполагает, что у вас есть директива using для System.Linq в верхней части файла.

С другой стороны, если вы ищете что-то, что может быть динамически изменено, как, похоже, в случае PHP (я никогда не изучал это), тогда вы можете использовать List вместо int [] . Вот как будет выглядеть код который:

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

Обратите внимание, однако, что вы не можете просто добавить 401-й элемент, установив значение terms [400]. Вместо этого вам нужно будет вызвать Add (), например:

terms.Add(1337);

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

/*Output：

Value in index 0: 400
Value in index 1: 400
Value in index 2: 400
Value in index 3: 400
Value in index 4: 400
Value in index 5: 400
Value in index 6: 400
Value in index 7: 400
Value in index 8: 400
Value in index 9: 400
*/

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

Просто другой подход:

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

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

return scorecard.Split("!");

Если вам действительно нужен массив, возможно, самый простой вариант:

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

Если вы не знаете размер массива или уже имеете существующий массив, который вы добавляете. Вы можете сделать это двумя способами. Первый использует общий List<T>: Для этого вам нужно преобразовать массив в var termsList = terms.ToList(); и использовать метод Add. Затем, когда это будет сделано, используйте метод var terms = termsList.ToArray(); для обратного преобразования в массив.

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

Второй способ - изменить размер текущего массива:

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

Если вы используете .NET 3.5 Array.Add(...);

Оба они позволят вам делать это динамически. Если вы будете добавлять много элементов, просто используйте List<T>. Если это всего лишь пара элементов, то при изменении размера массива производительность будет выше. Это потому, что создание объекта List<T> требует больших усилий.

Разв тиках:

3 шт.

Array Resize Time: 6

List Add Time: 16

400 экспонатов

Array Resize Time: 305

List Add Time: 20

Использование списка в качестве посредника - это самый простой способ, как описывали другие, но поскольку ваш ввод представляет собой массив, и вы не просто хотите хранить данные в списке, я предполагаю, что вас может беспокоить производительность.

Наиболее эффективным методом, вероятно, является выделение нового массива, а затем использование Array.Copy или Array.CopyTo. Это несложно, если вы просто хотите добавить элемент в конец списка:

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

Я также могу опубликовать код для метода расширения Insert, который принимает индекс назначения в качестве входных данных, если это необходимо. Это немного сложнее и 1-2 раза использует статический метод Array.Copy.

Основываясь на ответе Thracx (у меня недостаточно очков, чтобы ответить):

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

Это позволяет добавить в массив более одного элемента или просто передать массив в качестве параметра для объединения двух массивов.

Использование метода ConcatLinq упрощает

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

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

результат 3,4,2

Я добавлю это для другого варианта. Я больше предпочитаю этот тип функциональных строк кодирования.

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

Чтобы добавить значения списка в массив строк с помощью C# без использования метода 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();
        }

Вывод массива значений содержит:

один

два

три

четыре

5

один из подходов - заполнить массив через LINQ

если вы хотите заполнить массив одним элементом вы можете просто написать

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

кроме того, если вы хотите заполнить массив несколькими элементами, вы можете использовать предыдущий код в цикле

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

Вы не можете сделать это напрямую. Однако вы можете использовать Linq для этого:

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

Если массив термины вначале не был пустым, вы можете сначала преобразовать его в Список, а затем продолжить работу. Нравиться:

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

Note: don't miss adding 'using System.Linq;' at the begaining of the file.

Мне кажется, это намного проще:

var usageList = usageArray.ToList();
usageList.Add("newstuff");
usageArray = usageList.ToArray();

Вы можете сделать это со списком. вот как

List<string> info = new List<string>();
info.Add("finally worked");

и если вам нужно вернуть этот массив, сделайте

return info.ToArray();

К 2019 году вы можете использовать Append, Prepend, используя LinQ, всего в одной строке

using System.Linq;

а потом:

terms= terms.Append(21).ToArray();

Я думаю, что это лучший способ сделать это
Пример отправки массива

public void ArrayPush<T>(ref T[] table, object value)
{
    Array.Resize(ref table, table.Length + 1); // Resizing the array for the cloned length (+-) (+1)
    table.SetValue(value, table.Length - 1); // Setting the value for the new element
}