imprimir todo o conteúdo da matriz em C #

Estou tentando imprimir o conteúdo de uma matriz depois de invocar alguns métodos que a alteram, em Java que uso:

System.out.print(Arrays.toString(alg.id));

como faço isso em c #?

Você pode tentar isto:

foreach(var item in yourArray)
{
    Console.WriteLine(item.ToString());
}

Além disso, você pode querer tentar algo assim:

yourArray.ToList().ForEach(i => Console.WriteLine(i.ToString()));

EDITAR: para obter a saída em uma linha [com base em seu comentário]:

 Console.WriteLine("[{0}]", string.Join(", ", yourArray));
 //output style:  [8, 1, 8, 8, 4, 8, 6, 8, 8, 8]

EDIT (2019): Como mencionado em outras respostas é melhor usar Array.ForEach<T>método e não há necessidade de fazer o ToListpasso.

Array.ForEach(yourArray, Console.WriteLine);

Existem muitas maneiras de fazer isso, as outras respostas são boas, aqui está uma alternativa:

Console.WriteLine(string.Join("\n", myArrayOfObjects));

O mais fácil, por exemplo, se você tiver um array de strings declarado como este string [] myStringArray = new string [];

Console.WriteLine("Array : ");
Console.WriteLine("[{0}]", string.Join(", ", myStringArray));

Devido a algum tempo de inatividade no trabalho, decidi testar as velocidades dos diferentes métodos postados aqui.

Esses são os quatro métodos que usei.

static void Print1(string[] toPrint)
{
    foreach(string s in toPrint)
    {
        Console.Write(s);
    }
}

static void Print2(string[] toPrint)
{
    toPrint.ToList().ForEach(Console.Write);
}

static void Print3(string[] toPrint)
{
    Console.WriteLine(string.Join("", toPrint));
}

static void Print4(string[] toPrint)
{
    Array.ForEach(toPrint, Console.Write);
}

Os resultados são os seguintes:

 Strings per trial: 10000
 Number of Trials: 100
 Total Time Taken to complete: 00:01:20.5004836
 Print1 Average: 484.37ms
 Print2 Average: 246.29ms
 Print3 Average: 70.57ms
 Print4 Average: 233.81ms

Logo, Print3 é o mais rápido, pois possui apenas uma chamada para o Console.WriteLineque parece ser o principal gargalo para a velocidade de impressão de um array. Print4 é ligeiramente mais rápido que Print2 e Print1 é o mais lento de todos.

Acho que Print4 é provavelmente o mais versátil dos 4 que testei, embora Print3 seja mais rápido.

Se eu tiver cometido algum erro, sinta-se à vontade para me informar / corrigi-lo por conta própria!

EDIT: Estou adicionando o IL gerado abaixo

g__Print10_0://Print1
IL_0000:  ldarg.0     
IL_0001:  stloc.0     
IL_0002:  ldc.i4.0    
IL_0003:  stloc.1     
IL_0004:  br.s        IL_0012
IL_0006:  ldloc.0     
IL_0007:  ldloc.1     
IL_0008:  ldelem.ref  
IL_0009:  call        System.Console.Write
IL_000E:  ldloc.1     
IL_000F:  ldc.i4.1    
IL_0010:  add         
IL_0011:  stloc.1     
IL_0012:  ldloc.1     
IL_0013:  ldloc.0     
IL_0014:  ldlen       
IL_0015:  conv.i4     
IL_0016:  blt.s       IL_0006
IL_0018:  ret         

g__Print20_1://Print2
IL_0000:  ldarg.0     
IL_0001:  call        System.Linq.Enumerable.ToList<String>
IL_0006:  ldnull      
IL_0007:  ldftn       System.Console.Write
IL_000D:  newobj      System.Action<System.String>..ctor
IL_0012:  callvirt    System.Collections.Generic.List<System.String>.ForEach
IL_0017:  ret         

g__Print30_2://Print3
IL_0000:  ldstr       ""
IL_0005:  ldarg.0     
IL_0006:  call        System.String.Join
IL_000B:  call        System.Console.WriteLine
IL_0010:  ret         

g__Print40_3://Print4
IL_0000:  ldarg.0     
IL_0001:  ldnull      
IL_0002:  ldftn       System.Console.Write
IL_0008:  newobj      System.Action<System.String>..ctor
IL_000D:  call        System.Array.ForEach<String>
IL_0012:  ret   

Outra abordagem com o Array.ForEach<T> Method (T[], Action<T>)método da Arrayaula

Array.ForEach(myArray, Console.WriteLine);

Isso leva apenas uma iteração em comparação com a array.ToList().ForEach(Console.WriteLine)qual leva duas iterações e cria internamente uma segunda matriz para o List(tempo de execução de iteração dupla e consumo de memória duplo)

