6 conseils pour écrire du code C# élégant

Même si votre délai est serré, il est toujours possible d'écrire du beau code. J'ai donc créé une liste de six conseils pour rendre votre syntaxe C# élégante.

Écrire du code n'est pas une tâche facile, et lorsqu'il s'agit d'écrire du code de qualitécela devient encore plus difficile.

Il faut se rappeler qu'en programmation, nous avons plusieurs façons de faire quelque chose, et tant que cela fonctionne, cela ne signifie pas que cette façon est bonne ou mauvaise.

Mais en plus de simplement « travailler », notre application doit être cohérente et contenir une bonne syntaxe. Voici donc quelques exemples de la façon d'améliorer encore votre écriture C# et d'augmenter la qualité de votre code.

1. Conventions de nommage 💅

Les conventions de nommage font référence à la déclaration de noms d'objets. Vous devez suivre ceci pour avoir un code agréable et cohérent lorsque vous nommez vos objets.

Pour déclarer une variable qui renvoie une seule entité/objet, nous utilisons un nom simple. Pour déclarer une variable qui renvoie plusieurs entités/objets, il est nécessaire d'ajouter le suffixe « s » ou « List » afin que l'on puisse facilement identifier qu'elle renverra une liste de classes/objets :

var = new Item();
var ItemList = new List<Article>();


var article = new Article(); 
 var articles = new Liste<Item>();   
 
 var itemList = new List<Item>(); 




private int value  = 10;


private int _value = 10;

Table of Naming Conventio ns

2. Optimiser la syntaxe 🦄

Nous avons expliqué comment, en programmation, il existe plusieurs façons de faire la même chose, mais une chose qui peut toujours améliorer votre code est l'optimisation de la syntaxe. Voici quelques exemples.

• Pour déclarer une méthode qui ne renvoie qu'un seul résultat, nous pouvons la déclarer comme suit :

public ActionResult Dashboard()  
{[19659079]retour Affichage();  
}  


public Résultat de l'action Tableau de bord() = > View();

• Pour vérifier les conditions nulles ou vides, utilisez ce qui suit :

var varName = "John" ; 


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


if (!string.IsNullOrEmpty(varName))  
{[19659115]}



if (varName est { Longueur: >0[19659099]})
{
    
}

• Pour vérifier une valeur nulle, utilisez :

Test test = new Test() ;  


var varName = test.Name != null ? test.Nom : "";  


var varName = test.Nom ??[19659096]"";

Test test = nouveau Test();  


var détails =[19659009]string.Format("{0}, vous êtes le bienvenu, votre identifiant est {1}", test.Name , test.Id + "_emp");  


var détails = $"{test.Name}, vous êtes le bienvenu, votre identifiant est {test.Id}_emp"[19659011];


var détails = string.Join(" ,", test.Nom, « vous êtes les bienvenus, Votre identifiant est », test.Id , "_emp");

• Ce dernier bloc de code montre comment utiliser la nouvelle forme de commutateur introduite dans C# 8 :

int itemSwitch =[19659045]1;  


commutateur (itemSwitch)  
{  
	 case 1:
Console.WriteLine("Item 1");  
	 break;  
	 case 2:
Console.WriteLine("Item 2");  
	 break;  
	 default:
Console.WriteLine("Item case");  
	 break;  
}  


 var message = itemSwitch switch   
 {  
	 1 => Console.WriteLine("Item 1"[19659011]),  
	 2 => Console.WriteLine("Item 2")  
	 2 => Console.WriteLine("Item 3")  
 };

3. Validation des types de données primitifs 🌟

Avec la précipitation de la vie quotidienne, nous oublions parfois qu'il existe des méthodes disponibles pour valider les types de données primitifs tels que System.Int32.

Lorsque vous devez effectuer ces validations, évitez d'utiliser des méthodes personnalisées. Utilisez plutôt les méthodes déjà disponibles dans la langue pour cela.

public bool CheckIfIsNumber(string value)
{
	bool isNumeric = true;
	try
	{
		int i = Convert.ToInt32( valeur);
	}
	catch (FormatException ex)
	{
isNumeric = false;
	}
	return isNumeric;
}


public bool  CheckIfIsNumberic( 19659109]chaîne valeur)
{
	bool isNumeric = false;
	int résultat =  0;

	if(!string.EstNullOuEmpy(valeur))
isNumeric = int.TryParse(value, out result );

	return est Numérique;       
}

4. Utilisation de l'opérateur conditionnel « ? » (Ternaire) à la vérification de la valeur nulle 🎯

Une façon de suivre le concept de « Clean Code » et d'améliorer la lisibilité et l'écriture de votre code en C# consiste à utiliser l'opérateur ternaire « ? »

