No artigo de hoje veremos as funções locais, um novo recurso da versão 7.0 do C#.

As funções locais foram introduzidas na versão 7.0 da linguagem C#, mas o que são, afinal?

Funções locais são métodos privados de um tipo que está aninhado em outro membro.

As funções locais podem ser declaradas e chamadas em:

• Métodos
• Construtores
• Acessadores de propriedades
• Acessadores de eventos
• Métodos anônimos
• Expressões Lambdas
• Finalizadores
• Outras funções locais

Assim, podemos definir uma função dentro de outra função, mas não podemos declarar funções locais dentro de um Expression-Body Member.

Você pode usar esse recurso para isolar um método que possui um escopo limitado dentro de outro método.

Nota: o conceito de funções locais é semelhante aos métodos anônimos quando você precisa criar uma funcionalidade que é apenas local.

A figura abaixo exibe o escopo das funções locais:

• 1. Public Function: pode ser acessada de qualquer lugar do programa
• 2. Private Function: pode ser acessada somente a partir da classe onde foi declarada
• 3. Local Function: pode ser acessada somente a partir do membro na qual foi declarada

Vamos supor que você esteja criando um método chamado Calcular() para realizar cálculos que receberão uma expressão contendo o cálculo a ser realizado, e que esse cálculo envolve realizar operações de adição, subtração, multiplicação e divisão. Exemplo:

• [2 + ( 3*5)/2 – 1 ]

public static string Calcular(string expressao)   
{  
    string resultado = string.Empty;   
      // realizar cálculos
      // .......
    return resultado;  
}

Neste cenário os cálculos serão usados somente pelo método Calcular(). Podemos, então, pensar em criar funções locais ou métodos privados dentro do método Calcular().

Vamos criar quatro funções locais: Adicionar(), Subtrair(), Multiplicar() e Dividir(), dentro do método Calcular():

public static string Calcular(string expressao)   
{  
    string resultado = string.Empty;  
    T Adicionar < T > (T a, T b) { return (a + b);  }  
    T Subtrair < T > (T a, T b) { return (a - b);  }  
    T Multiplicar < T > (T a, T b) { return (a * b); }  
    T Dividir < T > (T a, T b) { return (a / b); }  
    return resultado;  
}

Vamos ver agora um exemplo prático de como calcular o fatorial de um número usando funções locais.

Temos a classe Calculo, contendo o método CalcularFatorial(), e no interior desse método definimos uma função local chamada Multiplicar(), que vai ser chamada apenas nesse método.

A seguir, temos o código que usa a classe Calculo() e o método CalcularFatorial():

 

Abaixo temos o resultado da execução do código:

Devemos lembrar algumas restrições das funções locais, que são:

• Não podemos incluir um modificador de acesso de membro
• Não podemos usar a palavra-chave static na definição de uma função local
• Não podemos aplicar atributos aos membros de uma função local

Pegue o projeto aqui: CShp_FuncLocal.zip.