Anzeigen von Listenelementen im Konsolenfenster in C #

Eigentlich können Sie es ziemlich einfach machen, da die Liste eine ForEach-Methode hat und Sie Console.WriteLine als Methodengruppe übergeben können. Der Compiler konvertiert die Methodengruppe dann in eine implizite Konvertierung in Action<int> und wählt die spezifischste Methode aus der Gruppe aus, in diesem Fall `Console.WriteLine (int):

  var list = new List<int>(Enumerable.Range(0, 50));

  list.ForEach(Console.WriteLine);

Funktioniert auch mit Strings =)

Um absolut pedantisch zu sein (und ich schlage keine Änderung Ihrer Antwort vor - nur aus Interesse, um Interesse zu zeigen) "Console.WriteLine" ist eine Methodengruppe. Der Compiler verwendet dann eine implizite Konvertierung von der Methodengruppe in Action und wählt die spezifischste Methode aus (in diesem Fall Console.WriteLine (int)).

Angenommen, die Elemente überschreiben ToString entsprechend:

public void WriteToConsole(IEnumerable items)
{
    foreach (object o in items)
    {
        Console.WriteLine(o);
    }
}

(Die Verwendung von Generics in dieser Schleife wäre nicht von Vorteil - wir würden am Ende trotzdem Console.WriteLine(object) aufrufen, also würde es immer noch ein Box sein, wie es in diesem Fall im Teil foreach der Fall ist.)

BEARBEITEN: Die Antworten mit List<T>.ForEach sind sehr gut.

Meine obige Schleife ist flexibler, wenn Sie eine beliebige Reihenfolge haben (z. B. als Ergebnis eines LINQ-Ausdrucks). Wenn Sie jedoch definitiv einen List<T> haben, würde ich sagen, dass List<T>.ForEach eine bessere Option ist.

Ein Vorteil von List<T>.ForEach ist, dass bei einem konkreten Listentyp die am besten geeignete Überladung verwendet wird. Zum Beispiel:

List<int> integers = new List<int> { 1, 2, 3 };
List<string> strings = new List<string> { "a", "b", "c" };

integers.ForEach(Console.WriteLine);
strings.ForEach(Console.WriteLine);

Beim Herausschreiben der Ganzzahlen wird Console.WriteLine(int) verwendet, während beim Ausschreiben der Zeichenfolgen Console.WriteLine(string) verwendet wird. Wenn keine bestimmte Überladung verfügbar ist (oder wenn Sie nur einen generischen List<T> verwenden und der Compiler nicht weiß, was T ist), wird Console.WriteLine(object) verwendet.

Beachten Sie übrigens die Verwendung von Console.WriteLine als Methodengruppe. Dies ist prägnanter als die Verwendung eines Lambda-Ausdrucks und tatsächlich etwas effizienter (da der Delegat nur ein Aufruf an Console.WriteLine sein wird, anstatt ein Aufruf einer Methode, die wiederum Console.WriteLine aufruft).

Die Antworten mit List<T>.ForEach sind zwar sehr gut.

Ich fand String.Join<T>(string separator, IEnumerable<T> values) method nützlicher.

Beispiel:

List<string> numbersStrLst = new List<string>
            { "One", "Two", "Three","Four","Five"};

Console.WriteLine(String.Join(", ", numbersStrLst));//Output:"One, Two, Three, Four, Five"

int[] numbersIntAry = new int[] {1, 2, 3, 4, 5};
Console.WriteLine(String.Join("; ", numbersIntAry));//Output:"1; 2; 3; 4; 5"

Bemerkungen :

Wenn das Trennzeichen null ist, wird stattdessen eine leere Zeichenfolge (String.Empty) verwendet. Wenn ein Wertemember null ist, wird stattdessen eine leere Zeichenfolge verwendet.

Join(String, IEnumerable<String>) ist eine bequeme Methode, mit der Sie jedes Element in einer IEnumerable (Of String) -Sammlung verketten können, ohne die Elemente zunächst in ein String-Array zu konvertieren. Dies ist besonders nützlich bei LINQ-Abfrageausdrücken (Language-Integrated Query). 

Dies sollte für das Problem gut funktionieren, während andere Array-Werte haben. Verwenden Sie andere Überladungen derselben Methode, String.Join-Methode (String, Object [])

Referenz: https://msdn.Microsoft.com/en-us/library/dd783876(v=vs.110).aspx

Sie können auch foreas eingebaute List verwenden, wie:

List<T>.ForEach(item => Console.Write(item));

Dieser Code läuft auch bedeutend schneller!

Mit dem obigen Code können Sie auch Console.WriteLine bearbeiten, beispielsweise:

List<T>.ForEach(item => Console.Write(item + ",")); //Put a,b etc.

Console.WriteLine(string.Join<TYPE>("\n", someObjectList));

Ich fand das einfacher zu verstehen:

List<string> names = new List<string> { "One", "Two", "Three", "Four", "Five" };
        for (int i = 0; i < names.Count; i++)
        {
            Console.WriteLine(names[i]);
        }

Angenommen, wir müssen einige Daten in der Eingabeaufforderung anzeigen, die aus einer Datenbanktabelle stammen. Zuerst erstellen wir eine Liste. Team_Details ist meine Eigentumsklasse.

    List<Team_Details> teamDetails = new List<Team_Details>();

Dann können Sie eine Verbindung zur Datenbank herstellen und den Datenabrufteil ausführen und wie folgt in der Liste speichern.

            string connetionString = "Data Source=.;Initial Catalog=your DB name;Integrated Security=True;MultipleActiveResultSets=True";
            using (SqlConnection conn = new SqlConnection(connetionString)){
            string getTeamDetailsQuery = "select * from Team";
            conn.Open();
            using (SqlCommand cmd = new SqlCommand(getTeamDetailsQuery, conn))
                    {
                        SqlDataReader rdr = cmd.ExecuteReader();
                    {
                        teamDetails.Add(new Team_Details
                        {
                            Team_Name = rdr.GetString(rdr.GetOrdinal("Team_Name")),
                            Team_Lead = rdr.GetString(rdr.GetOrdinal("Team_Lead")),
                        });
                    }

Dann können Sie diese Liste in der Eingabeaufforderung wie folgt drucken.

foreach (Team_Details i in teamDetails)
                        {
                            Console.WriteLine(i.Team_Name);
                            Console.WriteLine(i.Team_Lead);
                        }