C# Eşzamanlı Liste (Geliştiriciler İçin Nasıl Çalışır)

C#'da İş Parçacığı Güvenliği ve Eşzamanlı Koleksiyonlar

Trafik lambalarının olmadığı hareketli bir şehir kavşağını hayal etmeye başlayalım. Kaosu hayal edebilirsiniz! Bu, birden fazla iş parçacığının uygun bir sistem olmaksızın aynı anda paylaşılan bir kaynağa eriştiğinde meydana gelen duruma benzer. Neyse ki, C#'da iş parçacıklarımız için trafik lambalarımız var - bunlara eşzamanlı koleksiyonlar denir. Bu koleksiyon sınıfları, aynı anda tek bir iş parçacığının bir kaynağa erişmesine izin verir. Bu iş parçacığı güvenliği, birden fazla iş parçacığı ile çalışırken önemlidir.

C#'da Eşzamanlı İş Parçacığı Güvenli Koleksiyonları Keşfetme

C# dilinde, System.Collections.Concurrent ad alanı ConcurrentDictionary, ConcurrentQueue, ConcurrentStack ve ConcurrentBag gibi çeşitli eşzamanlı koleksiyon sınıflarına sahiptir. Bu düzensiz koleksiyon sınıfları, eşzamansız meslektaşlarının iş parçacığı güvenli bir versiyonunu sunar. Eşzamanlı koleksiyonları farklı kılan, onların düzensiz eşzamanlı koleksiyonları olmasıdır; yani, öğeler belirli bir sıraya sahip değildir. Örneğin, bir eşzamanlı listede, bir öğenin tam olarak nereye ekleneceğini bilemezsiniz. Odak, sırayı korumaktan ziyade iş parçacığı güvenliğini sağlamaktır.

Gerçek bir örnek ele alalım. Bir web sitesinde parola gönderme gönderisini düşünün. Bir eşzamanlı koleksiyon ile birden fazla kullanıcı parolalarını aynı anda gönderebilir. Her 'gönder' işlemi bir iş parçacığı gibidir ve eşzamanlı koleksiyon, her gönderimin iş parçacığı güvenliğini, güvenli ve etkili bir şekilde işlenmesini sağlamak için vardır.

ConcurrentDictionary: Gerçek Dünya Örneği

Şimdi, gerçek yaşamdan bir örnekle ConcurrentDictionary koleksiyon sınıfını inceleyelim. Bir öneri özelliği olan çevrimiçi bir kitapçı hayal edin. Her kullanıcının tıklaması, bir sözlük ile temsil edilen kişisel öneri listelerine bir kitap ekler. Birden fazla kullanıcı aynı anda kitaplara göz atıp tıklarken, sözlük'e eşzamanlı olarak erişen birden fazla iş parçacığımız var.

C# dilinde bir ConcurrentDictionary şöyle görünebilir:

using System.Collections.Concurrent;

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

using System.Collections.Concurrent;

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

Imports System.Collections.Concurrent

Private recommendedBooks As New ConcurrentDictionary(Of String, String)()

Bir kullanıcının tüm tavsiye koleksiyonuna bir kitap eklemek için TryAdd yöntemini kullanabiliriz:

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

Public Sub Insert(ByVal user As String, ByVal book As String)
	' Try to add the book to the user's recommendations
	recommendedBooks.TryAdd(user, book)
End Sub

Bu senaryoda, ConcurrentDictionary koleksiyon sınıfı her tıklamanın (veya 'iş parçacığının') ayrı ayrı ele alınmasını sağlar, böylece iki kullanıcının tavsiyeleri karışmaz. İş parçacığı güvenliğinin tümünü ele alır, böylece siz çoklu iş parçacıklarına ilişkin veri yarışmaları ve diğer eşzamanlılık sorunları hakkında endişelenmek zorunda kalmazsınız.

İş Parçacık Güvenli İşlemlerinin Uygulanması

TryAdd dışında, C# dilindeki eşzamanlı koleksiyonlar TryRemove ve TryUpdate gibi çeşitli başka iş parçacığı güvenli işlemleri sağlar. Bu yöntemler, yalnızca bir iş parçacığının bir işlemi aynı anda gerçekleştirebilmesini sağlar. Örneğin, önceki örnekte bir kullanıcının tavsiyelerinden bir kitabı çıkarmak isteseydik, TryRemove yöntemini kullanabilirdik:

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

Public Sub RemoveAt(ByVal user As String)
	' Attempt to remove the book for the specified user
	Dim removedBook As String = Nothing
	recommendedBooks.TryRemove(user, removedBook)
End Sub

TryRemove yöntemi, sağlanan anahtarın (bu durumda bir kullanıcı) değerini kaldırmayı dener ve onu removedBook değişkenine koyar.

Eşzamanlı Koleksiyonları Kopyalama

Şimdi, eşzamanlı koleksiyonunuzu bir diziye kopyalamak istediğinizi varsayalım. Eşzamanlı koleksiyonlar, tam olarak bu amaç için CopyTo yöntemini sunar:

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

