.NET-HILFE

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

Regan Pun

6. Juni 2024

Teilen Sie:

Einführung in die `IList`

iList" ist Teil des Collections-Namensraums des .NET-Frameworks. Es handelt sich um eine nicht-generische Sammlungsschnittstelle, die den Bauplan für eine Sammlung von Objekten liefert, auf die einzeln über ihren Index zugegriffen werden kann. Anders als bei Arrays,iListe ermöglicht eine dynamische Anzahl von Objektwertelementen, d. h. Sie können der Sammlung nach Bedarf Elemente hinzufügen oder entfernen. Sie dient als Basisschnittstelle für alle nicht-generischen Listen im .NET-Framework und bietet eine Möglichkeit, eine Sammlung von Objekten auf flexiblere Weise als Arrays zu verwalten. Wir werden etwas über die IList-Schnittstelle und dieIronPDF C# PDF-Bibliothek in diesem Lernprogramm.

Verstehen der `IList`-Schnittstelle

Die "public interface IList"-Deklaration ist ein grundlegender Bestandteil der Erstellung von benutzerdefinierten Sammlungen in C#, die den vom Collections-Namespace des .NET-Frameworks spezifizierten "IList"-Vertrag einhalten. iList" enthält Eigenschaften und Methoden, die es ermöglichen, auf Elemente in der Sammlung zuzugreifen, sie zu zählen und die Sammlung durch Hinzufügen, Einfügen oder Entfernen von Elementen zu ändern. Im Folgenden werden einige der wichtigsten Eigenschaften und Methoden der Schnittstelle "IList" beschrieben:

