3,454 lectures

C# : des principes fondamentaux aux techniques avancées - Un aide-mémoire adapté aux débutants

par Sukhpinder Singh16m2024/03/24

Trop long; Pour lire

L'aide-mémoire C# complet est conçu pour aider les développeurs à maîtriser la syntaxe et les concepts clés liés à la programmation C#.

featured image - C# : des principes fondamentaux aux techniques avancées - Un aide-mémoire adapté aux débutants

L'aide-mémoire C# complet est conçu pour aider les développeurs à maîtriser la syntaxe et les concepts clés liés à la programmation C#.

Contenu

Structure basique
Types de données
Variables
Constantes
Expressions conditionnelles
Boucles
Tableaux
Listes
Dictionnaires
Méthodes
Classes et objets
Gestion des exceptions
Délégués, événements et Lambdas
LINQ (requête intégrée au langage)
Les attributs
Asynchrone/Attente
Divers
Manipulation des chaînes
E/S de fichier
Date et heure
Génériques
Nullables
Attributs et réflexion
Méthodes d'extension
Injection de dépendance
Cours partiels
Interopérabilité
Types anonymes
Tuples
Correspondance de motifs
Fonctions locales
Enregistrements
avec des expressions
Indexeurs et plages
en utilisant la déclaration
Types de référence nullables (NRT)
Utilisation basée sur des modèles
Modèles de propriété
Implémentations d'interface par défaut
Liaison dynamique

1. Structure de base

Tous les programmes C# suivent une structure fondamentale, décrite ci-dessous :

 using System; public class HelloWorld { public static void Main(string[] args) { Console.WriteLine("Hello, World!"); } }

À partir de .NET 5, les instructions de niveau supérieur simplifient le contenu de Program.cs :

 Console.WriteLine("Hello, World");

2. Types de données

C# prend en charge différents types de données tels que :

Types de valeur : int, char et float
Types de référence : chaîne, classe et tableau

3. Variables

Les variables sont des noms symboliques pour les valeurs :

 int age = 30; // integer variable string name = "John"; // string variable double PI = 3.14159; // double for floating-point numbers bool isLoggedIn = true; // boolean variable

Utilisez 'var' pour l'inférence de type :

 var number = 5; // compiler infers type as int var message = "This is a message"; // compiler infers type as string

4. Constantes

Les constantes contiennent des valeurs immuables :

 const double GRAVITY = 9.81; // constant for gravitational acceleration const string COMPANY_NAME = "MyCompany"; // constant company name

5. Déclarations conditionnelles

Contrôlez le déroulement du programme en fonction des conditions :

 int age = 20; if (age >= 18) { Console.WriteLine("You are eligible to vote."); } else { Console.WriteLine("You are not eligible to vote."); } switch (variable) { /*...*/ } // Switch statement

6. Boucles

Exécutez le code à plusieurs reprises :

 for (int i = 1; i <= 5; i++) { Console.WriteLine(i); } foreach (var item in collection) { /*...*/ } // Foreach loop while (condition) { /*...*/ } // While loop do { /*...*/ } while (condition); // Do-while loop

7. Tableaux

Collections d'éléments de taille fixe :

 string[] names = new string[3] { "Alice", "Bob", "Charlie" }; Console.WriteLine(names[1]); // Output: Bob (accessing element at index 1)

8. Listes

Collections dynamiques similaires aux tableaux :

 List<int> numbers = new List<int>(); numbers.Add(1); numbers.Add(2); numbers.Add(3); foreach (var number in numbers) { Console.WriteLine(number); }

9. Dictionnaires

Paires clé-valeur pour l'association de données :

 Dictionary<string, string> phonebook = new Dictionary<string, string>(); phonebook.Add("John Doe", "123-456-7890"); phonebook.Add("Jane Doe", "987-654-3210"); Console.WriteLine(phonebook["John Doe"]); // Output: 123-456-7890

10. Méthodes

Encapsulez la logique réutilisable :

 public class Rectangle { public double Width { get; set; } public double Height { get; set; } public double GetArea() { return Width * Height; } } public class Program { public static void Main(string[] args) { Rectangle rect = new Rectangle(); rect.Width = 5; rect.Height = 10; double area = rect.GetArea(); Console.WriteLine($"Area of rectangle: {area}"); } }

11. Classes et objets

Les classes définissent des plans pour les objets :

 public class MyClass // Class definition { public string PropertyName { get; set; } // Properties store data public void MethodName() { /*...*/ } // Methods define actions } MyClass obj = new MyClass(); // Object creation

