1. IronPDF
  2. IronPDF-Blog
  3. .NET-Hilfe
  4. C# ArrayList
.NET-HILFE

C# ArrayList (Wie es funktioniert für Entwickler)

Chipego
Chipego Kalinda
6. März 2024
Teilen Sie:

Die ArrayList-Klasse ist Teil des Collections-Namespace des .NET Frameworks und wurde entwickelt, um eine Sammlung von Objekten zu speichern. Es handelt sich um eine nicht-generische Sammlung, d. h. sie kann Elemente jedes Datentyps enthalten. Diese Eigenschaft macht sie sehr flexibel, aber weniger typsicher im Vergleich zu generischen Sammlungen. Die ArrayList kann doppelte Elemente enthalten und ermöglicht eine dynamische Größenänderung, wenn ein gültiger Wert hinzugefügt oder entfernt wird. In diesem Artikel besprechen wir die Grundlagen von ArrayList und die IronPDF-Bibliotheksfunktionen.

Die Grundlagen von ArrayList

Die ArrayList ist im Wesentlichen eine nicht-generische Sammlung, die in der Lage ist, eine Anzahl von Elementen beliebiger Datentypen zu speichern, was sie zu einer vielseitigen Wahl für verschiedene Programmierszenarien macht. Die Möglichkeit, Elemente nach Belieben hinzuzufügen oder zu entfernen, ohne an eine feste Größe gebunden zu sein, ist eines der Hauptmerkmale des Systems. Die ArrayList passt ihre Größe automatisch an, um neue Elemente aufzunehmen, eine Funktion, die durch ihre Implementierung des IList-Interfaces ermöglicht wird. Diese dynamische Größenanpassung ist von entscheidender Bedeutung für Anwendungen, die Sammlungen mit einer unterschiedlichen Anzahl von Elementen während ihrer Lebensdauer benötigen.

Wenn Sie eine ArrayList instanziieren, erstellen Sie eine Sammlung, die jeden Objektwert enthalten kann, von Ganzzahlen und Zeichenketten bis hin zu komplexen benutzerdefinierten Objekten. Das Hinzufügen von Elementen zu einer ArrayList ist dank Methoden wie Add, die einen Objektwert am Ende der Sammlung anhängt, und Insert, die ein neues Element an einem angegebenen Index platziert und vorhandene Elemente bei Bedarf verschiebt, um Platz zu schaffen, einfach. Diese Flexibilität ermöglicht es Entwicklern, Sammlungen effektiver zu verwalten und sich an die Bedürfnisse der sich entwickelnden Anwendung anzupassen.

Arbeiten mit Elementen

Das Hinzufügen von Elementen zu einer ArrayList ist einfach und intuitiv. Betrachten Sie beispielsweise ein Szenario, in dem Sie eine Sammlung von verschiedenen Datentypen erstellen. Mit der Add-Methode können Sie jedes Objekt an Ihre ArrayList anhängen, von Zeichenfolgen über ganze Zahlen bis hin zu anderen Sammlungen. Die Kapazität der ArrayList wird bei Bedarf automatisch erhöht, um sicherzustellen, dass immer Platz für neue Objekt-Obj-Elemente vorhanden ist. Diese automatische Größenanpassung ist ein wesentlicher Vorteil gegenüber herkömmlichen Arrays, die eine manuelle Größenanpassung oder die Erstellung eines neuen Arrays erfordern, um mehr Elemente unterzubringen.

Die ArrayList bietet auch Methoden zum Einfügen und Entfernen von Elementen an bestimmten Positionen oder an einem int-Index. Die Insert-Methode ermöglicht es Ihnen, ein Element an einer bestimmten Position hinzuzufügen, so dass Sie neue Elemente genau an einem bestimmten Index in der Sammlung platzieren können. Ähnlich unterstützen die Methoden Remove und RemoveAt das Löschen von Elementen, entweder durch Angabe des zu entfernenden Objekts oder dessen Index innerhalb der Sammlung. Diese feingranulare Kontrolle über die Elemente innerhalb der ArrayList macht sie zu einem leistungsstarken Werkzeug zur Verwaltung dynamischer Daten.

Erstellen und Hinzufügen von Elementen

Um mit der Verwendung einer ArrayList zu beginnen, müssen Sie zuerst eine Instanz davon erstellen. Dann können Sie Elemente zur ArrayList mit der Add-Methode hinzufügen, die ein Objekt am Ende der ArrayList einfügt.

