1. Livres et vidéos
  2. C# 7 - Développez des applications Windows avec Visual Studio 2017

C# 7 Développez des applications Windows avec Visual Studio 2017

  • 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

Ce livre sur le développement d'applications Windows avec le langage C# et Visual Studio 2017 est destiné aux développeurs qui débutent avec le framework .NET. Il leur permet d'apprendre les bases du langage C# et introduit des concepts plus avancés leur donnant une vue d'ensemble des possibilités offertes par le langage C#, Visual Studio et le framework .NET en général. L'auteur a choisi une approche pas à pas tout en construisant une application fonctionnelle tout au long de l'ouvrage pour illustrer de manière pratique et cohérente les concepts abordés.

L'apprentissage commence par la familiarisation avec l'interface de Visual Studio 2017 ainsi qu'avec le concept de l'architecture .NET. Les détails du langage C#, sa syntaxe et ses fonctionnalités comme les classes, l'héritage, les interfaces, les types génériques ou encore les délégués et les évènements sont ensuite expliqués avant d'aborder la conception d'interfaces utilisateur.

La conception de l'interface utilisateur couvre toutes les phases utiles pour créer des applications Windows à la fois fonctionnelles et ergonomiques, allant de la création de formulaires à la création de contrôles en passant par l'implémentation de gestionnaire d'évènements et la validation des données saisies. Une introduction à la conception d’application WPF est également incluse.

Les outils de Visual Studio qui permettent de réaliser les tests et le débogage des applications sont également détaillés en présentant les techniques de gestion des erreurs mais aussi les concepts permettant de surveiller les applications comme le traçage, l'interaction avec les journaux d'évènements et l'utilisation des compteurs de performance.

L'utilisation de Entity Framework est détaillée au sein d'exemples concrets permettant de comprendre rapidement comment créer des modèles de données et comment les utiliser pour communiquer avec une base de données, tout en apprenant à utiliser le langage de requête LINQ pour interagir avec des données sous différents formats (objets, SQL ou XML). L'alternative au stockage de données d'une application sur le système de fichiers et l'utilisation du concept de la sérialisation sont également détaillés, fournissant ainsi une vision globale des possibilités offertes par le framework .NET concernant la gestion des données.

Des concepts plus avancés sont également abordés afin d'exposer une gamme plus large des possibilités offertes par le langage C# et Visual Studio : l'utilisation des expressions régulières, le développement d'applications multitâches et asynchrones, la globalisation et la localisation d'une application, la sécurité du code, l'implémentation d'applications client/serveur, le dessin avec GDI+ ainsi que la réflexion font partie des sujets introduits.

La dernière partie de l'ouvrage est consacrée à la création d'assemblages ainsi qu'au déploiement des applications. Les outils et techniques mis à disposition par Visual Studio pour créer des installeurs Windows et configurer les applications y sont détaillés.

Le code de l'application exemple traitée dans l'ouvrage est en téléchargement sur le site www.editions-eni.fr.


Les chapitres du livre :
Avant-propos – Travailler avec Visual Studio 2017 – L'architecture .NET – Introduction au langage C# – La création de types – L'héritage – Types génériques – Délégués, évènements et expressions lambda – Création de formulaires – Implémentation de gestionnaires d'évènements – Validation de la saisie – Création de contrôles utilisateurs – Création d'applications UWP – Débogage – Gestion des exceptions – Monitoring – Tests unitaires – Création du modèle de données – Présentation de Entity Framework – Présentation de LINQ – LINQ to Entities – LINQ to SQL – LINQ to XML – Le système de fichiers – Sérialisation – Expressions régulières – Multi-threading – Globalisation et localisation – Sécurité – Pour aller plus loin – Assemblages et configurations – Déploiement

