csharp cheatsheet
1.0.0
La feuille de triche C # complète est conçue pour aider les développeurs à maîtriser la syntaxe clé et les concepts liés à la programmation C #.
Structure de base
Types de données
Variables
Constantes
Déclarations 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 en langue)
Attributs
Asynchrone / attendre
Divers
Manipulation de cordes
Fichier d'E / S
Date et heure
Génériques
Nullable
Attributs et réflexion
Méthodes d'extension
Injection de dépendance
Classes partielles
Interopérabilité
Types anonymes
Tuples
Correspondance de motifs
Fonctions locales
Enregistrements
avec des expressions
Indexes et gammes
Utilisation de la déclaration
Types de référence annulés (NRTS)
Modèles en utilisant
Modèles de propriété
Implémentations d'interface par défaut
Liaison dynamique
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!");
}
}
En commençant par .NET 5, les instructions de niveau supérieur simplifient le contenu Program.cs:
Console.WriteLine("Hello, World");
C # prend en charge divers types de données tels que:
Types de valeur: int, char, flotteur
Types de référence: chaîne, classe, tableau
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
Les constantes contiennent des valeurs immuables:
const double GRAVITY = 9.81; // constant for gravitational acceleration
const string COMPANY_NAME = "MyCompany"; // constant company name
Contrôle le flux du programme basé sur les 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
Exécuter 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
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)
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);
}
Paires de valeurs clés pour l'association des 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
Encapsuler 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}");
}
}
Classes définissent les 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
Gérer les erreurs d'exécution gracieusement:
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}");
}
Pour la programmation et la gestion des méthodes motivées par des événements:
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)
}
}
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
}
}
Ajouter 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
}
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...");
}
Caractéristiques linguistiques supplémentaires:
enum, interface, classe, enregistrement, structure
dynamique, est, comme, var, nomof
Méthodes de traitement de cordes puissantes:
string.Concat(); // Combine strings
string.Join(); // Join elements
str.Split(); // Split string
str.ToUpper(); // Convert to uppercase
str.ToLower(); // Convert to lowercase
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
Manipulation de date et d'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");
}
Structures de données de type type:
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
}
Autoriser les types de valeur nuls:
int? nullableInt = null; // Nullable integer
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
}
}
Ajouter 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!
}
Conception de code couplée vaguement:
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();
}
Diraction d'une définition d'une seule classe:
public partial class MyClass { /*...*/ } // Partial class definition
Interprète avec d'autres langues:
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);
}
Création de types sans nom: code CSharpcopy
var person = new { Name = "John", Age = 30 };
Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");
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
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.");
}
Encapsuler 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}");
}
Syntaxe concise pour les types de 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");
}
}
Mutation non destructive pour les enregistrements:
var john = new Person("John", 30);
var jane = john with { Name = "Jane" }; // Non-destructive mutation
Accès aux données flexibles:
int[] arr = {0, 1, 2, 3, 4, 5};
var subset = arr[1..^1]; // Indexer and range usage
Disposer des objets iDisposables:
using var reader = new StreamReader("file.txt"); // using declaration
Évitez les exceptions de référence nuls:
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");
}
}
Plus de modèles dans la déclaration d'utilisation:
public ref struct ResourceWrapper { /*...*/ } // Resource wrapper
using var resource = new ResourceWrapper(); // Pattern-based using
Déconstruire les objets dans la correspondance de motifs:
if (obj is Person { Name: "John", Age: var age }) { /*...*/ } // Property pattern matching
Interfaces avec les implémentations de la méthode par défaut:
public interface IPerson { /*...*/ } // Interface with default method
public class MyClass : IPerson { /*...*/ } // Class implementing interface
Résolution de type d'exécution:
dynamic d = 5; // Dynamic binding
d = "Hello"; // No compile-time type checking
Cette feuille de triche C # structurée se termine par des sujets et techniques avancés, fournissant une référence complète aux développeurs visant à 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. Codage heureux!
Inspiré par: https://zerotomastery.io/cheatsheets/csharp-cheat-sheet/#constants
