C# Nito.Asyncex (Funktionsweise für Entwickler)

Funktionen von Nito.AsyncEx

Primitiven mit asynchroner Koordination:

Versionen gängiger Synchronisationsprimitiven wie Sperren, Semaphoren, Countdown-Ereignisse und Barrieren werden von AsyncEx angeboten. Durch die Koordination des Zugriffs auf gemeinsam genutzte Ressourcen in asynchronen Kontexten helfen diese Techniken Entwicklern, Race-Probleme zu vermeiden und die Thread-Sicherheit zu gewährleisten.

Asynchrone Sammlungen:

Gängige Sammlungstypen wie Warteschlangen, Stapel und Puffer werden in der Bibliothek asynchron implementiert. Diese asynchronen Sammlungen verbessern die Leistung und Skalierbarkeit asynchroner Workflows, indem sie effektive asynchrone Datenverarbeitung und -manipulation ermöglichen.

Nito ist ein asynchroner Stream:

AsyncEx bietet Werkzeuge zur Arbeit mit asynchronen Streams, was die Integration asynchroner Datenverarbeitungspipelines und I/O-Aktivitäten erleichtert. Entwickler können die Reaktionsfähigkeit und Effizienz von I/O-gebundenen Aktivitäten steigern, indem sie asynchron von oder zu asynchronen Streams lesen oder schreiben.

Aufgabenorganisation:

Mit den Planungswerkzeugen der Bibliothek können Entwickler das Timing und die Methode asynchroner Aktionen verwalten. Diese Funktionalität ermöglicht eine präzisere Steuerung der Aufgabenausführung, maximiert die Ressourcennutzung und verbessert die Anwendungsleistung.

Erweiterungen und asynchrone Methodologien:

Durch das Hinzufügen asynchroner Methoden und Erweiterungen zum .NET-Framework vereinfacht Nito.AsyncEx die Nutzung standardmäßiger asynchroner Programmierungsmuster und -prozesse. Diese Verbesserungen machen es Entwicklern leichter, asynchrone Anwendungen zu erstellen und zu debuggen, verbessern die Lesbarkeit und Wartbarkeit des asynchronen Codes.

Projekt erstellen und konfigurieren

Die folgenden Schritte können verwendet werden, um Nito.AsyncEx in einem C#-Projekt zu erstellen und zu konfigurieren:

Nito.AsyncEx-Paket installieren

Fügen Sie das Nito.AsyncEx-Paket zu Ihrem Projekt hinzu, indem Sie die .NET CLI oder den NuGet-Paketmanager verwenden. Geben Sie im Paketmanager-Konsolen oder in einem Terminal den folgenden Befehl ein, um das Paket zu installieren:

Install-Package Nito.AsyncEx

Das Nito.AsyncEx-Projekt konfigurieren

Nach der Installation des Pakets können Sie Nito.AsyncEx in Ihrem Projekt verwenden. Wo immer Sie in Ihren C#-Projekten die Funktionalität von Nito.AsyncEx nutzen möchten, importieren Sie dessen Namensraum:

using Nito.AsyncEx;

using Nito.AsyncEx;

IRON VB CONVERTER ERROR developers@ironsoftware.com

Codebeispiel für die Verwendung von Nito.AsyncEx

Jetzt können Sie in Ihrem Code die Funktionalität nutzen, die Nito.AsyncEx bietet. Zum Beispiel können Sie Ihre asynchronen Programmierungs-Workflows verbessern und optimieren, indem Sie asynchrone Koordinationsprimitiven wie Sperren und Semaphoren, asynchrone Sammlungen, asynchrone Streams und mehr nutzen.

using System;
using System.Threading.Tasks;
using Nito.AsyncEx;

