imprimir todo el contenido de la matriz en C #

Estoy tratando de imprimir el contenido de una matriz después de invocar algunos métodos que la alteran, en Java uso:

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

¿cómo hago esto en c #?

Puedes probar esto:

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

También es posible que desee probar algo como esto:

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

EDITAR: para obtener salida en una línea [según su comentario]:

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

EDITAR (2019): Como se menciona en otras respuestas, es mejor usar el Array.ForEach<T>método y no es necesario realizar el ToListpaso.

Array.ForEach(yourArray, Console.WriteLine);

Hay muchas formas de hacerlo, las otras respuestas son buenas, aquí hay una alternativa:

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

El más fácil, por ejemplo, si tiene una matriz de cadenas declarada como esta cadena [] myStringArray = new string [];

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

Debido a que tuve un tiempo de inactividad en el trabajo, decidí probar las velocidades de los diferentes métodos publicados aquí.

Estos son los cuatro métodos que utilicé.

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

Los resultados son los siguientes:

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

Entonces Print3 es el más rápido, porque solo tiene una llamada a la Console.WriteLineque parece ser el principal cuello de botella para la velocidad de impresión de una matriz. Print4 es un poco más rápido que Print2 e Print1 es el más lento de todos.

Creo que Print4 es probablemente el más versátil de los 4 que probé, aunque Print3 es más rápido.

Si cometí algún error, ¡no dudes en hacérmelo saber / corregirlo por tu cuenta!

EDITAR: estoy agregando el IL generado a continuación

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   

Otro enfoque con el Array.ForEach<T> Method (T[], Action<T>)método de la Arrayclase.

Array.ForEach(myArray, Console.WriteLine);

Eso toma solo una iteración en comparación con la array.ToList().ForEach(Console.WriteLine)que toma dos iteraciones y crea internamente una segunda matriz para List(tiempo de ejecución de doble iteración y consumo de memoria doble)

En C # puede recorrer la matriz imprimiendo cada elemento. Tenga en cuenta que System.Object define un método ToString (). Cualquier tipo que se derive de System.Object () puede anular eso.

Devuelve una cadena que representa el objeto actual.

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

De forma predeterminada, se imprimirá el nombre de tipo completo del objeto, aunque muchos tipos incorporados anulan ese valor predeterminado para imprimir un resultado más significativo. Puede anular ToString () en sus propios objetos para proporcionar una salida significativa.

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

Si tuviera su propia clase Foo, podría anular ToString () como:

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

A partir de C # 6.0 , cuando se introdujo la interpolación $ - string, hay una forma más:

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

//output
A, B, C

La concatenación podría proceder al archivo usando el System.Linq, convierta el string[]que char[]e imprimir como unastring

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

//output
ABC

Si quieres ponerte lindo, puedes escribir un método de extensión que escriba una IEnumerable<object>secuencia en la consola. Esto funcionará con enumerables de cualquier tipo, porque IEnumerable<T>es covariante en 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);
        }
    }
}

(No creo que usarías esto más que en el código de prueba).

Elegí la respuesta del método de extensión de Matthew Watson, pero si está migrando / visitando desde Python, puede encontrar este 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())));
    }
}

-> esto imprimirá cualquier colección usando el separador provisto. Es bastante limitado (¿colecciones anidadas?).

Para un script (es decir, una aplicación de consola C # que solo contiene Program.cs, y la mayoría de las cosas suceden en Program.Main), esto puede estar bien.

esta es la forma más fácil de imprimir la cadena utilizando una matriz.

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

Si es una matriz de cadenas, puede usar Aggregate

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

de esa manera puede revertir el orden cambiando el orden de los parámetros así

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

Puedes usar for loop

    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]}, ");
         }
     }

Si no desea utilizar la función 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();
    }
}