Topic: 100 Mots à connaitre

[EloiStree]

🤖🧙‍♂️

• 1. Variable / Variable #
• 2. Data Type / Type de Donnée #
• 3. Integer / Entier #
• 4. Float / Flottant #
• 5. Double / Double #
• 6. String / Chaîne #
• 7. Boolean / Booléen # #
• 8. Array / Tableau #
• 9. List / Liste #
• 10. Dictionary / Dictionnaire #
• 11. Class / Classe #
• 12. Object / Objet #
• 13. Method / Méthode #
• 14. Function / Fonction #
• 15. Constructor / Constructeur #
• 16. Destructor / Destructeur #
• 17. Inheritance / Héritage #
• 18. Polymorphism / Polymorphisme #
• 19. Encapsulation / Encapsulation #
• 20. Abstraction / Abstraction #
• 21. Interface / Interface #
• 22. Namespace / Espace de Noms #
• 23. Access Modifier / Modificateur d'Accès #
• 24. Public / Public #
• 25. Private / Privé #
• 26. Protected / Protégé #
• 27. Static / Statique #
• 28. Instance / Instance #
• 29. Reference Type / Type de Référence #
• 30. Value Type / Type de Valeur #
• 31. Nullable / Nullable #
• 32. Enum / Enum #
• 33. Struct / Struct #
• 34. Delegate / Délégué #
• 35. Event / Événement #
• 36. Lambda / Lambda #
• 37. LINQ / LINQ #
• 38. Exception / Exception #
• 39. Try-Catch / Try-Catch #
• 40. Finally / Finally #
• 41. Throw / Throw #
• 42. Using / Using #
• 43. Block / Bloc #
• 44. Scope / Portée #
• 45. Loop / Boucle #
• 46. For Loop / Boucle For #
• 47. While Loop / Boucle While #
• 48. Do-While Loop / Boucle Do-While #
• 49. Foreach Loop / Boucle Foreach #
• 50. If Statement / Instruction If #
• 51. Else Statement / Instruction Else #
• 52. Switch Statement / Instruction Switch #
• 53. Case / Cas #
• 54. Break / Break #
• 55. Continue / Continue #
• 56. Return / Retour #
• 57. Parameter / Paramètre #
• 58. Argument / Argument #
• 59. Overloading / Surcharge #
• 60. Recursion / Récursion #
• 61. String Interpolation / Interpolation de Chaîne #
• 62. String Manipulation / Manipulation de Chaîne #
• 63. Console / Console #
• 64. WriteLine / WriteLine #
• 65. ReadLine / ReadLine #
• 66. Input / Entrée #
• 67. Output / Sortie #
• 68. Comment / Commentaire #
• 69. Documentation / Documentation #
• 70. Refactoring / Refactoring #
• 71. Debugging / Débogage #
• 72. Unit Test / Test Unitaire #
• 73. Framework / Framework #
• 74. Library / Bibliothèque #
• 75. API / API #
• 76. CLR (Common Language Runtime) / CLR (Common Language Runtime) #
• 77. JIT (Just-In-Time Compilation) / JIT (Compilation Just-In-Time) #
• 78. Assembly / Assembly #
• 79. Namespace / Espace de Noms #
• 80. Attribute / Attribut #
• 81. Reflection / Réflexion #
• 82. Thread / Fil #
• 83. Task / Tâche #
• 84. Async / Async #
• 85. Await / Await #
• 86. Lock / Verrou #
• 87. Monitor / Moniteur #
• 88. Garbage Collection / Collecte des Déchets #
• 89. Memory Management / Gestion de la Mémoire #
• 90. Performance / Performance #
• 91. Optimization / Optimisation #
• 92. Design Pattern / Modèle de Conception #
• 93. MVC (Model-View-Controller) / MVC (Modèle-Vue-Contrôleur) #
• 94. MVVM (Model-View-ViewModel) / MVVM (Modèle-Vue-ViewModel) #
• 95. Dependency Injection / Injection de Dépendances #
• 96. SOLID Principles / Principes SOLID #
• 97. TDD (Test-Driven Development) / TDD (Développement Dirigé par les Tests) #
• 98. Version Control / Contrôle de Version #
• 99. Git / Git #
• 100. IDE (Integrated Development Environment) / IDE (Environnement de Développement Intégré) #

