C# 信號量管理器（開發者使用方法）

SemaphoreSlim 是 .NET 中的一個同步原語，它限制了可以同時存取特定資源或資源池的執行緒數。 它是完整信號量類的輕量級版本，旨在更有效率地處理那些只需要更簡單、更快速的信號量的情況。

使用 SemaphoreSlim 的一些好處是，與 Semaphore 相比，系統開銷有所降低，它非常適合管理有限的資源（例如資料庫連接或文件存取），並且它支援非同步等待方法，使其非常適合現代 async/await 程式設計模式。

SemaphoreSlim 基本用法的程式碼範例

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    // Semaphore count
    private static SemaphoreSlim _semaphore = new SemaphoreSlim(3); // Limit to 3 concurrent threads.

    static async Task Main(string[] args)
    {
        // Start tasks that will wait on the semaphore.
        var tasks = new Task[5];

        for (int i = 0; i < tasks.Length; i++)
        {
            tasks[i] = Task.Run(() => AccessResource(i));
        }

        // Simulate some work in the main thread (e.g., initialization).
        Console.WriteLine("Main thread is preparing resources...");
        await Task.Delay(2000);  // Simulate initialization delay.

        // Main thread calls release, releases semaphore permits to allow waiting tasks to proceed.
        Console.WriteLine("Main thread releasing semaphore permits...");
        _semaphore.Release(2);  // Releases 2 permits, allowing up to 2 tasks to proceed.

        // Wait for all tasks to complete.
        await Task.WhenAll(tasks);
        Console.WriteLine("All tasks completed.");
    }

    static async Task AccessResource(int id)
    {
        Console.WriteLine($"Task {id} waiting to enter...");
        await _semaphore.WaitAsync();

        try
        {
            Console.WriteLine($"Current thread successfully entered by Task {id}.");
            await Task.Delay(1000); // Simulate work.
        }
        finally
        {
            Console.WriteLine($"Task {id} releasing.");
            _semaphore.Release();
        }
    }
}

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    // Semaphore count
    private static SemaphoreSlim _semaphore = new SemaphoreSlim(3); // Limit to 3 concurrent threads.

    static async Task Main(string[] args)
    {
        // Start tasks that will wait on the semaphore.
        var tasks = new Task[5];

        for (int i = 0; i < tasks.Length; i++)
        {
            tasks[i] = Task.Run(() => AccessResource(i));
        }

        // Simulate some work in the main thread (e.g., initialization).
        Console.WriteLine("Main thread is preparing resources...");
        await Task.Delay(2000);  // Simulate initialization delay.

        // Main thread calls release, releases semaphore permits to allow waiting tasks to proceed.
        Console.WriteLine("Main thread releasing semaphore permits...");
        _semaphore.Release(2);  // Releases 2 permits, allowing up to 2 tasks to proceed.

        // Wait for all tasks to complete.
        await Task.WhenAll(tasks);
        Console.WriteLine("All tasks completed.");
    }

    static async Task AccessResource(int id)
    {
        Console.WriteLine($"Task {id} waiting to enter...");
        await _semaphore.WaitAsync();

        try
        {
            Console.WriteLine($"Current thread successfully entered by Task {id}.");
            await Task.Delay(1000); // Simulate work.
        }
        finally
        {
            Console.WriteLine($"Task {id} releasing.");
            _semaphore.Release();
        }
    }
}

在程式運行期間，當所有可用的許可都被執行緒取得後，信號量的計數可以動態地達到零執行緒。 此狀態表示已達到允許的最大並發存取數。

如果需要，您可以設定初始執行緒數和最大執行緒數，將初始信號量計數設為零，然後使用單獨的初始化任務在資源準備就緒時增加信號量計數，從而允許您選擇數量的執行緒繼續執行。 當信號量計數為零時，執行緒在嘗試進入信號量時會等待，這稱為"阻塞等待"。

您可以追蹤先前的信號量計數，以便根據先前的計數調整信號量的行為。 然後您可以相應地操作信號量（例如，透過釋放或等待）。 隨著線束釋放，信號燈數量減少。

