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

Die Klasse ArrayList gehört zum Namespace für Sammlungen des .NET-Frameworks und dient zum Speichern einer Sammlung von Objekten. 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 werden wir über die Grundlagen von ArrayList und IronPDF bibliothek.

Die Grundlagen von ArrayList

Die ArrayList ist im Wesentlichen eine nicht-generische Sammlung, die in der Lage ist, eine Reihe von Elementen eines beliebigen Datentyps 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, was durch die Implementierung der IList-Schnittstelle 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, das einen Objektwert an das Ende der Sammlung anhängt, und Insert, das ein neues Element an einem bestimmten Index platziert und vorhandene Elemente nach Bedarf verschiebt, um Platz zu schaffen, sehr 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 zum Beispiel ein Szenario, in dem Sie eine Sammlung verschiedener Datentypen erstellen. Mit der Methode Add können Sie jedes beliebige Objekt an Ihre ArrayList anhängen, von Zeichenketten über Ganzzahlen 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 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. In ähnlicher Weise erleichtern die Methoden Remove und RemoveAt das Löschen von Elementen, indem sie entweder das zu entfernende Objekt oder seinen Index innerhalb der Sammlung angeben. Diese granulare Kontrolle über die Elemente innerhalb der ArrayList macht sie zu einem leistungsstarken Werkzeug für die Verwaltung dynamischer Daten.

Erstellen und Hinzufügen von Elementen

Um eine ArrayList zu verwenden, müssen Sie zunächst eine Instanz dieser Liste erstellen. Anschließend können Sie der ArrayList Elemente hinzufügen, indem Sie die Methode Add verwenden, 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

Dieses Beispiel zeigt, wie man eine neue ArrayList erstellt und ihr 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")

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 mit dem 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

Beispiel: Verwaltung einer ArrayList

Bei der Erstellung eines fortgeschrittenen Beispiels für die Verwendung von ArrayList in C# werden nicht nur die grundlegenden Operationen wie das Hinzufügen oder Entfernen von Elementen gezeigt, sondern auch komplexere Manipulationen wie das Sortieren, Suchen und Konvertieren von 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

Dieser Codeschnipsel zeigt, wie das geht:

• Initialisieren einer ArrayList mit einer Menge von Elementen.
• Hinzufügen einzelner und mehrerer Elemente zur ArrayList.
• Elemente nach Wert und nach Index entfernen.
• Sortieren Sie die ArrayList, um die Elemente zu ordnen.
• Suchen Sie nach einem Element und finden Sie seinen Index.
• Konvertiert die ArrayList in ein Standard-Array.

• Verwenden Sie LINQ mit ArrayList, um gerade Zahlen herauszufiltern, und zeigen Sie, wie Sie nicht-generische Sammlungen mit den leistungsstarken Abfragefunktionen von LINQ verbinden können.

  

Einführung von IronPDF: C# PDF-Bibliothek

IronPDF ist eine leistungsstarke Bibliothek für C#, die den komplexen Prozess der PDF-Erzeugung vereinfacht und eine breite Palette von Funktionen für die PDF-Bearbeitung bietet, einschließlich der Fähigkeit, PDF zu erzeugen PDFs aus HTMLsie können Texte und Bilder hinzufügen, Dokumente 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 mit diesen Elementen zu erzeugen.

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

In diesem Beispiel erstellen wir zunächst eine ArrayList mit dem Namen itemList und füllen sie mit mehreren Zeichenkettenelementen. Als Nächstes initialisieren wir eine neue Instanz der Klasse ChromePdfRenderer von IronPDF, mit der wir den HTML-Inhalt in ein PDF-Dokument umwandeln werden.

Ausgabe

Hier ist die von IronPDF erzeugte PDF-Ausgabe:

Schlussfolgerung

Die ArrayList ist eine leistungsfähige Sammlung, die C# zum Speichern einer Liste von Objekten anbietet. 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 ArrayList und seinen Methoden wird Ihnen helfen, seine Verwendungszwecke zu verstehen und herauszufinden, wie es in Ihre Anwendungen passen kann.

Für diejenigen, die ihre C#-Fähigkeiten auf die PDF-Bearbeitung ausdehnen möchten, bietet IronPDF außerdem ein kostenloser Test um seine Funktionen zu erkunden. Die Lizenzen beginnen bei $749 und bieten eine umfassende Lösung für die Integration von PDF-Funktionen in .NET-Anwendungen.