Wie kann ich den Index von Elementen in einer C# foreach-Schleife verfolgen?

Um den Index in einer C# foreach-Schleife zu verfolgen, können Sie eine separate Indexvariable manuell inkrementieren, die Select -Methode von LINQ verwenden, um Elemente mit ihrem Index zu projizieren, oder einen benutzerdefinierten Iterator erstellen, der sowohl das Element als auch seinen Index liefert.

Was ist die LINQ Select-Methode und wie hilft sie beim Indexieren?

Die LINQ Select -Methode kann jedes Element in einer Sammlung in eine neue Form transformieren, die den Index des Elements enthält. Diese Projektion ermöglicht den Zugriff auf sowohl das Element als auch seinen Index während der Iteration in einer foreach-Schleife.

Wie erstelle ich einen benutzerdefinierten Iterator in C#?

Ein benutzerdefinierter Iterator in C# kann unter Verwendung des yield return -Schlüsselworts erstellt werden. Dies ermöglicht es, eine Methode zu erstellen, die über eine Sammlung iteriert und sowohl das aktuelle Element als auch seinen Index liefert, was die Schleifenindexierung vereinfacht.

Kann eine PDF-Bibliothek bei der Erstellung von indiziertem Inhalt in C# helfen?

Ja, eine PDF-Bibliothek wie IronPDF kann zusammen mit einer C# foreach-Schleife verwendet werden, um über Datensammlungen zu iterieren und indizierten Inhalt in ein PDF einzufügen. Dieser Ansatz ermöglicht dynamische Inhaltspositionierung und präzise Indexierung.

Wie iterieren Sie über ein Wörterbuch mit einer foreach-Schleife in C#?

In C# kann eine foreach-Schleife über ein Wörterbuch iterieren, indem auf jedes Schlüssel-Wert-Paar zugegriffen wird. Dies ermöglicht es Entwicklern, direkt mit den Schlüsseln und Werten während des Iterationsprozesses zu arbeiten.

Was sind die Vorteile der Verwendung von PDF-Bibliotheken in der C#-Entwicklung?

PDF-Bibliotheken ermöglichen es Entwicklern, PDFs aus HTML zu erstellen und verschiedene PDF-Manipulationen in C# durchzuführen. Sie bieten in der Regel kostenlose Testversionen an, um Funktionen zu erkunden, mit Lizenzen, die zum Kauf erhältlich sind.

Wie kann die while-Schleife für indizierte Iterationen in C# verwendet werden?

Eine while-Schleife kann mit einer Indexvariable verwendet werden, um über Sammlungen in C# zu iterieren, wobei sowohl der Index als auch das aktuelle Element durch Nutzung des Index als Subskript zugänglich sind.

How can IronPDF be utilized with a foreach loop and indexing?

IronPDF can be combined with a foreach loop and index to dynamically insert indexed data items into a PDF, managing layout and custom logic.

What are the licensing options available for IronPDF?

IronPDF offers a free trial to explore its features, and licenses are available starting from a lite license option.

Die C# PDF-Bibliothek

Explore IronPDF Gratis testen

HTML zu PDF

Online Demo Alle Codebeispiele anzeigen

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >Install-Package IronPdf

Install-Package IronPdf

ENTWICKLER-UPDATES

C# foreach mit Index (Wie es funktioniert)

Jacob Mellor

Updated: 21. April 2026

In C#, die foreach-Anweisung wird typischerweise verwendet, um über Sammlungen wie Arrays, Listen oder anderen aufzählbaren Typen zu iterieren. Allerdings bietet die foreach-Schleife keine integrierte Indexvariable, um die aktuelle Iteration zu verfolgen. Entwickler müssen oft auf den Index des aktuellen Elements zugreifen. Unten werden wir verschiedene Wege erkunden, um diese Funktionalität zu implementieren und die IronPDF-Bibliothek.

Die Grundlagen der foreach-Schleife

