Altbilgi içeriğine atla
.NET YARDıM

C# Lambda İfadeleri (Geliştiriciler için Nasıl Çalışır)

C# programlama alanında, lambda ifadeleri en güçlü özelliklerden biri olarak öne çıkar. Bu öz ve ifadeli yapılar, geliştiricilerin kompakt ama güçlü kod yazmasına olanak tanır, okunabilirliği, sürdürülebilirliği ve genel verimliliği artırır.

Bu makalede, C# lambda ifadelerine derinlemesine dalacağız, sözdizimini, kullanım durumlarını, faydalarını ve ileri teknikleri keşfedeceğiz. IronPDF'nin olanaklarının, Iron Software bağlantısından, C# uygulamalarında anında PDF belgesi oluşturabileceğini de keşfedeceğiz.

Lambda İfadeleri Anlama

C# 3.0'da tanıtılan lambda ifadeleri, anonim fonksiyonları veya delege tanımlamanın özlü bir yolunu sunar. Temelde bir delege türü beklendiğinde 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
$vbLabelText   $csharpLabel

Ö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
$vbLabelText   $csharpLabel

Burada, parameters lambda ifadesinin giriş parametreleridir ve expression çalıştırılacak deyim veya deyim bloklarıdır. .NET ortak dil çalışma zamanı, derleme zamanında her bir lambda ifadesi için anonim bir işlev oluşturur.

Temel Kullanım

Integer listesinin bulunduğu bir Lambda ifadesi örneğine bakalım ve doğru sayıları filtrelemek istiyoruz.

Bunu List<t>.FindAll yöntemini ve bir lambda ifadesini kullanarak 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)
$vbLabelText   $csharpLabel

Yukarıdaki örnekte x => x % 2 == 0, bir tamsayı x alan ve eğer x çiftse true döndüren, aksi halde false döndüren bir lambda ifadesidir. Lambda gövdesi ifadesi her liste ögesi üzerinde çalıştırılır.

Kullanım Alanları

Modern uygulama programlamasında bir Lambda ifadesi kullanmak, aşağıdakiler de dahil olmak üzere çeşitli kullanım durumlarına sahiptir:

  1. LINQ Sorguları: Lambda ifadeleri, veri koleksiyonları üzerinde filtreleme, projeksiyon, sıralama ve gruplama işlemleri yapmak için LINQ'de (Dil Entegre Sorgusu) yaygın olarak kullanılır.
  2. Olay İşleme: Olaylar ve delegeerle çalışırken, lambda ifadeleri olaya bağlılayıcıları satır içi tanımlamak için özlü bir yol sunar.
  3. Asenkron Programlama: Task.Run gibi asenkron programlama kalıplarında, çalıştırılacak asenkron işlemi tanımlamak için lambda ifadeleri kullanılabilir.
  4. Fonksiyonel Programlama: Lambda ifadeleri fonksiyonel programlama paradigmalarını destekler, haritalama, filtreleme ve koleksiyonlar üzerinde azaltma gibi işlemleri sağlar.

Lambda ifadelerinin türleri

İfade Lambdaları

=> ile lambda ifadelerine ifade lambdaları denir. Formatları şöyle olur:

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
$vbLabelText   $csharpLabel

Yukarıdaki örnekte, bir sayının karesini oluşturuyoruz. İfade lambdalarında, gövdeye yöntem çağrıları dahil edilebilir. Ancak, .NET Ortak Dil Çalışma Zamanı (CLR) dışında değerlendirilmesi amaçlanan ifade ağaçları oluştururken, SQL Server gibi, lambda ifadeleri içinde herhangi bir yöntem çağrısından kaçınılması tavsiye edilir.

Bu, yöntemlerin CLR bağlamı dışında anlam taşımayabileceği içindir. Bu nedenle, bir ifade ağacı oluştururken hedef ortamı düşünmek, uyumluluğu ve anlamlı yorumu sağlamak önemlidir.

İfade ve Gövde Lambdaları

Gövde lambda ifadeleri birden çok ifadeye izin verir ve daha karmaşık işlemleri sağlar:

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
$vbLabelText   $csharpLabel

Bu kodda, tamsayılar üzerinde çalışan ve bunların karesini döndüren bir delege tanımlanır. Lambda gövdesi, bir blok {} içinde birden fazla deyimi kapsayabilir.

Gelişmiş Teknikler

Değişken Yakalama

Lambda ifadeleri, kapsayan kapsamdan değişkenleri yakalayabilir. Değişken yakalama veya kapatma olarak bilinen bu özellik, lambda ifadelerinin gövdesi dışında tanımlanan değişkenlere erişip kullanmasına olanak 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
$vbLabelText   $csharpLabel

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

Çoklu Parametreler ve İfadeler

Lambda ifadeleri birden fazla parametreye sahip olabilir ve bir @@--CODE-6995--@@ içinde birden fazla ifade ç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
$vbLabelText   $csharpLabel

IronPDF: Iron Software'dan PDF Kütüphanesi

IronPDF'yi Keşfedin ve Iron Software'dan PDF Belgeler oluşturmak için kullanılabilen çok yönlü ve yüksek performanslı bir PDF oluşturma ve çözümleme kütüphanesi.

IronPDF'yi NuGet paket yöneticisinden aşağıdaki komutla yükleyebilirsiniz:

Install-Package IronPdf

