Chapitre 1 | Commençons la programmation

1.1 Histoire des langages de programmation
Les débuts de l'informatique, les débuts de la programmation
__La naissance de Fortran
__Des notions de base que même les élèves du primaire peuvent programmer
C pour, par et de Unix
__C+1 == C++
__C# pour un monde meilleur
1.2 Fichiers C# de base et paramètres d'environnement
__Fichiers sources et projets qui composent le programme
Préférences de Visual Studio

Chapitre 2 | Créer votre premier programme C#

2.1 Bonjour, monde !
2.2 Examen du premier programme
__utilisant le système
__using static System.Console;
__namespace Bonjour { }
__class MainApp { }
__// Début de l'exécution du programme
__static void Main(string[ ] args) { }
__if(args.Length == 0) { }
2.3 À propos de CLR
[Exercices pratiques]

Chapitre 3 | Archivage des données

3.1 Différents types de données
3.2 Variables
3.3 Types de valeurs et types de référence
Types de pile et de valeur
Types de tas et de références
3.4 Formats de données de base
__Type de données numériques
[Quiz sur les vitamines 3-1]
[Quiz sur les vitamines 3-2]
Format à virgule flottante
format de caractères et format de chaîne
[Quiz sur les vitamines 3-3]
__format logique
__format d'objet
__Emballage et déballage
__Modifier le format des données
3.5 Constantes et types d'énumération
Constante : Je ne changerai jamais
Format d'énumération : Organiser plusieurs constantes
3.6 Types nullables
3.7 var : Un compilateur C# intelligent qui détermine les types de données
3.8 Système de format commun
3.9 Manipulation des cordes
Trouver dans la chaîne
__Transformer la chaîne
__Séparer une chaîne
Formatage de chaînes de caractères
[Exercices pratiques]

Chapitre 04 | Opérateurs de traitement des données

4.1 Aperçu des opérateurs fournis par C#
4.2 Opérateurs arithmétiques
4.3 Opérateurs d'incrémentation et de décrémentation
4.4 Opérateurs de concaténation de chaînes
4.5 Opérateurs relationnels
4.6 Opérateurs logiques
4.7 Opérateurs conditionnels
4.8 Opérateur conditionnel nul
4.9 Opérateurs bit à bit
opérateur de décalage
opérateur logique bit à bit
4.10 Opérateurs d'affectation
4.11 Opérateur de coalescence nulle
4.12 Priorité de l'opérateur
[Exercices pratiques]

Chapitre 5 | Contrôle du flux de code

5.1 Déclaration de succursale
__si, sinon, sinon si
Utilisation d'instructions __if imbriquées
instruction __switch
__expression de commutation
5.2 Boucles
__alors que
__faire pendant
__pour
__Imbriqué pour
__pour chaque
Code de boucle infinie utilisant __for ou while
5.3 Porte de secours
__casser
__continuer
__aller
5.4 Correspondance des motifs
Modèle de déclaration
Modèle __format
Modèle constant
Modèle de propriété
[Quiz sur les vitamines 5-1]
Modèle de relation
Modèle logique
Modèle entre parenthèses
Modèle de localisation
__var modèle
__Ignorer le motif
Modèle de liste __list
[Exercices pratiques]

Chapitre 6 | Simplifier le code avec des méthodes

6.1 Qu'est-ce qu'une méthode ?
6.2 À propos des retours
6.3 À propos des paramètres
6.4 Passage de paramètres par référence
6.5 Retourner le résultat d'une méthode par référence
6.6 Paramètres de sortie uniquement
6.7 Surcharge de méthode
6.8 Nombre variable d'arguments
6.9 Arguments nommés
6.10 Arguments optionnels
6.11 Fonctions locales
[Exercices pratiques]

Chapitre 07 | Classe

7.1 Programmation orientée objet et classes
[Quiz sur les vitamines 7-1]
7.2 Déclaration de classe et création d'objet
7.3 À propos de la vie et de la mort des objets : constructeurs et finaliseurs
__constructeur
__Terminator
7.4 Champs statiques et méthodes
7.5 Copie d'objets : Copie superficielle et copie profonde
7.6 ce mot-clé
__moi
constructeur __this()
7.7 Détermination du niveau public avec des modificateurs d'accès
7.8 Réutilisation de code avec héritage
7.9 Conversion de type entre les classes de base et les classes dérivées
7.10 Surcharge et polymorphisme
7.11 Méthodes de dissimulation
7.12 Scellement prioritaire
7.13 Champs en lecture seule
7.14 Classes imbriquées
Classe fractionnée 7.15
7.16 Méthodes d'extension
[Quiz sur les vitamines 7-2]
7.17 Structure
7.18 Tuples
[Exercices pratiques]

Chapitre 8 | Interfaces et classes abstraites

