1. Livres et vidéos
  2. Programmation en C# - Préparation aux certifications MCSA - Examen 70-483

Programmation en C# Préparation aux certifications MCSA - Examen 70-483

  • Accès illimité 24h/24, 7J/7
  • Tous les livres en ligne, les vidéos et les cours enregistrés ENI
  • Plus de 10 nouveautés livres et vidéos chaque mois
  • Les nouveautés disponibles le jour de leur sortie
  • Accès 100% en ligne
  • En stock
  • Expédié en 24h00
  • Livraison à partir de 0,01 €
  • Version en ligne offerte pendant 1 an
  • 1 h d'accès gratuit à tous nos livres et vidéos pour chaque commande
  • Accessible immédiatement
  • Version HTML
  • Accès illimité 24h/24, 7J/7

Présentation

L'examen 70-483 Programmation en C# est l'un des deux examens obligatoires requis pour obtenir la certification MCSA Universal Windows Platform. Il est aussi l'un des examens qui peut être passé pour obtenir la certification MCSA Web Applications.

Pour vous aider à préparer efficacement l'examen, ce livre couvre les objectifs officiels, tant d'un point de vue théorique que d'un point de vue pratique. Il a été rédigé en français (il ne s'agit pas d'une traduction) par un développeur C# expérimenté, certifié techniquement par Microsoft. Ainsi, les savoir-faire pédagogique et technique de l'auteur conduisent à une approche claire et visuelle, d'un très haut niveau technique.

Chapitre après chapitre, vous pourrez valider vos acquis théoriques, à l'aide de questions-réponses (132 au total) mettant en exergue aussi bien les éléments fondamentaux que les caractéristiques spécifiques aux concepts abordés.

Chaque chapitre est agrémenté d'exemples pratiques permettant de mesurer votre autonomie. Ces manipulations concrètes vous permettront de vous forger une première expérience significative et d'acquérir de véritables compétences techniques.

À cette maîtrise des concepts s'ajoute la préparation spécifique à l'examen 70-483 : sur le site www.edieni.com vous pourrez accéder gratuitement à 1 examen blanc en ligne, destiné à vous entraîner dans des conditions proches de celles de l'épreuve. Sur ce site, chaque question posée s'inscrit dans l'esprit de la certification et, pour chacune, les réponses sont suffisamment commentées pour combler ou identifier vos ultimes lacunes.


Les chapitres du livre :
Préparer efficacement la certification 70-483 – Création de types – Utilisation et consommation des types – Encapsulation – Créer et implémenter une hiérarchie de classes – Utilisation transversale de la réflexion – Gestion du cycle de vie d'un objet – Manipulation des chaînes – Validation des entrées de l'application – Chiffrement symétrique et asymétrique – Gestion des assemblages – Débogage d'application – Diagnostic d'une application – Exécution des opérations d'entrée-sortie – Utilisation des données – Manipulation à l'aide de LINQ – Sérialisation et désérialisation des données – Stockage des données dans les collections et extraction des données de celles-ci – Multithreading et traitement asynchrone – Gestion du multithreading – Mise en œuvre du flux de programmes – Création et mise en œuvre des évènements et des rappels – Mise en œuvre de la gestion des exceptions – Tableau des objectifs