控制台輸出

C# 信號量（開發者使用方法）：圖 1

使用 SemaphoreSlim 時，您可以有效地控制對 PDF 生成任務的存取。 這樣可以確保您的應用程式不會嘗試同時產生過多的 PDF 文件，從而避免影響效能或導致故障。

以下範例程式碼示範了 SemaphoreSlim 與 IronPDF 的基本用法。

using IronPdf;
using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    private static SemaphoreSlim _semaphore = new SemaphoreSlim(2); // Limit to 2 concurrent threads.

    static async Task Main(string[] args)
    {
        var tasks = new Task[5];

        for (int i = 0; i < tasks.Length; i++)
        {
            string htmlContent = $"<h1>PDF Document {i}</h1><p>This is a sample PDF content for task {i}.</p>";
            string outputPath = $"output_{i}.pdf";

            // Start multiple tasks to demonstrate controlled concurrency.
            tasks[i] = GeneratePdfAsync(htmlContent, outputPath, i);
        }

        await Task.WhenAll(tasks);
    }

    static async Task GeneratePdfAsync(string htmlContent, string outputPath, int taskId)
    {
        Console.WriteLine($"Task {taskId} is waiting for access...");

        // Wait to enter the semaphore.
        await _semaphore.WaitAsync();

        try
        {
            Console.WriteLine($"Task {taskId} has started PDF generation.");
            ChromePdfRenderer renderer = new ChromePdfRenderer();
            PdfDocument pdf = await renderer.RenderHtmlAsPdfAsync(htmlContent);
            pdf.SaveAs(outputPath);
            Console.WriteLine($"Task {taskId} has completed PDF generation.");
        }
        finally
        {
            // Ensure semaphore is released to allow other tasks to proceed.
            _semaphore.Release();
            Console.WriteLine($"Task {taskId} has released semaphore.");
        }
    }
}

using IronPdf;
using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    private static SemaphoreSlim _semaphore = new SemaphoreSlim(2); // Limit to 2 concurrent threads.

    static async Task Main(string[] args)
    {
        var tasks = new Task[5];

        for (int i = 0; i < tasks.Length; i++)
        {
            string htmlContent = $"<h1>PDF Document {i}</h1><p>This is a sample PDF content for task {i}.</p>";
            string outputPath = $"output_{i}.pdf";

            // Start multiple tasks to demonstrate controlled concurrency.
            tasks[i] = GeneratePdfAsync(htmlContent, outputPath, i);
        }

        await Task.WhenAll(tasks);
    }

    static async Task GeneratePdfAsync(string htmlContent, string outputPath, int taskId)
    {
        Console.WriteLine($"Task {taskId} is waiting for access...");

        // Wait to enter the semaphore.
        await _semaphore.WaitAsync();

        try
        {
            Console.WriteLine($"Task {taskId} has started PDF generation.");
            ChromePdfRenderer renderer = new ChromePdfRenderer();
            PdfDocument pdf = await renderer.RenderHtmlAsPdfAsync(htmlContent);
            pdf.SaveAs(outputPath);
            Console.WriteLine($"Task {taskId} has completed PDF generation.");
        }
        finally
        {
            // Ensure semaphore is released to allow other tasks to proceed.
            _semaphore.Release();
            Console.WriteLine($"Task {taskId} has released semaphore.");
        }
    }
}

在這個例子中，我們首先初始化了 SemaphoreSlim，並將 SemaphoreSlim 的初始計數和最大計數設為"2"，將其限制為同時產生兩個 PDF。 然後我們建立了一個任務數組，用於控製程式必須執行的任務數量，之後我們使用 for 迴圈根據任務數組中的任務數量動態建立 PDF。

然後使用WaitAsync()方法進入信號量，並在 finally 程式碼區塊中使用Release()來確保即使發生異常，信號量也始終被釋放。 控制台輸出日誌顯示每個任務何時開始、何時結束以及何時釋放信號量，這使您能夠追蹤並發行為。