class Program
{
// public static void main
    public static void Main()
    {
        ArrayList myArrayList = new ArrayList();
        myArrayList.Add("Hello");
        myArrayList.Add(100);
        var item = "World";
        myArrayList.Add(item);
        foreach (var obj in myArrayList)
        {
            Console.WriteLine(obj);
        }
    }
}
class Program
{
// public static void main
    public static void Main()
    {
        ArrayList myArrayList = new ArrayList();
        myArrayList.Add("Hello");
        myArrayList.Add(100);
        var item = "World";
        myArrayList.Add(item);
        foreach (var obj in myArrayList)
        {
            Console.WriteLine(obj);
        }
    }
}
Friend Class Program
' public static void main
	Public Shared Sub Main()
		Dim myArrayList As New ArrayList()
		myArrayList.Add("Hello")
		myArrayList.Add(100)
		Dim item = "World"
		myArrayList.Add(item)
		For Each obj In myArrayList
			Console.WriteLine(obj)
		Next obj
	End Sub
End Class
$vbLabelText   $csharpLabel

C# ArrayList (Wie es für Entwickler funktioniert): Abbildung 1 - ArrayList-Ausgabe erstellen

Dieses Beispiel zeigt, wie man eine neue ArrayList erstellt und verschiedene Arten von Elementen hinzufügt. Die foreach-Schleife durchläuft dann die ArrayList und gibt jedes Element aus.

Elemente einfügen

Um ein Element an einem bestimmten Index einzufügen, verwenden Sie die Methode Insert, wobei zu beachten ist, dass es sich um ein nullbasiertes Indexsystem handelt.

myArrayList.Insert(1, "Inserted Item");
myArrayList.Insert(1, "Inserted Item");
myArrayList.Insert(1, "Inserted Item")
$vbLabelText   $csharpLabel

Entfernen von Elementen

Um Elemente zu entfernen, sind die Methoden Remove und RemoveAt sehr nützlich. Remove löscht das erste Vorkommen eines bestimmten Objekts, während RemoveAt das Element am angegebenen ganzzahligen Index entfernt.

myArrayList.Remove("Hello"); // Removes the first occurrence of "Hello"
myArrayList.RemoveAt(0); // Removes the element at index 0
myArrayList.Remove("Hello"); // Removes the first occurrence of "Hello"
myArrayList.RemoveAt(0); // Removes the element at index 0
myArrayList.Remove("Hello") ' Removes the first occurrence of "Hello"
myArrayList.RemoveAt(0) ' Removes the element at index 0
$vbLabelText   $csharpLabel

Beispiel: Verwaltung einer ArrayList

Ein fortgeschrittenes Beispiel für die Verwendung von ArrayList in C# umfasst nicht nur die grundlegenden Operationen wie das Hinzufügen oder Entfernen von Elementen, sondern auch komplexere Manipulationen wie Sortieren, Suchen und das Umwandeln der ArrayList in andere Datenstrukturen. Fügen Sie das folgende Beispiel in die Datei Program.cs ein, um es auszuführen:

