C# occupe une place centrale dans la version initiale de Microsoft.net. Il s'agit du dernier langage de programmation orienté objet développé par Microsoft. Il combine la puissance du C++ avec la facilité d'utilisation de Visual Basic. Ce livre est divisé en trois parties pour aider les lecteurs à apprendre le langage C#. La première partie fournit une discussion complète du langage C#, décrivant les mots-clés, les instructions et les fonctionnalités définis dans le langage C#. Les procédures d'E/S, de traitement de fichiers, de mappage et de prétraitement sont également introduites. La deuxième partie traite de la bibliothèque de classes C#, qui est également . NET bibliothèque de classes de framework. En raison de l'espace limité, ce livre se concentre sur les bibliothèques de classes principales contenues dans l'espace de noms système. Cette partie du contenu est utilisée par presque tous les programmeurs C#. La partie 3 comprend des exemples d'applications C#.
Le contenu de ce livre va du superficiel au approfondi et présente un large éventail d'applications. Il convient également aux lecteurs sans expérience en programmation et aux programmeurs ayant une certaine base en C++ ou Java.
Le répertoire est le suivant :
Partie 1 : langage C#
Chapitre 1 L'origine de C#
1.1 Historique du développement C#
1.2 Comment C# est lié au .NET Framework
1.3 Fonctionnement du Universal Language Runtime
1.4 Code gérable et code ingérable
Chapitre 2 Présentation de C#
2.1 Programmation orientée objet
2.2 Le premier programme simple
2.3 Gestion des erreurs de syntaxe
2.4 Une petite amélioration
2.5 Le deuxième programme simple
2.6 Un autre type de données
2.7 Deux déclarations de contrôle
2.8 Utiliser des blocs de code
2.9 Point-virgule et positionnement
2.10 Retrait
2.11 Identifiants
2.12 Bibliothèque de classes C#
Chapitre 3 Types de données, littéraux et variables
3.1 Importance des types de données
3.2 Types numériques en C#
3.3 Types entiers
3.4 Types à virgule flottante
3,5 type décimal
3,6 caractères
3.7 type booléen
3.8 Quelques options de sortie
3.9 Quantité directe
3.10 Variables
3.11 Portée et durée d'utilisation des variables
3.12 Conversion de type et coercition
3.13 Conversion de types dans les expressions
Chapitre 4 Opérateurs
4.1 Opérateurs arithmétiques
4.2 Opérateurs relationnels et opérateurs logiques
4.3 Opérateur d'affectation
Opérateurs 4.4 bits
4,5 ? opérateur
4.6 Espacement et supports
4.7 Priorité des opérateurs
Chapitre 5 Déclarations de contrôle du programme
5.1 si instruction
5.2 instruction de commutation
5.3 pour la boucle
5.4 boucle while
5.5 faire une boucle while
5.6 boucle foreach
5.7 Utiliser l'instruction break pour quitter la boucle
5.8 Continuer l'instruction
5.9 instruction aller à
Chapitre 6 Classes, objets et méthodes
6.1 Bases du cours
6.2 Comment créer des objets
6.3 Variables de référence et affectation
6.4 Méthodes
6.5 Constructeur
6.6 nouvel opérateur
6.7 Collecte des déchets et destructeurs
6.8 ce mot clé
Chapitre 7 Tableaux et chaînes
7.1 Tableau
7.2 Tableaux multidimensionnels
7.3 Baies non intégrées
7.4 Allocation de références de tableau
7.5 Attribut de longueur
7.6 boucle foreach
7.7 Chaîne
Chapitre 8 Méthodes et classes
8.1 Contrôler l'accès aux membres du groupe
8.2 Passer des objets aux méthodes
8.3 paramètres ref et paramètres out
8.4 Le nombre d'arguments est variable
8.5 Objet de retour
8.6 Surcharge de méthode
8.7 Surcharge des constructeurs
8.8 Méthode Main()
8.9 Récursion
8.10 mot-clé statique
Chapitre 9 Surcharge des opérateurs
9.1 Notions de base sur la surcharge des opérateurs
9.2 Gestion des opérations sur les types internes C#
9.3 Surcharge des opérateurs relationnels
9.4 Surcharge vrai et faux
9.5 Surcharge des opérateurs logiques
9.6 Opérateurs de conversion
9.7 Conseils et limites en matière de surcharge de l'opérateur
9.8 Un autre exemple de surcharge des opérateurs
Chapitre 10 Index et propriétés
10.1 Indice
10.2 Propriétés
10.3 Utilisation des index et des propriétés
Chapitre 11 Héritage
11.1 Bases de l'héritage
11.2 Accès des membres et héritage
11.3 Constructeurs et héritage
11.4 Héritage et masquage de nom
11.5 Création de hiérarchies multi-niveaux
11.6 Quand appeler les constructeurs
11.7 Références de classe de base et objets dérivés
11.8 Méthodes virtuelles et surcharge
11.9 Utiliser des classes abstraites
11.10 Utilisation scellée pour empêcher l'héritage
11.11 classe d'objet
Chapitre 12 Interfaces, structures et énumérations
12.1 Interfaces
12.2 Utilisation des références d'interface
12.3 Propriétés de l'interface
12.4 Index des interfaces
12.5 Les interfaces peuvent être héritées
12.6 L'héritage de l'interface entraîne le masquage du nom
12.7 Implémentation explicite
12.8 Choisir entre les interfaces et les classes abstraites
12.9Interface standard .NET
12.10 Exemple d'étude d'interfaces
12.11 Structure
12.12 Énumérations
Chapitre 13 Gestion des exceptions
13.1 Classe System.Exception
13.2 Bases de la gestion des exceptions
13.3 Conséquences des exceptions non interceptées
13.4 Les exceptions permettent une gestion raisonnable des erreurs
13.5 Utilisation de plusieurs instructions catch
13.6 Capturer toutes les exceptions
13.7 Modules d'essai imbriqués
13.8 Lancement d'exceptions
13.9 Déclaration finale
13.10 Analyse détaillée des exceptions
13.11 Classes d'exceptions dérivées
13.12 Capture des exceptions de classe dérivée
13.13 déclarations vérifiées et déclarations non vérifiées
Chapitre 14 Entrée et sortie
14.1 Les E/S de C# reposent sur des flux de données
14.2 Classe de flux de données
14.3 E/S de la console
14.4 Flux de données de fichier et E/S de fichier orientées octets
14.5 E/S de fichiers basés sur des caractères
14.6 Redirection des flux de données standards
14.7 Lecture et écriture de données binaires
14.8 Fichiers à accès aléatoire
14.9 Classe MemoryStream
14.10 Classe StringReader et classe StringWriter
14.11 Convertir une chaîne numérique en sa représentation interne
Chapitre 15 Agents et événements
15.1 Mandataire
15.2 Événements
15.3 Principes des événements .NET
15.4 Événements de candidature : étude de cas
Chapitre 16 Espaces de noms, préprocesseurs et assemblys
16.1 Espaces de noms
16.2 Préprocesseur
16.3 Modificateurs d'assemblage et d'accès interne
Chapitre 17 ID de type d'exécution, mappages et propriétés
17.1 Identification du type d'exécution
17.2 Cartographie
17.3 Utilisation des mappages
17.4 Propriétés
17.5 Utilisation des propriétés intégrées
Chapitre 18 Codes dangereux, pointeurs et autres sujets
18.1 Code dangereux
18.2 Autres mots-clés
18.3 const et volatile
Partie 2 : Bibliothèque de classes C#
Chapitre 19 Espace de noms du système
19.1 Membres du système
19.2 Cours de mathématiques
19.3 Structure des types numériques
19.4 Classe de tableau
19.5 Classe BitConverter
19.6 Utiliser Random pour générer des nombres aléatoires
19.7 Gestion de la mémoire et classes GC
19.8 Classe d'objet
19.9 Interface comparable
19.10 Interface IConvertible
19.11 Interface clonable
19.12 Interfaces IFormatProvider et IFormattable
Chapitre 20 Chaînes et formatage
20.1 Chaînes en C#
20.2 Classe de chaînes
20.3 Formatage
20.4 Formatage des données à l'aide de String.Format() et ToString()
20.5 Création de formats de nombres personnalisés
20.6 Formater la date et l'heure
20.7 Formatage des énumérations
Chapitre 21 Programmation multithread
21.1 Bases du multithreading
21.2 Classe de fil
21.3 Déterminer l'heure de fin du thread
21.4 Propriété IsBackground
21.5 Priorité des fils de discussion
21.6 Synchronisation
21.7 Communication par thread utilisant Wait(), Pulse() et PulseAll()
21.8 Attribut MethodImplAttribute
21.9 Suspendre, reprendre et arrêter les threads
21.10 Détermination de l'état du thread
21.11 Utilisation du fil principal
21.12 Conseils sur le multithreading
21.13 Démarrer des tâches indépendantes
Chapitre 22 Rassemblement
22.1 Aperçu des collections
22.2 Interface de collecte
22.3 Structure d'entrée de dictionnaire
22.4 Classe de collecte générale
22.5 Utiliser BitArray pour stocker des bits
22.6 Collections privées
22.7 Accéder aux collections via les compteurs
22.8 Stockage des classes définies par l'utilisateur dans des collections
22.9 Résumé
Chapitre 23 Mise en réseau via Internet
23.1 Membres de System.Net
23.2 Identificateur de ressource uniforme
23.3 Bases de l'accès à Internet
23.4 Gestion des erreurs réseau
23.5 Classe Uri
23.6 Accéder à des informations de réponse HTTP supplémentaires
23.7 MiniCrawler : étude de cas
23.8 Utilisation de WebClient
La troisième partie applique C#
Chapitre 24 Composants du bâtiment
24.1 La notion de composants
24.2 Concept des composants C#
24.3 Interface IComponent
24.4 Classe de composants
24.5 Un composant simple
24.6 Surcharge de Dispose()
24.7 Utilisation de l'instruction using
24.8 Conteneurs
24.9 Les composants sont l'avenir de la programmation
Chapitre 25 Création d'applications Windows basées sur des formulaires
25.1 Un bref historique de la programmation Windows
25.2 Deux façons d'écrire des applications Windows basées sur des formulaires
25.3 Méthodes permettant à Windows d'interagir avec les utilisateurs
25.4 Formulaires Windows
25.5 Programmes-cadres Windows basés sur des formulaires
25.6 Ajouter des boutons
25.7 Traitement des messages
25.8 Utiliser les boîtes de message
25.9 Ajouter un menu
25.10 Résumé
Chapitre 26 Analyseur d'expressions récursives
26.1 Expressions
26.2 Analyse d'expressions : problèmes
26.3 Analyser des expressions
26.4 Analyser des expressions
26.5 Un analyseur d'expressions simples
26.6 Ajout de variables à l'analyseur
26.7 Vérification de la syntaxe dans les analyseurs récursifs
26.8 Quelques tentatives
Annexe A Référence rapide des commentaires XML Annexe BC# et robotique
Développer