輸出控制台

C# 信號量（開發者使用方法）：圖 3

輸出 PDF 文件

C# 信號量（開發者使用方法）：圖 4

當多個執行緒與共享資源互動時，線程安全至關重要。 在 PDF 操作中，SemaphoreSlim 確保只有定義數量的執行緒可以同時修改 PDF，從而防止競爭條件並確保一致性。 在以下程式碼中，我們模擬了一個場景，即為多個 PDF 添加浮水印，同時確保一次只執行一個操作。

using IronPdf;
using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    private static SemaphoreSlim _semaphore = new SemaphoreSlim(1);

    static async Task Main(string[] args)
    {
        // Setting array of tasks
        var tasks = new Task[3];

        for (int i = 0; i < tasks.Length; i++)
        {
            string inputPath = $"input_{i}.pdf";  // Input PDF file path
            string outputPath = $"output_{i}.pdf";  // Output PDF file path
            string watermarkText = @"
<img src='https://ironsoftware.com/img/products/ironpdf-logo-text-dotnet.svg'>
<h1>Iron Software</h1>";

            // Start multiple tasks to add watermarks concurrently.
            tasks[i] = AddWatermarkAsync(inputPath, outputPath, watermarkText, i);
        }

        await Task.WhenAll(tasks); // Wait for all tasks to finish.
    }

    static async Task AddWatermarkAsync(string input, string outputPath, string watermark, int taskId)
    {
        Console.WriteLine($"{DateTime.Now:HH:mm:ss} - Task {taskId} is waiting to add a watermark...");

        // Wait to enter the semaphore.
        await _semaphore.WaitAsync();

        try
        {
            Console.WriteLine($"{DateTime.Now:HH:mm:ss} - Task {taskId} is adding a watermark.");
            var pdf = PdfDocument.FromFile(input);
            pdf.ApplyWatermark(watermark); // Add watermark
            pdf.SaveAs(outputPath); // Save the modified PDF
            Console.WriteLine($"{DateTime.Now:HH:mm:ss} - Task {taskId} has completed watermarking.");
        }
        finally
        {
            // Release the semaphore after the task is done.
            _semaphore.Release();
            Console.WriteLine($"{DateTime.Now:HH:mm:ss} - Task {taskId} has released semaphore.");
        }
    }
}

using IronPdf;
using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    private static SemaphoreSlim _semaphore = new SemaphoreSlim(1);

    static async Task Main(string[] args)
    {
        // Setting array of tasks
        var tasks = new Task[3];

        for (int i = 0; i < tasks.Length; i++)
        {
            string inputPath = $"input_{i}.pdf";  // Input PDF file path
            string outputPath = $"output_{i}.pdf";  // Output PDF file path
            string watermarkText = @"
<img src='https://ironsoftware.com/img/products/ironpdf-logo-text-dotnet.svg'>
<h1>Iron Software</h1>";

            // Start multiple tasks to add watermarks concurrently.
            tasks[i] = AddWatermarkAsync(inputPath, outputPath, watermarkText, i);
        }

        await Task.WhenAll(tasks); // Wait for all tasks to finish.
    }

    static async Task AddWatermarkAsync(string input, string outputPath, string watermark, int taskId)
    {
        Console.WriteLine($"{DateTime.Now:HH:mm:ss} - Task {taskId} is waiting to add a watermark...");

        // Wait to enter the semaphore.
        await _semaphore.WaitAsync();

        try
        {
            Console.WriteLine($"{DateTime.Now:HH:mm:ss} - Task {taskId} is adding a watermark.");
            var pdf = PdfDocument.FromFile(input);
            pdf.ApplyWatermark(watermark); // Add watermark
            pdf.SaveAs(outputPath); // Save the modified PDF
            Console.WriteLine($"{DateTime.Now:HH:mm:ss} - Task {taskId} has completed watermarking.");
        }
        finally
        {
            // Release the semaphore after the task is done.
            _semaphore.Release();
            Console.WriteLine($"{DateTime.Now:HH:mm:ss} - Task {taskId} has released semaphore.");
        }
    }
}