using System;
using System.Collections;
using System.Linq;
class AdvancedArrayListExample
{
    static void Main(string [] args)
    {
        // Initialize an ArrayList with some elements
        ArrayList numbers = new ArrayList() { 5, 8, 1, 3, 2 };
        // Adding elements
        numbers.Add(6); // Add an element to the end
        numbers.AddRange(new int [] { 7, 9, 0 }); // Add multiple elements from a specified collection.
        Console.WriteLine("Initial ArrayList:");
        foreach (int number in numbers)
        {
            Console.Write(number + " ");
        }
        Console.WriteLine("\n");
        // Removing elements
        numbers.Remove(1); // Remove the element 1
        numbers.RemoveAt(0); // Remove the first element
        Console.WriteLine("After Removal:");
        foreach (int number in numbers)
        {
            Console.Write(number + " ");
        }
        Console.WriteLine("\n");
        // Sorting
        numbers.Sort(); // Sort the ArrayList
        Console.WriteLine("Sorted ArrayList:");
        foreach (int number in numbers)
        {
            Console.Write(number + " ");
        }
        Console.WriteLine("\n");
        // Searching
        int searchFor = 5;
        int index = numbers.IndexOf(searchFor); // Find the index of the element
        if (index != -1)
        {
            Console.WriteLine($"Element {searchFor} found at index {index}");
        }
        else
        {
            Console.WriteLine($"Element {searchFor} not found.");
        }
        Console.WriteLine("\n");
        // Converting ArrayList to Array
        int [] numbersArray = (int [])numbers.ToArray(typeof(int));
        Console.WriteLine("Converted Array:");
        foreach (int number in numbersArray)
        {
            Console.Write(number + " ");
        }
        Console.WriteLine("\n");
        // Demonstrate LINQ with ArrayList (Requires System.Linq)
        var evenNumbers = numbers.Cast<int>().Where(n => n % 2 == 0).ToList(); // Assign values to evenNumbers from the filtered results.
        Console.WriteLine("Even Numbers:");
        evenNumbers.ForEach(n => Console.Write(n + " "));
        Console.WriteLine();
    }
}
using System;
using System.Collections;
using System.Linq;
class AdvancedArrayListExample
{
    static void Main(string [] args)
    {
        // Initialize an ArrayList with some elements
        ArrayList numbers = new ArrayList() { 5, 8, 1, 3, 2 };
        // Adding elements
        numbers.Add(6); // Add an element to the end
        numbers.AddRange(new int [] { 7, 9, 0 }); // Add multiple elements from a specified collection.
        Console.WriteLine("Initial ArrayList:");
        foreach (int number in numbers)
        {
            Console.Write(number + " ");
        }
        Console.WriteLine("\n");
        // Removing elements
        numbers.Remove(1); // Remove the element 1
        numbers.RemoveAt(0); // Remove the first element
        Console.WriteLine("After Removal:");
        foreach (int number in numbers)
        {
            Console.Write(number + " ");
        }
        Console.WriteLine("\n");
        // Sorting
        numbers.Sort(); // Sort the ArrayList
        Console.WriteLine("Sorted ArrayList:");
        foreach (int number in numbers)
        {
            Console.Write(number + " ");
        }
        Console.WriteLine("\n");
        // Searching
        int searchFor = 5;
        int index = numbers.IndexOf(searchFor); // Find the index of the element
        if (index != -1)
        {
            Console.WriteLine($"Element {searchFor} found at index {index}");
        }
        else
        {
            Console.WriteLine($"Element {searchFor} not found.");
        }
        Console.WriteLine("\n");
        // Converting ArrayList to Array
        int [] numbersArray = (int [])numbers.ToArray(typeof(int));
        Console.WriteLine("Converted Array:");
        foreach (int number in numbersArray)
        {
            Console.Write(number + " ");
        }
        Console.WriteLine("\n");
        // Demonstrate LINQ with ArrayList (Requires System.Linq)
        var evenNumbers = numbers.Cast<int>().Where(n => n % 2 == 0).ToList(); // Assign values to evenNumbers from the filtered results.
        Console.WriteLine("Even Numbers:");
        evenNumbers.ForEach(n => Console.Write(n + " "));
        Console.WriteLine();
    }
}
Imports Microsoft.VisualBasic
Imports System
Imports System.Collections
Imports System.Linq
Friend Class AdvancedArrayListExample
	Shared Sub Main(ByVal args() As String)
		' Initialize an ArrayList with some elements
		Dim numbers As New ArrayList() From { 5, 8, 1, 3, 2 }
		' Adding elements
		numbers.Add(6) ' Add an element to the end
		numbers.AddRange(New Integer () { 7, 9, 0 }) ' Add multiple elements from a specified collection.
		Console.WriteLine("Initial ArrayList:")
		For Each number As Integer In numbers
			Console.Write(number & " ")
		Next number
		Console.WriteLine(vbLf)
		' Removing elements
		numbers.Remove(1) ' Remove the element 1
		numbers.RemoveAt(0) ' Remove the first element
		Console.WriteLine("After Removal:")
		For Each number As Integer In numbers
			Console.Write(number & " ")
		Next number
		Console.WriteLine(vbLf)
		' Sorting
		numbers.Sort() ' Sort the ArrayList
		Console.WriteLine("Sorted ArrayList:")
		For Each number As Integer In numbers
			Console.Write(number & " ")
		Next number
		Console.WriteLine(vbLf)
		' Searching
		Dim searchFor As Integer = 5
		Dim index As Integer = numbers.IndexOf(searchFor) ' Find the index of the element
		If index <> -1 Then
			Console.WriteLine($"Element {searchFor} found at index {index}")
		Else
			Console.WriteLine($"Element {searchFor} not found.")
		End If
		Console.WriteLine(vbLf)
		' Converting ArrayList to Array
		Dim numbersArray() As Integer = DirectCast(numbers.ToArray(GetType(Integer)), Integer ())
		Console.WriteLine("Converted Array:")
		For Each number As Integer In numbersArray
			Console.Write(number & " ")
		Next number
		Console.WriteLine(vbLf)
		' Demonstrate LINQ with ArrayList (Requires System.Linq)
		Dim evenNumbers = numbers.Cast(Of Integer)().Where(Function(n) n Mod 2 = 0).ToList() ' Assign values to evenNumbers from the filtered results.
		Console.WriteLine("Even Numbers:")
		evenNumbers.ForEach(Sub(n) Console.Write(n & " "))
		Console.WriteLine()
	End Sub