Die foreach-Schleife ist dazu ausgelegt, das Iterieren durch Arrays, Listen, Wörterbücher und andere Typen, die IEnumerable implementieren, zu vereinfachen. Hier ist ein einfaches Beispiel dafür, wie man eine foreach-Anweisung verwendet, um durch ein Array des Datentyps Integer zu iterieren:

int[] numbers = { 10, 20, 30, 40 };
foreach (int number in numbers)
{
    Console.WriteLine(number);
}

int[] numbers = { 10, 20, 30, 40 };
foreach (int number in numbers)
{
    Console.WriteLine(number);
}

Dim numbers() As Integer = { 10, 20, 30, 40 }
For Each number As Integer In numbers
	Console.WriteLine(number)
Next number

Dim numbers() As Integer = { 10, 20, 30, 40 }
For Each number As Integer In numbers
	Console.WriteLine(number)
Next number

In diesem Beispiel steht number für das Element der Sammlung während jeder Iteration. Die Schleife iteriert automatisch durch alle Elemente im Array. Es gibt jedoch keinen integrierten Weg, um auf den Index des aktuellen Elements zuzugreifen.

Behandlung des Index in einer foreach-Schleife

Obwohl C# den Index in einer foreach-Schleife nicht direkt bereitstellt, können mehrere Techniken dies lösen. Lassen Sie uns diese Methoden im Detail besprechen.

Methode 1: Verwendung einer separaten Variable

Eine der einfachsten Möglichkeiten, den Index des aktuellen Elements zu erhalten, besteht darin, eine externe Indexvariable zu verwenden. Sie müssen sie manuell innerhalb der Schleife inkrementieren:

int[] numbers = { 10, 20, 30, 40 };
int numberIndex = 0;
foreach (int number in numbers)
{
    Console.WriteLine($"Index: {numberIndex}, Value: {number}");
    numberIndex++;
}

int[] numbers = { 10, 20, 30, 40 };
int numberIndex = 0;
foreach (int number in numbers)
{
    Console.WriteLine($"Index: {numberIndex}, Value: {number}");
    numberIndex++;
}

Dim numbers() As Integer = { 10, 20, 30, 40 }
Dim numberIndex As Integer = 0
For Each number As Integer In numbers
	Console.WriteLine($"Index: {numberIndex}, Value: {number}")
	numberIndex += 1
Next number

Dim numbers() As Integer = { 10, 20, 30, 40 }
Dim numberIndex As Integer = 0
For Each number As Integer In numbers
	Console.WriteLine($"Index: {numberIndex}, Value: {number}")
	numberIndex += 1
Next number

In diesem Code wird die Indexvariable vor dem Start der Schleife initialisiert und dann innerhalb der Schleife bei jeder Iteration inkrementiert. Während dieser Ansatz funktioniert, erfordert er die manuelle Pflege des Index, was nicht immer ideal ist.

Methode 2: Verwendung der Select-Methode von LINQ

Mit der Select-Methode von LINQ können Sie jedes Element einer Sammlung in eine neue Form projizieren, einschließlich seines Indexes. Hier ist ein Beispiel:

int[] numbers = { 10, 20, 30, 40 };
foreach (var item in numbers.Select((value, index) => new { value, index }))
{
    Console.WriteLine($"Index: {item.index}, Value: {item.value}");
}

int[] numbers = { 10, 20, 30, 40 };
foreach (var item in numbers.Select((value, index) => new { value, index }))
{
    Console.WriteLine($"Index: {item.index}, Value: {item.value}");
}

Dim numbers() As Integer = { 10, 20, 30, 40 }
For Each item In numbers.Select(Function(value, index) New With {
	Key value,
	Key index
})
	Console.WriteLine($"Index: {item.index}, Value: {item.value}")
Next item