Vous pouvez l'utiliser. dans les cas où une instruction vérifie la possibilité qu'une valeur soit nulle, l'opérateur de coalescence nulle peut être utilisé pour s'assurer qu'une valeur non nulle est renvoyée.

Le code ci-dessous renvoie le nom du contact reçu ou le nom par défaut si l'élément est nul. Comme vous pouvez le voir, cet opérateur est un excellent choix lorsque vous travaillez avec la condition null.

public static string CheckContactNameError(Contact contact)
 {
	var defaultName = "Default";

	if (contact.Name !=[19659009]null)
	{
		return contact.Name;
	}
	else
	{
		return defaultName ;
	}
}


public static string CheckContactName(string contactName)
{[19659242]var defaultName = "Default";
	return contactName ?? defaultName;
}[19659335]5. Optimisation des requêtes avec LINQ 🐍
Language-Integrated Query (LINQ) est le nom d'un ensemble de technologies basées sur l'intégration de capacités de requête directement dans le langage C#.
LINQ simplifie les requêtes en offrant un modèle de travail cohérent. avec des données provenant de divers types de sources et de formats. Dans une requête LINQ, vous travaillez toujours avec des objets. Vous utilisez les mêmes modèles de codage de base pour interroger et transformer des données dans des documents XML, des bases de données SQL, des ensembles de données ADO.NET, des collections .NET et tout autre format pour lequel un fournisseur LINQ est disponible.
 Ci-dessous, nous obtiendrons une liste de " Bons prix » en parcourant une liste de « entreprises » qui ont des « produits » avec divers « prix du marché ».
 Si le prix du marché est inférieur à 100, nous ajoutons le produit à la liste des bons prix et le renvoyons à la fin de l'expression.

public List<GoodPrice> GetGoodPrices(List<Company>  entreprises)
{
    Liste<BonPrix> bonPrix = nouveau Liste<BonPrix>()[19659011];

    foreach (Entreprise in entreprises)
    {
        foreach (Produit produit in entreprise.Produits)
        {
            if (produit.MarketValue < 100 )
            {
                bonPrix.Ajouter(produit);
            }
        }
    }
    retour bonPrix;[19659123]}


public IEnumerable<GoodPrice> Obtenir de bons prix(List<Société>[1945904] entreprises)
{
   IEnumerable<GoodPrice> goodPrices = entreprises.Où(
    c => c.Produits.Tout(p => p.MarketValue < 100)
    );
    
    
    
    IEnumerable<GoodPrice> goodPrices = de entreprise dans entreprises
                                de produit dans entreprises.Produits
                                où product.MarketValue < 100
                                select company;
    return goodPrix;[19659123]}
6. Remplir les propriétés de l'objet 😉
 La définition des valeurs d'un objet est très courante au cours du développement et il existe de nombreuses façons de le faire. Mais avec cette astuce, vous pouvez le rendre plus simple et plus intuitif, en plus de faciliter le processus de mise en œuvre des tests.
 Pour cela, nous utiliserons un paradigme appelé "Fluent Code". Il est inspiré de LINQ, déjà traité dans cet article. Vous pouvez en savoir plus sur le « Code fluide ».
Prenons un exemple :
 
 public class Contact
 {
	 public string Nom {  get; set; }
	 public string E-mail { get; set[19659011]; }
	 public long Téléphone { get; set; }
 }

public  statique Contact RemplirContactPrêt()
{
Contact contact = nouveau Contact();

contact.Nom = "John Smith";
contact.E-mail = "johnsmith@email.com";
contact.Téléphone = 25454471414;
	
	retour contact;
}


public classe FluentContact[19659123]{
	public class Contact
	{
		public string Nom { get; set ; }
		public string E-mail { get; set; }
		public long Téléphone { get; set; }
	}

	public Contact contact = nouveau[19659010]Contact();

	public FluentContact AddName(string name)
	{
contact.Name = name;
		return this;
	}
	
	public FluentContact AddEmail[19659011](chaîne e-mail)
	{
contact.Email = email;
		retourner this;
	}

	public FluentContact AddPhone[19659011](long téléphone)
	{
contact.Téléphone = téléphone;
		retourner this;
	}
}

public statique FluentContact FillFluentContactReady()
{
	return new FluentContact()
	.AddName ("John Smith")
	.Ajouter un e-mail("johnsmith@email.com").Ajouter un téléphone( 25454471414);
}
Conclusion
J'espère qu'à travers ces conseils je vous ai aidé à écrire un code propre et élégant.
Que vous soyez novice en . NET ou déjà développeur expérimenté, si vous utilisez ces astuces, vous serez certainement reconnu pour écrire du code de qualité et pourrez cibler des objectifs encore plus grands.