[EloiStree]

🤖 Here’s a brief summary of each topic in 16 words or fewer:

1. Variable: Variables store data values, which can change during program execution to manage information dynamically.
2. Data Type: Data types define the nature of data a variable can hold, influencing memory and operations.
3. Integer: Integers are whole numbers, both positive and negative, without decimal points, used in calculations.
4. Float: Floats represent real numbers with decimal points, enabling precision in calculations and scientific representations.
5. Double: Doubles are floating-point data types with double the precision of floats, suitable for high-accuracy computations.
6. String: Strings are sequences of characters, used to represent text data in programming languages and applications.
7. Boolean: Boolean data types hold true or false values, used in logical operations and condition checks.
8. Array: Arrays are collections of elements, stored in contiguous memory locations, accessible via indices.
9. List: Lists are ordered collections that can dynamically resize, allowing storage of multiple items of varying types.
10. Dictionary: Dictionaries store key-value pairs, enabling fast data retrieval based on unique keys for efficient lookups.
11. Class: Classes are blueprints for creating objects, encapsulating data and methods in object-oriented programming.
12. Object: Objects are instances of classes that encapsulate data and behavior, representing real-world entities in programming.
13. Method: Methods are functions defined within a class, providing behavior for objects and enabling code reuse.
14. Function: Functions are reusable blocks of code that perform specific tasks, accepting inputs and returning outputs.
15. Constructor: Constructors are special methods invoked when creating an object, initializing properties and setting up state.
16. Destructor: Destructors are methods called when an object is destroyed, releasing resources and performing cleanup.
17. Inheritance: Inheritance allows classes to derive properties and methods from other classes, promoting code reuse and hierarchy.
18. Polymorphism: Polymorphism enables methods to process objects differently based on their data type or class.
19. Encapsulation: Encapsulation restricts access to object details, exposing only necessary components and promoting data security.
20. Abstraction: Abstraction simplifies complex systems by hiding unnecessary details, focusing on essential features and functionality.
21. Interface: Interfaces define contracts for classes, specifying methods that implementing classes must provide without defining behavior.
22. Namespace: Namespaces organize code into logical groups, preventing naming conflicts and enhancing code maintainability.
23. Access Modifier: Access modifiers control visibility of class members, determining how they can be accessed by other code.
24. Public: Public members are accessible from anywhere in the program, promoting ease of access and use.
25. Private: Private members are restricted to the defining class, enhancing encapsulation and protecting sensitive data.
26. Protected: Protected members are accessible within the class and derived classes, supporting inheritance while restricting external access.
27. Static: Static members belong to the class itself rather than instances, shared among all instances of the class.
28. Instance: Instances are unique objects created from a class, holding specific data and behavior defined by the class.
29. Reference Type: Reference types store references to memory locations rather than the actual data, enabling efficient data management.
30. Value Type: Value types store data directly, with each variable holding its own copy, promoting performance and efficiency.
31. Nullable: Nullable types allow variables to represent an absence of value, enhancing flexibility when dealing with optional data.
32. Enum: Enums define named constants, improving code readability and maintainability by representing fixed sets of related values.
33. Struct: Structs are value types that can encapsulate data and behavior, often used for lightweight objects.
34. Delegate: Delegates are type-safe function pointers, enabling methods to be passed as parameters or assigned to variables.
35. Event: Events allow objects to notify other objects when something of interest occurs, promoting loose coupling.
36. Lambda: Lambda expressions provide concise syntax for defining anonymous functions, enhancing readability and simplifying functional programming.
37. LINQ: LINQ (Language Integrated Query) enables querying data from various sources using a consistent syntax in C#.
38. Exception: Exceptions are errors that occur during program execution, requiring proper handling to maintain program stability.
39. Try-Catch: Try-catch blocks handle exceptions gracefully, allowing programs to continue executing even when errors occur.
40. Finally: Finally blocks execute code after try-catch statements, ensuring cleanup regardless of whether an exception occurred.
41. Throw: The throw statement raises exceptions deliberately, indicating that an error has occurred and needs handling.
42. Using: The using statement ensures proper disposal of resources, managing memory effectively and preventing resource leaks.
43. Block: Code blocks group statements, defining scope and control flow within functions, loops, or conditional statements.
44. Scope: Scope determines the visibility and lifetime of variables, affecting accessibility throughout the program.
45. Loop: Loops execute a block of code repeatedly based on specified conditions, facilitating iteration over collections or data.
46. For Loop: For loops provide a controlled way to iterate through a range of values, with defined start and end points.
47. While Loop: While loops execute as long as a specified condition remains true, providing dynamic control over iterations.
48. Do-While Loop: Do-while loops guarantee at least one execution of the code block, checking the condition after each iteration.
49. Foreach Loop: Foreach loops iterate over collections, simplifying syntax for accessing each item in a collection sequentially.
50. If Statement: If statements execute blocks of code based on specified conditions, allowing for decision-making in programs.
51. Else Statement: Else statements provide alternative execution paths when conditions in if statements are not met, enhancing control flow.
52. Switch Statement: Switch statements simplify multi-way branching based on specific values, improving readability over multiple if statements.
53. Case: Cases within switch statements define distinct conditions for executing associated code blocks, enabling structured decision-making.
54. Break: The break statement exits loops or switch cases, controlling flow and preventing unintended executions of subsequent code.
55. Continue: Continue statements skip the current iteration in loops, resuming execution at the next iteration based on conditions.
56. Return: The return statement exits a method, providing a value back to the caller, enabling method outputs.
57. Parameter: Parameters are variables in method definitions, allowing input values to be passed into functions for processing.
58. Argument: Arguments are actual values passed to methods when called, matching the parameters defined in the method signature.
59. Overloading: Method overloading allows multiple methods with the same name but different parameters, enhancing flexibility and code clarity.
60. Recursion: Recursion occurs when a method calls itself, solving problems through repeated division into smaller subproblems.
61. String Interpolation: String interpolation simplifies formatting strings by embedding expressions directly within string literals for clarity.
62. String Manipulation: String manipulation involves altering and processing strings through various methods to achieve desired outcomes.
63. Console: The console is a text-based interface for input and output, facilitating interaction between users and applications.
64. WriteLine: WriteLine outputs text to the console, automatically appending a new line after each message for readability.
65. ReadLine: ReadLine captures user input from the console, enabling interaction and data collection within applications.
66. Input: Input refers to data received from users or external sources, crucial for dynamic program behavior and functionality.
67. Output: Output represents data produced by a program, displayed to users or sent to external devices or systems.
68. Comment: Comments are non-executable text in code, providing explanations and documentation for better code understanding.
69. Documentation: Documentation provides comprehensive guides and explanations for code and its usage, improving maintainability and usability.
70. Refactoring: Refactoring involves restructuring existing code for improved readability, maintainability, and performance without altering functionality.
71. Debugging: Debugging identifies and resolves errors or bugs in code, enhancing program reliability and overall performance.
72. Unit Test: Unit tests validate individual components of code, ensuring each unit performs as expected and enhancing software quality.
73. Framework: Frameworks are pre-defined structures providing foundational code and tools to simplify application development and enhance productivity.
74. Library: Libraries are collections of pre-written code and functions, promoting code reuse and facilitating faster development processes.
75. API: APIs (Application Programming Interfaces) define protocols for interacting with software components, enabling communication between different systems.
76. CLR (Common Language Runtime): The CLR is a runtime environment in .NET that manages memory and execution of .NET applications.
77. JIT (Just-In-Time Compilation): JIT compilation translates intermediate code to machine code at runtime, optimizing performance for .NET applications.
78. Assembly: Assemblies are compiled code libraries in .NET, serving as the building blocks for .NET applications and libraries.
79. Namespace: Namespaces group related classes and functions, preventing naming conflicts and organizing code into manageable sections.
80. Attribute: Attributes provide metadata about classes, methods, or properties, enhancing functionality through annotations and configurations.
81. Reflection: Reflection allows inspection and manipulation of types and members at runtime, enabling dynamic behavior in applications.
82. Thread: Threads enable concurrent execution of code, allowing programs to perform multiple operations simultaneously for

[EloiStree]

Apprendre plus sur C# et Unity3D ?

https://github.com/EloiTeaching/2024_08_04_CleanDiskUnityCode