Initialisieren einer Liste mit Werten in C#

1. Verwenden Sie die Klasse List<T>, um eine Liste mit Werten in C# zu initialisieren
2. Verwenden Sie die Methode List.Add(), um eine Liste mit Werten in C# zu initialisieren
3. Verwenden Sie C#-Auflistungsinitialisierer, um eine Liste mit Werten zu initialisieren

In diesem Tutorial lernen Sie verschiedene Methoden zum Initialisieren einer Liste und zum Umgang mit den Implementierungsdetails kennen. C# ermöglicht es Programmierern, eine Liste zu instanziieren, sie mit dem Schlüsselwort new zu initialisieren und Mitgliederzuweisungen in einer einzigen Anweisung durchzuführen.

Das Hauptziel dieses Tutorials besteht darin, die C#-Entwickler mit den generischen Listen und ihrer Implementierung mithilfe der Collection-Klasse List<T> vertraut zu machen. Die generische Klasse List<T> gehört zum Namespace System.Collections.Generic und ist eine der einfachsten Sammlungsklassen, die vom .NET Framework definiert werden.

Eine Liste enthält eine einfache geordnete Liste von Elementen mit der Fähigkeit, mehrere Arten von Objekten zu speichern. Die Klasse List<T> in C# implementiert die Schnittstellen ICollection, IEnumerable, IList, ICollection<T>, IEnumerable<T> und IList<T>.

Verwenden Sie die Klasse List<T>, um eine Liste mit Werten in C# zu initialisieren