End Class
$vbLabelText   $csharpLabel

Dieser Codeschnipsel zeigt, wie das geht:

  • Initialisieren Sie eine ArrayList mit einer Menge von Elementen.
  • Fügen Sie einzelne und mehrere Elemente zur ArrayList hinzu.
  • Elemente nach Wert und nach Index entfernen.
  • Sortieren Sie die ArrayList, um die Elemente anzuordnen.
  • Suchen Sie nach einem Element und finden Sie seinen Index.
  • Konvertieren Sie die ArrayList in ein Standard-Array.

  • Verwenden Sie LINQ mit ArrayList, um gerade Zahlen herauszufiltern, und zeigen Sie, wie nicht-generische Sammlungen mit den leistungsstarken Abfragefähigkeiten von LINQ verbunden werden können.

    C# ArrayList (Wie es für Entwickler funktioniert): Abbildung 2 - ArrayList-Ausgabe

Einführung von IronPDF: C# PDF-Bibliothek

C# ArrayList (Wie es für Entwickler funktioniert): Abbildung 3 - IronPDF

IronPDF ist eine leistungsstarke Bibliothek für C#, die den komplexen Prozess der PDF-Erstellung vereinfacht und eine breite Palette von Funktionen zur PDF-Bearbeitung bietet, einschließlich der Möglichkeit, PDFs aus HTML zu erstellen, Text und Bilder hinzuzufügen, Dokumente zu sichern und vieles mehr.

Integration von IronPDF mit ArrayList

Schreiben wir ein einfaches C#-Programm, das eine ArrayList von Elementen erstellt und dann IronPDF verwendet, um ein PDF-Dokument zu generieren, das diese Elemente auflistet.

using IronPdf;
using System;
using System.Collections;
class pdfocde
{
    static void Main(string [] args)
    {
        IronPdf.License.LicenseKey = "License";
        // Create a new ArrayList and add some items
        ArrayList itemList = new ArrayList();
        itemList.Add("Apple");
        itemList.Add("Banana");
        itemList.Add("Cherry");
        itemList.Add("Date");
        // Initialize a new PDF document
        var Renderer = new ChromePdfRenderer();
        // Create an HTML string to hold our content
        string htmlContent = "<h1>Items List</h1><ul>";
        // Iterate over each item in the ArrayList and add it to the HTML string
        foreach (var item in itemList)
        {
            htmlContent += $"<li>{item}</li>";
        }
        htmlContent += "</ul>";
        // Convert the HTML string to a PDF document
        var PDF = Renderer.RenderHtmlAsPdf(htmlContent);
        // Save the PDF to a file
        PDF.SaveAs("e:\\ItemList.pdf");
        Console.WriteLine("PDF file 'ItemList.pdf' has been generated.");
    }
}
using IronPdf;
using System;
using System.Collections;
class pdfocde
{
    static void Main(string [] args)
    {
        IronPdf.License.LicenseKey = "License";
        // Create a new ArrayList and add some items
        ArrayList itemList = new ArrayList();
        itemList.Add("Apple");
        itemList.Add("Banana");
        itemList.Add("Cherry");
        itemList.Add("Date");
        // Initialize a new PDF document
        var Renderer = new ChromePdfRenderer();
        // Create an HTML string to hold our content
        string htmlContent = "<h1>Items List</h1><ul>";
        // Iterate over each item in the ArrayList and add it to the HTML string
        foreach (var item in itemList)
        {
            htmlContent += $"<li>{item}</li>";
        }
        htmlContent += "</ul>";
        // Convert the HTML string to a PDF document
        var PDF = Renderer.RenderHtmlAsPdf(htmlContent);
        // Save the PDF to a file
        PDF.SaveAs("e:\\ItemList.pdf");
        Console.WriteLine("PDF file 'ItemList.pdf' has been generated.");
    }
}
Imports IronPdf
Imports System
Imports System.Collections
Friend Class pdfocde
	Shared Sub Main(ByVal args() As String)
		IronPdf.License.LicenseKey = "License"
		' Create a new ArrayList and add some items
		Dim itemList As New ArrayList()
		itemList.Add("Apple")
		itemList.Add("Banana")
		itemList.Add("Cherry")
		itemList.Add("Date")
		' Initialize a new PDF document
		Dim Renderer = New ChromePdfRenderer()
		' Create an HTML string to hold our content
		Dim htmlContent As String = "<h1>Items List</h1><ul>"
		' Iterate over each item in the ArrayList and add it to the HTML string
		For Each item In itemList
			htmlContent &= $"<li>{item}</li>"
		Next item
		htmlContent &= "</ul>"
		' Convert the HTML string to a PDF document
		Dim PDF = Renderer.RenderHtmlAsPdf(htmlContent)
		' Save the PDF to a file
		PDF.SaveAs("e:\ItemList.pdf")
		Console.WriteLine("PDF file 'ItemList.pdf' has been generated.")
	End Sub
