Adicionando valores a uma matriz C #

Provavelmente é realmente simples - estou começando com C # e preciso adicionar valores a uma matriz, por exemplo:

int[] terms;

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

Para quem já usou PHP, eis o que estou tentando fazer em c #:

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

Você pode fazer assim -

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

Como alternativa, você pode usar Listas - a vantagem das listas é que você não precisa saber o tamanho da matriz ao instanciar a lista.

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) para loops na Lista <T> são um pouco mais do que 2 vezes mais baratos que foreach loops na Lista <T>, b) Looping no array é cerca de 2 vezes mais barato que o loop na Lista <T>, c) loop o array usando for é 5 vezes mais barato que o loop na Lista <T> usando foreach (o que a maioria de nós faz).

Se você estiver escrevendo em C # 3, poderá fazê-lo com uma única linha:

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

Esse trecho de código pressupõe que você tenha uma diretiva de uso para System.Linq na parte superior do seu arquivo.

Por outro lado, se você está procurando algo que possa ser redimensionado dinamicamente, como parece ser o caso do PHP (eu nunca o aprendi), convém usar uma lista em vez de um int [] . Aqui está como seria esse código:

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

Observe, no entanto, que você não pode simplesmente adicionar um elemento 401, definindo os termos [400] para um valor. Você precisaria chamar Add (), assim:

terms.Add(1337);

Usando o método Linq , o Concat simplifica

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

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

resultado 3,4,2

As respostas sobre como fazê-lo usando uma matriz são fornecidas aqui.

No entanto, o C # tem uma coisa muito útil chamada System.Collections :)

Coleções são alternativas sofisticadas ao uso de uma matriz, embora muitas delas usem uma matriz internamente.

Por exemplo, o C # tem uma coleção chamada List que funciona muito semelhante à matriz 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);
}

Usar uma lista como intermediária é a maneira mais fácil, como outros descreveram, mas como sua entrada é uma matriz e você não deseja apenas manter os dados em uma lista, presumo que você possa estar preocupado com o desempenho.

O método mais eficiente é provavelmente alocar uma nova matriz e depois usar Array.Copy ou Array.CopyTo. Isso não é difícil se você deseja adicionar um item ao final da lista:

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

Também posso postar o código para um método de extensão Insert que usa um índice de destino como entrada, se desejado. É um pouco mais complicado e usa o método estático Array.Copy 1-2 vezes.

Com base na resposta da Thracx (não tenho pontos suficientes para responder):

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

Isso permite adicionar mais de um item à matriz ou apenas passar uma matriz como parâmetro para unir duas matrizes.

Você precisa alocar a matriz primeiro:

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;

}

Seria assim que eu codificaria.

Matrizes C # são de comprimento fixo e sempre indexadas. Vá com a solução de Motti:

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

Observe que essa matriz é uma matriz densa, um bloco contíguo de 400 bytes onde você pode soltar coisas. Se você deseja uma matriz de tamanho dinâmico, use uma Lista <int>.

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

Nem int [] nem List <int> são uma matriz associativa - isso seria um dicionário <> em C #. Matrizes e listas são densas.

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

/*Resultado:

Valor no índice 0: 400
Valor no índice 1: 400
Valor no índice 2: 400
Valor no índice 3: 400
Valor no índice 4: 400
Valor no índice 5: 400
Valor no índice 6: 400
Valor no índice 7: 400
Valor em índice 8: 400
Valor no índice 9: 400
* /

Você não pode simplesmente adicionar um elemento a uma matriz facilmente. Você pode definir o elemento em uma determinada posição, conforme descrito em " fall888" , mas eu recomendo usar um List<int>ou um Collection<int>e, ToArray()se necessário, convertê-lo em uma matriz.

Se você realmente precisa de uma matriz, o seguinte é provavelmente o mais 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();

Vou adicionar isso para uma outra variante. Eu prefiro esse tipo de linhas de codificação funcionais mais.

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

Se você não souber o tamanho da matriz ou já tiver uma matriz existente à qual está adicionando. Você pode fazer isso de duas maneiras. A primeira é usar um genérico List<T>: para fazer isso, convém converter a matriz em a var termsList = terms.ToList();e usar o método Add. Em seguida, quando terminar, use o var terms = termsList.ToArray();método para converter novamente em uma matriz.

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

A segunda maneira é redimensionar a matriz atual:

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

Se você estiver usando o .NET 3.5 Array.Add(...);

Ambos permitem que você faça isso dinamicamente. Se você adicionar muitos itens, basta usar a List<T>. Se forem apenas alguns itens, o desempenho será melhor redimensionado a matriz. Isso ocorre porque você recebe mais sucesso ao criar o List<T>objeto.

Vezes em ticks:

3 itens

Tempo de redimensionamento da matriz: 6

Tempo para adicionar lista: 16

400 itens

Tempo de redimensionamento da matriz: 305

Tempo para adicionar lista: 20

Apenas uma abordagem diferente:

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

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

return scorecard.Split("!");

Uma abordagem é preencher uma matriz via LINQ

se você quiser preencher uma matriz com um elemento, basta escrever

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

Além disso, se você deseja preencher uma matriz com vários elementos, pode usar o código anterior em um loop

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

Para adicionar os valores da lista à matriz de cadeias usando C # sem usar o método 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();
        }

A saída da matriz de valores contém:

1

dois

três

quatro

cinco