IListIList ist Teil des .NET Framework's Collections-Namespace. Es ist ein nicht-generisches Sammlungs-Interface, das den Bauplan für eine Sammlung von Objekten bereitstellt, auf die einzeln über ihren Index zugegriffen werden kann. Im Gegensatz zu Arrays erlaubt IList eine dynamische Anzahl von Objektelementen, das bedeutet, Sie können Elemente der Sammlung nach Bedarf hinzufügen oder entfernen. Es dient als Basisinterface für alle nicht-generischen Listen im .NET Framework und bietet eine flexiblere Möglichkeit zur Verwaltung einer Sammlung von Objekten als Arrays. In diesem Tutorial werden wir mehr über das IList-Interface und die IronPDF C# PDF-Bibliothek lernen.
IList-InterfaceDie public interface IList-Deklaration ist ein grundlegender Bestandteil bei der Erstellung benutzerdefinierter Sammlungen in C#, die dem von .NET Framework's Collections-Namespace festgelegten IList-Vertrag entsprechen. IList umfasst Eigenschaften und Methoden, die den Zugriff auf Elemente in der Sammlung, das Zählen dieser sowie die Modifikation der Sammlung durch Hinzufügen, Einfügen oder Entfernen von Elementen ermöglichen. Hier sind einige der wichtigsten Eigenschaften und Methoden, die im IList-Interface definiert sind:
IsFixedSize und IsReadOnly geben an, ob die Sammlung eine feste Größe hat oder schreibgeschützt ist.Add, Insert, Remove und RemoveAt werden zur Modifikation der Elemente innerhalb der Sammlung verwendet. Sie können Elemente hinzufügen, einfügen und entfernen.IndexOf-Methode dient zum Auffinden von Elementen und die Item-Eigenschaft (oder Indexer in C#) ermöglicht das Abrufen und Festlegen von Elementen basierend auf ihrem Index.IList-InterfaceUm zu zeigen, wie IList funktioniert, erstellen wir ein einfaches Beispiel. Dieses Beispiel zeigt, wie man ein IList deklariert, Elemente hinzufügt und über seine Inhalte iteriert.
IListZuerst sehen wir, wie man ein IList deklariert und Elemente hinzufügt:
using System;
using System.Collections;
class Program
{
static 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 using the Count property
Console.WriteLine($"Number of elements: {myIList.Count}");
// Accessing elements using a loop
foreach (var element in myIList)
{
Console.WriteLine(element);
}
}
}Imports System
Imports System.Collections
Friend Class Program
Shared 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 using the Count property
Console.WriteLine($"Number of elements: {myIList.Count}")
' Accessing elements using a loop
For Each element In myIList
Console.WriteLine(element)
Next element
End Sub
End ClassIm obigen Beispiel haben wir eine IList-Instanz mit ArrayList erstellt, einer Klasse, die IList implementiert. Wir haben eine Mischung aus verschiedenen Objekttypen hinzugefügt, um zu zeigen, dass ein IList jedes Objekt enthalten kann. Schließlich haben wir über die Sammlung iteriert und jedes Element ausgegeben.
Das Zugreifen und Modifizieren von Elementen über ihren Index ist ein wichtiges Merkmal von IList. Das folgende Beispiel zeigt, wie Sie das tun können:
using System;
using System.Collections;
class Program
{
static void Main(string[] args)
{
IList myIList = new ArrayList { "Hello", 10, new object() };
// 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]}");
}
}Imports System
Imports System.Collections
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim myIList As IList = New ArrayList From { "Hello", 10, New Object() }
' 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)}")
End Sub
End ClassIListManchmal benötigen Sie eine maßgeschneiderte Sammlung, die IList erbt. Dies erlaubt mehr Kontrolle darüber, wie Elemente gespeichert, darauf zugegriffen und modifiziert werden. Unten ist ein Beispiel für eine einfache benutzerdefinierte Sammlung, die IList implementiert:
using System;
using System.Collections;
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;
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();
}
}Imports System
Imports System.Collections
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
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 ClassDiese CustomCollection-Klasse kapselt eine ArrayList, eine Klasse, die selbst IList implementiert. Unser CustomCollection leitet Aufrufe an die zugrunde liegende ArrayList weiter, sodass sie sich wie jede andere Sammlung verhält, die IList implementiert. Dieses Beispiel zeigt die Erstellung einer Sammlung, die nach Index zugegriffen, modifiziert (Elemente hinzugefügt, eingefügt oder entfernt) und durchlaufen werden kann, genau wie jede eingebaute .NET-Sammlung, die IList implementiert.
IListÜber grundlegende Add-, Remove- und Zugriffsoperationen hinaus ermöglicht IList komplexere Manipulationen und Abfragen. Beispielsweise kann das Überprüfen, ob die Sammlung ein bestimmtes Objekt enthält oder der Index eines Objekts innerhalb der Sammlung gefunden werden, wesentliche Vorgänge für bestimmte Anwendungen sein:
using System;
using System.Collections;
class Program
{
static void Main(string[] args)
{
IList myIList = new ArrayList { "Hello", 10, new object() };
// 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}");
}
}Imports System
Imports System.Collections
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim myIList As IList = New ArrayList From { "Hello", 10, New Object() }
' 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}")
End Sub
End ClassDiese Operationen können besonders nützlich sein, wenn man mit Sammlungen von Objekten arbeitet, bei denen die Anwesenheit oder Position bestimmter Elemente bestimmt werden muss, ohne über die gesamte Sammlung zu iterieren.
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 Umwandlung von HTML in PDF-Dokumente, Bilder und Webseiten zu PDF. Entwickler können mit dieser Bibliothek einfach PDF-Funktionalitäten zu ihren Anwendungen hinzufügen. IronPDF enthält auch Funktionen zum Bearbeiten, Zusammenführen und Teilen von PDF-Dateien, die eine umfassende Kontrolle über die PDF-Bearbeitung bieten.
IronPDF überzeugt in der HTML-zu-PDF-Konvertierung, indem es den originalen Layouts und Stilen präzise erhält. Es ist ideal zur Erstellung von PDFs aus webbasierten Inhalten wie Berichten, Rechnungen und Dokumentationen. Mit Unterstützung für HTML-Dateien, URLs und rohe HTML-Strings erstellt IronPDF problemlos 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");
}
}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 ClassHier ist ein einfaches Beispiel, das die Erstellung eines einfachen PDF-Dokuments aus einer Liste von Zeichenfolgen unter Verwendung von IronPDF und dem IList-Interface 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);
}
}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 ClassIn diesem Beispiel wird ein IList<string> verwendet, um eine Sammlung von Objekenteilnahmen zu speichern. Die GeneratePDFFromList-Methode durchläuft dann diese Liste und erstellt einen HTML-String, der jedes Element in einer ungeordneten Liste enthält. IronPDF's ChromePdfRenderer konvertiert diesen HTML-Inhalt in ein PDF-Dokument, das anschließend in einer Datei gespeichert wird.
Dieser anfängerfreundliche Leitfaden zielte darauf ab, die Grundlagen und praktischen Anwendungen von IList in C# abzudecken. Mit Beispielen von einfacher Nutzung bis hin zu benutzerdefinierter Implementierung ist klar, dass IList ein mächtiges Werkzeug im Werkzeugkasten eines C#-Entwicklers ist. Egal, ob Sie Datensammlungen manipulieren oder Ihre eigenen Sammlungstypen erstellen, IList bietet die Funktionalität und Flexibilität, die für eine effektive Softwareentwicklung benötigt werden. IronPDF bietet eine kostenlose Testversion seiner PDF-Bibliothek für interessierte Benutzer an, mit Lizenzen, die ab $999 verfügbar sind.
Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO Cameron Rimington in ein Unternehmen mit mehr als 50 Mitarbeitern verwandelt, das die NASA, Tesla und globale Regierungsbehörden beliefert.
IronPDF ist ein Teil der IRONSUITE
10 .NET-API-Produkte für Ihre Bürodokumente
Wenn Ihr PDF wie HTML aussehen soll, schnell.