class Program
{
    static async Task Main(string[] args)
    {
        // Create an instance of AsyncLock
        var mutex = new AsyncLock();

        // It can be locked asynchronously using await
        using (await mutex.LockAsync())
        {
            // Code inside the lock
            Console.WriteLine("Inside the lock.");

            // Simulate some asynchronous operation
            await Task.Delay(1000); // Delay for 1 second

            Console.WriteLine("Lock released.");
        }
    }
}

using System;
using System.Threading.Tasks;
using Nito.AsyncEx;

class Program
{
    static async Task Main(string[] args)
    {
        // Create an instance of AsyncLock
        var mutex = new AsyncLock();

        // It can be locked asynchronously using await
        using (await mutex.LockAsync())
        {
            // Code inside the lock
            Console.WriteLine("Inside the lock.");

            // Simulate some asynchronous operation
            await Task.Delay(1000); // Delay for 1 second

            Console.WriteLine("Lock released.");
        }
    }
}

Imports System
Imports System.Threading.Tasks
Imports Nito.AsyncEx

Friend Class Program
	Shared Async Function Main(ByVal args() As String) As Task
		' Create an instance of AsyncLock
		Dim mutex = New AsyncLock()

		' It can be locked asynchronously using await
		Using Await mutex.LockAsync()
			' Code inside the lock
			Console.WriteLine("Inside the lock.")

			' Simulate some asynchronous operation
			Await Task.Delay(1000) ' Delay for 1 second

			Console.WriteLine("Lock released.")
		End Using
	End Function
End Class

Um sicherzustellen, dass es keine Kompilierungsfehler gibt, erstellen Sie Ihren C#-Code. Führen Sie dann Ihre Anwendung aus, um sicherzustellen, dass Nito.AsyncEx ordnungsgemäß funktioniert.

Diese Verfahren ermöglichen es Ihnen, die Funktionalität von Nito.AsyncEx für asynchrone Programmieraufgaben zu nutzen, indem Sie es in einem C#-Projekt erstellen und konfigurieren.

Was ist IronPDF?

IronPDF ist eine reichhaltige Bibliothek zum Arbeiten mit PDF-Dokumenten in .NET-Anwendungen. Mit seinem umfangreichen Funktionsumfang können Benutzer bestehende PDF-Dokumente ändern, indem sie Abschnitte hinzufügen, entfernen oder umordnen, sowie PDFs von Grund auf oder aus HTML-Inhalten erstellen. IronPDF erleichtert die Arbeit mit PDFs in .NET-Anwendungen durch Bereitstellung einer leistungsstarken API für die Erstellung, Bearbeitung und Konvertierung von PDF-Dateien.

Hauptfunktionen von IronPDF

• HTML-zu-PDF-Konvertierung: IronPDF ermöglicht es Ihnen, HTML-Inhalte, wie CSS und JavaScript, zu verwenden, um qualitativ hochwertige PDF-Dokumente zu erstellen. Beim Erstellen von PDFs aus Webseiten oder dynamischen Inhalten ist diese Funktion besonders nützlich.
• Bearbeiten und Verbessern von PDFs: IronPDF bietet Bearbeitungsfunktionen für bestehende PDF-Dokumente. Ein PDF kann Seiten extrahiert, Text, Bilder, Wasserzeichen oder Kommentare hinzugefügt und viele PDFs zu einem Dokument kombiniert werden.
• Direktes Erstellen eines PDFs: Sie können programmatisch Text, Bilder, Formen und andere Objekte zu neuen PDF-Dokumenten mit der API von IronPDF hinzufügen. Dies ermöglicht die dynamische Erstellung von PDF-Berichten, Rechnungen und anderen dokumentbasierten Ausgaben.
• PDF-Sicherheit: Sie können den Zugriff steuern und wichtige Daten schützen, indem Sie Passwortsicherheit hinzufügen und PDF-Dokumente mit IronPDF verschlüsseln.
• PDF-Formulare: Benutzer können mit PDF-Dokumenten arbeiten, indem sie mit IronPDF Formulare erstellen und ausfüllen und Daten in Formularfeldern eingeben.
• Textauszüge: IronPDF extrahiert Textinhalte aus PDF-Dokumenten, um Textdaten einfach zu durchsuchen, zu analysieren und zu bearbeiten.
• Konvertierung in Bildformate: Da IronPDF PDF-Dokumente in gängige Bildformate wie PNG, JPEG und BMP konvertieren kann, eignet es sich in Szenarien, in denen Bilder anstelle von PDFs erforderlich sind.

