Titre : C# 2.0 : Guide pratique du développeur
Auteurs : Michel de Champlain, Brian G Patrick
Langue : Français
Editeur : Dunod
ISBN : 2100493272
Nombre de pages : 246

1. Introduction au C# et à .Net 2. Classes, objets et espaces de noms
3. Classes : membres et réutilisation
4. Le système unifié de types
5. Opérateurs, affectations et expressions
6. Instructions et exceptions
7. Types avancés, polymorphisme et accesseurs
8. Collections et génériques
9. Libération des ressources, entrées/sorties et threads
10. Réflexion et attributs

Se concentrer sur les éléments essentiels de C# 2.0 afin de commencer à développer rapidement et en toute confiance: c'est en résumé l'objectif de cet ouvrage pratique et synthétique. Vous y trouverez une explication concise des caractéristiques de la nouvelle version de C# illustrées de courts exemples complets. Vous y découvrirez aussi la complémentarité qui existe entre C# et la plate-forme Net, ainsi qu'un rappel des concepts orientés objet. Issu de l'expérience des auteurs en formation auprès de développeurs en entreprise ou auprès d'étudiants, cet ouvrage fournit de nombreux exemples qui ont tous été vérifiés et compilés. 25 exercices vous permettront en outre de tester vos connaissances. Le code de la plupart des exemples et de tous les exercices est téléchargeable sur le site web associé à ce livre.

Si comme moi, vous comptez sur ce livre pour découvrir les nouveautés du framework 2.0 en C#, vous serez grandement décus. Ce livre est clairement le manuel de découverte du C#, destiné aux débutants voire aux habitués du framework .Net 1.x qui souhaitent revoir leurs bases. Les explications sont claires et les interconnexions interchapitres sont bien choisies mais l'ensemble me laisse néanmoins une impression de trop léger. j'aurais aimé plus de développement sur des parties du framework non spécifiques au C# mais utilisables par celui-ci: le cryptage, la sécurité, la gestion I/O, le xml, etc

Même si ce livre a pour objectif d'apprendre le C# et de se focaliser sur son fonctionnement, sans s'étaler sur son utilisation dans les applications Winforms et Webforms, il était impossible d'écrire un bon livre sur le C#, sans avant expliquer le principe de la plateforme .Net et de ses différents composants. Ce premier chapitre amène à la découverte du la plateforme .Net, de ses différents langages dit "dotnet" ou le CIL. Mais également différents principes fonctionnels comme le GAC (Global Assemby Cache) ou le CLR (Common Language Runtime).

Le chapitre 2 entame la discussion sur les classes et les objets, le premier des trois dogmes de la technologie orientée objet. Vous verrez comment les classes sont définies comme un amalgame de comportement et d'état, comment les objets sont créés et comment contrôler les accès aux classes et aux membres des classes. Les espaces de noms, un aspect important de la " programmation au sens large ", sont aussi définis dans ce chapitre. Ils servent à organiser les classes en groupes logiques, à prévenir les conflits de noms et à faciliter l'intégration de la réutilisation des autres classes dans les applications.

Le chapitre 3 propose un exposé plus complet des membres de classes du C# : les méthodes définissant le comportement et les données membres définissant l' "tat. Ce chapitre couvre aussi les constructeurs, les destructeurs et le passage des paramètres par valeur et par référence. Ce chapitre se conclut par une discussion importante sur la réutilisation des classes et sur la façon dont celles-ci dérivent, perfectionnent et redéfinissent leur comportement et leur état au moyen de l'héritage, le deuxième dogme de la programmation orientée objet. Nous comparons l'héritage à l'agrégation et nous exposons quelques indications sur l'emploi de l'un ou de l'autre.

Le chapitre 4 s'intéresse au système de type unifié du C#, par la présentation des types de valeur et de référence, tous deux dérivés de la même classe d'origine appelée Object. Tous les types de valeur, y compris les types annulables, sont entièrement décrits, accompagnés d'une brève introduction de la notion de base d'un type de référence. La classe Object elle-même fournit un excellent support l'introduction du polymorphisme (le troisième dogme de la POO), aux méthodes virtuelles et au clonage par la copie complète et superficielle. Ce chapitre se termine par la présentation de deux classes prédéfinies mais courantes, les tableaux et les chaînes.

Les opérateurs sont le point central de ce 5ème chapitre. Vous apprendrez à les utiliser aussi bien dans les opérations arithmétiques les plus communes, que les opérateurs pour les opérations logiques. Vous y découvrirez (ou redécouvrirez) les opérateurs unaires ou encore la surcharge d'opérateur. Vous y apprendrez comment faire du décalage de bits ou contrôler le dépassement de capacité avec les opérateurs checked et unchecked.

Le chapitre 6 s'intéresse plus précisément aux instructions et leur utilisation au sein de différentes types de fonctionnement intra-programme. Il s'intéresse également à l'utilisation des exceptions, leur implémentation et leur utilisation, tout spécifiquement dans une architecture multi-couches

Le chapitre 7 étend la discussion sur les types de référence introduits au chapitre 5. Ces types de référence évolués comprennent les délégations, les événements, les classes abstraites et les interfaces. De nouvelles entités comme les inférences de délégué et les méthodes anonymes sont également examinées. Dans ce chapitre, nous établissons soigneusement la distinction entre l'héritage simple des classes et l'implémentation multiple des interfaces. Le polymorphisme, d'abord cité en référence à la classe d'origine Object, est à nouveau illustré par un exemple complet reposant sur une hiérarchie de classe counet et d'interfaces. Les deux types d'accesseurs du C#, les propriétés et les indexeurs, sont présentés ici, notant les dernières spécifications des modificateurs d'accès.

Vous n'êtes pas sans savoir qu'en net, tout est objet. De la même façon, en net, les collections sont très présentes. Vous apprendrez donc à les remarquer, les comprendre, les utiliser et surtout en tirer partie.
La deuxième partie se concentre sur une nouveauté du framework 2.0: les generics (templates). Ces generics, déjà présents en C++ et en JAVA, permettent d'augmenter la réutilisation du code en créant des classe, méthodes ou collections acceptant des types "dynamiques" tout en restant structurées et logiques.

Si à la lecture des précédents chapitres, vous avez appris à utiliser correctement le C# et développer des applications bien construites, ayant une bonne gestion des erreurs, vous n'avez malheureusement pas appris à gérer les ressources de vos programmes. En effet, même si les machines ont de plus de en plus de mémoire, il n'est pas question d'abuser excessivement de celle-ci aussi bien pour le bon fonctionnement du système que pour l'optimisation de l'application elle-même. Vous y découvrirez à travers différents cas d'utilisation comment éviter la surutilisation de la mémoire en libérant les ressources soit via les destructeurs soit via l'utilisation de mots clés comme using. Vous y apprendrez également comment gérer efficacement les flux d'entrée/sortie pour éviter d'avoir des flux bloquants.
Enfin, vous découvrirez en profondeur l'utilisation des threads et les effets qu'ils apportent à une application.

Ce chapitre traite (trop rapidement) de la reflexion ainsi que l'utilisation des attributs. Même si cette dernière partie est un peu developpée, elle reste néanmoins très succinte et se concentre sur les bases. Quant à la réflexion, c'est vraiment la partie du livre qui eu mérité d'être plus developpée.

En conclusion, très bon pour découvrir, très bon pour avoir de bonnes bases mais trop limité sur bon nombre de points. Il n'est bien sûr pas possible d'expliquer tout le C# en seulement 250 pages et ce livre le montre bien... Il reste néanmoins un livre que je conseillerai à ceux qui souhaitent découvrir le C# tant ses explications sont claires.