Dim numbers() As Integer = { 10, 20, 30, 40 }
For Each item In numbers.Select(Function(value, index) New With {
	Key value,
	Key index
})
	Console.WriteLine($"Index: {item.index}, Value: {item.value}")
Next item

In diesem Beispiel erstellt Select ein anonymes Objekt, das sowohl den Wert des aktuellen Elements als auch seinen Index enthält. Die foreach-Schleife kann dann über diese Objekte iterieren und sowohl auf den Index als auch den Wert direkt zugreifen.

Methode 3: Verwendung eines benutzerdefinierten Iterators

Sie können eine benutzerdefinierte Iteratorerweiterungsmethode mit dem Schlüsselwort yield return implementieren, um eine Methode zu erzeugen, die sowohl das aktuelle Element als auch seinen Index ergibt. Dies ist etwas fortgeschrittener, bietet aber eine flexible Lösung.

public static IEnumerable<(int index, T value)> WithIndex<t>(this IEnumerable<t> source)
{
    int index = 0;
    foreach (T value in source)
    {
        yield return (index, value);
        index++;
    }
}

public static IEnumerable<(int index, T value)> WithIndex<t>(this IEnumerable<t> source)
{
    int index = 0;
    foreach (T value in source)
    {
        yield return (index, value);
        index++;
    }
}

Imports System.Collections.Generic

Public Module Extensions
    <System.Runtime.CompilerServices.Extension> 
    Public Iterator Function WithIndex(Of T)(source As IEnumerable(Of T)) As IEnumerable(Of (index As Integer, value As T))
        Dim index As Integer = 0
        For Each value As T In source
            Yield (index, value)
            index += 1
        Next
    End Function
End Module

Imports System.Collections.Generic

Public Module Extensions
    <System.Runtime.CompilerServices.Extension> 
    Public Iterator Function WithIndex(Of T)(source As IEnumerable(Of T)) As IEnumerable(Of (index As Integer, value As T))
        Dim index As Integer = 0
        For Each value As T In source
            Yield (index, value)
            index += 1
        Next
    End Function
End Module

Nun können Sie diese Erweiterungsmethode mit Ihren Sammlungen verwenden:

int[] numbers = { 10, 20, 30, 40 };
foreach (var (index, value) in numbers.WithIndex())
{
    Console.WriteLine($"Index: {index}, Value: {value}");
}

int[] numbers = { 10, 20, 30, 40 };
foreach (var (index, value) in numbers.WithIndex())
{
    Console.WriteLine($"Index: {index}, Value: {value}");
}

Dim numbers() As Integer = { 10, 20, 30, 40 }
foreach var(index, value) In numbers.WithIndex()
	Console.WriteLine($"Index: {index}, Value: {value}")
Next

Dim numbers() As Integer = { 10, 20, 30, 40 }
foreach var(index, value) In numbers.WithIndex()
	Console.WriteLine($"Index: {index}, Value: {value}")
Next

Dieser Ansatz schafft eine elegantere Lösung für das Problem der foreach mit Index, indem das manuelle Indexmanagement in eine wiederverwendbare Methode abstrahiert wird.

Verwendung einer while-Schleife für den Zugriff auf Indizes

Wenn Sie mit Sammlungen wie Arrays oder Listen arbeiten, können Sie eine While-Schleife in Verbindung mit einer Indexvariable verwenden, um sowohl auf den Index als auch auf das aktuelle Element zuzugreifen:

int[] numbers = { 10, 20, 30, 40 };
int index = 0;
while (index < numbers.Length)
{
    Console.WriteLine($"Index: {index}, Value: {numbers[index]}");
    index++;
}

int[] numbers = { 10, 20, 30, 40 };
int index = 0;
while (index < numbers.Length)
{
    Console.WriteLine($"Index: {index}, Value: {numbers[index]}");
    index++;
}

Dim numbers() As Integer = { 10, 20, 30, 40 }
Dim index As Integer = 0
Do While index < numbers.Length
	Console.WriteLine($"Index: {index}, Value: {numbers(index)}")
	index += 1