Veya aşağıda gösterildiği gibi Visual Studio'dan yüklendiği gibi:

C# Lambda İfadeleri (Geliştiriciler İçin Nasıl Çalışır): Şekil 1 - IronPDF'in NuGet paket yöneticisi ile yüklenmesi

Şimdi bir lambda ifadesini 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
$vbLabelText   $csharpLabel

Çıktı

C# Lambda İfadeleri (Geliştiriciler İçin Nasıl Çalışır): Şekil 2

Deneme Lisansı

IronPDF kodu yalnızca IronPDF deneme lisansı sayfasından alınan bir deneme lisansı ile çalıştırılabilir. Bir lisans anahtarı üretmek ve bu anahtarı e-posta ile teslim etmek için açılır pencerede bir E-posta kimliği verin.

"IronPdf.LicenseKey": "<YourKey>"

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

Sonuç

C# lambda ifadeleri, satır içi işlevleri tanımlamak için özlü ve ifadeli bir yol sunar, bu da kodu daha okunabilir, sürdürülebilir ve verimli hale getirir. Çeşitli alanlarda uygulama bulurlar, özelikle LINQ sorguları, olay işleme, asenkron programlama ve fonksiyonel programlamada.

Lambda ifadelerinde ustalaşarak, geliştiriciler, C# kod temellerinde yeni üretkenlik ve zarafet boyutlarının kilidini açabilirler.

İster deneyimli bir C# geliştiricisi olun, ister yolculuğunuzun başında olun, lambda ifadelerinin gücünü anlamak ve kullanmak programlama becerilerinizi yeni yüksekliklere çıkaracaktır.

Bu yüzden dalın, deneyin ve C# projelerinizde lambda ifadelerinin güzelliğini kucaklayın!

Sıkça Sorulan Sorular

C#'da lambda ifadeleri kullanarak PDF'leri nasıl üretebilirim?

IronPDF ile programatik olarak PDF'ler üretirken lambda ifadelerini kodu düzene sokmak için kullanabilirsiniz. Örneğin, IronPDF'in yöntemlerini kullanarak bir PDF belgesine dönüştürmeden önce verileri filtrelemek üzere bir lambda kullanabilirsiniz.

Lambda ifadelerinin LINQ sorgularındaki önemi nedir?

Lambda ifadeleri, veri filtreleme, sıralama ve yansıtma gibi işlemler için işlev tanımlamak üzere özlü bir yol sağlayarak LINQ sorgularında kritik bir rol oynar. Bu, C#'ta LINQ sorgularının okunabilirliğini ve etkinliğini artırır.

Lambda ifadeleri, C#'da asenkron programlamayı nasıl iyileştirir?

Lambda ifadeleri, geliştiricilerin çağrı geri döndürme işlevlerini satır içinde tanımlamalarına izin vererek asenkron programlamayı basitleştirir. Bu, özellikle olay odaklı programlamada ve asenkron görevleri ele alırken kullanışlıdır, kodu daha okunabilir ve sürdürülebilir hale getirir.

C# uygulamalarında olay işleme işlemlerinde lambda ifadeleri kullanılabilir mi?

Evet, lambda ifadeleri, olay işleyicilerini özlü bir şekilde tanımlama yetenekleri nedeniyle genellikle olay işlemekte kullanılır. Bu, kodu daha temiz ve sezgisel hale getirebilir, özellikle IronPDF gibi belgelerin olayları için kütüphaneler kullanıldığında.

C#'da ifade lambdaları ile deyim lambdaları arasındaki farklar nelerdir?

İfade lambdaları tek bir ifade içerir ve x => x * x söz dizimini kullanırken, deyim lambdaları bir blok içinde birden çok deyim içerebilir ve (x) => { return x * x; } söz dizimini kullanır. Bu fark, geliştiricilerin fonksiyonun karmaşıklığına göre seçim yapmasına olanak tanır.

Değişken yakalama, lambda ifadelerinin işlevselliğini nasıl artırabilir?

Lambda ifadeleri, etraflarındaki kapsamdan değişkenleri yakalayabilir, bu özellik değişken yakalama veya kapanış olarak bilinir. Bu, dış değişkenlere erişim ve kullanımına olanak tanır, C#'da daha dinamik ve esnek işlev tanımlarına olanak tanır.

Birden fazla parametre ile lambda ifadeleri kullanmanın bazı ileri teknikleri nelerdir?

Lambda ifadeleri, parantez içinde virgülle ayrılan birden çok parametreyi ele alabilir. Bu esneklik, geliştiricilerin satır içinde karmaşık fonksiyonlar tanımlamasına olanak tanır, bu da IronPDF ile karmaşık PDF belgeleri oluşturma gibi ileri programlama senaryolarında kullanılabilir.

Jacob Mellor, Teknoloji Direktörü @ Team Iron
Chief Technology Officer

Jacob Mellor, Iron Software'in Teknoloji Müdürü ve C# PDF teknolojisinin öncüsü olan vizyoner bir mühendis. Iron Software’in temel kod tabanının ilk geliştiricisi olarak, şirketin ürün mimarisini kuruluşundan bu yana şekillendirdi ve CEO Cameron Rimington ile birlikte NASA, Tesla ve ...

Daha Fazlasını Oku

Iron Destek Ekibi

Haftanın 5 günü, 24 saat çevrimiçiyiz.
Sohbet
E-posta
Beni Ara