6 consejos para escribir código C # elegante

Incluso si su fecha límite es ajustada, aún es posible escribir código hermoso. Entonces, he creado una lista de seis consejos para hacer que su sintaxis de C # sea elegante.

Escribir código no es una tarea fácil y, cuando se trata de escribir código de calidad , se vuelve aún más difícil.

Algo para recordar es que en programación tenemos varias formas de hacer algo, y mientras funcione, no significa que esa forma sea correcta o incorrecta.

Pero además de simplemente "trabajar", nuestra aplicación debe ser coherente y contener una buena sintaxis. Por lo tanto, a continuación se muestran algunos ejemplos de cómo mejorar aún más su escritura en C # y aumentar la calidad de su código.

1. Convenciones de nomenclatura 💅

Las convenciones de nomenclatura se refieren a la declaración de nombres de objetos. Debe seguir esto para tener un código agradable y coherente al nombrar sus objetos.

Para declarar una variable que devuelve una sola entidad / objeto, usamos un nombre simple. Para declarar una variable que devuelve múltiples entidades / objetos, es necesario agregar el sufijo "s" o "Lista" para que podamos identificar fácilmente que devolverá una lista de clases / objetos:

//avoid

var Item = new Item();

var ItemList = new List<Item>();



//use

var item = new Item();

 var items = new List<Item>();   

 //or  

 var itemList = new List<Item>(); 



//To declare a private variable, we use an underline (_)



//avoid 

private int value = 10;



//use

private int _value = 10;

Tabla de convenciones de nomenclatura

2. Optimización de la sintaxis 🦄

Hablamos sobre cómo, en programación, hay varias formas de hacer lo mismo, pero una cosa que siempre puede mejorar tu código es la optimización de la sintaxis. A continuación se muestran algunos ejemplos.

• Para declarar un método que devuelve solo un resultado, podemos declararlo de la siguiente manera:

//Avoid  

public ActionResult Dashboard()  

{  

    return View();  

}  



//Use  

public ActionResult Dashboard() => View();

• Para comprobar si hay condiciones nulas o vacías, utilice lo siguiente:

var varName = "John"; 



//Avoid  

if (varName != null && varName != "")  

{  

   //code  

}  



//Use

if (!string.IsNullOrEmpty(varName))  

{  

    //code  

}



//or (In C# 9 or more)



if (varName is { Length: >0 })

{

    //code

}

• Para verificar un valor nulo, use:

Test test = new Test();  



//Avoid  

var varName = test.Name != null ? test.Name : string.Empty;



//Use  

var varName = test.Name ?? string.Empty;

• Para unir cadenas, use:

Test test = new Test();



//Avoid  

var details = string.Format("{0}, you are welcome, Your Id is {1}", test.Name , test.Id + "_emp");  



//Use  

var details = $"{test.Name}, you are welcome, Your Id is {test.Id}_emp";



//or

var details = string.Join(" ,", test.Name, "you are welcome, Your Id is", test.Id, "_emp");

• Este último bloque de código demuestra cómo usar la nueva forma de cambio introducida en C # 8:

string firstName = "Thomas";

string favoriteTask = string.Empty;



//Good  

switch (firstName)

{

	case "Jennifer":

		favoriteTask = "Writing code";

		break;

	case "Thomas":

		favoriteTask = "Writing blog post";

		break;

	default:

		favoriteTask = "Watching TV";

		break;

}



//Better

favoriteTask = firstName switch

{

	"Jennifer" => "Writing code",

	"Thomas"  => "Writing blog post",

	_ => "Watching TV",

};

3. Validación del tipo de datos primitivos 🌟

Con el ajetreo de la vida cotidiana, a veces olvidamos que existen métodos disponibles para validar tipos de datos primitivos como System.Int32.

Cuando necesite realizar estas validaciones, evite el uso de métodos personalizados. En su lugar, utilice los métodos ya disponibles en el idioma para ello.

//Avoid

public bool CheckIfIsNumber(string value)

{

	bool isNumeric = true;

	try

	{

		int i = Convert.ToInt32(value);

	}

	catch (FormatException ex)

	{

		isNumeric = false;

	}

	return isNumeric;

}



//Use

public bool CheckIfIsNumberic(string value) => int.TryParse(value, out int _);

4. ¿Usar el operador condicional "?" (Ternario) Para verificación de valor nulo 🎯

Una forma de seguir el concepto de "Código limpio" y mejorar la legibilidad y escritura de su código en C # es utilizar el operador ternario "?".

