Clean Code #04 (2nd Edition): Parámetros de Salida

Hemos visto, hasta el momento, algunas de las reglas que debemos tener para mejorar nuestro código y mantenerlo bien ordenado. Ahora veremos cómo trabajar de una mejor manera con parámetros de salida.

Veamos un ejemplo que debemos evitar y cuál es la causa, por la cual, debemos hacerlo.

int count = 0;
var products = GetProducts(pageIndex, out count);

En este fragmento podemos ver que tenemos un método que recibe un variable que será el total de products. El problema es que estamos obligados a declarar e inicializar una variable, pasarla al método y declararla como out para obtener el resultado de salida de la ejecución del método. Esto puede empeorar si tenemos mas parametros de salida como el siguiente código.

int count = 0;
bool other = false;

var products = GetProducts(pageIndex, out count, out other);

En este caso tenemos 2 variables de salida y declaramos 2 en el método como salida. Veamos cómo podemos refactorizar

public class OutputParameters
{
    public void DisplayProducts()
    {
        int totalCount = 0;
        var products = GetProducts(1, out totalCount);

        Console.WriteLine("Total products: " + totalCount);
        foreach (var c in products)
            Console.WriteLine(c);
    }
    public IEnumerable<Product> GetProducts(int pageIndex, out int totalCount)
    {
        totalCount = 100;
        return new List<Product>();
    }
}

Tenemos 2 métodos, GetProducts, este, requiere un parámetro de salida y DisplayProducts que es el que lo invoca o hace referencia.

Vamos a crear una clase que se llame GetProductsResult, con las siguientes propiedades:

public class GetProductsResult
{
    public IEnumerable<Product> Products { get; set; }
    public int TotalCount { get; set; }
    
}

Ahora podemos modificar nuestro código GetProducts para que retorne un resultado del tipo GetProductResult y eliminaremos el parámetro de salida, y por último, modificaremos el método para que devuelva GetProductResult.

public GetProductsResult GetProducts(int pageIndex)
    {
        totalCount = 100;
        return new GetProductsResult(){ Customers = new List<Customer>(), TotalCount = totalCount };
    }

Nuestro método que invoca quedará de la siguiente manera:

public void DisplayProducts()
    {
        int totalCount = 0;
        var result = GetProducts(1);
        totalCount = result.TotalCount;
        var products = result.Products;

        Console.WriteLine("Total products: " + totalCount);
        foreach (var p in products)
            Console.WriteLine(p);
    }

Otros Ajustes que debemos hacer son: 

• Var customers, no tiene mucho sentido, para esto la usaremos una Inline Variable. 
• El foreach tomamos la variable products y la cambiamos por result.Products. 
• Eliminaremos var products = result.Products. 

Lo mismo haremos con totalCount. Cambiaremos Console.WriteLine(«Total products: » + totalCount); para que también se una variable en línea.

   public void DisplayProducts()
    {
        int totalCount = 0;
        var result = GetProducts(1);
    
        Console.WriteLine("Total products: " + result.TotalCount);
        foreach (var p in result.Products)
            Console.WriteLine(p);
    }

Una cosa más, si vemos el método dice GetProducts(1). El 1 no dice que es. Para solucionarlo vamos cambiarlos por una constante para sea más significativo.

const int pageIndex = 1;
var result = GetProducts(pageIndex);

Otro camino es declararlo con una característica de c#:

var result = GetCustomers(pageIndex : 1);

Conclusiones

Finalmente, luego de realizar todos los pasos necesarios, nuestro código ha quedado limpio y mucho más fácil de leer. Siempre es mejor tener devolución de parámetros y no tener métodos void con parámetros de salida.

En próximos post veremos más cosas interesantes para mejorar nuestro código.