Estándares de escritura C# (Parte I)
Tags: csharp, dotnet, programming, spanish
Published: 2022-07-31 23:25:00

Como desarrolladores parte de nuestro tiempo es la escritura del código para las funcionalidades de una solución del negocio. Esta actividad no es solo escribirlo y ya, sino también es escribirlo bien e implementando buenas prácticas.
Por eso, hoy hablaremos de los Estandares de la escritura de código en el lenguaje C#.

##¿Qué es un estandar de escritura?
Primero hay que saber que un estándar es la forma de hacer algo con una serie de rúbricas que lo harán comprensible a otras personas del rubro. Por eso en el código cada una de las lineas debería implementar las buenas practicas.

Algunas de las ventajas de implementarlo son:

- Dan una apariencia más coherente a nuestro código, para que los lectores puedan centrarse en el contenido, no en el diseño.
- Permiten la rapida comprensión del código al poder hacer suposiciones basadas en experiencias anteriores.
- Facilitan la realización de copias, cambios y mantenimiento del código.
- Muestran los procedimientos recomendados.

Recuerda no es solo escribir el código, sino escribirlo bien o como dijo Linus Torvalds

> Hablar es fácil. Enséñame el código.

## Pascal Case
Este tipo de nomenclatura lo utilizaremos al momento de escribir los nombres de nuestras `Class`, `Struct` o `Record`.

``` csharp
// Ejemplo de clases
public class DataService
{
}
// Ejemplo de record
public record PhysicalAddress(
    string Street,
    string City,
    string StateOrProvince,
    string ZipCode);
// Ejemplo de struct
public struct ValueCoordinate
{
}
```

Tambien cuando asignamos nombres a mi3mbros de clase.

``` csharp
public class ExampleEvents 
{
    public bool IsValid;
    public IWorkerQueue WorkerQueue;
    public void StartEventProcessing()
    {
        static int CountQueueItems () => WorkerQueue.Coun;
    }
}
```
---
## Uso de Prefijos
Generalmente no utilizamos prefijos, pero en ciertas ocasiones resulta bastante útil implementarlos. Por ejemplo, para escribir el nombre de una `interfaz` utilizaremos el prefijo en mayusacula `I` así quien haga una implementación de nuestro código sabrá que eso es una `interfaz`.
```  csharp
public interface IWorkerQueue
{
}
```

También cuando hacemos uso de tipos `internal` o `private` colocaremos como prefijo `_`.
``` csharp
public class DataService
{
    private IWorkerQueue _workerQueue;
}
```

O cuando implementamos campos `static` que sean del tipo `private` o `internal` usaremos `s_` y para los subprocesos estaticos `t_`.
``` csharp
public class DataService
{
    private static IWorkerQueue s_workerQueue;

    [ThreadStatic]
    private static TimeSpan t_timeSpan;
}
```
---
## Camel Case
Cuando escribimos los parametros de `method` utilizamos la nomenclatura del tipo `camelCase`.
``` csharp
public T SomeMethod<T>(int someNumber, bool isValid)
{
}
```
---
## Estandares Adicionales
Los estandares adicionales nos ayudarán a encontrar maneras de hacer nuestro código más eficiente y limpio.

Por ejm.
Utilizar las interpolaciones proporcionadas por el lenguaje puede resultar en codigo más práctico y fácil de leer.
``` csharp
string displayName = $"{nameList[n].LastName}, {nameList[n].FirstName}";
```

Cuando necesitamos anexar cadenas en un bucle es una mejor opción implementar un objeto del tipo `StringBuilder`
``` csharp
var frase= "lalalalalalalalalalalalalalalalalalalalalalalalalalalalalala";
var muchasFrases = new StringBuilder();
for (var i = 0; i < 10000; i++)
{
    muchasFrases.Append(frase);
}
Console.WriteLine("tra" + muchasFrases);
```
---
## Buenas Prácticas en Uso de Variables
1. Una buena práctica es utilizar los tipos implícitos solo cuando la asignación hace evidente el tipo de la variable y en los bucles `for`.
``` csharp
var var1 = "This is clearly a string.";
var var2 = 27;

// Bucles for
var frase= "lalalalalalalalalalalalalalalalalalalalalalalalalalalalalala";
var muchasFrases = new StringBuilder();
for (var i = 0; i < 10000; i++)
{
    muchasFrases.Append(frase);
}
//Console.WriteLine("tra" + muchasFrases);
```
2. **No** utilizar tipos implícitos cuando no es evidente el tipo de la variable o cuando desea determinar el tipo en el bucle `foreach`.
_Nota: Se considera que la variable tiene un tipo claro si implementa un operador `new` o se origina en una conversión._
``` csharp
int var3 = Convert.ToInt32(Console.ReadLine()); 
int var4 = new ExampleClass.ResultSoFar();
```
3. **No** confíe en especificar el tipo de la variable en el nombre.
``` csharp
var inputInt = Console.ReadLine();
Console.WriteLine(inputInt);
// Como se puede obserar el nombre de la variable es engañoso
// ya que inputInt es una _cadena_
```
En las próximas entregas continuaremos hablando de buenas prácticas de desarrollo con C#, por el momento estas son todas. Hasta la próxima.

**_¡Happy Hacking!_**