web-dev-qa-db-fra.com

imprimer tout le contenu du tableau en C #

J'essaie d'imprimer le contenu d'un tableau après avoir appelé certaines méthodes qui le modifient. En Java, j'utilise

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

comment puis-je faire cela en c #?

c#.netarrayslinq
41
Padraic Cunningham

Vous pouvez essayer ceci:

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

Aussi, vous voudrez peut-être essayer quelque chose comme ceci:

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

EDIT: Ou comme suggéré dans les commentaires:

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

EDIT: pour obtenir une sortie sur une ligne [en fonction de votre commentaire]:

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

Il y a plusieurs façons de le faire, les autres réponses sont bonnes, voici une alternative:

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

Le plus simple, par exemple si vous avez un tableau de chaînes déclaré comme ceci: [] myStringArray = new string []; 

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

En C #, vous pouvez parcourir le tableau en imprimant chaque élément. Notez que System.Object définit une méthode ToString (). Tout type donné qui dérive de System.Object () peut le remplacer. 

Retourne une chaîne qui représente l'objet actuel.

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

Par défaut, le nom de type complet de l'objet sera imprimé, bien que de nombreux types intégrés remplacent cette valeur par défaut pour imprimer un résultat plus significatif. Vous pouvez remplacer ToString () dans vos propres objets pour fournir une sortie significative.

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

Si vous aviez votre propre classe Foo, vous pouvez remplacer ToString () comme ceci:

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

En raison de certains temps d'arrêt au travail, j'ai décidé de tester les vitesses des différentes méthodes publiées ici. 

Ce sont les quatre méthodes que j'ai utilisées.

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

Les résultats sont les suivants:

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

Donc, Print3 est le plus rapide, car il n’ya qu’un appel au Console.WriteLine, qui semble être le principal goulot d’étranglement pour la vitesse d’impression d’un tableau. Print4 est légèrement plus rapide que Print2 et Print1 est le plus lent de tous.

Je pense que Print4 est probablement le plus polyvalent des 4 que j'ai testés, même si Print3 est plus rapide.

Si j'ai commis des erreurs, n'hésitez pas à me le faire savoir/à les corriger vous-même!

EDIT: J'ajoute l'IL généré ci-dessous

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
3
TJ Wolschon

Une autre approche avec la méthode Array.ForEach<T> Method (T[], Action<T>) de la classe Array

Array.ForEach(myArray, Console.WriteLine);

Cela ne prend qu'une seule itération par rapport à array.ToList().ForEach(Console.WriteLine) qui prend deux itérations et crée en interne un second tableau pour la List (exécution à deux itérations et double consommation de mémoire)

2
fubo

Si vous voulez être mignon, vous pouvez écrire une méthode d’extension qui écrit une séquence IEnumerable<object> sur la console. Cela fonctionnera avec des énumérables de tout type, parce que IEnumerable<T> est covariant sur 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);
        }
    }
}

(Je ne pense pas que vous utiliseriez ceci autrement que dans le code de test.)

1
Matthew Watson

J'ai voté pour la méthode d'extension answer par Matthew Watson, mais si vous migrez/visitez Python, vous pouvez trouver une telle méthode utile:

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

-> Ceci imprimera n'importe quelle collection en utilisant le séparateur fourni. C'est assez limité (collections imbriquées?). 

Pour un script (c'est-à-dire une application console C # qui ne contient que Program.cs, et la plupart des choses se passent dans Program.Main) - cela peut suffire.

0
Tomasz Gandor

c'est le moyen le plus simple d'imprimer la chaîne à l'aide d'un tableau !!!

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

À partir de C # 6.0 , lorsque l’interpolation de chaîne $ - a été introduite, il existe un moyen supplémentaire:

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

//output
A, B, C

La concaténation peut être archivée à l'aide du System.Linq, convertir le string[] en char[] et imprimer sous la forme string

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

//output
ABC
0
Johnny