C# Gleichzeitige Liste (Wie es für Entwickler funktioniert)

Thread-Sicherheit und gleichzeitige Sammlungen in C

Beginnen wir damit, eine geschäftige Stadtkreuzung ohne Ampeln vorzustellen. Sie können sich das Chaos vorstellen! Dies ist ähnlich wie das, was passiert, wenn mehrere Threads gleichzeitig auf eine gemeinsame Ressource zugreifen, ohne dass ein angemessenes System vorhanden ist. Glücklicherweise haben wir in C# Ampeln für unsere Threads - sie werden parallele Kollektionen genannt. Dies sind Sammlungsklassen, die es nur einem Thread erlauben, gleichzeitig auf eine Ressource zuzugreifen. Diese Thread-Sicherheit ist entscheidend, wenn mit mehreren Threads gearbeitet wird.

Untersuchung von parallelen threadsicheren Sammlungen in C

In C# bietet der Namensraum System.Collections.Concurrent eine Vielzahl von parallelen Sammlungsklassen, wie ConcurrentDictionary, ConcurrentQueue, ConcurrentStack und ConcurrentBag. Diese ungeordneten Sammlungsklassen bieten eine threadsichere Version ihrer nicht-parallelen Gegenstücke. Was parallele Sammlungen auszeichnet, ist, dass sie ungeordnete parallele Sammlungen sind, was bedeutet, dass Elemente keine spezifische Reihenfolge haben. Beispielsweise wissen Sie bei einer parallelen Liste nicht genau, wo ein Element eingefügt wird. Der Fokus liegt auf der Gewährleistung von Thread-Sicherheit, nicht auf der Aufrechterhaltung einer Ordnung.

Lassen Sie uns ein reales Beispiel nehmen. Denken Sie an einen Passwortübermittlungsbeitrag auf einer Website. Mit einer gleichzeitigen Sammlung können mehrere Benutzer ihre Passwörter gleichzeitig übermitteln. Jede 'Absendung' entspricht einem Thread, und die parallele Sammlung sorgt dafür, dass jede Übermittlung threadsicher, sicher und effektiv verarbeitet wird.

ConcurrentDictionary: Ein Beispiel aus der Praxis

Jetzt lassen Sie uns die ConcurrentDictionary Sammlungsklasse mit einem realen Beispiel erkunden. Stellen Sie sich einen Online-Buchladen mit einer Empfehlung Funktion vor. Jeder Klick eines Benutzers fügt ein Buch seiner persönlichen Empfehlungsliste hinzu, die durch ein Wörterbuch dargestellt wird. Während mehrere Benutzer gleichzeitig Bücher durchsuchen und anklicken, haben wir mehrere Threads, die gleichzeitig auf das Wörterbuch zugreifen.

Ein ConcurrentDictionary in C# sähe etwa so aus:

using System.Collections.Concurrent;

ConcurrentDictionary<string, string> recommendedBooks = new ConcurrentDictionary<string, string>();

using System.Collections.Concurrent;

ConcurrentDictionary<string, string> recommendedBooks = new ConcurrentDictionary<string, string>();

Um einem Benutzer eine ganze Sammlung von Empfehlungen hinzuzufügen, könnten wir die TryAdd-Methode verwenden:

public void Insert(string user, string book)
{
    // Try to add the book to the user's recommendations
    recommendedBooks.TryAdd(user, book);
}

public void Insert(string user, string book)
{
    // Try to add the book to the user's recommendations
    recommendedBooks.TryAdd(user, book);
}

In diesem Szenario sorgt die ConcurrentDictionary-Sammlungsklasse dafür, dass jeder Klick (oder 'Thread') individuell behandelt wird, sodass die Empfehlungen von zwei Benutzern nicht vermischt werden. Sie kümmert sich um die gesamte Thread-Sicherheit, sodass Sie sich keine Gedanken über Datenrennen und andere Problematik im Zusammenhang mit konkurrierenden Threads machen müssen.

Implementierung von thread-sicheren Operationen

Abgesehen von TryAdd bieten parallele Sammlungen in C# eine Vielzahl anderer threadsicherer Operationen wie TryRemove und TryUpdate. Diese Methoden stellen sicher, dass jeweils nur ein Thread einen Vorgang ausführen kann. Wenn wir beispielsweise ein Buch aus den Empfehlungen eines Benutzers im vorherigen Beispiel entfernen wollten, könnten wir die TryRemove-Methode verwenden:

