Local functions

Aprendimos en artículos anteriores que los métodos y propiedades pertenecen a clases en C#. Dentro de los métodos, puede tener variables locales, que son variables solo accesibles en el alcance de este método específico. Esto tiene sentido porque a menudo tendras datos temporales que necesitará almacenar, pero que no deberían ser accesibles desde otras clases o incluso por otros métodos en la misma clase. Anteriormente, no se podía hacer lo mismo con los métodos: si un método se declaraba en una clase, solo se podía acceder a él desde otros métodos dentro de la misma clase, pero en la versión 7 de C #, el concepto de funciones localesera introducido

Una función local es declarada en un método existente y puede solamente ser accedida desde este método. Esto encapsula funcionalidad muy estrechamente y también hace claro a cualquier lector de su código que esta funcionalidad es solamente relevante para el método declarado. Una función local se parece a un método regular, pero sin el modificador de visibilidad, ya que una función local es siempre accesible desde dentro del método declarante. Aquí está un ejemplo:

public void MethodWithLocalFunction()
{
	bool doesNameStartWithUppercaseChar(string name)
	{
		if(String.IsNullOrEmpty(name))
			throw new Exception("name parameter must contain a value!");
		return Char.IsUpper(name[0]);
	}

	List<string> names = new List<string>()
	{
		"john doe",
		"Jane doe",
		"dog Doe"
	};

	foreach(string name in names)
		Console.WriteLine(name + " starts with uppercase char: " + doesNameStartWithUppercaseChar(name));
}

Un ejemplo un poco tonto, pero demuestra como puede declarar una función local (en este caso llamada doesNameStartWithUppercaseChar) dentro de un método (llamado MethodWithLocalFunction) y luego llamar una o varias veces desde el método.

Como puede ver en mi ejempo, declaré la función local en el inicio del método. Es libre de cambiar esto, por ejemplo, declarandolo en medio del método o en el final del método. Solamente en un caso hará una diferencia: Una función local es permitida para acceder variables declaradas dentro del método declarante, pero solamente si ellas han sido declaradas antes de la función local. Así si quiere tomar ventaja de este comportamiento, tendrá que modificar el método, por ejemplo como esto:

public void MethodWithLocalFunction()
{
	int nameMaxLength = 10;

	List<string> names = new List<string>()
	{
		"john doe",
		"Jane doe",
		"dog Doe"
	};

	foreach(string name in names)
		Console.WriteLine(name + " starts with uppercase char: " + doesNameStartWithUppercaseChar(name));

	bool doesNameStartWithUppercaseChar(string name)
	{
		if(String.IsNullOrEmpty(name))
			throw new Exception("name parameter must contain a value!");
		if(name.Length > nameMaxLength)
			throw new Exception("name is too long! Max length: " + nameMaxLength);
		return Char.IsUpper(name[0]);

	}
}

Note como declaro la variable nameMaxLength dentro del método y luego la acceso dentro de la función local.

Funciones estáticas locales

En C# version 8, fue agregado soporte para funciones estáticas locales . En cuanto a la escritura, la unica diferencia entre una función local regular y una estática local es el hecho de que la función estática local no puede usar variable de la declaración del método - en otras palabras, ellas no comparten más el alcance. Así si quiere asegurase de que su función local no haga referencia o cambie variables del método solo declarela como estática, como esto:

public void MethodWithLocalStaticFunction()
{
	int nameMaxLength = 10;
	
	static bool doesNameStartWithUppercaseChar(string name)
	{
		// Local variables, e.g. nameMaxLength, are no longer accessible here....
		if(String.IsNullOrEmpty(name))
			throw new Exception("name parameter must contain a value!");
		return Char.IsUpper(name[0]);
	}
	....
}

Resumen

En algunas situaciones, las funciones locales pueden ser de gran ayuda cuando necesita encapsular y reusar funcionalidad muy específica. Como una alternativa, si la funcionalidad puede ser reusada de otros métodos, puede querer considerar agregarla como un método real en una clase auxiliar o como un método de extensión.