Puede usarlo en los casos en que una declaración verifica la posibilidad de que un valor sea nulo; el operador de coalescencia nulo se puede usar para garantizar que se devuelva un valor no nulo.

El siguiente código devuelve el nombre del contacto recibido o el nombre predeterminado si el elemento es nulo. Como puede ver, este operador es una excelente opción cuando se trabaja con la condición nula.

//Avoid

public static string CheckContactNameError(Contact contact)

{

	var defaultName = "Default";



	if (contact.Name != null)

	{

		return contact.Name;

	}

	else

	{

		return defaultName;

	}

}



//Use

public static string CheckContactName(string contactName) => contactName ?? "Default";

5. Optimización de consultas con LINQ 🐍

Language-Integrated Query (LINQ) es el nombre de un conjunto de tecnologías basadas en la integración de capacidades de consulta directamente en el lenguaje C #.

LINQ simplifica las consultas al ofrecer un modelo coherente para trabajar con datos en varios tipos de fuentes y formatos. En una consulta LINQ, siempre está trabajando con objetos. Utiliza los mismos patrones de codificación básicos para consultar y transformar datos en documentos XML, bases de datos SQL, conjuntos de datos ADO.NET, colecciones .NET y cualquier otro formato para el que esté disponible un proveedor LINQ.

A continuación, obtendremos una lista de "Buenos precios" revisando una lista de "Empresas" que tienen "Productos" con varios "Precios de mercado".

Si el precio de mercado es menor que 100, agregamos el producto a la lista de buenos precios y lo devolvemos al final de la expresión.

//Good

public GoodPrice GetGoodPricesGood(List<Company> companies)

{

	GoodPrice goodPrices = new GoodPrice();



	foreach (Company company in companies)

	{

		foreach (Product product in company.Products)

		{

			if (product.MarketValue < 100)

			{

				goodPrices.Products.Add(product);

			}

		}

	}

	return goodPrices;

}



//Better

public GoodPrice GetGoodPricesBetter(List<Company> companies)

{

	GoodPrice goodPrices = new GoodPrice();



	IEnumerable<Product> lambdaProducts = companies.SelectMany(c => c.Products).Where(p => p.MarketValue < 100);

	goodPrices.Products = lambdaProducts.ToList();



	//Or

	//If you are not a fan of lambda expressions

	var products = from company in companies

				   from product in company.Products

				   where product.MarketValue < 100

			       select product;



	goodPrices.Products = products.ToList();



	return goodPrices;

}

6. Llenado de propiedades del objeto 😉

Establecer los valores de un objeto es muy común durante el desarrollo y hay muchas formas de hacerlo. Pero con este consejo, puede hacerlo más simple e intuitivo, además de facilitar el proceso de implementación de la prueba.

Para ello, usaremos un paradigma llamado "Código fluido". Está inspirado en LINQ, que ya hemos cubierto en este artículo. Puede investigar más sobre "Fluent Code"; es común usarlo para proyectos de prueba en los que el llenado de objetos se repite con frecuencia.

Tomemos un ejemplo:

 //Good

 public class Contact

 {

	 public string Name { get; set; }

	 public string Email { get; set; }

	 public long Phone { get; set; }

 }



public static Contact FillContactReady()

{

	Contact contact = new Contact();



	contact.Name = "John Smith";

	contact.Email = "johnsmith@email.com";

	contact.Phone = 25454471414;

	

	return contact;

}



//Better

public class FluentContact

{

	public class Contact

	{

		public string Name { get; set; }

		public string Email { get; set; }

		public long Phone { get; set; }

	}



	public Contact contact = new Contact();



	public FluentContact AddName(string name)

	{

		contact.Name = name;

		return this;

	}

	

	public FluentContact AddEmail(string email)

	{

		contact.Email = email;

		return this;

	}



	public FluentContact AddPhone(long phone)

	{

		contact.Phone = phone;

		return this;

	}

}



public static FluentContact FillFluentContactReady()

{

	return new FluentContact()

	.AddName("John Smith")

	.AddEmail("johnsmith@email.com")

	.AddPhone(25454471414);

}

Conclusión

Espero que a través de estos consejos te haya ayudado a escribir código limpio y elegante.

Tanto si es nuevo en .NET como si ya es un desarrollador experimentado, si utiliza estos consejos, sin duda será reconocido por escribir código de calidad y podrá alcanzar objetivos aún mayores.