Public Sub CopyTo()
	' Create an array to hold the recommended books
	Dim bookArray(recommendedBooks.Count - 1) As String

	' Copy the values of the concurrent dictionary to the array
	recommendedBooks.Values.CopyTo(bookArray, 0)
End Sub

Burada CopyTo yöntemi, recommendedBooks eşzamanlı sözlükten tüm kitapları (değerleri) bookArray içine kopyalar.

İş Parçacık Güvenli Koleksiyon

C# ayrıca iş parçacığı güvenli koleksiyonlar sağlar, bu koleksiyonlar çok iş parçacıklı ortamlarda paylaşılan kaynaklara güvenli erişimi sağlamak için tasarlanmıştır. Bu koleksiyonlar, ConcurrentBag, ConcurrentQueue ve ConcurrentStack gibi, çoklu iş parçacıklarının aynı anda koleksiyona erişip değiştirebilmesini ve çatışma veya veri bozulmasına yol açmadan işlem yapabilmelerini sağlamak için iş parçacığı güvenli uygulamalar sunar.

Senkronizasyonu dahili olarak yöneterek tutarlılığı ve bütünlüğü garanti ederler, bu da sırasız bir koleksiyonun yeterli olduğu ve iş parçacığı güvenliğinin C# uygulamalarınızda en önemli olduğu senaryolar için onları ideal hale getirir.

IronPDF Hakkında Daha Fazla Bilgi Edinin, HTML'den çok kolay bir şekilde PDF belgeleri üretmenize olanak tanıyan popüler bir C# kütüphanesidir.

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

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 Class

Başlangıçta eşzamanlı listelerle doğrudan ilgili görünmese de IronPDF, eşzamanlı koleksiyon işlemlerini tamamlayarak eşzamanlı işlem sonuçlarını yakalayan PDF raporları, logları veya başka herhangi bir belge oluşturmaya kolay bir yol sağlar.

Veri işleme ile ilgili yoğun işlem yapan çok iş parçacıklı bir uygulamanız olduğunu düşündüğünüzde. İş parçacıkları veri üzerinde çalışmalarını gerçekleştirirken, sonuçları yakalamak ve daha fazla analiz veya kayıt tutma için bir PDF raporu oluşturmak isteyebilirsiniz. İşte burada IronPDF devreye girer.

IronPDF kullanmak, kütüphaneyi projenize eklemek ve kullanışlı API'sini kullanmak kadar basittir. İşte IronPDF'i eşzamanlı koleksiyon işlemleriyle nasıl entegre edebileceğinize dair bir örnek:

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
}

Imports IronPdf
Imports System.Collections.Concurrent
Imports System.Collections.Generic
Imports System.Threading.Tasks

' Create a concurrent dictionary to hold your processed data
Private processedData As New ConcurrentDictionary(Of Integer, String)()

' Define your data list (replace with your actual data source)
Private dataList As List(Of DataItem) = GetDataList()

' Process your data concurrently and store the results in the dictionary
Parallel.ForEach(dataList, Sub(dataItem)
	' Process each data item and add the result to the dictionary
	Dim processedResult As String = ProcessDataItem(dataItem)
	processedData.TryAdd(dataItem.Id, processedResult)
End Sub)

' Generate a PDF report with the processed data
Dim renderer = New ChromePdfRenderer()
Dim 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)
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'List(Of 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)
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'string ProcessDataItem(DataItem dataItem)
'{
'	' Simulating data processing with a delay
'	Task.Delay(100).Wait();
'	Return string.Format("Processed: {0}", dataItem.Name);
'}

' Method to build the HTML report using the processed data (replace with your actual reporting logic)
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'string BuildHtmlReport(ConcurrentDictionary(Of int, string) processedData)
'{
'	string html = "<h1>Processed Data Report</h1><ul>";
'	foreach (var kvp in processedData)
'	{
'		html += string.Format("<li>Item {0}: {1}</li>", kvp.Key, kvp.Value);
'	}
'	html += "</ul>";
'	Return html;
'}

' Placeholder class for your data item (replace with your actual data item class)
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'public class DataItem
'{
'	public int Id
'	{
'		get;
'		set;
'	}
'	public string Name
'	{
'		get;
'		set;
'	}
'	' Add other properties as needed
'}

İşte kodun çıktısı:

Sonuç

Sonuç olarak, eşzamanlı listeler gibi C# eşzamanlı koleksiyonları anlamak ve kullanmak, çok iş parçacıklı senaryoları yönetme yeteneğinizi büyük ölçüde artırabilir ve uygulamalarınızda iş parçacık güvenliğini sağlayabilir. Eşzamanlı koleksiyonlarla, paylaşılan kaynakları etkili bir şekilde yönetebilir, iş parçacıkları arasında veri yarışları ve çarpışmaları önleyebilirsiniz.

IronPDF gibi harici kütüphaneleri entegre etmek, eşzamanlı koleksiyonların işlevselliğini, görsel olarak çekici PDF raporları veya belgeleri oluşturmayı sağlayarak daha da artırabilir. IronPDF, HTML'den PDF'e dönüştürme kütüphanesi için bir ücretsiz deneme sunar, bu sayede yeteneklerini keşfedebilir ve $799'dan başlayan lisans seçeneklerini değerlendirebilirsiniz.