W świecie programowania w języku C# wyrażenia lambda są jedną z najpotężniejszych funkcji. Te zwięzłe i wyraziste konstrukcje umożliwiają programistom pisanie kompaktowego, a jednocześnie solidnego kodu, poprawiając czytelność, łatwość konserwacji i ogólną wydajność.

W tym artykułe zagłębimy się w wyrażenia lambda w języku C#, badając ich składnię, przypadki użycia, zalety i zaawansowane techniki. Zbadamy również, w jaki sposób funkcje IronPDF firmy Iron Software mogą generować dokumenty PDF w locie w aplikacjach C#.

Zrozumienie wyrażeń lambda

Wyrażenia lambda, wprowadzone w C# 3.0, zapewniają zwięzły sposób definiowania funkcji anonimowych lub delegatów. Są to zasadniczo wbudowane funkcje anonimowe, których można używać wszędzie tam, gdzie wymagany jest typ delegata.

Składnia wyrażenia lambda jest następująca:

(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

Przykład:

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

Tutaj, parameters to parametry wejściowe wyrażenia lambda, a expression to instrukcja lub blok instrukcji do wykonania. Środowisko uruchomieniowe .NET Common Language Runtime tworzy anonimową funkcję dla każdego wyrażenia lambda w czasie kompilacji.

Podstawowe zastosowanie

Przyjrzyjmy się przykładowi wyrażenia Lambda, w którym mamy listę liczb całkowitych i chcemy odfiltrować liczby parzyste.

Możemy to osiągnąć, używając metody List<t>.FindAll wraz z wyrażeniem lambda:

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)

W powyższym przykładzie x => x % 2 == 0 to wyrażenie lambda, które przyjmuje liczbę całkowitą x jako parametr wejściowy i zwraca true, jeśli x jest parzysta, a false w przeciwnym razie. Wyrażenie ciała lambdy jest wykonywane na każdym elemencie listy.

Przykłady zastosowań

Wykorzystanie wyrażenia Lambda w nowoczesnym programowaniu aplikacji znajduje wiele zastosowań, w tym:

1. Zapytania LINQ: Wyrażenia lambda są szeroko stosowane w LINQ (Language Integrated Query) do wykonywania operacji filtrowania, projekcji, sortowania i grupowania zbiorów danych.
2. Obsługa zdarzeń: Podczas pracy ze zdarzeniami i delegatami wyrażenia lambda zapewniają zwięzły sposób definiowania procedur obsługi zdarzeń w kodzie.
3. Programowanie asynchroniczne: W asynchronicznych wzorcach programowania, takich jak Task.Run, wyrażenia lambda mogą być używane do definiowania asynchronicznej operacji do wykonania.
4. Programowanie funkcjonalne: Wyrażenia lambda obsługują paradygmaty programowania funkcjonalnego, umożliwiając operacje takie jak map, filter i reduce na zbiorach.

Rodzaje wyrażeń Lambda

Wyrażenia lambda

Wyrażenia lambda z => nazywa się wyrażeniami lambda. Mają one następujący format:

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

W powyższym przykładzie tworzymy kwadrat liczby. W wyrażeniach lambda treść może zawierać wywołania metod. Jednak podczas generowania drzew wyrażeń przeznaczonych do oceny poza środowiskiem .NET Common Language Runtime (CLR), np. w SQL Server, zaleca się unikanie wywołań metod w wyrażeniach lambda.

Wynika to z faktu, że metody mogą nie mieć znaczenia poza kontekstem CLR. Dlatego podczas tworzenia drzewa wyrażeń kluczowe znaczenie ma uwzględnienie środowiska docelowego, aby zapewnić kompatybilność i sensowną interpretację.

Wyrażenia lambda

Wyrażenia lambda typu statement pozwalają na stosowanie wielu instrukcji i umożliwiają wykonywanie bardziej złożonych operacji:

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

W tym kodzie zadeklarowano delegat, który działa na liczbach całkowitych i zwraca ich kwadrat. Ciało lambdy może zawierać wiele instrukcji wewnątrz bloku {}.

Zaawansowane techniki

Przechwytywanie zmiennych

Wyrażenia lambda mogą przechwytywać zmienne z otaczającego zakresu. Ta funkcja, znana jako przechwytywanie zmiennych lub zamknięcie, pozwala wyrażeniom lambda na dostęp do zmiennych zadeklarowanych poza ich treścią oraz na ich wykorzystanie:

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

W tym przykładzie wyrażenie lambda x => x * factor przechwytuje zmienną factor z otaczającego zakresu.

Wiele parametrów i instrukcji

Wyrażenia lambda mogą mieć więcej niż jeden parametr i wykonywać wiele instrukcji zawartych w bloku:

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: biblioteka PDF firmy Iron Software

Poznaj IronPDF jako wszechstronną i wydajną bibliotekę do generowania i analizowania plików PDF firmy Iron Software, którą można wykorzystać do tworzenia dokumentów PDF.

IronPDF można zainstalować z menedżera pakietów NuGet za pomocą poniższego polecenia:

Install-Package IronPdf

Lub zainstalować z Visual Studio, jak pokazano poniżej:

Przejdźmy teraz do generowania plików PDF przy użyciu wyrażenia lambda:

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

Wynik

Licencja Trial

Kod IronPDF może działać wyłącznie z Licencją Trial uzyskaną ze strony Licencji Trial IronPDF. Podaj adres e-mail w wyskakującym okienku, aby wygenerować klucz licencyjny i otrzymać go na swoją skrzynkę e-mailową.

"IronPdf.LicenseKey": "<YourKey>"

"IronPdf.LicenseKey": "<YourKey>"

Umieść klucz licencyjny w pliku AppSettings.json.

Wnioski

Wyrażenia lambda w języku C# oferują zwięzły i wyrazisty sposób definiowania funkcji wbudowanych, dzięki czemu kod staje się bardziej czytelny, łatwiejszy w utrzymaniu i wydajniejszy. Znajdują one zastosowanie w różnych dziedzinach, w tym w zapytaniach LINQ, obsłudze zdarzeń, programowaniu asynchronicznym i programowaniu funkcjonalnym.

Opanowując wyrażenia lambda, programiści mogą odkryć nowe wymiary produktywności i elegancji w swoich kodach C#.

Niezależnie od tego, czy jesteś doświadczonym programistą C#, czy dopiero zaczynasz swoją przygodę, zrozumienie i wykorzystanie potęgi wyrażeń lambda bez wątpienia wyniesie Twoje umiejętności programistyczne na nowy poziom.

Zanurz się więc w tym świecie, eksperymentuj i odkryj piękno wyrażeń lambda w swoich projektach C#!