imprimiendo todos los contenidos de la matriz en C #

Estoy tratando de imprimir los contenidos de una matriz después de invocar algunos métodos que la modifican, en Java utilizo:

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

¿Cómo hago esto en c #?

Puedes intentar 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 : O como se sugiere en los comentarios:

 yourArray.ToList().ForEach(Console.WriteLine); 

EDITAR: para obtener salida en una línea [en función de tu comentario]:

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

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

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

El más fácil:

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

En C #, puede recorrer la matriz imprimiendo cada elemento. Tenga en cuenta que System.Object define un método ToString (). Cualquier tipo dado que se deriva 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 un resultado significativo.

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

Debido a tener 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

Así que Print3 es el más rápido, ya que solo tiene una llamada a Console.WriteLine que parece ser el principal cuello de botella para la velocidad de impresión de una matriz. Print4 es ligeramente 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 dude en avisarme / corregirlo por su 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 IL_0006: ldnull IL_0007: ldftn System.Console.Write IL_000D: newobj System.Action..ctor IL_0012: callvirt System.Collections.Generic.List.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..ctor IL_000D: call System.Array.ForEach IL_0012: ret 

Si quieres ser lindo, podrías escribir un método de extensión que haya escrito una IEnumerable en la consola. Esto funcionará con enumerables de cualquier tipo, porque IEnumerable 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 @this) { foreach (var obj in @this) Console.WriteLine(obj); } } } 

(No creo que uses esto aparte del código de prueba).

Otro enfoque con el Array.ForEach Method (T[], Action) de la clase Array

 Array.ForEach(myArray, Console.WriteLine); 

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

Volví a subir la respuesta del método de extensión por Matthew Watson, pero si estás migrando / visitando desde Python, tal vez te resulte útil este método:

 class Utils { static void dump(IEnumerable 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 una secuencia de comandos (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 el String usando 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(); } } }