透過使用private static SemaphoreSlim _semaphore = new SemaphoreSlim(1);將信號計數設為 1，我們確保一次只能有一個任務操作 PDF。

控制台輸出

C# 信號量（開發者工作原理）：圖 5

IronPDF 擅長處理資源密集型任務，例如將大型 HTML 檔案轉換為 PDF，並且擅長在非同步環境中執行這些任務。 使用 SemaphoreSlim 管理這些操作可確保您的應用程式即使在高負載下也能保持回應，而不會損失效能。

以下範例程式碼示範了我們需要限制同時進行的大型 HTML 到 PDF 轉換的數量，以避免系統資源過載的場景。

using IronPdf;
using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    // Limit concurrent large PDF conversions to 2.
    private static SemaphoreSlim _semaphore = new SemaphoreSlim(2);

    static async Task Main(string[] args)
    {
        var tasks = new Task[4];

        for (int i = 0; i < tasks.Length; i++)
        {
            string htmlContent = $"<h1>Large Document {i}</h1><p>Content for a large HTML file {i}.</p>";
            string outputPath = $"large_output_{i}.pdf";

            // Start multiple tasks to convert large HTML files to PDFs.
            tasks[i] = ConvertLargeHtmlAsync(htmlContent, outputPath, i);
        }

        await Task.WhenAll(tasks); // Wait for all tasks to finish.
    }

    // Method to convert large HTML to PDF using SemaphoreSlim to control resource usage.
    public static async Task ConvertLargeHtmlAsync(string htmlContent, string outputPath, int taskId)
    {
        Console.WriteLine($"Task {taskId} is waiting to start conversion...");

        // Wait to enter the semaphore.
        await _semaphore.WaitAsync();

        try
        {
            Console.WriteLine($"Task {taskId} is converting large HTML to PDF.");
            var renderer = new ChromePdfRenderer();
            var pdf = await renderer.RenderHtmlAsPdfAsync(htmlContent); // Convert large HTML to PDF
            pdf.SaveAs(outputPath); // Save the PDF file
            Console.WriteLine($"Task {taskId} has completed conversion.");
        }
        finally
        {
            // Ensure the semaphore is released to allow other tasks to proceed.
            _semaphore.Release();
            Console.WriteLine($"Task {taskId} has released semaphore.");
        }
    }
}

using IronPdf;
using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    // Limit concurrent large PDF conversions to 2.
    private static SemaphoreSlim _semaphore = new SemaphoreSlim(2);

    static async Task Main(string[] args)
    {
        var tasks = new Task[4];

        for (int i = 0; i < tasks.Length; i++)
        {
            string htmlContent = $"<h1>Large Document {i}</h1><p>Content for a large HTML file {i}.</p>";
            string outputPath = $"large_output_{i}.pdf";

            // Start multiple tasks to convert large HTML files to PDFs.
            tasks[i] = ConvertLargeHtmlAsync(htmlContent, outputPath, i);
        }

        await Task.WhenAll(tasks); // Wait for all tasks to finish.
    }

    // Method to convert large HTML to PDF using SemaphoreSlim to control resource usage.
    public static async Task ConvertLargeHtmlAsync(string htmlContent, string outputPath, int taskId)
    {
        Console.WriteLine($"Task {taskId} is waiting to start conversion...");

        // Wait to enter the semaphore.
        await _semaphore.WaitAsync();

        try
        {
            Console.WriteLine($"Task {taskId} is converting large HTML to PDF.");
            var renderer = new ChromePdfRenderer();
            var pdf = await renderer.RenderHtmlAsPdfAsync(htmlContent); // Convert large HTML to PDF
            pdf.SaveAs(outputPath); // Save the PDF file
            Console.WriteLine($"Task {taskId} has completed conversion.");
        }
        finally
        {
            // Ensure the semaphore is released to allow other tasks to proceed.
            _semaphore.Release();
            Console.WriteLine($"Task {taskId} has released semaphore.");
        }
    }
}