Loop

Dim numbers() As Integer = { 10, 20, 30, 40 }
Dim index As Integer = 0
Do While index < numbers.Length
	Console.WriteLine($"Index: {index}, Value: {numbers(index)}")
	index += 1
Loop

C# foreach mit Index (Wie es für Entwickler funktioniert): Abbildung 1 - Indexausgabe

Diese Methode ermöglicht es Ihnen, sowohl auf den Index als auch auf das aktuelle Element direkt zuzugreifen, indem Sie die Indexvariable als Subskript für das Array oder die Liste verwenden.

Benutzerdefinierte Sammlungen und Iteratoren in .NET

Wenn Sie mit angepassten Sammlungen arbeiten, können Sie Ihre Iteratoren implementieren, um den Zugriff mit Indexen zu unterstützen. Durch die Implementierung des IEnumerable-Interfaces und die Verwendung der yield return-Anweisung können Sie Iteratoren erstellen, die sowohl das Element als auch seinen Index zurückgeben.

Hier ist ein Beispiel zum Erstellen einer benutzerdefinierten Sammlung, die IEnumerable implementiert:

public class CustomCollection<t> : IEnumerable<t>
{
    private T[] _items;
    public CustomCollection(T[] items)
    {
        _items = items;
    }
    public IEnumerator<t> GetEnumerator()
    {
        for (int i = 0; i < _items.Length; i++)
        {
            yield return _items[i];
        }
    }
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

public class CustomCollection<t> : IEnumerable<t>
{
    private T[] _items;
    public CustomCollection(T[] items)
    {
        _items = items;
    }
    public IEnumerator<t> GetEnumerator()
    {
        for (int i = 0; i < _items.Length; i++)
        {
            yield return _items[i];
        }
    }
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

Imports System.Collections
Imports System.Collections.Generic

Public Class CustomCollection(Of T)
    Implements IEnumerable(Of T)

    Private _items As T()

    Public Sub New(items As T())
        _items = items
    End Sub

    Public Function GetEnumerator() As IEnumerator(Of T) Implements IEnumerable(Of T).GetEnumerator
        For i As Integer = 0 To _items.Length - 1
            Yield _items(i)
        Next
    End Function

    Private Function IEnumerable_GetEnumerator() As IEnumerator Implements IEnumerable.GetEnumerator
        Return GetEnumerator()
    End Function
End Class

Imports System.Collections
Imports System.Collections.Generic

Public Class CustomCollection(Of T)
    Implements IEnumerable(Of T)

    Private _items As T()

    Public Sub New(items As T())
        _items = items
    End Sub

    Public Function GetEnumerator() As IEnumerator(Of T) Implements IEnumerable(Of T).GetEnumerator
        For i As Integer = 0 To _items.Length - 1
            Yield _items(i)
        Next
    End Function