IronPDF installieren

Stellen Sie sicher, dass beide Bibliotheken Ihrem Projekt hinzugefügt werden, bevor Sie beginnen, Nito.AsyncEx in C# mit IronPDF zu verwenden. Sie können die .NET CLI oder den NuGet Package Manager verwenden, um IronPDF zu Ihrem Projekt hinzuzufügen. Der Befehl im NuGet-Paketmanager-Konsolen ist unten:

Install-Package IronPdf

Integrieren Sie IronPDF mit Nito.AsyncEx

using System;
using System.Threading.Tasks;
using Nito.AsyncEx;
using IronPdf;

class Program
{
    static async Task Main(string[] args)
    {
        // Create an asynchronous lock
        AsyncLock asyncLock = new AsyncLock();

        // Use the lock to ensure only one thread is accessing IronPDF at a time
        using (await asyncLock.LockAsync())
        {
            // Generate the PDF document asynchronously
            await GeneratePdfAsync();
        }
    }

    static async Task GeneratePdfAsync()
    {
        // Create IronPDF Renderer
        var Renderer = new IronPdf.HtmlToPdf();

        // Create HTML content for the PDF
        string htmlContent = "<h1>Hello, IronPDF!</h1>";

        // Convert HTML to PDF asynchronously
        var pdfDocument = await Renderer.RenderHtmlAsPdfAsync(htmlContent);

        // Save the PDF document
        pdfDocument.SaveAs("example.pdf");
    }
}

using System;
using System.Threading.Tasks;
using Nito.AsyncEx;
using IronPdf;

class Program
{
    static async Task Main(string[] args)
    {
        // Create an asynchronous lock
        AsyncLock asyncLock = new AsyncLock();

        // Use the lock to ensure only one thread is accessing IronPDF at a time
        using (await asyncLock.LockAsync())
        {
            // Generate the PDF document asynchronously
            await GeneratePdfAsync();
        }
    }

    static async Task GeneratePdfAsync()
    {
        // Create IronPDF Renderer
        var Renderer = new IronPdf.HtmlToPdf();

        // Create HTML content for the PDF
        string htmlContent = "<h1>Hello, IronPDF!</h1>";

        // Convert HTML to PDF asynchronously
        var pdfDocument = await Renderer.RenderHtmlAsPdfAsync(htmlContent);

        // Save the PDF document
        pdfDocument.SaveAs("example.pdf");
    }
}

Imports System
Imports System.Threading.Tasks
Imports Nito.AsyncEx
Imports IronPdf

Friend Class Program
	Shared Async Function Main(ByVal args() As String) As Task
		' Create an asynchronous lock
		Dim asyncLock As New AsyncLock()

		' Use the lock to ensure only one thread is accessing IronPDF at a time
		Using Await asyncLock.LockAsync()
			' Generate the PDF document asynchronously
			Await GeneratePdfAsync()
		End Using
	End Function

	Private Shared Async Function GeneratePdfAsync() As Task
		' Create IronPDF Renderer
		Dim Renderer = New IronPdf.HtmlToPdf()

		' Create HTML content for the PDF
		Dim htmlContent As String = "<h1>Hello, IronPDF!</h1>"

		' Convert HTML to PDF asynchronously
		Dim pdfDocument = Await Renderer.RenderHtmlAsPdfAsync(htmlContent)

		' Save the PDF document
		pdfDocument.SaveAs("example.pdf")
	End Function
End Class