C# programlama dünyasında lambda ifadeleri en güçlü özelliklerden biri olarak durur. Bu özlü ve ifadeli yapılar, geliştiricilerin kısa ama dayanıklı kod yazmalarını sağlar, okunabilirliği, sürdürülebilirliği ve genel verimliliği artırır.

Bu makalede, C# lambda ifadelerine derinlemesine dalacağız, sözdizimlerini, kullanım alanlarını, faydalarını ve gelişmiş tekniklerini keşfedeceğiz. IronPDF'nin becerilerini Iron Software den anlık olarak bir PDF belgesi üretebileceğini de keşfedeceğiz.

Lambda İfadeleri Anlamak

C# 3.0'da tanıtılan lambda ifadeleri, anonim fonksiyonlar veya delegeler tanımlamak için kısa bir yol sağlar. Esasen, lambda ifadeleri delegelerin beklendiği yerlerde kullanılabilecek satır içi anonim fonksiyonlardır.

Bir lambda ifadesinin sözdizimi:

(parameters) => expression // lambda expression syntax

(parameters) => expression // lambda expression syntax

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'(parameters) => expression ' lambda expression syntax

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'(parameters) => expression ' lambda expression syntax

Örnek:

x => x * x // lambda expression to square a number

x => x * x // lambda expression to square a number

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'x => x * x ' lambda expression to square a number

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'x => x * x ' lambda expression to square a number

Burada, parameters lambda ifadesinin giriş parametreleridir ve expression çalıştırılacak ifade veya ifade bloğudur. .NET ortak dil işletim sistemi, derleme zamanında her lambda ifadesi için anonim bir fonksiyon oluşturur.

Temel Kullanım

Lambda ifadesine bir örnek verilmesi için, elimizde bir dizi tamsayı olduğu ve çift sayıları filtrelemek istediğimiz bir duruma bakalım.

Bunu bir lambda ifadesi ile birlikte List<t>.FindAll yöntemi kullanılarak başarabiliriz:

List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
List<int> evenNumbers = numbers.FindAll(x => x % 2 == 0);

List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
List<int> evenNumbers = numbers.FindAll(x => x % 2 == 0);