Table des matières

  • Chapitre 1 Préparer efficacement la certification 70-483
    • A. Introduction
    • B. Présentation de la certification
    • C. Les quatre thématiques
      • 1. La première thématique : « Gestion du flux de programme »
      • 2. La seconde thématique : « Création et utilisation des types »
      • 3. La troisième thématique : « Débogage d'applications et mise en œuvre de la sécurité »
      • 4. La quatrième thématique : « Mise en œuvre de l'accès aux données »
    • D. La structure du livre
      • 1. La table des matières
      • 2. Aperçu de la table des matières
      • 3. Les questions de fin de chapitre
    • E. Retour sur la plate-forme .Net
      • 1. Introduction
      • 2. Architecture
    • F. Généralités sur le langage C#
      • 1. Historique du langage
      • 2. Le langage C# et programmation orientée objet
        • a. Objet et encapsulation
        • b. L'héritage
        • c. Le polymorphisme
    • G. Vocabulaire et premières considérations syntaxiques
      • 1. Introduction
      • 2. Éléments de syntaxe
    • H. Rappels fondamentaux quant à la structure de la mémoire
      • 1. Introduction
      • 2. La pile
      • 3. Le tas
  • Chapitre 2 Création de types
    • A. Introduction
    • B. Typages en C#
    • C. L'énumération en C#
    • D. La structure en C#
    • E. La classe en C#
      • 1. Méthode de classe en C#
        • a. Considérations sur l'accessibilité
        • b. Arguments nommés
        • c. Arguments facultatifs
      • 2. Considérations sur les membres et les méthodes de classes
      • 3. Les mots-clés readonly et const
      • 4. Les mots-clés virtual et override
      • 5. Les constructeurs
    • F. Les types génériques
      • 1. Le type Nullable
      • 2. Construire un type générique basé sur un Nullable
    • G. Étendre un type par ses méthodes
      • 1. Créer une méthode d'extension
      • 2. Surcharge de méthodes
    • H. Validation des acquis : questions/réponses
  • Chapitre 3 Utilisation et consommation des types
    • A. Introduction
    • B. Le boxing
    • C. L'unboxing
      • 1. Invalidité du boxing/unboxing
      • 2. Considération sur les performances
    • D. Les conversions entre types
      • 1. Conversions implicites
      • 2. Conversions explicites
      • 3. Conversions définies par l'utilisateur
      • 4. Conversion avec une classe .Net dédiée
      • 5. Vérifier la validité d'une conversion
      • 6. Les types dynamiques
        • a. DynamicObject
        • b. ExpandoObject
    • E. PIA et interopérabilité
    • F. Validation des acquis : questions/réponses
  • Chapitre 4 Encapsulation
    • A. Introduction
    • B. Utiliser les accesseurs
      • 1. Visibilité et accesseurs
      • 2. Visibilités possibles selon les cas
    • C. Implémenter une interface
    • D. Implémenter des interfaces de façon explicite
    • E. Considération sur les objectifs du chapitre
    • F. Validation des acquis : questions/réponses
  • Chapitre 5 Créer et implémenter une hiérarchie de classes
    • A. Définir une interface
    • B. Hériter d'une classe
      • 1. Considérations sur l'héritage multiple
      • 2. Créer et utiliser une classe dite de base
        • a. Mécanisme général
        • b. Masquer un membre avec le mot-clé new
        • c. Classe abstraite et classe « feuille »
        • d. Le mot-clé sealed
      • 3. Piège de l'héritage et principe de substitution de Liskov
    • C. Implémenter une interface standard .Net
      • 1. IComparable
      • 2. IEnumerable
      • 3. IDisposable
    • D. Retour sur l'interface IUnknown
    • E. Validation des acquis : questions/réponses
  • Chapitre 6 Utilisation transversale de la réflexion
    • A. Les attributs en C#
      • 1. Aspects syntaxiques
        • a. Attributs multiples
        • b. Cible d'un attribut
      • 2. Savoir si un attribut est en place
      • 3. Créer ses propres attributs
    • B. Bases de la réflexion en C#
      • 1. La réflexion en informatique
      • 2. L'approche réflexive en C#
    • C. Générer du code à l’exécution avec CodeDOM
    • D. Les expressions lambda
      • 1. Introduction
      • 2. Quelques exemples
      • 3. Les arbres d'expressions
        • a. Introduction
        • b. Exemple
    • E. Validation des acquis : questions/réponses
  • Chapitre 7 Gestion du cycle de vie d'un objet
    • A. Retour sur le ramasse-miettes
    • B. Gérer le code « non managé »
      • 1. La « finalisation » en C#
      • 2. Rappels au sujet de l'interface IDisposable
      • 3. Créer un objet implémentant IDisposable
    • C. Pointeurs faibles
    • D. Validation des acquis : questions/réponses
  • Chapitre 8 Manipulations des chaînes
    • A. Introduction
      • 1. Définitions
      • 2. De l’immutabilité du type string
    • B. Manipulation de chaînes
      • 1. La classe StringBuilder
      • 2. Les classes StringWriter et StringReader
    • C. Recherche
    • D. Énumération
    • E. Formatage
      • 1. Formatage de base
      • 2. Recours aux interfaces IFormatProvider et IFormattable
    • F. Mise en situation
      • 1. Étape 1
      • 2. Étape 2
    • G. Validation des acquis : questions/réponses
  • Chapitre 9 Validation des entrées de l'application
    • A. Introduction
    • B. Présentation rapide de l'EntityFramework
    • C. Parse, TryParse et Convert, trois outils de conversion
    • D. Utiliser les expressions régulières
    • E. Valider un flux JSON
      • 1. Désérialisation d'un flux JSON
      • 2. Validité d'un flux XML
        • a. Première approche
        • b. Exemple complet
    • F. Validation des acquis : questions/réponses
  • Chapitre 10 Chiffrement symétrique et asymétrique
    • A. Éléments de cryptographie
    • B. Chiffrement symétrique en C#
    • C. Chiffrement asymétrique en C#
    • D. Table de hachage en C#
    • E. Manipuler des certificats en C#
      • 1. Présentation et intérêt du certificat
      • 2. Générer des certificats avec Makecert.exe
      • 3. Utiliser des certificats en C#
    • F. Utiliser Code Access Permissions (CAS)
      • 1. CAS déclaratif
      • 2. CAS impératif
    • G. Les chaînes de caractères sécurisées
      • 1. Créer et utiliser un SecureString
      • 2. Convertir un SecureString en un string
    • H. Validation des acquis : questions/réponses
  • Chapitre 11 Gestion des assemblages
    • A. Un assemblage, c'est quoi au juste ?
      • 1. Premiers aspects
      • 2. Définition
    • B. Signature des assemblages
    • C. Les assemblages face au GAC
    • D. Versions d'assemblages
    • E. Notions sur les fichiers de politique d'édition
    • F. Notions sur les assemblages WinMD
    • G. Résumé en vue de la certification
    • H. Validation des acquis : questions/réponses
  • Chapitre 12 Débogage d'application
    • A. Les modes de compilation
    • B. Les directives du préprocesseur
      • 1. #if, #else et #endif
      • 2. Définir ses propres symboles de préprocesseur
      • 3. Plus loin avec les directives de préprocesseur
        • a. #warning et #error
        • b. #line
        • c. #pragma warning
    • C. Utiliser l'attribut DebuggerDisplay
    • D. Gérer et utiliser le fichier PDB
    • E. Validation des acquis : questions/réponses
  • Chapitre 13 Diagnostic d'une application
    • A. Introduction
    • B. Utiliser la classe Debug
    • C. Utiliser la classe TraceSource
    • D. Utiliser la classe TraceListener
    • E. Utiliser l’observateur d'évènements de Windows
    • F. Évaluer les performances
      • 1. La classe Stopwatch
      • 2. Outils de performance dans les IDE
      • 3. Les compteurs de performances
    • G. Validation des acquis : questions/réponses
  • Chapitre 14 Exécution des opérations d'entrée-sortie
    • A. Introduction
    • B. L'accès physique aux fichiers
    • C. Les répertoires
      • 1. Créer un répertoire
        • a. Première façon de créer un répertoire
        • b. Seconde façon de créer un répertoire
      • 2. Supprimer un répertoire
        • a. Première façon de supprimer un répertoire
        • b. Seconde façon de supprimer un répertoire
      • 3. Déplacer un répertoire
        • a. Première façon de déplacer un répertoire
        • b. Seconde façon de déplacer un répertoire
      • 4. Gérer l'accès aux répertoires
    • D. Les fichiers
      • 1. Créer un fichier
        • a. Une première façon de créer un fichier
        • b. Une seconde façon de créer un fichier
      • 2. Supprimer un fichier
        • a. Première façon de supprimer un fichier
        • b. Seconde façon de supprimer un fichier
      • 3. Déplacer un fichier
        • a. Première façon de déplacer un fichier
        • b. Seconde façon de déplacer un fichier
      • 4. Copier un fichier
    • E. Manipulation avancée des chemins
      • 1. Créer un chemin
      • 2. Récupérer les données du chemin
    • F. Considérations sur les flux d'entrée-sortie
    • G. Entrée-sortie et requêtes web
    • H. Appels asynchrones
      • 1. Nature des appels asynchrones
      • 2. Utilisation des mots-clés async et await
      • 3. Parallélisme
    • I. Validation des acquis : questions/réponses
  • Chapitre 15 Utilisation des données
    • A. Introduction
    • B. Travailler avec les bases de données
      • 1. Requêter une base de données relationnelle depuis C#
      • 2. Utiliser les transactions
      • 3. Comprendre et utiliser un ORM
    • C. Utiliser les webservices avec WCF
    • D. Utiliser un flux JSON ou XML
      • 1. Flux JSON
      • 2. Flux XML
      • 3. Lire du XML
      • 4. Écrire du XML
      • 5. Utiliser XmlDocument
      • 6. Requêter du XML avec XPath
        • a. Premier exemple d'utilisation
        • b. Syntaxe XPath pour XML
    • E. Validation des acquis : questions/réponses
  • Chapitre 16 Manipulation à l'aide de LINQ
    • A. Présentation de LINQ
      • 1. Typages implicites des variables
      • 2. Syntaxe intuitive de l'initialisation des variables
      • 3. Expressions lambda
      • 4. Méthodes d'extension
      • 5. Types anonymes
    • B. Manipuler les requêtes LINQ
      • 1. Premier exemple
      • 2. Les opérateurs de LINQ
      • 3. Trier les résultats
      • 4. Travailler avec des sources multiples
      • 5. Utilisation de Group By
      • 6. Alternative avec GroupBy
      • 7. Premières jointures en LINQ
      • 8. Usage de GroupJoin en LINQ
    • C. Considérations autour de la pagination en LINQ
    • D. Manipuler du XML en LINQ
      • 1. Introduction
      • 2. Premières requêtes avec XDocument
      • 3. Créer du XML avec LINQ
    • E. Validation des acquis : questions/réponses
  • Chapitre 17 Sérialisation et désérialisation des données
    • A. Introduction et définitions
    • B. Le mécanisme de sérialisation en .NET
    • C. Travailler avec XmlSerializer
      • 1. Considération sur la technologie SOAP
      • 2. La classe XmlSerializer
      • 3. Premier exemple de l'utilisation de XmlSerializer
        • a. Configuration de XmlSerializer
        • b. Second exemple de l'utilisation de XmlSerializer
    • D. Travailler avec BinaryFormatter
      • 1. Exemple de l'utilisation de BinaryFormatter
      • 2. L'interface ISerializable
    • E. Travailler avec DataContractSerializer
      • 1. Introduction
      • 2. Exemple d'utilisation
      • 3. Contrat de données et JSON
    • F. Validation des acquis : questions/réponses
  • Chapitre 18 Stockage des données dans les collections et extraction des données de celles-ci
    • A. Introduction
    • B. Les tableaux
      • 1. Introduction
      • 2. Éléments de syntaxe
      • 3. Tableaux multidimensionnels
        • a. Introduction
        • b. Exemple
      • 4. Tableaux de tableaux
        • a. Introduction
        • b. Exemple
    • C. Les listes
      • 1. Introduction
      • 2. Exemple général
    • D. Les dictionnaires
      • 1. Introduction
      • 2. Exemple général
    • E. Les tables de hachage
      • 1. Introduction
      • 2. Exemple général
    • F. Les files
    • G. Les piles
    • H. La problématique du choix de la « bonne » structure de données
    • I. Hériter d'une structure de données
    • J. Considérations sur les DataTable
      • 1. Introduction
      • 2. Exemple d'utilisation
      • 3. Utilisation de DataView
    • K. Validation des acquis : questions/réponses
  • Chapitre 19 Multithreading et traitement asynchrone
    • A. Introduction
    • B. Les threads en C#
      • 1. La classe Thread
      • 2. Création d'un thread associé à une méthode
      • 3. Suspension et attente d'un thread
      • 4. Notion de priorité d'un thread
      • 5. Background vs Foreground
      • 6. Passer des paramètres à un thread
      • 7. Considération sur l'arrêt d'un thread en cours
      • 8. Utiliser [ThreadStatic] et ThreadLocal<T>
    • C. La notion de « Pool de threads »
    • D. Les tâches et la classe Task
      • 1. Introduction
      • 2. La classe Task
      • 3. Création d'une tâche
      • 4. Comprendre la continuation d'une tâche
      • 5. Comprendre les tâches enfants
      • 6. La notion d'usine de fabrication de tâches (classe TaskFactory)
      • 7. WaitAll, WaitAny, etc.
        • a. WaitAll
        • b. WaitAny
    • E. Le parallélisme et la classe Parallel
      • 1. Introduction
      • 2. Quelques exemples
        • a. Avec For
        • b. Avec ForEach
        • c. Interruption de boucles
    • F. async et await, mots-clés magiques
      • 1. Introduction
        • a. Mot-clé async
        • b. Mot-clé await
      • 2. Premier exemple
      • 3. Considérations sur le contexte d'appel et utilisation de ConfigureAwait
    • G. Parallel Language Integrated Query (PLINQ)
      • 1. Introduction
      • 2. Premier exemple
      • 3. Séquentiel vs parallèle
      • 4. PLINQ et gestion des exceptions
    • H. Les collections concurrentes
      • 1. Introduction
      • 2. BlockingCollection<T>
        • a. Premier exemple
        • b. Exemple d'une utilisation concurrentielle
        • c. La méthode GetConsumingEnumerable
      • 3. ConcurrentBag<T>
        • a. Introduction
        • b. Exemple d'utilisation
      • 4. ConcurrentDictionary<T>
      • 5. ConcurrentQueue<T>
      • 6. ConcurrentStack<T>
    • I. Validation des acquis : questions/réponses
  • Chapitre 20 Gestion du multithreading
    • A. Introduction
    • B. Synchronisation des ressources
      • 1. Introduction
      • 2. Mise en évidence du caractère stochastique
      • 3. Le mot-clé lock
        • a. Exemple d'utilisation
        • b. Bonne pratique de l'usage de lock
      • 4. Notion de deadlock
    • C. Usage du mot-clé volatile
      • 1. Mise en évidence du problème à résoudre
      • 2. Présentation du mot-clé volatile
        • a. Définition
        • b. Exemple d'utilisation
    • D. La classe Interlocked
      • 1. Introduction
      • 2. Exemple d'utilisation
    • E. Annuler des tâches en C#
      • 1. Présentation du contexte
      • 2. Premier exemple avec CancellationToken
      • 3. Gestion des exceptions lors d'une annulation de tâches
      • 4. Poursuivre une tâche annulée
      • 5. Annulation de tâches et TimeOut
    • F. Validation des acquis : questions/réponses
  • Chapitre 21 Mise en œuvre du flux de programmes
    • A. Introduction
    • B. Les expressions booléennes en C#
      • 1. Introduction
      • 2. Opérateurs d'égalité et de comparaisons en C#
      • 3. Opérateurs logiques en C#
        • a. Le ET logique
        • b. Le OU logique
        • c. Le OU exclusif
        • d. L'inversion logique
      • 4. Les opérateurs bit à bit
    • C. Aspects conditionnels en C#
      • 1. Introduction
      • 2. if else
      • 3. Opérateur de coalescence ??
      • 4. Opérateur conditionnel ?
      • 5. Utiliser la déclaration switch en C#
    • D. Les déclarations de parcours de collections en C#
      • 1. Introduction
      • 2. Boucle for
      • 3. Boucle foreach
      • 4. Boucle while
      • 5. Boucle do while
    • E. Les sauts en C#
      • 1. Les déclarations break et continue
      • 2. La déclaration goto
    • F. Validation des acquis : questions/réponses
  • Chapitre 22 Création et mise en œuvre des évènements et des rappels
    • A. Première approche événementielle en C#
      • 1. Introduction
      • 2. Premier exemple d'un délégué
      • 3. Combinaison de délégués
      • 4. Covariance de délégués
      • 5. Contravariance de délégués
      • 6. Retour sur les expressions lambda dans la définition des délégués
    • B. Les délégués génériques en C#
      • 1. Introduction
      • 2. Utilisation du délégué Action
        • a. Premier exemple
        • b. Second exemple
    • C. Le mot-clé event
      • 1. Introduction
      • 2. Exemple d'utilisation
      • 3. Les arguments personnalisés
      • 4. Accesseurs de l'évènement
    • D. Validation des acquis : questions/réponses
  • Chapitre 23 Mise en œuvre de la gestion des exceptions
    • A. Introduction
      • 1. Mots-clés try et catch
      • 2. Mot-clé finally
      • 3. Mot-clé throw
      • 4. La classe Exception
    • B. Mise en évidence des exceptions en C#
      • 1. Premier exemple, division par zéro
      • 2. Second exemple, conversion inappropriée
      • 3. Première gestion d'exception (sur la division par zéro)
    • C. Gestion des exceptions en C#
      • 1. Gérer différents types d'exceptions
      • 2. Utilisation de finally
    • D. Inventaire des principales exceptions en C#
    • E. Déclencher une exception
      • 1. Introduction
      • 2. La classe ExceptionDispatchInfo
    • F. Créer ses propres exceptions
      • 1. Introduction
      • 2. Exemple
    • G. Validation des acquis : questions/réponses
    • Tableau des objectifs
    • Index

Auteur

Benoît PRIEUREn savoir plus

Ingénieur en informatique diplômé de l'ISIMA de Clermont-Ferrand, Benoît PRIEUR conduit des missions de conseil pour le compte de sa société Soarthec. Spécialisé dans le développement en Python et en C#, il met quotidiennement en œuvre ses compétences de développement auprès de ses clients. Il est également formateur sur les technologies .NET et le développement Python.

Caractéristiques

  • Niveau Expert
  • Nombre de pages 438 pages
  • Parution mai 2018
    • Livre (broché) - 17 x 21 cm
    • ISBN : 978-2-409-01382-9
    • EAN : 9782409013829
    • Ref. ENI : CEPROCSHA
  • Niveau Expert
  • Parution mai 2018
    • HTML
    • ISBN : 978-2-409-01383-6
    • EAN : 9782409013836
    • Ref. ENI : LNCEPROCSHA

Téléchargements

En complétant ce formulaire, vous acceptez d'être contacté afin de recevoir des informations sur nos produits et services ainsi que nos communications marketing. Vous aurez la possibilité de vous désabonner de nos communications à tout moment. Pour plus d'informations sur notre politique de protection des données, cliquez ici.
  • Des fichiers complémentaires (73,6 Mo)