8.1 Déclaration d'une interface
8.2 L'interface est une promesse
[Quiz sur les vitamines 8-1]
8.3 Interfaces héritant d'interfaces
8.4 Héritage simultané de plusieurs interfaces
[Quiz sur les vitamines 8-2]
8.5 Méthodes d'implémentation par défaut des interfaces
8.6 Classes abstraites : entre interfaces et classes
[Exercices pratiques]

Chapitre 09 | Propriétés

9.1 La tentation du champ public
9.2 Propriétés sur les méthodes
9.3 Propriétés implémentées automatiquement
Que se passe-t-il en coulisses avec les propriétés implémentées automatiquement ?
9.4 Propriétés et constructeurs
9.5 Propriétés auto-implémentées lors de l'initialisation uniquement
9.6 Le mot-clé requis pour forcer l'initialisation de la propriété
9.7 Création d'objets immuables au format d'enregistrement
__Déclarer un enregistrement
Copie des enregistrements à l'aide de __with
__Comparaison des objets d'enregistrement
9.8 Format anonyme
9.9 Propriétés des interfaces
9.10 Propriétés des classes abstraites
[Exercices pratiques]

Chapitre 10 | Tableaux, collections et indexeurs

10.1 Tous pour un, un pour tous
10.2 Trois façons d'initialiser un tableau
10.3 System.Array : Le connaître enrichira votre vie.
10.4 Division d'un tableau
10.5 Tableaux bidimensionnels
[Quiz sur les vitamines 10-1]
[Quiz sur les vitamines 10-2]
10.6 Tableaux multidimensionnels
10.7 Tableaux de variables
Aperçu de la collection 10.8
__ArrayList
__File d'attente
__Empiler
__Table de hachage
10.9 Comment initialiser une collection
Indexeur 10.10
10.11 Création d'un objet prenant en charge la boucle foreach
[Exercices pratiques]

Chapitre 11 | Programmation généralisée

11.1 Qu'est-ce que la programmation générale ?
11.2 Méthodes de généralisation
11.3 Classes généralisées
11.4 Contraintes sur les paramètres formels
[Quiz sur les vitamines 11-1]
11.5 Collections généralisées
__Liste〈T〉
__File d'attente〈T〉
__Pile〈T〉
__Dictionnaire〈TKey, TValue〉
11.6 Classes génériques pouvant utiliser foreach
[Exercices pratiques]

Chapitre 12 | Gestion des exceptions

12.1 À propos des exceptions
12.2 Gestion des exceptions avec try~catch
12.3 Classe System.Exception
12.4 Lever des exceptions
12.5 try~catch et enfin
12.6 Création d'une classe d'exception personnalisée
12.7 Filtrage des exceptions
12.8 Repenser la gestion des exceptions
[Exercices pratiques]

Chapitre 13 | Agents et événements

13.1 Qu'est-ce qu'un proxy ?
13.2 Pourquoi et quand utiliser un proxy ?
13.3 Agents généralisés
13.4 Chaîne de délégués
13.5 Méthodes anonymes
13.6 Événements : Notification des événements aux objets
13.7 Agents et événements
[Exercices pratiques]

Chapitre 14 | Expressions lambda

14.1 Expression Lambda, d'où viens-tu ?
14.2 Première rencontre avec les expressions lambda
14.3 Expressions lambda sous forme d'instruction
14.4 Création simplifiée de fonctions anonymes avec Func et Action
__Délégué de fonction
__Délégué d'action
14.5 Arbre nourricier
L'effectif est composé de 14,6 membres.
[Exercices pratiques]

Chapitre 15 | LINQ

15.1 Des données ! Des données ! Des données !
15.2 Notions de base de LINQ
__depuis
__où
__trier par
__sélectionner
15.3 Interrogation de plusieurs sources de données
15.4 Tri des données avec GROUP BY
15.5 Fusion de deux sources de données
__inner join
Jointure externe
15.6 Secrets LINQ et opérateurs standard LINQ
[Exercices pratiques]

Chapitre 16 | Réflexion et attributs

16.1 Réflexion
Méthode __Object.GetType() et classe Type
[Quiz sur les vitamines 16-1]
Création d'objets par réflexion
Format d'exportation __
16.2 Attributs
En utilisant l'attribut __
Attribut d'information de l'appelant
__Attributs que je crée
[Exercices pratiques]

Chapitre 17 | Format dynamique

17.1 Introduction du format dynamique
__Duck Typing
17.2 Types dynamiques pour l'interopérabilité entre COM et .NET
17.3 Format dynamique pour l'interopérabilité avec les langages dynamiques

Chapitre 18 | Gestion des fichiers

18.1 Gestion des informations sur les fichiers et les répertoires
__Exemple de programme : Récupération d’informations sur un répertoire/fichier
__Exemple de programme : Création d’un répertoire/fichier
18.2 Ce que vous devez savoir pour lire et écrire des fichiers
Classe __System.IO.Stream
[Quiz sur les vitamines 18-1]
18.3 Utiliser les déclarations pour réduire les erreurs
18.4 BinaryWriter/BinaryReader pour le traitement des données binaires
[Quiz sur les vitamines 18-2]
18.5 StreamWriter/StreamReader pour le traitement des fichiers texte
18.6 Sérialisation des objets
[Quiz sur les vitamines 18-3]