    Private Function IEnumerable_GetEnumerator() As IEnumerator Implements IEnumerable.GetEnumerator
        Return GetEnumerator()
    End Function
End Class

Sie können dann diese benutzerdefinierte Sammlung in einer foreach-Schleife verwenden:

var customCollection = new CustomCollection<int>(new int[] { 10, 20, 30, 40 });
foreach (int number in customCollection)
{
    Console.WriteLine(number);
}

var customCollection = new CustomCollection<int>(new int[] { 10, 20, 30, 40 });
foreach (int number in customCollection)
{
    Console.WriteLine(number);
}

Dim customCollection As New CustomCollection(Of Integer)(New Integer() { 10, 20, 30, 40 })
For Each number As Integer In customCollection
	Console.WriteLine(number)
Next number

Dim customCollection As New CustomCollection(Of Integer)(New Integer() { 10, 20, 30, 40 })
For Each number As Integer In customCollection
	Console.WriteLine(number)
Next number

Durch die Implementierung der GetEnumerator-Methode und die Verwendung von yield return erstellen Sie einen Iterator, der es der foreach-Schleife ermöglicht, mit Ihrer benutzerdefinierten Sammlung genauso zu arbeiten wie mit jeder anderen Sammlung in .NET.

Verwendung von Wörterbüchern und Iteration mit Schlüssel-Werte-Paaren

Bei der Arbeit mit Dictionarys ermöglicht es die foreach-Schleife, direkt über Schlüssel-Werte-Paare zu iterieren. Dies ist ein häufiger Anwendungsfall, um sowohl den Schlüssel als auch den Wert während jeder Iteration zuzugreifen:

Dictionary<int, string> dict = new Dictionary<int, string>
{
    { 1, "Apple" },
    { 2, "Banana" },
    { 3, "Cherry" }
};
foreach (var kvp in dict)
{
    Console.WriteLine($"Key: {kvp.Key}, Value: {kvp.Value}");
}

Dictionary<int, string> dict = new Dictionary<int, string>
{
    { 1, "Apple" },
    { 2, "Banana" },
    { 3, "Cherry" }
};
foreach (var kvp in dict)
{
    Console.WriteLine($"Key: {kvp.Key}, Value: {kvp.Value}");
}

Dim dict As New Dictionary(Of Integer, String) From {
	{1, "Apple"},
	{2, "Banana"},
	{3, "Cherry"}
}
For Each kvp In dict
	Console.WriteLine($"Key: {kvp.Key}, Value: {kvp.Value}")
Next kvp

Dim dict As New Dictionary(Of Integer, String) From {
	{1, "Apple"},
	{2, "Banana"},
	{3, "Cherry"}
}
For Each kvp In dict
	Console.WriteLine($"Key: {kvp.Key}, Value: {kvp.Value}")
Next kvp

In diesem Beispiel gibt kvp.Key Ihnen den aktuellen Schlüssel und kvp.Value gibt Ihnen den aktuellen Wert.

Verwendung von IronPDF mit C# foreach-Schleife und Index

C# foreach mit Index (Wie es für Entwickler funktioniert): Abbildung 2 - IronPDF

IronPDF ist eine PDF-Bibliothek zum Umgang mit PDF-Erstellung aus HTML und anderen PDF-bezogenen Aufgaben in C#. Es ist auch mit dem neuesten .NET Framework kompatibel. Beim Generieren von PDFs mit IronPDF müssen Sie möglicherweise über eine Sammlung von Daten iterieren und dynamisch Inhalt in Ihre PDF-Datei einfügen. Die Kombination der foreach-Schleife mit Indexhandhabung ermöglicht es Ihnen, das Positionieren, Nummerieren oder benutzerdefinierte Logik basierend auf dem Index des aktuellen Elements in der Sammlung zu verwalten. Hier ist ein praktisches Beispiel für die Verwendung von IronPDF zur Erstellung eines PDFs, in dem jedes Element einer Sammlung zusammen mit seinem Index in das Dokument eingefügt wird.

using IronPdf;
class Program
{
    static void Main(string[] args)
    {
        // Create a new PDF document renderer
        var pdf = new ChromePdfRenderer();
        
        // Sample data array
        string[] items = { "First Item", "Second Item", "Third Item" };
        
        // Initialize the HTML content with foreach loop and index
        string htmlContent = "<html><body>";
        int index = 0;
        foreach (var item in items)
        {
            htmlContent += $"<h2>Item {index + 1}: {item}</h2>";
            index++;
        }
        htmlContent += "</body></html>";
        
        // Render the HTML to PDF
        var pdfDocument = pdf.RenderHtmlAsPdf(htmlContent);
        
        // Save the PDF document
        pdfDocument.SaveAs("output.pdf");
        
        // Notify completion
        Console.WriteLine("PDF created successfully with indexed items.");
    }
}

using IronPdf;
class Program
{
    static void Main(string[] args)
    {
        // Create a new PDF document renderer
        var pdf = new ChromePdfRenderer();
        
        // Sample data array
        string[] items = { "First Item", "Second Item", "Third Item" };
        
        // Initialize the HTML content with foreach loop and index
        string htmlContent = "<html><body>";
        int index = 0;
        foreach (var item in items)
        {
            htmlContent += $"<h2>Item {index + 1}: {item}</h2>";
            index++;
        }
        htmlContent += "</body></html>";
        
        // Render the HTML to PDF
        var pdfDocument = pdf.RenderHtmlAsPdf(htmlContent);
        
        // Save the PDF document
        pdfDocument.SaveAs("output.pdf");
        
        // Notify completion
        Console.WriteLine("PDF created successfully with indexed items.");
    }
}

Imports IronPdf

Class Program
    Shared Sub Main(ByVal args As String())
        ' Create a new PDF document renderer
        Dim pdf = New ChromePdfRenderer()

