Drucken des gesamten Inhalts des Arrays in C #

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

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

Wie mache ich das in c #?

Sie können dies versuchen:

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

Vielleicht möchten Sie auch so etwas ausprobieren:

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

BEARBEITEN: um die 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]

EDIT (2019): Wie in anderen Antworten erwähnt, ist es besser, die Array.ForEach<T>Methode zu verwenden , und es besteht keine Notwendigkeit, den ToListSchritt auszuführen.

Array.ForEach(yourArray, Console.WriteLine);

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

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

Am einfachsten, z. B. wenn Sie ein String-Array wie dieses deklariert haben [] myStringArray = new string [];

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

Aufgrund von Ausfallzeiten bei der Arbeit habe ich mich entschlossen, die Geschwindigkeit der verschiedenen hier aufgeführten 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 gibt, der Console.WriteLineder Hauptengpass für die Geschwindigkeit des Ausdrucks eines Arrays zu sein scheint. Print4 ist etwas schneller als Print2 und Print1 ist der 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, können Sie mich diese gerne selbst mitteilen / beheben!

EDIT: Ich füge die generierte IL unten 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   

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

Array.ForEach(myArray, Console.WriteLine);

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

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

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

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

Standardmäßig wird der vollständige Typname des Objekts gedruckt, obwohl viele integrierte Typen diesen Standard überschreiben, um ein aussagekräftigeres Ergebnis zu drucken. Sie können ToString () in Ihren eigenen Objekten überschreiben, um eine aussagekräftige Ausgabe bereitzustellen.

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

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

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ählungen jeglichen Typs, da IEnumerable<T>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.)

Ich habe die Antwort der Erweiterungsmethode von Matthew Watson positiv bewertet, aber wenn Sie 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())));
    }
}

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

Für ein Skript (dh eine C # -Konsolenanwendung, die nur Program.cs enthält und in der die meisten Dinge passieren Program.Main) ist dies möglicherweise in Ordnung.

Dies ist der einfachste Weg, 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();
        }
    }
}

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

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

//output
A, B, C

Die Verkettung kann mithilfe von archiviert werden System.Linq. Konvertieren Sie die string[]in char[]und drucken Sie alsstring

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

//output
ABC

Wenn es sich um ein Array von Zeichenfolgen handelt, können Sie Aggregate verwenden

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

Auf diese Weise können Sie die Reihenfolge umkehren, indem Sie die Reihenfolge der Parameter wie folgt ändern

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

Wenn Sie die Array-Funktion nicht verwenden möchten.

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