12. Gestion des exceptions

Gérez les erreurs d'exécution avec élégance :

 public static int GetNumberInput() { while (true) { try { Console.WriteLine("Enter a number: "); string input = Console.ReadLine(); return int.Parse(input); } catch (FormatException) { Console.WriteLine("Invalid input. Please enter a number."); } } } public static void Main(string[] args) { int number = GetNumberInput(); Console.WriteLine($"You entered: {number}"); }

13. Délégués, événements et Lambda

Pour la programmation événementielle et la gestion des méthodes :

 public delegate void MyDelegate(); // Delegate declaration event MyDelegate MyEvent; // Event declaration public class Person { public string Name { get; set; } public int Age { get; set; } } public static void Main(string[] args) { List<Person> people = new List<Person>() { new Person { Name = "Alice", Age = 30 }, new Person { Name = "Bob", Age = 25 }, new Person { Name = "Charlie", Age = 40 }, }; people.Sort((p1, p2) => p1.Name.CompareTo(p2.Name)); foreach (var person in people) { Console.WriteLine(person.Name); // Output: Alice, Bob, Charlie (sorted by name) } }

14. LINQ (requête intégrée au langage)

Capacités de requête pour la manipulation des données :

 using System.Linq; public static void Main(string[] args) { List<int> numbers = new List<int>() { 1, 2, 3, 4, 5, 6 }; var evenNumbers = numbers.Where(x => x % 2 == 0); foreach (var number in evenNumbers) { Console.WriteLine(number); // Output: 2, 4, 6 } }

15. Attributs

Ajoutez des métadonnées aux éléments de code :

 [Obsolete("Use the new DoSomethingV2 method instead.")] public void DoSomething() { // Implementation here } public void DoSomethingV2() { // New and improved implementation }

16. Asynchrone/Attendre

Pour l'exécution de code non bloquant :

 using System.Threading.Tasks; public static async Task DownloadFileAsync(string url, string filePath) { // Simulate downloading data asynchronously await Task.Delay(2000); // Simulate a 2-second download // Write downloaded data to the file File.WriteAllText(filePath, "Downloaded content"); Console.WriteLine($"File downloaded to: {filePath}"); } public static void Main(string[] args) { string url = "https://example.com/data.txt"; string filePath = "downloaded_data.txt"; DownloadFileAsync(url, filePath); // Continue program execution while download happens in the background Console.WriteLine("Downloading file..."); Console.WriteLine("Meanwhile, you can do other things..."); }

17. Divers

Fonctionnalités linguistiques supplémentaires :

énumération, interface, classe, enregistrement et structure

dynamique, est, as, var et nom de

18. Manipulation des chaînes

Méthodes puissantes de gestion des chaînes :

 string.Concat(); // Combine strings string.Join(); // Join elements str.Split(); // Split string str.ToUpper(); // Convert to uppercase str.ToLower(); // Convert to lowercase

19. E/S de fichier

Opérations avec des fichiers :

 using System.IO; // Required for File I/O File.ReadAllText(path); // Read file content File.WriteAllText(path, content); // Write to file File.Exists(path); // Check file existence

20. Date et heure

Manipulation de la date et de l'heure :

 using System; public static void Main(string[] args) { DateTime startDate = DateTime.Parse("2024-03-10"); DateTime endDate = DateTime.Now; TimeSpan difference = endDate - startDate; Console.WriteLine($"Time difference: {difference.Days} days, {difference.Hours} hours"); }

21. Génériques

Structures de données de type sécurisé :

 public class Stack<T> { private List<T> items = new List<T>(); public void Push(T item) { items.Add(item); } public T Pop() { T item = items[items.Count - 1]; items.RemoveAt(items.Count - 1); return item; } } public static void Main(string[] args) { Stack<string> messages = new Stack<string>(); messages.Push("Hello"); messages.Push("World"); string message = messages.Pop(); Console.WriteLine(message); // Output: World }

22. Nullables

Autoriser les types de valeur à être nul :

 int? nullableInt = null; // Nullable integer

23. Attributs et réflexion

Métadonnées et introspection de type :

 public class Person { public string Name { get; set; } public int Age { get; set; } } public static void Main(string[] args) { Type personType = typeof(Person); PropertyInfo[] properties = personType.GetProperties(); foreach (PropertyInfo property in properties) { Console.WriteLine(property.Name); // Output: Name, Age } }

24. Méthodes d'extension

Ajoutez des méthodes aux types existants :

 public static class StringExtensions { public static string ToUppercase(this string str) { return str.ToUpper(); } } public static void Main(string[] args) { string message = "Hello, world!"; string uppercased = message.ToUppercase(); // Using the extension method Console.WriteLine(uppercased); // Output: HELLO, WORLD! }

25. Injection de dépendance

Conception de code faiblement couplé :

 public interface ILogger { void LogMessage(string message); } public class MyService { private readonly ILogger _logger; public MyService(ILogger logger) { _logger = logger; } public void DoSomething() { _logger.LogMessage("Doing something..."); } } // Implementing the ILogger interface (example) public class ConsoleLogger : ILogger { public void LogMessage(string message) { Console.WriteLine(message); } } public static void Main(string[] args) { ILogger logger = new ConsoleLogger(); MyService service = new MyService(logger); service.DoSomething(); }

26. Cours partiels

Fractionner une seule définition de classe :

 public partial class MyClass { /*...*/ } // Partial class definition

27. Interopérabilité

Interopérabilité avec d'autres langages :

 using System; using System.Runtime.InteropServices; [DllImport("user32.dll")] public static extern int MessageBox(IntPtr hWnd, string lpText, string lpCaption, uint uType); public static void Main(string[] args) { MessageBox(IntPtr.Zero, "Hello from C#!", "Interop Example", 0); }

28. Types anonymes

Création de types sans nom :csharpCopier le code

 var person = new { Name = "John", Age = 30 }; Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");

29. Tuple

Structures de données avec un nombre spécifique d'éléments :

 (string Name, int Age) person = ("Alice", 30); Console.WriteLine($"Name: {person.Name}, Age: {person.Age}"); // Accessing elements using Item1 and Item2

30. Correspondance de motifs

Simplifie certaines tâches de programmation :

 object obj = new Person { Name = "Bob", Age = 25 }; if (obj is Person { Name: "Bob", Age >= 18 }) { Console.WriteLine("Bob is an adult."); }

31. Fonctions locales

Encapsulez la logique dans les méthodes :

 public static int Calculate(int number) { int Factorial(int n) { if (n == 0) return 1; return n * Factorial(n - 1); } return Factorial(number); } public static void Main(string[] args) { int result = Calculate(5); Console.WriteLine($"5! = {result}"); }

32. Dossiers

Syntaxe concise pour les types référence :

 public record Person(string Name, int Age); public static void Main(string[] args) { Person person1 = new Person("Alice", 30); Person person2 = new Person("Alice", 30); // Records provide default equality comparison if (person1 == person2) { Console.WriteLine("People are equal"); } }

33. avec des expressions

Mutation non destructive pour les enregistrements :

 var john = new Person("John", 30); var jane = john with { Name = "Jane" }; // Non-destructive mutation

34. Indexeurs et plages

Accès flexible aux données :

 int[] arr = {0, 1, 2, 3, 4, 5}; var subset = arr[1..^1]; // Indexer and range usage

35. en utilisant la déclaration

Jetez les objets IDisposable :

 using var reader = new StreamReader("file.txt"); // using declaration

36. Types de référence nullables (NRT)

Évitez les exceptions de référence nulle :

 public class Person { public string Name { get; set; } public int Age { get; set; } } public static void Main(string[] args) { Person person = new Person() { Age = 30 }; // NRTs require null checks before accessing properties if (person?.Name != null) { Console.WriteLine(person.Name); } else { Console.WriteLine("Name is null"); } }

37. Utilisation basée sur des modèles

Plus de modèles dans l'instruction using :

 public ref struct ResourceWrapper { /*...*/ } // Resource wrapper using var resource = new ResourceWrapper(); // Pattern-based using

38. Modèles de propriété

Déconstruire les objets en correspondance de motifs :

 if (obj is Person { Name: "John", Age: var age }) { /*...*/ } // Property pattern matching

39. Implémentations d'interface par défaut

Interfaces avec implémentations de méthodes par défaut :

 public interface IPerson { /*...*/ } // Interface with default method public class MyClass : IPerson { /*...*/ } // Class implementing interface

40. Liaison dynamique

Résolution du type d'exécution :

 dynamic d = 5; // Dynamic binding d = "Hello"; // No compile-time type checking

Conclusion

Cette aide-mémoire C# structurée se termine par des sujets et techniques avancés, fournissant une référence complète aux développeurs souhaitant améliorer leurs compétences en programmation C#. Pour des exemples détaillés et une exploration plus approfondie, reportez-vous aux sections spécifiques décrites dans ce guide. Bon codage !