Dim numbers As New List(Of Integer) From {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
Dim evenNumbers As List(Of Integer) = numbers.FindAll(Function(x) x Mod 2 = 0)

Dim numbers As New List(Of Integer) From {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
Dim evenNumbers As List(Of Integer) = numbers.FindAll(Function(x) x Mod 2 = 0)

Yukarıdaki örnekte, x => x % 2 == 0, bir tamsayı olan x değerini giriş parametresi olarak alan ve eğer x çiftse true döndüren bir lambda ifadesidir, aksi takdirde false döner. Lambda gövde ifadesi, listedeki her elemanda çalıştırılır.

Kullanım Alanları

Modern uygulama programlamasında lambda ifadesi kullanımı aşağıdaki dahil olmak üzere çeşitli kullanılan durumlar bulur:

1. LINQ Sorguları: Lambda ifadeleri, veri koleksiyonları üzerinde filtreleme, projeksiyon, sıralama ve gruplama işlemlerini gerçekleştirmek için LINQ (Language Integrated Query) içinde yaygın bir şekilde kullanılır.
2. Olay İşleme: Olaylar ve delegelerle çalışırken lambda ifadeleri, olay işleyicileri satır içinde tanımlamak için özlü bir yol sağlar.
3. Asenkron Programlama: Task.Run gibi asenkron programlama desenlerinde, çalıştırılacak asenkron işlemi tanımlamak için lambda ifadeleri kullanılabilir.
4. Fonksiyonel Programlama: Lambda ifadeleri, koleksiyonlar üzerinde harita, filtre ve indirgeme gibi işlemleri olan fonksiyonel programlama paradigmalarını destekler.

Lambda İfadeleri Türleri

İfade Lambdaları

=> ile olan lambda ifadelerine ifade lambdaları denir. Şu formatı alırlar:

x => x * x // expression to square a number

x => x * x // expression to square a number

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'x => x * x ' expression to square a number

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'x => x * x ' expression to square a number

Yukarıdaki örnekte, bir sayının karesini oluşturuyoruz. İfade lambdalarında, gövde çağrılar içerebilir. Ancak, .NET ortak dil işletim sistemi (CLR) dışında değerlendirilmesi amaçlanan ifade ağaçları oluştururken, örneğin SQL Server'da, lambda ifadeleri içinde herhangi bir yöntem çağrısından kaçınmak önerilir.

Bu, yöntemlerin CLR bağlamı dışında anlam ifade etmemesi nedeniyle olabilir. Bu nedenle, ifade ağacı oluştururken hedef ortamı göz önünde bulundurmak ve uyumluluk ve anlamlı yorumlama sağlamak önemlidir.

Önerge Lambdaları

Önerge lambda ifadeleri birden fazla beyanı yerine getirme ve daha karmaşık işlemler yapma imkanı tanır:

Func<int, int> mySquareDelegate = (x) =>
{
    return x * x;
};

Console.WriteLine(mySquareDelegate(4)); // Output: 16

Func<int, int> mySquareDelegate = (x) =>
{
    return x * x;
};

Console.WriteLine(mySquareDelegate(4)); // Output: 16

Dim mySquareDelegate As Func(Of Integer, Integer) = Function(x)
	Return x * x
End Function

Console.WriteLine(mySquareDelegate(4)) ' Output: 16

Dim mySquareDelegate As Func(Of Integer, Integer) = Function(x)
	Return x * x
End Function

Console.WriteLine(mySquareDelegate(4)) ' Output: 16

Bu kodda, tamsayılar üzerinde çalışan ve onların karesini döndüren bir delege beyan ediliyor. Lambda gövdesi, {} bloğu içinde birden fazla ifade içerebilir.

İleri Teknikler

Değişkenlerin Yakalanması

Lambda ifadeleri, kapsayıcı kapsamdan değişkenleri yakalayabilir. Bu özellik, değişken yakalama veya kapanış (closure) olarak bilinir ve lambda ifadelerinin gövdeleri dışında beyan edilen değişkenlere erişmesini ve kullanmasını sağlar:

int factor = 2;
Func<int, int> multiplier = x => x * factor;

int factor = 2;
Func<int, int> multiplier = x => x * factor;

Dim factor As Integer = 2
Dim multiplier As Func(Of Integer, Integer) = Function(x) x * factor

Dim factor As Integer = 2
Dim multiplier As Func(Of Integer, Integer) = Function(x) x * factor

Bu örnekte, lambda ifadesi x => x * factor, çevreleyen bağlamdan factor değişkenini yakalar.

Birden Fazla Parametre ve Önerge

Lambda ifadeleri birden fazla parametresi olabilir ve bir blok içinde birçok beyanı çalıştırabilir:

Func<int, int, int> add = (a, b) =>
{
    int result = a + b;
    Console.WriteLine($"The sum of {a} and {b} is {result}");
    return result;
};

Func<int, int, int> add = (a, b) =>
{
    int result = a + b;
    Console.WriteLine($"The sum of {a} and {b} is {result}");
    return result;
};

Dim add As Func(Of Integer, Integer, Integer) = Function(a, b)
	Dim result As Integer = a + b
	Console.WriteLine($"The sum of {a} and {b} is {result}")
	Return result
End Function

Dim add As Func(Of Integer, Integer, Integer) = Function(a, b)
	Dim result As Integer = a + b
	Console.WriteLine($"The sum of {a} and {b} is {result}")
	Return result
End Function

IronPDF: Iron Software'den Bir PDF Kütüphanesi

IronPDF'yi keşfedin Iron Software'in PDF Belgeleri oluşturmak için kullanılabilecek, kapsamlı ve yüksek performanslı bir PDF oluşturma ve ayrıştırma kütüphanesi.

IronPDF, aşağıdaki komutla NuGet paket yöneticisinden kurulabilir:

Install-Package IronPdf

Ya da aşağıda gösterilen şekliyle Visual Studio'dan kurulur:

Şimdi bir lambda ifadesi kullanarak PDF oluşturma işine dalalım:

using IronPdf; // Import the IronPdf library
using System;
using System.Collections.Generic;
using System.Linq;

namespace IronPatterns
{
    class Program
    {
        static void Main()
        {
            Console.WriteLine("-----------Iron Software-------------");
            var renderer = new ChromePdfRenderer(); // Initialize the PDF renderer
            var content = "<h1> Iron Software is Awesome </h1> Made with IronPDF!";
            content += "<h2>Demo C# lambda expressions</h2>";
            content += $"<p>Generating Square of list of numbers x=>x*x</p>";

            List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
            // Use Select to create a list of squared numbers
            List<int> squares = numbers.Select(x => x * x).ToList();

            content += $"<p>Numbers list: {string.Join(",", numbers)}</p>";
            content += $"<p>Squares: {string.Join(",", squares)}</p>";

            var pdf = renderer.RenderHtmlAsPdf(content); // Render the HTML as a PDF
            pdf.SaveAs("output.pdf"); // Save the PDF document
        }
    }
}

using IronPdf; // Import the IronPdf library
using System;
using System.Collections.Generic;
using System.Linq;

namespace IronPatterns
{
    class Program
    {
        static void Main()
        {
            Console.WriteLine("-----------Iron Software-------------");
            var renderer = new ChromePdfRenderer(); // Initialize the PDF renderer
            var content = "<h1> Iron Software is Awesome </h1> Made with IronPDF!";
            content += "<h2>Demo C# lambda expressions</h2>";
            content += $"<p>Generating Square of list of numbers x=>x*x</p>";

            List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
            // Use Select to create a list of squared numbers
            List<int> squares = numbers.Select(x => x * x).ToList();

            content += $"<p>Numbers list: {string.Join(",", numbers)}</p>";
            content += $"<p>Squares: {string.Join(",", squares)}</p>";

            var pdf = renderer.RenderHtmlAsPdf(content); // Render the HTML as a PDF
            pdf.SaveAs("output.pdf"); // Save the PDF document
        }
    }
}

Imports IronPdf ' Import the IronPdf library
Imports System
Imports System.Collections.Generic
Imports System.Linq

Namespace IronPatterns
	Friend Class Program
		Shared Sub Main()
			Console.WriteLine("-----------Iron Software-------------")
			Dim renderer = New ChromePdfRenderer() ' Initialize the PDF renderer
			Dim content = "<h1> Iron Software is Awesome </h1> Made with IronPDF!"
			content &= "<h2>Demo C# lambda expressions</h2>"
			content &= $"<p>Generating Square of list of numbers x=>x*x</p>"

			Dim numbers As New List(Of Integer) From {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
			' Use Select to create a list of squared numbers
			Dim squares As List(Of Integer) = numbers.Select(Function(x) x * x).ToList()

			content &= $"<p>Numbers list: {String.Join(",", numbers)}</p>"
			content &= $"<p>Squares: {String.Join(",", squares)}</p>"

			Dim pdf = renderer.RenderHtmlAsPdf(content) ' Render the HTML as a PDF
			pdf.SaveAs("output.pdf") ' Save the PDF document
		End Sub
	End Class
End Namespace

Imports IronPdf ' Import the IronPdf library
Imports System
Imports System.Collections.Generic
Imports System.Linq

Namespace IronPatterns
	Friend Class Program
		Shared Sub Main()
			Console.WriteLine("-----------Iron Software-------------")
			Dim renderer = New ChromePdfRenderer() ' Initialize the PDF renderer
			Dim content = "<h1> Iron Software is Awesome </h1> Made with IronPDF!"
			content &= "<h2>Demo C# lambda expressions</h2>"
			content &= $"<p>Generating Square of list of numbers x=>x*x</p>"

			Dim numbers As New List(Of Integer) From {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
			' Use Select to create a list of squared numbers
			Dim squares As List(Of Integer) = numbers.Select(Function(x) x * x).ToList()

			content &= $"<p>Numbers list: {String.Join(",", numbers)}</p>"
			content &= $"<p>Squares: {String.Join(",", squares)}</p>"

			Dim pdf = renderer.RenderHtmlAsPdf(content) ' Render the HTML as a PDF
			pdf.SaveAs("output.pdf") ' Save the PDF document
		End Sub
	End Class
End Namespace

Çıktı

Deneme Lisansı

IronPDF kodu, sadece IronPDF deneme lisansı sayfasından elde edilen deneme lisansıyla çalışabilir. Bir e-posta ID'si sağlayın ve size bir lisans anahtarı oluşturulacaktır, bu anahtar e-postanıza teslim edilecektir.

"IronPdf.LicenseKey": "<YourKey>"

"IronPdf.LicenseKey": "<YourKey>"

Lisans anahtarını AppSettings.json dosyasına yerleştirin.

Sonuç

C# lambda ifadeleri, kodu daha okunabilir, sürdürülebilir ve etkili hale getirerek satır içi fonksiyonları tanımlamak için özlü ve ifadeli bir yol sunar. Onlar, LINQ sorguları, olay işlemleri, asenkron programlama ve fonksiyonel programlama dahil olmak üzere birçok alanda uygulama bulurlar.

Lambda ifadelerini ustalaşarak, geliştiriciler C# kod tabanlarında yeni üretkenlik ve zarafet boyutlarını açığa çıkarabilirler.

İster deneyimli bir C# geliştirici olun isterse yeni başlamış olun, lambda ifadelerinin gücünü anlamak ve kullanmak, kesinlikle programlama becerilerinizi yeni zirvelere yükseltecektir.

Öyleyse dalın, deneyin ve C# projelerinizde lambda ifadelerinin güzelliğini kucaklayın!