Table des matières

  • Travailler avec Visual Studio
    • 1. Introduction
    • 2. L'interface de développement
      • 2.1 L'éditeur de texte
      • 2.2 Le concepteur de vues
      • 2.3 Le débogueur intégré
      • 2.4 Le gestionnaire d'extensions
      • 2.5 NuGet
      • 2.6 Fenêtres personnalisées
    • 3. La création de solutions
      • 3.1 Définir le point d'entrée
      • 3.2 La différence entre projets et solutions
      • 3.3 Configurer le projet
      • 3.4 La conversion de solutions
      • 3.5 Les projets partagés
      • 3.6 Les outils de refactorisation
  • L'architecture .NET
    • 1. Introduction
    • 2. CLR
    • 3. Les bibliothèques de classes
    • 4. Les types
      • 4.1 Les types valeur
      • 4.2 Les types référence
  • Introduction au langage C#
    • 1. La syntaxe
      • 1.1 Les identifiants
      • 1.2 Les mots-clés
      • 1.3 La ponctuation
      • 1.4 Les opérateurs
        • 1.4.1 Les opérateurs de calcul
        • 1.4.2 Les opérateurs d'assignation
        • 1.4.3 Les opérateurs de comparaison
      • 1.5 La déclaration de variables
      • 1.6 Les instructions de contrôle
        • 1.6.1 Les instructions conditionnelles
        • 1.6.2 Les instructions itératives
        • 1.6.3 Les instructions de saut
      • 1.7 Les commentaires
    • 2. Les espaces de noms
      • 2.1 Le mot-clé using
      • 2.2 Le mot-clé alias
      • 2.3 Les classes statiques
    • 3. Les types de base
      • 3.1 Les types numériques
        • 3.1.1 Les entiers
        • 3.1.2 Les décimaux
      • 3.2 Les booléens
      • 3.3 Les chaînes de caractères
      • 3.4 Les types nullable
      • 3.5 La conversion de types
        • 3.5.1 La conversion implicite
        • 3.5.2 La conversion explicite
    • 4. Les constantes et les énumérations
      • 4.1 Les constantes
      • 4.2 Les énumérations
    • 5. Les tableaux
    • 6. Les collections
    • 7. Les directives preprocessor
  • La création de types
    • 1. Introduction
    • 2. Les niveaux d'accès
    • 3. Les structures
    • 4. Les classes
      • 4.1 Les champs
      • 4.2 Les propriétés
      • 4.3 Les méthodes
        • 4.3.1 La surcharge
        • 4.3.2 Les paramètres
        • 4.3.3 Les tuples
      • 4.4 Les constructeurs
      • 4.5 Les destructeurs
      • 4.6 Les classes et membres statiques
      • 4.7 Les classes partielles
      • 4.8 Le mot-clé this
      • 4.9 Les indexeurs
      • 4.10 La surcharge d'opérateurs
        • 4.10.1 Les opérateurs arithmétiques
        • 4.10.2 Les opérateurs de comparaison
  • L'héritage
    • 1. L'héritage de classe
      • 1.1 Implémenter l'héritage
      • 1.2 Les membres virtuels
      • 1.3 Masquer les membres hérités
      • 1.4 Le mot-clé base
      • 1.5 Les classes et membres abstraits
      • 1.6 Les classes et les méthodes scellées
      • 1.7 Les constructeurs dérivés
      • 1.8 Le polymorphisme
    • 2. Les interfaces
      • 2.1 L'implémentation d'interfaces
      • 2.2 Le polymorphisme d'interface
      • 2.3 L'héritage d'interfaces
  • Types génériques
    • 1. Introduction
    • 2. La création de types génériques
    • 3. Les contraintes de type
    • 4. Les interfaces génériques
      • 4.1 La variance dans les interfaces génériques
        • 4.1.1 La covariance
        • 4.1.2 La contravariance
      • 4.2 La création d'interfaces génériques variantes
      • 4.3 L'héritage d'interfaces génériques variantes
    • 5. La création de méthodes génériques
    • 6. Valeur par défaut générique
    • 7. L'héritage de classe générique
  • Délégués, évènements et expressions lambda
    • 1. Les délégués
      • 1.1 Les paramètres de méthode
      • 1.2 Les méthodes cibles multiples
      • 1.3 Les délégués génériques
      • 1.4 La compatibilité des délégués
    • 2. Les évènements
    • 3. Les expressions lambda
      • 3.1 L'utilisation des expressions lambda
      • 3.2 Les délégués génériques
      • 3.3 La capture de variable
      • 3.4 Les fonctions locales
  • Création de formulaires
    • 1. Utiliser les formulaires
      • 1.1 Ajouter des formulaires au projet
      • 1.2 Modifier le formulaire de démarrage
      • 1.3 Les propriétés des formulaires
      • 1.4 Les méthodes des formulaires
      • 1.5 Les évènements des formulaires
    • 2. Utiliser les contrôles
      • 2.1 Les types de contrôles
      • 2.2 Ajouter des contrôles aux formulaires
      • 2.3 Les propriétés des contrôles
      • 2.4 Les menus
      • 2.5 Les conteneurs
      • 2.6 L'ergonomie
      • 2.7 Ajouter des contrôles à la boîte à outils
  • Implémentation de gestionnaires d'évènements
    • 1. Introduction
    • 2. La création de gestionnaires d'évènements
      • 2.1 La mécanique d'un évènement
      • 2.2 L'ajout dynamique d'un gestionnaire d'évènements
      • 2.3 La suppression dynamique d'un gestionnaire d'évènements
    • 3. Les gestionnaires d'évènements avancés
      • 3.1 Un gestionnaire pour plusieurs évènements
      • 3.2 Plusieurs gestionnaires pour un évènement
  • Validation de la saisie
    • 1. Introduction
    • 2. La validation au niveau des champs
      • 2.1 Les propriétés de validation
      • 2.2 Les évènements de validation
        • 2.2.1 KeyDown et KeyUp
        • 2.2.2 KeyPress
        • 2.2.3 Validating et Validated
    • 3. La validation au niveau du formulaire
    • 4. Les méthodes de retour à l'utilisateur
      • 4.1 MessageBox
      • 4.2 ErrorProvider
  • Création de contrôles utilisateurs
    • 1. Introduction
    • 2. Les contrôles personnalisés
    • 3. L'héritage de contrôles
    • 4. Les contrôles utilisateurs
  • Création d'applications UWP
    • 1. Introduction
    • 2. Principes
    • 3. Les outils de développement
    • 4. Le langage XAML
    • 5. Une première application UWP
      • 5.1 Les bases d’un projet UWP
      • 5.2 Les contrôles et évènements
      • 5.3 Les styles
  • Débogage
    • 1. Les types d'erreur
      • 1.1 Les erreurs de syntaxe
      • 1.2 Les erreurs d'exécution
      • 1.3 Les erreurs de logique
    • 2. Le débogueur
      • 2.1 Contrôler l'exécution
      • 2.2 Les points d'arrêt
        • 2.2.1 Les conditions d'arrêt
        • 2.2.2 Le nombre d'accès
        • 2.2.3 Le filtrage
        • 2.2.4 Les actions
        • 2.2.5 Exécuter jusqu'au clic
      • 2.3 Les DataTips
      • 2.4 Les PerfTips
      • 2.5 Les attributs Caller
    • 3. Les fenêtres
      • 3.1 La fenêtre Sortie
      • 3.2 La fenêtre Variables locales
      • 3.3 La fenêtre Automatique
      • 3.4 La fenêtre Espion
      • 3.5 La fenêtre Exécution
      • 3.6 Les autres fenêtres
  • Gestion des exceptions
    • 1. La classe Exception
    • 2. La création d'exceptions personnalisées
    • 3. Le déclenchement des exceptions
    • 4. L'interception et la gestion des exceptions
  • Monitoring
    • 1. Le traçage
      • 1.1 Les classes Debug et Trace
      • 1.2 La collection d'écouteurs
        • 1.2.1 La création d'écouteurs
        • 1.2.2 La sauvegarde des traces
      • 1.3 Les commutateurs de trace
        • 1.3.1 Le fonctionnement des commutateurs de trace
        • 1.3.2 La configuration des commutateurs de trace
    • 2. Les journaux d'évènements
      • 2.1 L'interaction avec les journaux d'évènements
      • 2.2 La gestion des journaux d'évènements
      • 2.3 L'écriture d'évènements
    • 3. Les compteurs de performance
      • 3.1 La création de compteurs de performance
        • 3.1.1 Depuis Visual Studio
        • 3.1.2 Depuis le code
      • 3.2 L'utilisation de compteurs de performance
      • 3.3 L'analyse de compteurs de performance
  • Tests unitaires
    • 1. Introduction aux tests unitaires
      • 1.1 La création du projet
      • 1.2 Les classes de tests unitaires
    • 2. La mise en place d'une série de tests
      • 2.1 La création de tests au projet
      • 2.2 Le déroulement des tests
  • Création du modèle de données
    • 1. Introduction
    • 2. La création d'un modèle
    • 3. La création d'entités
    • 4. La génération de la base de données
    • 5. La création d'entités à partir du code (Code First)
  • Présentation de Entity Framework
    • 1. Introduction
    • 2. Le mappage
      • 2.1 La couche logique
      • 2.2 La couche conceptuelle
      • 2.3 La couche de mappage
    • 3. Travailler avec les entités
      • 3.1 Les entités
      • 3.2 La classe DbContext
      • 3.3 Les relations
        • 3.3.1 Le concept de table par type
        • 3.3.2 Le concept de table par hiérarchie
  • Présentation de LINQ
    • 1. Les requêtes LINQ
      • 1.1 La syntaxe
      • 1.2 Les méthodes d'extension
    • 2. Les opérateurs de requêtes
      • 2.1 Filtrer
        • 2.1.1 Where
        • 2.1.2 OfType<TResult>
        • 2.1.3 SelectMany
        • 2.1.4 Skip et Take
      • 2.2 Ordonner
        • 2.2.1 OrderBy
        • 2.2.2 ThenBy
      • 2.3 Grouper
        • 2.3.1 GroupBy
        • 2.3.2 Join
      • 2.4 Agréger
      • 2.5 Convertir
    • 3. Les requêtes parallèles
      • 3.1 Partitionner une requête
      • 3.2 Annuler une requête
  • LINQ to Entities
    • 1. Introduction
    • 2. Extraire les données
      • 2.1 L'extraction simple
      • 2.2 L'extraction conditionnelle
    • 3. Ajouter, modifier et supprimer des données
      • 3.1 Ajouter des données
      • 3.2 Modifier des données
      • 3.3 Supprimer des données
      • 3.4 L'envoi des modifications
  • LINQ to SQL
    • 1. La création de classes LINQ to SQL
    • 2. L'objet DataContext
      • 2.1 La méthode ExecuteQuery
      • 2.2 Utiliser des transactions
      • 2.3 Les autres membres de DataContext
    • 3. Exécuter des requêtes avec LINQ
      • 3.1 Les requêtes simples
      • 3.2 Les requêtes filtrées
      • 3.3 Les requêtes de jointure
    • 4. Les procédures stockées
      • 4.1 L'ajout de procédures stockées au modèle
      • 4.2 L'exécution de procédures stockées
  • LINQ to XML
    • 1. Les objets XML
      • 1.1 XDocument
      • 1.2 XElement
      • 1.3 XNamespace
      • 1.4 XAttribute
      • 1.5 XComment
    • 2. Exécuter des requêtes avec LINQ
      • 2.1 Les requêtes simples
      • 2.2 Les requêtes filtrées
      • 2.3 Les requêtes de jointure
  • Le système de fichiers
    • 1. Les classes de gestion du système de fichiers
      • 1.1 DriveInfo
      • 1.2 Directory et DirectoryInfo
      • 1.3 File et FileInfo
      • 1.4 Path
    • 2. Travailler avec le système de fichiers
      • 2.1 Les objets Stream
      • 2.2 La classe FileStream
      • 2.3 Lire un fichier texte
        • 2.3.1 Lire avec la classe File
        • 2.3.2 Lire avec la classe StreamReader
      • 2.4 Écrire dans un fichier texte
        • 2.4.1 Écrire avec la classe File
        • 2.4.2 Écrire avec la classe StreamWriter
  • Sérialisation
    • 1. Introduction
    • 2. La sérialisation binaire
      • 2.1 Les bases
      • 2.2 Contrôler la sérialisation
        • 2.2.1 Le contrôle par attribut
        • 2.2.2 Le contrôle par interface
    • 3. La sérialisation XML
      • 3.1 Les bases
      • 3.2 Contrôler la sérialisation
      • 3.3 La sérialisation XML SOAP
  • Expressions régulières
    • 1. Introduction
    • 2. Une première expression régulière
    • 3. Les options de recherche
    • 4. Les caractères d'échappement
    • 5. Les ensembles
    • 6. Les groupes
    • 7. Les ancres
    • 8. Les quantifieurs
  • Multi-threading
    • 1. Introduction
    • 2. La classe Thread
      • 2.1 Créer un thread
      • 2.2 Suspendre ou annuler un thread
      • 2.3 Échanger des données avec un thread
      • 2.4 Verrouiller un thread
      • 2.5 Priorité des threads
    • 3. Fonctions asynchrones
      • 3.1 Task et Task<TResult>
      • 3.2 async et await
    • 4. Le composant BackgroundWorker
  • Globalisation et localisation
    • 1. Introduction
    • 2. La culture
    • 3. La globalisation
    • 4. La localisation
  • Sécurité
    • 1. Introduction
    • 2. Les éléments de base
      • 2.1 L'interface IPermission
      • 2.2 La classe CodeAccessPermission
      • 2.3 L'interface IPrincipal
    • 3. Implémentation de la sécurité
      • 3.1 La sécurité basée sur les rôles
        • 3.1.1 Sécurité impérative
        • 3.1.2 Sécurité déclarative
      • 3.2 La sécurité basée sur les droits d'accès
        • 3.2.1 Sécurité impérative
        • 3.2.2 Sécurité déclarative
    • 4. Introduction à la cryptographie
  • Pour aller plus loin
    • 1. Le dessin avec GDI+
      • 1.1 La classe Graphics
        • 1.1.1 Les coordonnées
        • 1.1.2 Les formes
      • 1.2 La structure Color et les classes Brush et Pen
        • 1.2.1 La structure Color
        • 1.2.2 La classe Brush
        • 1.2.3 La classe Pen
        • 1.2.4 Les paramètres système
      • 1.3 Les exemples
        • 1.3.1 L'affichage de texte
        • 1.3.2 Redimensionner une image
    • 2. Le remoting
      • 2.1 Le principe
      • 2.2 L'implémentation
        • 2.2.1 La couche commune
        • 2.2.2 L'application serveur
        • 2.2.3 L'application cliente
    • 3. Reflection
      • 3.1 La classe System.Type
      • 3.2 Charger un assemblage dynamiquement
        • 3.2.1 L'énumération des types
        • 3.2.2 L'instanciation d'objets
        • 3.2.3 L'utilisation des membres
  • Assemblages et configurations
    • 1. Introduction
    • 2. Les assemblages privés
    • 3. Les assemblages partagés
    • 4. Les fichiers de configuration
  • Déploiement
    • 1. Introduction
    • 2. Les projets de déploiement
      • 2.1 XCOPY
      • 2.2 Projet CAB
      • 2.3 Projet de module de fusion
      • 2.4 Projet d'installation
    • 3. L'assistant Installation
    • 4. Configuration du projet
      • 4.1 Les propriétés du projet
      • 4.2 Les éditeurs de configuration
        • 4.2.1 Éditeur du système de fichiers
        • 4.2.2 Éditeur du registre
        • 4.2.3 Éditeur des types de fichiers
        • 4.2.4 Éditeur de l'interface utilisateur
        • 4.2.5 Éditeur des actions personnalisées
        • 4.2.6 Éditeur des conditions de lancement
    • Index

Auteur

Jérôme HUGONEn savoir plus

Jérôme HUGON est développeur/consultant .NET depuis de nombreuses années et est certifié Microsoft sur les technologies .NET. Son expérience du développement de sites web ASP.NET et SharePoint comme d'applications Windows ou Microsoft Surface lui permet d'apporter au lecteur une connaissance de base solide du langage C# mais aussi une belle ouverture vers des concepts plus avancés pour une utilisation optimale de ce langage.

Caractéristiques

  • Niveau Confirmé à Expert
  • Nombre de pages 516 pages
  • Parution juillet 2017
    • Livre (broché) - 17 x 21 cm
    • ISBN : 978-2-409-00928-0
    • EAN : 9782409009280
    • Ref. ENI : EI7C17VIS
  • Niveau Confirmé à Expert
  • Parution juillet 2017
    • HTML
    • ISBN : 978-2-409-00990-7
    • EAN : 9782409009907
    • Ref. ENI : LNEI7C17VIS

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 - Partie 1 (522 Ko)
  • Des fichiers complémentaires - Partie 2 (49,9 Mo)
  • Des fichiers complémentaires - Partie 3 (49,9 Mo)
  • Des fichiers complémentaires - Partie 4 (50 Mo)