End Class
$vbLabelText   $csharpLabel

In diesem Beispiel beginnen wir mit der Erstellung einer ArrayList namens itemList und füllen diese mit mehreren Zeichenfolgen. Als Nächstes initialisieren wir eine neue Instanz der ChromePdfRenderer-Klasse von IronPDF, die wir verwenden werden, um HTML-Inhalte in ein PDF-Dokument umzuwandeln.

Ausgabe

Hier ist die von IronPDF erzeugte PDF-Ausgabe:

C# ArrayList (Wie es für Entwickler funktioniert): Abbildung 4 - PDF Ausgabe

Schlussfolgerung

C# ArrayList (Wie es für Entwickler funktioniert): Abbildung 5 - Lizenzierung

Die ArrayList ist eine leistungsstarke Sammlung, die von C# zum Speichern einer Liste von Objekten angeboten wird. Seine Fähigkeit, die Größe dynamisch anzupassen und Elemente jeder Art zu speichern, macht es vielseitig für eine breite Palette von Anwendungen. Aus Gründen der Typensicherheit und der besseren Leistung werden jedoch generische Sammlungen empfohlen. Das Experimentieren mit der ArrayList und ihren Methoden wird Ihnen helfen, deren Nutzen zu verstehen und wie sie in Ihre Anwendungen integriert werden kann.

Zusätzlich bietet IronPDF für diejenigen, die ihre C#-Fähigkeiten auf die PDF-Bearbeitung erweitern möchten, eine kostenlose Testversion für PDF-Funktionen in .NET an, um die Funktionen zu erkunden. Lizenzen beginnen ab $749 und bieten eine umfassende Lösung zur Integration von PDF-Funktionalität in .NET-Anwendungen.

Chipego
Chipego Kalinda
  Jetzt mit dem Ingenieurteam chatten
Software-Ingenieur
Chipego hat eine natürliche Fähigkeit zum Zuhören, die ihm hilft, Kundenprobleme zu verstehen und intelligente Lösungen anzubieten. Er trat dem Iron Software-Team 2023 bei, nachdem er einen Bachelor of Science in Informationstechnologie erworben hatte. IronPDF und IronOCR sind die beiden Produkte, auf die sich Chipego konzentriert hat, aber sein Wissen über alle Produkte wächst täglich, da er neue Wege findet, Kunden zu unterstützen. Er genießt die Zusammenarbeit bei Iron Software, da Teammitglieder aus dem gesamten Unternehmen ihre unterschiedlichen Erfahrungen einbringen und so zu effektiven, innovativen Lösungen beitragen. Wenn Chipego nicht an seinem Schreibtisch sitzt, kann man ihn oft bei einem guten Buch oder beim Fußballspielen antreffen.
< PREVIOUS
Math.Round C# (Wie es für Entwickler funktioniert)
NÄCHSTES >
C# Linter (Wie es für Entwickler funktioniert)

Ein Problem melden

Sind Sie bereit, loszulegen? Version: 2025.5 gerade veröffentlicht

Kostenloser Start
NuGet herunterladen DLL herunterladen Windows-Installationsprogramm Kostenlos testen
Lizenzen anzeigen >
Experience the full power of IronPDF Kostenlos testen
Textlogo Iron Suite related to C# ArrayList (Wie es funktioniert für Entwickler)

IronPDF ist ein Teil von IRONSUITE

10 .NET API-Produkte für Ihre Bürodokumente

Erhalten Sie 10 Produkte zum Preis von 2   Kostenlos testen