Chapitre 19 | Fils et tâches

19.1 Processus et threads
__Démarrez une discussion
__Terminer les threads arbitrairement
__Changements de vie et d'état du fil
__Interruption : Une autre façon de terminer un thread de manière arbitraire
__Synchronisation entre les threads
[Quiz sur les vitamines 19-1]
[Quiz sur les vitamines 19-2]
19.2 Tâche, Tâche〈TResult〉 et Parallèle
Classe __System.Threading.Tasks.Task
Classe __Task〈TResult〉 qui fournit le résultat de l'exécution asynchrone du code
Classe parallèle facilitant le traitement parallèle
19.3 Code asynchrone créé avec le modificateur async et l'opérateur await
Un aperçu des API asynchrones fournies par .NET

Chapitre 20 | Création d'une interface utilisateur avec WinForms

20.1 Mais que se passe-t-il donc ?
20.2 Création d'une fenêtre WinForm avec du code C#
20.3 Classe d'application
__Filtrage des messages
20.4 Classe de formulaire représentant une fenêtre
Connexion des événements et des gestionnaires d'événements définis dans __Form
Modifiez l'apparence d'une fenêtre en ajustant les propriétés de __Form
__Placez un contrôle au-dessus du formulaire
20.5 Création d'une interface utilisateur WinForm à l'aide du concepteur de formulaires
__Créer un nouveau projet
__Formulaire
__GroupBox, Label, ComboBox, CheckBox, TextBox
Barre de suivi, barre de progression
__Bouton, Formulaire, Boîte de dialogue
__TreeView, ListView
20.6 Interface utilisateur et tâches asynchrones
__Créer un nouveau projet
Implémentation des méthodes __CopySync()/CopyAsync()
__Configuration de l'interface utilisateur

Chapitre 21 | Programmation réseau

21.1 Notions de base à connaître avant la programmation réseau
L'origine d'Internet
Pile TCP/IP
Système d'adresses TCP/IP : adresse IP
__port
Processus de fonctionnement TCP/IP
21.2 TcpListener et TcpClient
21.3 Paquets en flux
21.4 Exemples de conception de protocoles et de programmation d'applications réseau
Protocole de téléchargement de fichiers
Mise en œuvre d'un serveur et d'un client de téléchargement de fichiers
Création d'une bibliothèque de classes utilisable à la fois par le serveur et le client
Mise en place d'un serveur de téléchargement de fichiers
__Mise en œuvre du client
__Test de téléchargement de fichier

Chapitre 22 | Collecte des ordures

22.1 Connaissez-vous les éboueurs ?
22.2 Répartir comme un chien et collecter comme un premier ministre.
22.3 Collecte des déchets générationnelle
22.4 Comprendre la collecte des déchets
Que devons-nous faire ?
N'allouez pas trop d'objets.
Évitez d'allouer des objets trop volumineux.
__Ne créez pas de relations de référence trop complexes
__Ne créez pas trop d'itinéraires
Une petite brèche rompt le barrage

[Recherche]

Plongeons dans le monde de la programmation avec « This is C# (3rd Edition) » !

C# a régulièrement ajouté de nouvelles syntaxes tout en conservant son objectif d'améliorer la productivité et l'expressivité des ingénieurs.
Avec l'évolution du langage, l'écosystème .NET s'est lui aussi développé de manière positive.
Il a été utilisé dans divers secteurs, du contrôle des machines au web, en passant par le cloud, les jeux vidéo et l'IA, et son développement et son déploiement sont possibles depuis un certain temps non seulement sur Windows, mais aussi sur macOS et Linux.
Le nombre de développeurs utilisant C# dans le monde entier continue également de croître.
Plongeons dans le monde merveilleux du C# à travers « This is C# (3e édition) ».


Les chapitres 1 à 10 couvrent les bases de la grammaire, ce qui les rend faciles à assimiler.
Les chapitres 11 à 17 traitent de la grammaire avancée qui peut être apprise en tirant parti des connaissances accumulées précédemment, et les chapitres 18 à 22 traitent de l'utilisation de la bibliothèque de classes .NET.
J'espère que ce livre vous sera utile.

Les lecteurs qui ont besoin de ce livre

Je souhaite apprendre le C# étape par étape, en commençant par la grammaire de base.
• J'ai besoin d'étudier le C# pour un nouveau projet.
Je veux apprendre le C# parce que je veux créer des jeux.

Ce que ce livre couvre

Grammaire de base pour la programmation C#
Introduction à la programmation orientée objet
Grammaire avancée pour accroître la productivité des programmeurs
• Comment utiliser le framework .NET et comment gérer la mémoire