在處理將大型 HTML 檔案轉換為 PDF 等資源密集型任務時，SemaphoreSlim 可以幫助平衡負載並優化資源使用。 透過限制同時執行的作業數量為 2，我們可以防止系統被資源密集的 PDF 產生任務壓垮。 這種方法有助於更均勻地分配工作負載，從而提高應用程式的整體效能和穩定性。

輸出影像：使用此方法產生的文件

C# 信號量（開發者工作原理）：圖 6

IronPDF 旨在高效處理並發 PDF 處理任務，其效能和可靠性優於許多其他 PDF 庫。 其強大的架構使其能夠隨著應用程式的需求而擴展，使其成為高需求環境的理想選擇。 根據效能、易用性和穩健性等標準與其他 PDF 庫進行比較，IronPDF 證明自己是一個強大的競爭對手。 為了展示這一點，我將 IronPDF 與幾個其他流行的 PDF 庫進行了比較，例如 iTextSharp、PDFsharp、DinkToPdf 和 EvoPDF：

1.性能

IronPDF：

*渲染速度：* IronPDF 以其快速且有效率的渲染能力而聞名，尤其是在將 HTML 轉換為 PDF 時。 它採用基於 Chrome 的渲染技術，能夠高度保真地還原原始 HTML 內容，包括 CSS 和 JavaScript 的執行。 資源管理：**與其他庫相比，IronPDF 針對處理大型複雜 PDF 進行了最佳化，記憶體佔用更少，因此適用於高容量應用程式。 *非同步操作：支援非同步 PDF 生成，從而在響應速度至關重要的 Web 應用程式中實現更好的效能。

iTextSharp：

*渲染速度：* iTextSharp 在處理文字較多的 PDF 檔案時表現良好，但在處理複雜的佈局或影像時速度會大幅下降。 資源管理：** iTextSharp 的記憶體使用量可能較高，尤其是在處理大型文件或複雜操作時，這在某些情況下會導致效能瓶頸。

PDFsharp：

*渲染速度：* PDFsharp 在處理複雜佈局或從 HTML 轉換時，通常比 IronPDF 慢，因為它缺少原生 HTML 渲染引擎。 資源管理：**它在記憶體使用方面優化較差，處理包含大量圖像的大型文件或文件時可能會遇到困難。

DinkToPdf：

*渲染速度：* DinkToPdf 使用 wkhtmltopdf 引擎，該引擎對於基本的 HTML 到 PDF 轉換非常有效，但對於更複雜或動態的內容可能會比較吃力。 資源管理：**它通常需要大量的記憶體和處理能力，並且缺乏對非同步操作的原生支持，這限制了它在高負載場景下的效能。

EvoPDF：

*渲染速度：* EvoPDF 也像 IronPDF 一樣提供基於 Chrome 的渲染，效能良好，尤其適用於 HTML 到 PDF 的轉換。 資源管理：**雖然經過了良好的優化，但在某些情況下，由於優化力度不夠，它仍然可能比 IronPDF 消耗更多資源。

2.易用性

IronPDF：

• API 設計： IronPDF 提供現代化、直覺的 API，方便各種技能等級的開發人員使用。 該程式庫旨在與 .NET 應用程式無縫協作，因此是 C# 開發人員的絕佳選擇。 *文件和支援：*全面的文件、大量的程式碼範例和優秀的客戶支持，讓您輕鬆上手並快速解決問題。 安裝與整合：**可透過 NuGet 輕鬆安裝，並可無縫整合到現有的 .NET 專案中，只需極少的配置。

iTextSharp：

• API 設計： iTextSharp 的學習曲線陡峭，其 API 較為複雜，對於初學者來說可能難以駕馭。 它的靈活性是以犧牲簡潔性為代價的。 *文件和支援：*雖然文件齊全，但大量的配置選項可能會使查找常見任務的簡單範例變得困難。 安裝和整合：**可透過 NuGet 獲取，但需要對 API 有更深入的了解才能有效整合。

PDFsharp：

