web-dev-qa-db-de.com

den gesamten Inhalt eines Arrays in C # drucken

Ich versuche, den Inhalt eines Arrays auszudrucken, nachdem ich einige Methoden aufgerufen habe, die ihn ändern. In Java verwende ich:

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

wie mache ich das in c #?

41

Sie können dies versuchen:

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

Vielleicht möchten Sie auch so etwas versuchen:

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

EDIT: Oder wie in Kommentaren vorgeschlagen:

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

EDIT: um eine Ausgabe in einer Zeile zu erhalten [basierend auf Ihrem Kommentar]:

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

Es gibt viele Möglichkeiten dies zu tun, die anderen Antworten sind gut, hier ist eine Alternative:

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

Der einfachste, z. wenn Sie ein String-Array haben, das wie folgt deklariert ist string [] myStringArray = new string []; 

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

In C # können Sie das Array durchlaufen und jedes Element drucken. Beachten Sie, dass System.Object eine Methode ToString () definiert. Jeder angegebene Typ, der von System.Object () abgeleitet wird, kann dies überschreiben. 

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.

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

Standardmäßig wird der vollständige Typname des Objekts gedruckt, obwohl viele integrierte Typen diese Standardeinstellung überschreiben, um ein aussagekräftigeres Ergebnis zu erhalten. Sie können ToString () in Ihren eigenen Objekten überschreiben, um eine sinnvolle Ausgabe zu ermöglichen.

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

Wenn Sie eine eigene Klasse Foo hätten, könnten Sie ToString () wie folgt überschreiben:

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

Aufgrund einiger Ausfallzeiten bei der Arbeit habe ich mich dazu entschlossen, die Geschwindigkeit der verschiedenen Methoden zu testen. 

Dies sind die vier Methoden, die ich verwendet habe.

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

Die Ergebnisse sind wie folgt:

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

Print3 ist also am schnellsten, da es nur einen Aufruf von Console.WriteLine gibt, der der größte Engpass für die Geschwindigkeit des Ausdrucks eines Arrays ist. Print4 ist etwas schneller als Print2 und Print1 ist das langsamste von allen.

Ich denke, dass Print4 wahrscheinlich die vielseitigste der 4 ist, die ich getestet habe, obwohl Print3 schneller ist.

Wenn ich Fehler gemacht habe, lass es mich wissen oder behebt sie selbst!

EDIT: Ich füge unten die generierte IL hinzu

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

Ein anderer Ansatz mit der Array.ForEach<T> Method (T[], Action<T>) Methode der Array Klasse

Array.ForEach(myArray, Console.WriteLine);

Dies erfordert nur eine Iteration im Vergleich zu array.ToList().ForEach(Console.WriteLine), das zwei Iterationen benötigt und intern ein zweites Array für die List erstellt (doppelte Iterationslaufzeit und doppelter Speicherverbrauch).

2
fubo

Wenn Sie süß werden möchten, können Sie eine Erweiterungsmethode schreiben, die eine IEnumerable<object>-Sequenz in die Konsole schreibt. Dies funktioniert mit Aufzählern eines beliebigen Typs, da IEnumerable<T> für T kovariant ist:

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

(Ich glaube nicht, dass Sie dies anders als im Testcode verwenden würden.)

1
Matthew Watson

Ich habe die Antwort der Erweiterungsmethode von Matthew Watson auf den neuesten Stand gebracht. Wenn Sie jedoch von Python aus migrieren/besuchen, ist eine solche Methode möglicherweise hilfreich:

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

-> Dadurch wird jede Sammlung mit dem bereitgestellten Trennzeichen gedruckt. Es ist ziemlich begrenzt (verschachtelte Sammlungen?). 

Für ein Skript (d. H. Eine C # -Konsolenanwendung, die nur Program.cs enthält und die meisten Dinge in Program.Main geschehen), kann dies in Ordnung sein.

0
Tomasz Gandor

dies ist die einfachste Möglichkeit, den String mit einem Array zu drucken !!!

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

Ab C # 6.0 gibt es eine weitere Möglichkeit, wenn die Interpolation von $ - string eingeführt wurde:

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

//output
A, B, C

Die Verkettung kann mit System.Linq archiviert werden, der string[] wird in char[] konvertiert und als string ausgegeben.

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

//output
ABC
0
Johnny