        ' Sample data array
        Dim items As String() = {"First Item", "Second Item", "Third Item"}

        ' Initialize the HTML content with foreach loop and index
        Dim htmlContent As String = "<html><body>"
        Dim index As Integer = 0
        For Each item In items
            htmlContent += $"<h2>Item {index + 1}: {item}</h2>"
            index += 1
        Next item
        htmlContent += "</body></html>"

        ' Render the HTML to PDF
        Dim pdfDocument = pdf.RenderHtmlAsPdf(htmlContent)

        ' Save the PDF document
        pdfDocument.SaveAs("output.pdf")

        ' Notify completion
        Console.WriteLine("PDF created successfully with indexed items.")
    End Sub
End Class

Imports IronPdf

Class Program
    Shared Sub Main(ByVal args As String())
        ' Create a new PDF document renderer
        Dim pdf = New ChromePdfRenderer()

        ' Sample data array
        Dim items As String() = {"First Item", "Second Item", "Third Item"}

        ' Initialize the HTML content with foreach loop and index
        Dim htmlContent As String = "<html><body>"
        Dim index As Integer = 0
        For Each item In items
            htmlContent += $"<h2>Item {index + 1}: {item}</h2>"
            index += 1
        Next item
        htmlContent += "</body></html>"

        ' Render the HTML to PDF
        Dim pdfDocument = pdf.RenderHtmlAsPdf(htmlContent)

        ' Save the PDF document
        pdfDocument.SaveAs("output.pdf")

        ' Notify completion
        Console.WriteLine("PDF created successfully with indexed items.")
    End Sub
End Class

Hier ist die Ausgabe-PDF-Datei:

C# foreach mit Index (Wie es für Entwickler funktioniert): Abbildung 3 - PDF-Ausgabe

Abschluss

In C#, obwohl die foreach-Schleife eine praktische Möglichkeit bietet, über Sammlungen zu iterieren, fehlt ihr die native Unterstützung für Indizes. Es gibt jedoch mehrere Möglichkeiten, dieses Limit zu überwinden. Egal ob Sie eine einfache Indexvariable, die Select-Methode von LINQ oder benutzerdefinierte Iteratoren verwenden, Sie können während der Iteration auf den Index des aktuellen oder nächsten Elements zugreifen. Das Verständnis dieser Techniken kann Ihnen helfen, die foreach-Schleife effizienter zu nutzen, insbesondere wenn Sie den Index jedes Elements wissen müssen.

Mit IronPDF müssen Sie sich nicht sofort verpflichten. Wir bieten eine kostenlose Testversion an, die es Ihnen ermöglicht, die Fähigkeiten der Software eingehend zu erkunden. Wenn Ihnen gefällt, was Sie sehen, beginnen die Lizenzen bei $999.

Jacob Mellor

Jetzt mit dem Ingenieurteam chatten

Chief Technology Officer

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.

...