Em C #, você pode percorrer a matriz imprimindo cada elemento. Observe que System.Object define um método ToString (). Qualquer tipo que derive de System.Object () pode sobrescrever isso.

Retorna uma string que representa o objeto atual.

http://msdn.microsoft.com/en-us/library/system.object.tostring.aspx

Por padrão, o nome do tipo completo do objeto será impresso, embora muitos tipos embutidos substituam esse padrão para imprimir um resultado mais significativo. Você pode substituir ToString () em seus próprios objetos para fornecer uma saída significativa.

foreach (var item in myArray)
{
    Console.WriteLine(item.ToString()); // Assumes a console application
}

Se você tivesse sua própria classe Foo, você poderia substituir ToString () como:

public class Foo
{
    public override string ToString()
    {
        return "This is a formatted specific for the class Foo.";
    }
}

A partir do C # 6.0 , quando a interpolação de $ - string foi introduzida, há mais uma maneira:

var array = new[] { "A", "B", "C" };
Console.WriteLine($"{string.Join(", ", array}");

//output
A, B, C

A concatenação pode ser arquivada usando System.Linq, converter string[]para char[]e imprimir como umstring

var array = new[] { "A", "B", "C" };
Console.WriteLine($"{new String(array.SelectMany(_ => _).ToArray())}");

//output
ABC

Se você quiser ser bonitinho, pode escrever um método de extensão que escreve uma IEnumerable<object>sequência no console. Isso funcionará com enumeráveis ​​de qualquer tipo, porque IEnumerable<T>é covariante em T:

using System;
using System.Collections.Generic;

namespace Demo
{
    internal static class Program
    {
        private static void Main(string[] args)
        {
            string[] array  = new []{"One", "Two", "Three", "Four"};
            array.Print();

            Console.WriteLine();

            object[] objArray = new object[] {"One", 2, 3.3, TimeSpan.FromDays(4), '5', 6.6f, 7.7m};
            objArray.Print();
        }
    }

    public static class MyEnumerableExt
    {
        public static void Print(this IEnumerable<object> @this)
        {
            foreach (var obj in @this)
                Console.WriteLine(obj);
        }
    }
}

(Não acho que você usaria isso a não ser no código de teste.)

Votei positivamente na resposta do método de extensão de Matthew Watson, mas se você estiver migrando / visitando vindo do Python, pode achar esse método útil:

class Utils
{
    static void dump<T>(IEnumerable<T> list, string glue="\n")
    {
        Console.WriteLine(string.Join(glue, list.Select(x => x.ToString())));
    }
}

-> isso irá imprimir qualquer coleção usando o separador fornecido. É bastante limitado (coleções aninhadas?).

Para um script (ou seja, um aplicativo de console C # que contém apenas Program.cs, e a maioria das coisas acontecem nele Program.Main) - isso pode ser suficiente.

esta é a maneira mais fácil de imprimir a String usando array !!!

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace arraypracticeforstring
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] arr = new string[3] { "Snehal", "Janki", "Thakkar" };

            foreach (string item in arr)
            {
                Console.WriteLine(item.ToString());
            }
            Console.ReadLine();
        }
    }
}

Se for uma matriz de strings, você pode usar Aggregate

var array = new string[] { "A", "B", "C", "D"};
Console.WriteLine(array.Aggregate((result, next) => $"{result}, {next}")); // A, B, C, D

dessa forma, você pode inverter a ordem, alterando a ordem dos parâmetros como

Console.WriteLine(array.Aggregate((result, next) => $"{next}, {result}")); // D, C, B, A

Você pode usar o loop for

    int[] random_numbers = {10, 30, 44, 21, 51, 21, 61, 24, 14}
    int array_length = random_numbers.Length;
    for (int i = 0; i < array_length; i++){
        if(i == array_length - 1){
              Console.Write($"{random_numbers[i]}\n");
        } else{
              Console.Write($"{random_numbers[i]}, ");
         }
     }

Se você não quiser usar a função Array.

public class GArray
{
    int[] mainArray;
    int index;
    int i = 0;

    public GArray()
    {
        index = 0;
        mainArray = new int[4];
    }
    public void add(int addValue)
    {

        if (index == mainArray.Length)
        {
            int newSize = index * 2;
            int[] temp = new int[newSize];
            for (int i = 0; i < mainArray.Length; i++)
            {
                temp[i] = mainArray[i];
            }
            mainArray = temp;
        }
        mainArray[index] = addValue;
        index++;

    }
    public void print()
    {
        for (int i = 0; i < index; i++)
        {
            Console.WriteLine(mainArray[i]);
        }
    }
 }
 class Program
{
    static void Main(string[] args)
    {
        GArray myArray = new GArray();
        myArray.add(1);
        myArray.add(2);
        myArray.add(3);
        myArray.add(4);
        myArray.add(5);
        myArray.add(6);
        myArray.print();
        Console.ReadKey();
    }
}