Eigenschaften wie "IsFixedSize" und "IsReadOnly" geben Auskunft darüber, ob die Sammlung eine feste Größe hat bzw. schreibgeschützt ist.
Methoden wie Add, void Insert, Remove und RemoveAt werden zur Änderung von Elementen innerhalb der Sammlung verwendet. Sie können Elemente hinzufügen, einfügen und entfernen.
Die "IndexOf"-Methode dient zum Auffinden von Elementen, und die "Item"-Eigenschaft(oder Indexer in C#) ermöglicht das Holen und Setzen von Elementen auf der Grundlage ihres Indexes.

Praktische Verwendung der öffentlichen Schnittstelle `IList`

Um zu zeigen, wie IList funktioniert, wollen wir ein einfaches Beispiel erstellen. Dieses allgemeine Beispiel zeigt, wie man eine IList deklariert, ihr Elemente hinzufügt und ihren Inhalt durchläuft.

Erstellen und Ändern einer `IListe`

Zunächst wollen wir uns ansehen, wie man eine IList deklariert und ihr Elemente hinzufügt:

using System;
using System.Collections;
class Program
{
    void Main(string[] args)
    {
        // Creating an IList instance
        IList myIList = new ArrayList();
        // Adding elements to the IList
        myIList.Add("Hello");
        myIList.Add(10);
        myIList.Add(new object());
        // Displaying the number of values in the IList interface using count property
        Console.WriteLine($"Number of elements: {myIList.Count}");
        // Access Elements
        foreach (var element in myIList)
        {
            Console.WriteLine(element);
        }
    }
}

using System;
using System.Collections;
class Program
{
    void Main(string[] args)
    {
        // Creating an IList instance
        IList myIList = new ArrayList();
        // Adding elements to the IList
        myIList.Add("Hello");
        myIList.Add(10);
        myIList.Add(new object());
        // Displaying the number of values in the IList interface using count property
        Console.WriteLine($"Number of elements: {myIList.Count}");
        // Access Elements
        foreach (var element in myIList)
        {
            Console.WriteLine(element);
        }
    }
}

Imports System
Imports System.Collections
Friend Class Program
	Private Sub Main(ByVal args() As String)
		' Creating an IList instance
		Dim myIList As IList = New ArrayList()
		' Adding elements to the IList
		myIList.Add("Hello")
		myIList.Add(10)
		myIList.Add(New Object())
		' Displaying the number of values in the IList interface using count property
		Console.WriteLine($"Number of elements: {myIList.Count}")
		' Access Elements
		For Each element In myIList
			Console.WriteLine(element)
		Next element
	End Sub
End Class

Im obigen Beispiel haben wir eine Instanz von IList mit Hilfe von ArrayList erstellt, einer Klasse, die IList implementiert. Wir haben eine Mischung aus verschiedenen Objekttypen hinzugefügt, um zu zeigen, dass eine IList jedes Objekt enthalten kann. Schließlich haben wir die Sammlung durchlaufen und jedes Element ausgedruckt.

Indexbasierter Zugriff und Modifikation

Der Zugriff auf und die Änderung von Elementen anhand ihres Indexes ist ein Hauptmerkmal von IList. Das folgende `IList'-Beispiel zeigt, wie Sie das machen können:

// Accessing an element by index
object value = myIList[1];
Console.WriteLine($"Element at index 1: {value}");
// Modifying an element by index
myIList[1] = 20;
Console.WriteLine($"Modified element at index 1: {myIList[1]}");

// Accessing an element by index
object value = myIList[1];
Console.WriteLine($"Element at index 1: {value}");
// Modifying an element by index
myIList[1] = 20;
Console.WriteLine($"Modified element at index 1: {myIList[1]}");

' Accessing an element by index
Dim value As Object = myIList(1)
Console.WriteLine($"Element at index 1: {value}")
' Modifying an element by index
myIList(1) = 20
Console.WriteLine($"Modified element at index 1: {myIList(1)}")

Implementierung einer benutzerdefinierten `IList`

Manchmal braucht man vielleicht eine maßgeschneiderte Sammlung, die IList erbt. Dies ermöglicht eine bessere Kontrolle darüber, wie Elemente gespeichert, aufgerufen und geändert werden. Nachstehend ein Beispiel für eine einfache benutzerdefinierte Sammlung, die IList implementiert:

public class CustomCollection : IList
{
    private ArrayList _innerList = new ArrayList();
    public object this[int index] { get => _innerList[index]; set => _innerList[index] = value; }
    public bool IsFixedSize => _innerList.IsFixedSize;
    public bool IsReadOnly => _innerList.IsReadOnly;
    public int Count => _innerList.Count;
    public bool IsSynchronized => _innerList.IsSynchronized;
    public object SyncRoot => _innerList.SyncRoot;
// int add
    public int Add(object value)
    {
        return _innerList.Add(value);
    }
    public void Clear()
    {
        _innerList.Clear();
    }
    public bool Contains(object value)
    {
        return _innerList.Contains(value);
    }
    public int IndexOf(object value)
    {
        return _innerList.IndexOf(value);
    }
    public void Insert(int index, object value)
    {
        _innerList.Insert(index, value);
    }
    public void Remove(object value)
    {
        _innerList.Remove(value);
    }
    public void RemoveAt(int index)
    {
        _innerList.RemoveAt(index);
    }
    public void CopyTo(Array array, int index)
    {
        _innerList.CopyTo(array, index);
    }
    public IEnumerator GetEnumerator()
    {
        return _innerList.GetEnumerator();
    }
}

public class CustomCollection : IList
{
    private ArrayList _innerList = new ArrayList();
    public object this[int index] { get => _innerList[index]; set => _innerList[index] = value; }
    public bool IsFixedSize => _innerList.IsFixedSize;
    public bool IsReadOnly => _innerList.IsReadOnly;
    public int Count => _innerList.Count;
    public bool IsSynchronized => _innerList.IsSynchronized;
    public object SyncRoot => _innerList.SyncRoot;
// int add
    public int Add(object value)
    {
        return _innerList.Add(value);
    }
    public void Clear()
    {
        _innerList.Clear();
    }
    public bool Contains(object value)
    {
        return _innerList.Contains(value);
    }
    public int IndexOf(object value)
    {
        return _innerList.IndexOf(value);
    }
    public void Insert(int index, object value)
    {
        _innerList.Insert(index, value);
    }
    public void Remove(object value)
    {
        _innerList.Remove(value);
    }
    public void RemoveAt(int index)
    {
        _innerList.RemoveAt(index);
    }
    public void CopyTo(Array array, int index)
    {
        _innerList.CopyTo(array, index);
    }
    public IEnumerator GetEnumerator()
    {
        return _innerList.GetEnumerator();
    }
}

Public Class CustomCollection
	Implements IList

	Private _innerList As New ArrayList()
	Default Public Property Item(ByVal index As Integer) As Object Implements IList.Item
		Get
			Return _innerList(index)
		End Get
		Set(ByVal value As Object)
			_innerList(index) = value
		End Set
	End Property
	Public ReadOnly Property IsFixedSize() As Boolean Implements IList.IsFixedSize
		Get
			Return _innerList.IsFixedSize
		End Get
	End Property
	Public ReadOnly Property IsReadOnly() As Boolean Implements IList.IsReadOnly
		Get
			Return _innerList.IsReadOnly
		End Get
	End Property
	Public ReadOnly Property Count() As Integer Implements System.Collections.ICollection.Count
		Get
			Return _innerList.Count
		End Get
	End Property
	Public ReadOnly Property IsSynchronized() As Boolean Implements System.Collections.ICollection.IsSynchronized
		Get
			Return _innerList.IsSynchronized
		End Get
	End Property
	Public ReadOnly Property SyncRoot() As Object Implements System.Collections.ICollection.SyncRoot
		Get
			Return _innerList.SyncRoot
		End Get
	End Property
' int add
	Public Function Add(ByVal value As Object) As Integer Implements IList.Add
		Return _innerList.Add(value)
	End Function
	Public Sub Clear() Implements IList.Clear
		_innerList.Clear()
	End Sub
	Public Function Contains(ByVal value As Object) As Boolean Implements IList.Contains
		Return _innerList.Contains(value)
	End Function
	Public Function IndexOf(ByVal value As Object) As Integer Implements IList.IndexOf
		Return _innerList.IndexOf(value)
	End Function
	Public Sub Insert(ByVal index As Integer, ByVal value As Object) Implements IList.Insert
		_innerList.Insert(index, value)
	End Sub
	Public Sub Remove(ByVal value As Object) Implements IList.Remove
		_innerList.Remove(value)
	End Sub
	Public Sub RemoveAt(ByVal index As Integer) Implements IList.RemoveAt
		_innerList.RemoveAt(index)
	End Sub
	Public Sub CopyTo(ByVal array As Array, ByVal index As Integer) Implements System.Collections.ICollection.CopyTo
		_innerList.CopyTo(array, index)
	End Sub
	Public Function GetEnumerator() As IEnumerator Implements System.Collections.IEnumerable.GetEnumerator
		Return _innerList.GetEnumerator()
	End Function
End Class

Diese Klasse "CustomCollection" kapselt eine "ArrayList", eine Klasse, die ihrerseits "IList" implementiert. Unsere CustomCollection leitet Aufrufe an die zugrundeliegende ArrayList weiter, so dass sie sich wie jede andere Sammlung, die IList implementiert, verhalten kann. Dieses Beispiel zeigt, wie eine Sammlung erstellt wird, auf die über einen Index zugegriffen werden kann und die geändert wird(hinzugefügte, eingefügte oder entfernte Elemente)und wie jede integrierte .NET-Sammlung, die IList implementiert, durchlaufen werden.

Erweiterte Operationen mit `IList`

Neben den grundlegenden Operationen zum Hinzufügen, Entfernen und Zugreifen ermöglicht IList auch komplexere Manipulationen und Abfragen. Die Überprüfung, ob die Sammlung ein bestimmtes Objekt enthält, oder die Suche nach dem Index eines Objekts innerhalb der Sammlung sind beispielsweise Operationen, die für bestimmte Anwendungen unerlässlich sein können:

// Check if the IList contains a specific object
bool contains = myIList.Contains(10); // Assuming 10 was added previously
Console.WriteLine($"Contains 10: {contains}");
// Find the index of a specific object
int index = myIList.IndexOf(10);
Console.WriteLine($"Index of 10: {index}");

// Check if the IList contains a specific object
bool contains = myIList.Contains(10); // Assuming 10 was added previously
Console.WriteLine($"Contains 10: {contains}");
// Find the index of a specific object
int index = myIList.IndexOf(10);
Console.WriteLine($"Index of 10: {index}");

' Check if the IList contains a specific object
Dim contains As Boolean = myIList.Contains(10) ' Assuming 10 was added previously
Console.WriteLine($"Contains 10: {contains}")
' Find the index of a specific object
Dim index As Integer = myIList.IndexOf(10)
Console.WriteLine($"Index of 10: {index}")

Diese Operationen können besonders nützlich sein, wenn es um Sammlungen von Objekten geht, bei denen Sie das Vorhandensein oder die Position bestimmter Elemente feststellen müssen, ohne die gesamte Sammlung zu durchlaufen.

IronPDF: C# PDF-Bibliothek

C# iList(Wie es für Entwickler funktioniert): Abbildung 1 - IronPDF

IronPDF ist eine PDF-Bibliothek für .NET-Entwickler, die die Erstellung und Bearbeitung von PDF-Dokumenten direkt in .NET-Anwendungen ermöglicht. Es unterstützt die KonvertierungHTML in PDF-Dokumentebilder und Webseiten in PDF. Mit dieser Bibliothek können Entwickler ihren Anwendungen problemlos PDF-Funktionen hinzufügen. IronPDF enthält auch Funktionen zum Bearbeiten, Zusammenführen und Aufteilen von PDF-Dateien, die eine umfassende Kontrolle über die PDF-Bearbeitung ermöglichen.

IronPDF zeichnet sich aus durchHTML zu PDFKonvertierung, die eine präzise Wahrung der ursprünglichen Layouts und Stile sicherstellt. Es ist perfekt geeignet, um PDFs aus webbasierten Inhalten wie Berichten, Rechnungen und Dokumentationen zu erstellen. Mit Unterstützung von HTML-Dateien, URLs und rohen HTML-Zeichenfolgen produziert IronPDF mühelos hochwertige PDF-Dokumente.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class

Code-Beispiel

Hier ist ein einfaches Beispiel, das die Erzeugung eines einfachen PDF-Dokuments aus einer Liste von Strings mit IronPDF und der IList-Schnittstelle demonstriert:

using IronPdf;
using System.Collections.Generic;
public class PDFGenerator
{
    public static void GeneratePDFFromList(IList<string> dataList)
    {
        // Initialize the HtmlToPdf renderer
        var renderer = new ChromePdfRenderer();
        // Start building HTML content from the dataList
        var htmlContent = "<h1>My Data List</h1><ul>";
        foreach (var item in dataList)
        {
            htmlContent += $"<li>{item}</li>";
        }
        htmlContent += "</ul>";
        // Convert HTML string to PDF
        var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);
        // Save the PDF to a file
        pdfDocument.SaveAs("DataList.pdf");
    }
}
// Example usage
class Program
{
    static void Main(string[] args)
    {
        License.LicenseKey = "License-Key";
        IList<string> myDataList = new List<string> { "Apple", "Banana", "Cherry" };
        PDFGenerator.GeneratePDFFromList(myDataList);
    }
}

using IronPdf;
using System.Collections.Generic;
public class PDFGenerator
{
    public static void GeneratePDFFromList(IList<string> dataList)
    {
        // Initialize the HtmlToPdf renderer
        var renderer = new ChromePdfRenderer();
        // Start building HTML content from the dataList
        var htmlContent = "<h1>My Data List</h1><ul>";
        foreach (var item in dataList)
        {
            htmlContent += $"<li>{item}</li>";
        }
        htmlContent += "</ul>";
        // Convert HTML string to PDF
        var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);
        // Save the PDF to a file
        pdfDocument.SaveAs("DataList.pdf");
    }
}
// Example usage
class Program
{
    static void Main(string[] args)
    {
        License.LicenseKey = "License-Key";
        IList<string> myDataList = new List<string> { "Apple", "Banana", "Cherry" };
        PDFGenerator.GeneratePDFFromList(myDataList);
    }
}

Imports IronPdf
Imports System.Collections.Generic
Public Class PDFGenerator
	Public Shared Sub GeneratePDFFromList(ByVal dataList As IList(Of String))
		' Initialize the HtmlToPdf renderer
		Dim renderer = New ChromePdfRenderer()
		' Start building HTML content from the dataList
		Dim htmlContent = "<h1>My Data List</h1><ul>"
		For Each item In dataList
			htmlContent &= $"<li>{item}</li>"
		Next item
		htmlContent &= "</ul>"
		' Convert HTML string to PDF
		Dim pdfDocument = renderer.RenderHtmlAsPdf(htmlContent)
		' Save the PDF to a file
		pdfDocument.SaveAs("DataList.pdf")
	End Sub
End Class
' Example usage
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		License.LicenseKey = "License-Key"
		Dim myDataList As IList(Of String) = New List(Of String) From {"Apple", "Banana", "Cherry"}
		PDFGenerator.GeneratePDFFromList(myDataList)
	End Sub
End Class

In diesem Beispiel wird eine IList<string> wird verwendet, um eine Sammlung von Obstnamen zu speichern. Die Methode GeneratePDFFromList iteriert dann über diese Liste und erstellt eine HTML-Zeichenkette, die jedes Element in einer ungeordneten Liste enthält. Der ChromePdfRenderer von IronPDF wandelt diesen HTML-Inhalt in ein PDF-Dokument um, das anschließend in einer Datei gespeichert wird.

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

Schlussfolgerung

C# iList(So funktioniert es für Entwickler): Abbildung 3 - Lizenzierung

Dieser einsteigerfreundliche Leitfaden soll die Grundlagen und die praktische Anwendung von IList in C# behandeln. Anhand von Beispielen, die von der einfachen Verwendung bis zur benutzerdefinierten Implementierung reichen, wird deutlich, dass IList ein leistungsfähiges Werkzeug im Werkzeugkasten des C#-Entwicklers ist. Egal, ob Sie Datensammlungen bearbeiten oder Ihre Sammlungstypen erstellen, IList bietet die Funktionalität und Flexibilität, die Sie für eine effektive Softwareentwicklung benötigen. IronPDF bietet einekostenlose Testversion der PDF-Bibliothek für interessierte Benutzer, wobei Lizenzen ab $749 erhältlich sind.

Regan Pun

Jetzt mit dem Ingenieurteam chatten

Software-Ingenieur

Regan schloss sein Studium an der University of Reading mit einem BA in Elektrotechnik ab. Bevor er zu Iron Software kam, konzentrierte er sich in seinen früheren Jobs auf einzelne Aufgaben. Was ihm bei Iron Software am meisten Spaß macht, ist das Spektrum der Aufgaben, die er übernehmen kann, sei es im Vertrieb, im technischen Support, in der Produktentwicklung oder im Marketing. Es macht ihm Spaß, die Art und Weise zu verstehen, wie Entwickler die Bibliothek von Iron Software nutzen, und dieses Wissen zu nutzen, um die Dokumentation und die Produkte kontinuierlich zu verbessern.

< PREVIOUS
C# Linked List (Wie es funktioniert für Entwickler)

NÄCHSTES >
Polly Retry (Wie es für Entwickler funktioniert)