• API 設計： PDFsharp 的設計旨在簡化基本的 PDF 任務，但缺乏開箱即用的高級功能，這可能會限制其在更複雜場景中的使用。 *文件和支援：*雖然有基本文檔，但與 IronPDF 相比，文件內容較少，缺乏高級用法的詳細範例。 安裝與整合：**可透過 NuGet 輕鬆安裝，但 HTML 轉 PDF 功能有限。

DinkToPdf：

• API 設計： DinkToPdf 的 API 相對簡單，但與 IronPDF 相比不夠完善。 它主要針對 HTML 到 PDF 的轉換，對直接操作 PDF 的功能較少。 *文件與支援：*文件有限，社群支援也不如其他函式庫強大，這使得故障排除更加困難。 安裝和整合：**安裝可能比較複雜，需要額外的依賴項，例如 wkhtmltopdf，這會使設定變得複雜。

EvoPDF：

• API 設計： EvoPDF 提供了一個類似於 IronPDF 的簡單易用的 API，主要專注於 HTML 到 PDF 的轉換，並考慮了易用性。 *文件和支援：*文件齊全，支援選項良好，但在社群驅動的範例方面不如 IronPDF 廣泛。 安裝和整合：**可透過 NuGet 套件輕鬆整合到 .NET 專案中。

3.穩健性

IronPDF：

*功能集：* IronPDF 功能非常強大，支援多種功能，包括 HTML 轉 PDF、PDF 編輯、文字擷取、加密、註解和數位簽章。 錯誤處理：**提供強大的錯誤處理和異常管理，使其在生產環境中可靠運作。 *相容性：完全相容於 .NET Core、.NET 5+ 和舊版 .NET Framework，使其能夠靈活應用於不同類型的專案。

iTextSharp：

*功能集：* iTextSharp 功能非常強大，具有全面的功能集，幾乎支援任何 PDF 任務，包括複雜的操作和表單處理。 錯誤處理：**錯誤處理良好，但由於庫的複雜性，管理起來可能比較複雜。 *相容性：非常適合各種環境，包括 .NET Framework 和 .NET Core。

PDFsharp：

*功能集：*基本的 PDF 建立和操作功能。 缺少一些高級功能，例如 HTML 轉 PDF 和更高級的文件編輯功能。 錯誤處理：**基本錯誤處理； 與 IronPDF 等更強大的庫相比，在複雜場景下可靠性較低。 *相容性：與 .NET Framework 和 .NET Core 相容，但進階功能有限。

DinkToPdf：

*功能集：*主要著重於 HTML 轉 PDF。 在直接操作 PDF 方面存在局限性，並且缺乏註釋和表單處理等高級功能。 錯誤處理：**基本錯誤處理； 處理複雜的 HTML 或大型檔案時容易崩潰或卡住。 *相容性：可與 .NET Core 和 .NET Framework 配合使用，但需要外部依賴項，這可能會引入相容性問題。

EvoPDF：

*功能集：*提供與 IronPDF 類似的強大功能集，包括進階 HTML 到 PDF 轉換和一些文件操作功能。 錯誤處理：**在生產環境中提供強大的錯誤處理能力和可靠的效能。 *相容性：完全相容於 .NET Core、.NET Framework 和更新的 .NET 版本，使其用途廣泛且可靠。

概括

*效能：* IronPDF 和 EvoPDF 由於採用了基於 Chrome 的渲染引擎，因此在效能方面領先，而 iTextSharp 和 PDFsharp 在處理複雜文件方面可能落後。 易用性：** IronPDF 憑藉其直覺的 API 和豐富的文件脫穎而出，使各個層級的開發人員都能輕鬆上手。 iTextSharp 功能強大，但操作不夠簡單；而 DinkToPdf 和 PDFsharp 操作更簡便，但功能較少。 *穩健性： IronPDF 和 iTextSharp 提供最強大的功能集，其中 IronPDF 提供更簡單的整合和非同步支援等現代功能，而 iTextSharp 則涵蓋更多小眾用例，但學習曲線更陡峭。