public void RemoveAt(string user)
{
    // Attempt to remove the book for the specified user
    string removedBook;
    recommendedBooks.TryRemove(user, out removedBook);
}

public void RemoveAt(string user)
{
    // Attempt to remove the book for the specified user
    string removedBook;
    recommendedBooks.TryRemove(user, out removedBook);
}

Die TryRemove-Methode versucht, den Wert des bereitgestellten Schlüssels (in diesem Fall einen Benutzer) zu entfernen und ihn in die Variable removedBook zu setzen.

Kopieren gleichzeitiger Sammlungen

Angenommen, Sie möchten Ihre parallele Sammlung in ein Array kopieren. Parallele Sammlungen bieten für diesen speziellen Zweck eine CopyTo-Methode:

public void CopyTo()
{
    // Create an array to hold the recommended books
    string[] bookArray = new string[recommendedBooks.Count];

    // Copy the values of the concurrent dictionary to the array
    recommendedBooks.Values.CopyTo(bookArray, 0);
}

public void CopyTo()
{
    // Create an array to hold the recommended books
    string[] bookArray = new string[recommendedBooks.Count];

    // Copy the values of the concurrent dictionary to the array
    recommendedBooks.Values.CopyTo(bookArray, 0);
}

Hier kopiert die CopyTo-Methode alle Bücher (Werte) aus dem parallelen Wörterbuch recommendedBooks in das bookArray.

Thread Safe Kollektion

C# bietet auch thread-sichere Sammlungen, die darauf ausgelegt sind, den sicheren Zugriff auf gemeinsame Ressourcen in Mehrthread-Umgebungen zu gewährleisten. Diese Sammlungen, wie ConcurrentBag, ConcurrentQueue und ConcurrentStack, bieten threadsichere Implementierungen, bei denen mehrere Threads gleichzeitig auf die Sammlung zugreifen und sie ändern können, ohne Konflikte oder Datenkorruption zu verursachen.

Sie gewährleisten Konsistenz und Integrität, indem sie die Synchronisation intern handhaben, was sie ideal für Szenarien macht, in denen eine ungeordnete Sammlung ausreicht und Thread-Sicherheit in Ihren C#-Anwendungen von größter Bedeutung ist.

Erfahren Sie mehr über IronPDF ist eine beliebte C#-Bibliothek, die es Ihnen ermöglicht, PDF-Dokumente mühelos aus HTML zu erstellen.

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");
    }
}

Obwohl es auf den ersten Blick nicht direkt im Zusammenhang mit parallelen Listen zu stehen scheint, kann IronPDF Ihre Operationen mit paralellen Sammlungen ergänzen, indem es einen einfachen Weg zum Erstellen von PDF-Berichten, Protokollen oder anderen Dokumenten bietet, die die Ergebnisse Ihrer parallelen Verarbeitung festhalten.

Betrachten Sie das Szenario, in dem Sie eine mehrfädige Anwendung haben, die intensive Datenverarbeitung durchführt. Während die Threads ihre Magie an den Daten entfalten, möchten Sie möglicherweise die Ergebnisse erfassen und einen PDF-Bericht zur weiteren Analyse oder zur Dokumentation erstellen. Hier kommt IronPDF ins Spiel.

Die Verwendung von IronPDF ist so einfach wie das Hinzufügen der Bibliothek zu Ihrem Projekt und die Nutzung ihrer praktischen API. Hier ist ein Beispiel dafür, wie Sie IronPDF mit Ihren Operationen mit parallelen Sammlungen integrieren können:

using IronPdf;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Threading.Tasks;

// Create a concurrent dictionary to hold your processed data
ConcurrentDictionary<int, string> processedData = new ConcurrentDictionary<int, string>();

// Define your data list (replace with your actual data source)
List<DataItem> dataList = GetDataList();

// Process your data concurrently and store the results in the dictionary
Parallel.ForEach(dataList, (dataItem) =>
{
    // Process each data item and add the result to the dictionary
    string processedResult = ProcessDataItem(dataItem);
    processedData.TryAdd(dataItem.Id, processedResult);
});

// Generate a PDF report with the processed data
var renderer = new ChromePdfRenderer();
var pdfDocument = renderer.RenderHtmlAsPdf(BuildHtmlReport(processedData));
pdfDocument.SaveAs("C:\\processed_data_report.pdf");