Das T in der Klasse List<T> stellt die Deklaration dar, die die Interkonnektivität der Klasse mit bestimmten Typen angibt. Die Deklaration der Listenklasse (List<T> Listenname; // Deklaration) verdeutlicht, mit welchem Datentyp sie arbeitet und welche manipuliert.

Verwenden Sie das Schlüsselwort new mit dem Standardkonstruktor, um eine leere Liste zu initialisieren, die vorübergehend in der Variablen listName gespeichert werden soll (listName = new List<T>(); // list initialization). Da die Standardkapazität einer Liste null Einträge beträgt, können Sie einer Liste mit der nützlichen Eigenschaft list.Capacity<T> eine andere Kapazität zuweisen.

Die Kapazität einer Liste ist variabel und kann mit Hilfe der List<T>.TrimExcess-Methode oder durch explizites Setzen der folgenden Syntax verringert werden, um eine stark typisierte Liste von Objekten zu initialisieren, auf die einfach und effizient per index in zugegriffen werden kann C#.

List<T>.Capacity` property. Use `new List<Type> {Value1, Value2, ..., ValueN};

Beispielcode:

using System;
using System.Collections.Generic;

public class listInitialization {
  public static void Main(string[] args) {
    // array as a parameter
    string[] array = { "value1", "value2", "value3" };

    // list initialization with values
    List<string> expList = new List<string>(array);

    // an alternative approach to initialize a list with values using the `List<T>` class | it is
    // called single-line list initialization with values
    List<string> expListAlt = new List<string>() { "value1", "value2", "value3" };

    // display the `expList` list
    Console.WriteLine("You initialized a list with " + expList.Count + " values.");
  }
}

Ausgang:

You initialized a list with 3 values.

Die Schnittstelle List<T> ist das generische Äquivalent der Klasse ArrayList in C# und verwendet ein Array, das je nach Bedarf dynamisch erweitert werden kann. Da die Kapazität einer Liste auf einem 64-Bit-System auf zwei Milliarden Elemente erhöht werden kann, können Sie Ihre benutzerdefinierte Synchronisierung implementieren, um den Zugriff mehrerer Threads zur Wertmanipulation (Lesen und Schreiben) zu ermöglichen, wodurch die Sicherheit des Threads durch Sperren gewährleistet wird eine Liste.

Verwenden Sie die Methode List.Add(), um eine Liste mit Werten in C# zu initialisieren

Die Syntax der Liste ist zunächst verwirrend, aber sie ist ideal für C#-Programme ohne strenge Speicher- oder Leistungsbeschränkungen. Sie können die Methode List.Add() verwenden, um der Liste nach ihrer Deklaration neue Elemente hinzuzufügen, aber Sie können auch Elemente zum Zeitpunkt der Deklaration erstellen.

Das Erstellen einer Liste von Strings mit einer Kapazität von 0 mit Hilfe eines parameterlosen Konstruktors ist eine universelle Art der Listeninitialisierung. Sie können die Methode Add() der Klasse List verwenden, um der Liste mehrere String-Werte hinzuzufügen.

Beispielcode:

using System;
using System.Collections.Generic;

public class listInitialization {
  public static void Main(string[] args) {
    // using `Add()` method to initialize a list with string values
    List<string> expList = new List<string>();
    expList.Add("value1");
    expList.Add("value2");
    expList.Add("value3");
    expList.Add("value4");
    expList.Add("value5");

    // display the `expList` list
    Console.WriteLine("You initialized a list with " + expList.Count + " values.");
  }
}

Ausgang:

You initialized a list with 5 values.

Das Interessanteste an dieser Methode ist, dass sie automatisch die Kapazität der Liste überprüft und die Größe ändert, wann immer es notwendig erscheint. Es fügt am Ende der Liste einen Wert hinzu und gibt den Index des Werts zurück, sodass die Kapazität einfacher erweitert werden kann.

Verwenden Sie C#-Auflistungsinitialisierer, um eine Liste mit Werten zu initialisieren

Die Syntax Collection initializer wurde erstmals in C# 3.0 eingeführt, und seitdem ist es hilfreich, Sammlungen Werte zuzuweisen. Es ist eine verkürzte Syntax, die eine Notation in geschweiften Klammern verwendet, um eine Liste zu initialisieren, und wenn es um die Deklaration geht, werden alle ihre Werte auf einmal zugewiesen.

Im Allgemeinen ist es als Kurzschreibweise für den mehrmaligen Aufruf der Methode Add() durch den C#-Compiler bekannt. Sie können eine Liste initialisieren, indem Sie List<string> name = new List<string> verwenden und ihre Werte wie {new Element() {Id = 1, Name = "first"} in geschweiften Klammern definieren, indem Sie Objekte füllen der Klasse Element.

Einzelne Objektinitialisierer ermöglichen es Ihnen, eine Liste zu erstellen und sie mit einem anfänglichen Satz von Werten zu füllen, die in geschweiften Klammern eingeschlossen und durch Kommas getrennt sind. Das Erstellen einer Liste in C# aus einer Reihe bekannter Werte wurde unglaublich mühelos.

Sie können einen Sammlungsinitialisierer identifizieren, indem Sie das Schlüsselwort From gefolgt von geschweiften Klammern {} verwenden, ähnlich wie bei der Array-Literal-Syntax. Es besteht aus einer Liste von durch Kommas getrennten Werten, die in geschweiften Klammern {} eingeschlossen sind, denen das Schlüsselwort From vorangestellt ist.

Beispielcode:

using System;
using System.Collections.Generic;

public class listInitialization {
  public static void Main(string[] args) {
    // using `C# Collection Initializers` to initialize a list with values
    List<Element> expList = new List<Element>() { new Element() { Id = 1, Name = "value1" },
                                                  new Element() { Id = 2, Name = "value2" },
                                                  new Element() { Id = 3, Name = "value3" },
                                                  new Element() { Id = 4, Name = "value4" } };

    // display the `expList` list
    Console.WriteLine("You initialized a list with " + expList.Count + " values.");
  }
}

// create a class to define list values
public class Element {
  public int Id { get; set; }
  public string Name { get; set; }
}

Ausgang:

You initialized a list with 4 values.

In diesem Lernprogramm haben Sie gelernt, wie Sie eine Liste mit Zeichenfolgenwerten erstellen und initialisieren. Dieses Tutorial gab eine vollständige Einführung in die Listeninitialisierung mit Werten und enthält kompilierbare C#-Codebeispiele, um die wichtigsten Konzepte der Listeninitialisierung zu verdeutlichen.

C#-Programme erledigen oft einfache Dinge wie das Einlesen von Zahlen, und mit einer Liste können Sie diese Elemente initialisieren und hinzufügen, wenn Sie darauf stoßen. Listeninitialisierer wurden wichtig, wenn Werte beliebigen zugänglichen Feldern von Eigenschaften einer Liste zum Zeitpunkt der Erstellung zugewiesen wurden, ohne dass ein Konstruktor gefolgt von Zuweisungsanweisungen aufgerufen wurde.