As poderosas Funções Anônimas e o Ecossistema C#

Uma função em C# geralmente segue o seguinte padrão: <Acesso> <modifiers> <return-type> <method-name> <parameter-list>

Acesso: Modificadores de acesso que tornam as funções publicas ou privadas, restrigindo ou não seu acesso fora ou dentro da classe onde ela é criada.

Modifiers são: asinc, unsafe, static, extern

Return-Type: É o tipo de retorno da função, como um objeto ou um tipo comum como string.

Method-Name: É o nome da função. Funções precisam ser nomeadas e devem começar com letra ou sublinhado (_).

Parameter-Lista: É a lista de parâmetros que uma função pode ter (passados por valor ou referência).

Ainda acrescento os

Exemplo de uma típica função local que soma dois inteiros e devolve o resultado.

public int soma(int a, int b)
{
return (a + b);
}

A palavra void especifica que a função não devolve nenhum valor (em outras linguagues como o pascal, é chamado de procedure).

public void mensagem(string mensagem)
{
Console.WriteLine(mensagem);
}

E a função anônima ?

Diz assim a definição: Uma função anônima é uma expressão que representa a definição de uma instrução em linha, é convertível a um delegate compatível ou do tipo expression tree.

Ou seja, função anônima é um método sem nome, é um método que não tem um símbolo associado a ele em tempo de compilação.

Geralmente declaramos assim: ( parâmetros de entrada ) => {expressão ou bloco de instrução};

Exemplo simples de uma função anônima:

static Func SomaLambda = i => i + 2;

E a chamada a esse método seria assim:

...

class Program

static void Main(string[] args)
{
 Console.WriteLine(SomaLambda(2));
}

Outro exemplo de função anônima:

Func<int, int> square = x => x * x;
Console.WriteLine(square(5));
// Output:
// 25

A mais trivial função anônima sem parâmetros e nome algum

() => Console.WriteLine()          // Sem parametros

Outras variantes de função anônima (lambda)

x => x + 1                         // tipo Implicito, expressão

x => { return x + 1; }             // tipo Implicito, bloco de instrução

(int x) => x + 1                   // tipo explicito, expressão

(int x) => { return x + 1; }       // tipo explicito, bloco de instrução

(x, y) => x * y                    // multiplos parametros

() => Console.WriteLine()          // Sem parametros

O uso de funções anônimas depende consideravelmente do estilo de programação adotado por cada desenvolvedor. Elas representam interações poderosas que têm o potencial de aprimorar o código produzido e refatorar para uma versão mais concisa, o que resulta em uma codificação mais limpa.

Essas expressões são frequentemente empregadas em consultas LINQ baseadas em métodos, servindo como argumentos para os métodos dos operadores de consulta padrão, como o Where.

Um exemplo seria como o código abaixo:

var fornecedores = lista.Where (fornec => fornec.Nome == "Nagem&Cia");

Segue documentação sobre este tema:

https://learn.microsoft.com/pt-br/dotnet/csharp/language-reference/operators/lambda-expressions

https://www.devmedia.com.br/csharp-lambda-expression-extension-methods-e-o-uso-de-nullable-types-hasvalue/16641

https://learn.microsoft.com/pt-br/dotnet/fundamentals/code-analysis/style-rules/ide0039

https://imasters.com.br/desenvolvimento/c-expressoes-lambda-revisitado#:~:text=Ao%20usar%20express%C3%B5es%20lambda%2C%20voc%C3%AA,escrever%20express%C3%B5es%20de%20consulta%20LINQ.