// Method to retrieve the data list (replace with your actual data source logic)
List<DataItem> GetDataList()
{
    List<DataItem> dataList = new List<DataItem>()
    {
        new DataItem { Id = 1, Name = "Item 1" },
        new DataItem { Id = 2, Name = "Item 2" },
        new DataItem { Id = 3, Name = "Item 3" },
        new DataItem { Id = 4, Name = "Item 4" }
    };
    return dataList;
}

// Method to process each data item and return the result (replace with your actual data processing logic)
string ProcessDataItem(DataItem dataItem)
{
    // Simulating data processing with a delay
    Task.Delay(100).Wait();
    return $"Processed: {dataItem.Name}";
}

// Method to build the HTML report using the processed data (replace with your actual reporting logic)
string BuildHtmlReport(ConcurrentDictionary<int, string> processedData)
{
    string html = "<h1>Processed Data Report</h1><ul>";
    foreach (var kvp in processedData)
    {
        html += $"<li>Item {kvp.Key}: {kvp.Value}</li>";
    }
    html += "</ul>";
    return html;
}

// Placeholder class for your data item (replace with your actual data item class)
public class DataItem
{
    public int Id { get; set; }
    public string Name { get; set; }
    // Add other properties as needed
}

using IronPdf;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Threading.Tasks;

// Create a concurrent dictionary to hold your processed data
ConcurrentDictionary<int, string> processedData = new ConcurrentDictionary<int, string>();

// Define your data list (replace with your actual data source)
List<DataItem> dataList = GetDataList();

// Process your data concurrently and store the results in the dictionary
Parallel.ForEach(dataList, (dataItem) =>
{
    // Process each data item and add the result to the dictionary
    string processedResult = ProcessDataItem(dataItem);
    processedData.TryAdd(dataItem.Id, processedResult);
});

// Generate a PDF report with the processed data
var renderer = new ChromePdfRenderer();
var pdfDocument = renderer.RenderHtmlAsPdf(BuildHtmlReport(processedData));
pdfDocument.SaveAs("C:\\processed_data_report.pdf");

// Method to retrieve the data list (replace with your actual data source logic)
List<DataItem> GetDataList()
{
    List<DataItem> dataList = new List<DataItem>()
    {
        new DataItem { Id = 1, Name = "Item 1" },
        new DataItem { Id = 2, Name = "Item 2" },
        new DataItem { Id = 3, Name = "Item 3" },
        new DataItem { Id = 4, Name = "Item 4" }
    };
    return dataList;
}

// Method to process each data item and return the result (replace with your actual data processing logic)
string ProcessDataItem(DataItem dataItem)
{
    // Simulating data processing with a delay
    Task.Delay(100).Wait();
    return $"Processed: {dataItem.Name}";
}

// Method to build the HTML report using the processed data (replace with your actual reporting logic)
string BuildHtmlReport(ConcurrentDictionary<int, string> processedData)
{
    string html = "<h1>Processed Data Report</h1><ul>";
    foreach (var kvp in processedData)
    {
        html += $"<li>Item {kvp.Key}: {kvp.Value}</li>";
    }
    html += "</ul>";
    return html;
}

// Placeholder class for your data item (replace with your actual data item class)
public class DataItem
{
    public int Id { get; set; }
    public string Name { get; set; }
    // Add other properties as needed
}

Hier ist die Ausgabe des Codes:

Abschluss

Abschließend kann das Verständnis und die Nutzung von C#-parallelen Sammlungen, wie paralleler Listen, Ihre Fähigkeit zur Handhabung von Mehrthread-Szenarien erheblich verbessern und die Thread-Sicherheit in Ihren Anwendungen gewährleisten. Mit parallelen Sammlungen können Sie gemeinsam genutzte Ressourcen effektiv verwalten und Datenrennen und -kollisionen zwischen Threads verhindern.

Das Integrieren externer Bibliotheken wie IronPDF kann die Funktionalität von parallelen Sammlungen weiter erweitern, indem es die Erstellung optisch ansprechender PDF-Berichte oder -Dokumente ermöglicht. IronPDF bietet eine kostenlose Testversion seiner Bibliothek zur HTML-zu-PDF-Konvertierung, die es Ihnen ermöglicht, seine Fähigkeiten zu erkunden, und Lizenzoptionen ab $799.