420-KE6-LG – Systèmes client/ serveur (SCS)

Ceci est un petit site de support pour le cours 420-KE6-LG – Systèmes client/ serveur.

Vous y trouverez les sections suivantes:

les documents sous forme électronique (ex.: le plan de cours);
le contenu des séances théoriques, séance par séance;
des documents relatifs aux travaux pratiques et de l'activité synthèse;
de petits programmes démonstrateurs; et
les sources des programmes apparaissant dans les notes de cours.

Documents sous forme électronique

	Cliquez sur cette cible pour le plan de cours, sous forme électronique.
	Cliquez sur cette cible pour une archive ZIP expliquant comment lire une question.

Contenu des séances – H2006

Index des séances théoriques
T00	T01	T02	T03	T04	T05	T06	T07	T08	T09	T10	T11	T12	T13	T14

À la séance T00, 30 janvier 2006, nous avons parlé:

de polymorphisme;
de méthodes abstraites;
de classes abstraites;
de l'exposition de types publics (souvenez-vous du type nombre_t dans les générateurs de petits nombres);
de vecteurs standard (std::vector<T> pour un type T donné; souvenez-vous qu'il faut inclure <vector>);
de certaines méthodes de std::vector (push_back(), l'opérateur [], begin(), end(), erase(), empty() et size());
de l'obtention de nombres aléatoires (std::srand() et std::rand()) – à ce sujet, voir cet article;
nous avons effleuré l'idée d'algorithme standard (std::find(), de la bibliothèque <algorithm>);
nous avons vu qu'il est possible de lever une exception qui soit une instance d'une classe vide – un pur concept;
de la possibilité de livrer plusieurs implémentations d'un même concept (les classes TiNombres et TiNombresHasard);
d'interfaces en tant que contrat (IGenerateurPetitsNombres), sujet que nous n'avons que commencé à effleurer.

À la séance T01, 6 février 2006, nous avons parlé:

de destructeurs virtuels; et
de classes internes.

À la séance T02, 13 février 2006, nous avons parlé:

de NULL dans le langage C++;
du danger de l'utilisation des macros;
de l'opérateur ternaire (pour certaines opérations comme a < b ? a : b;... mais prenez soin de ne pas en abuser!);
des templates (pour donner une idée de base de ce qu'on peut faire ne programmation générique), mais seulement en surface;
des conteneurs (comme le tableau et le vecteur) et des itérateurs, mais seulement en surface; et
des algorithmes standard (comme std::for_each()), mais seulement en surface.

À la séance T03, 20 février 2006, nous avons parlé:

de multiprogrammation à l'aide de fils d'exécution concurrents (de threads);
d'outils de synchronisation (de mutex);
d'une stratégie OO pour isoler le code non portable dans une classe Mutex; et
d'une stratégie pour automatiser la libération des Mutex (un Autoverrou).

À la séance T04, 27 février 2006, nous avons parlé:

de vocabulaire, surtout: qu'est-ce qu'un SCS par composants, qu'est-ce qu'un composant, qu'est-ce qu'une interface IDL, qu'est-ce qu'un intermédiaire (que ce soit un proxy ou un stub), qu'est-ce que le marshalling, qu'est-ce qu'un UUID, qu'est-ce qu'un attribut IDL, quelles sont les règles du modèle COM, etc.

À la séance T05, 13 mars 2006, nous avons parlé:

de particularités techniques, semblables à celles du cours T04 (mais il faut se souvenir que ce cours suivait la semaine de relâche).

À la séance T06, 20 mars 2006, nous avons parlé:

de techniques pour découper un projet, ce qui nous a permis de parler:
- de la spécification extern (à éviter pour des projets comme les nôtres);
- d'événements (au sens des outils de synchronisation);
- de vori une application concrète des singletons;
- d'aborder l'héritage multiple; et
- de voir une application concrète de la programmation générique (StdCreateInstance<T>()).

À la séance T07, 27 mars 2006, nous avons parlé:

d'une stratégie propre et rapide de conversion de types reposant sur la sérialisation à l'aide de std::stringstream;
de l'attente de l'occurence de plusieurs événements ou de la fin de plusieurs threads à l'aide de ::WaitForMultipleObjects();
de voir une technique permettant d'encapsuler de manière sécuritaire la synchronisation à même un objet; et
la question du mot clé volatile applicable à une donnée primitive, à un objet et à une méthode.

À la séance T08, 03 avril 2006, nous avons parlé:

de la mise en place d'un sevreur à contexte externe plutôt qu'interne, incluant:
- la gestion de la vie des fabriques;
- un programme principal paramétré et supportant les paramètres standard du modèle COM;
- la génération d'une DLL de marshalling;
- les ressemblances et les différences entre des composants dans un contexte interne et des composants dans un contexte externe;
nous avons aussi examiné les différences côté client, incluant:
- l'obtention de plusieurs pointeurs d'interface à la fois; et
- l'utilisation de mécanismes plus sophistiqués pour l'instanciation assistée.

À la séance T09, 10 avril 2006, nous avons parlé:

du TP02, portant principalement sur le volet serveur du TP01;
quelques points de design avoisinant cette nouvelle oeuvre qui se dessine dans votre proche futur;
d'une éventuelle surprise comprenant entre autres un composant .NET (écrit en C#) pour accéder en arrière-plan à une base de données à travers ADO.NET (sans donner d'indices, se pourrait-il que ce lien vous soit un jour utile?) et, sans doute, une interface personne/ machine en ASP.NET (à valider).

À la séance T10, 24 avril 2006, nous avons parlé:

du TP02;
de la correction du TP01;
de l'interfaçage entre .NET et COM à l'aide d'une TLB; et
de complexité algorithmique (brièvement). Prudence et tolérance avec le lien au début de cette puce, qui mène vers un vieux document de mes premières années d'enseignement.

À la séance T11, 1 mai 2006, nous avons parlé:

d'une stratégie de design OO par assemblage d'implémentations partielles;
de l'implémentation de QueryInterface() en situation d'héritage multiple;
du déverminage d'un exécutable déjà en cours d'exécution;
de contextes distants.

À la séance T12, 8 mai 2006, nous avons parlé:

du partage de pointeurs d'interfaces COM entre threads d'un même processus avec les fonctions ::CoMarshalInterThreadInterfaceInStream() et ::CoGetInterfaceAndReleaseStream();
de composants servant de ponts technologiques.

À la séance T13, 15 mai 2006, nous avons parlé:

de l'importance de valider et de tester les programmes. J'aurais dû plus insister sur le sujet dans ce cours, mais mieux vaut avouer la faute et s'en charger que chercher à la glisser sous le tapis;
de la possibilité de prendre l'habitude de se déverminer mutuellement, de manière rotative, pour développer des aptitudes à comprendre rapidement le code des autres, aptitudes des plus utiles en milieu de travail;
des stratégies CS de type biunivoque, où un serveur rappellera une méthode d'un client. Nous avons exploré brièvement l'implémentation COM qui repose sur des points de connexion, les avantages et les inconvénients de cette stratégie, et nous avons examiné brièvement sur quelle base décider d'avoir recours ou non à ce modèle de communication;
des approches AJAX, brièvement, en soulignant le lien avec les objets XMLHttpRequest et les avantages et inconvénients de cette approche très en vogue aujourd'hui; et
de schémas de conception (Design Patterns) vus en classe, pour que vous puissiez les identifier si on vous en parle lors d'une entrevue d'embauche. En particulier (la liste n'est pas exhaustive mais elle offre des points de repère faciles à identifier), nous avons vu:
- le schéma de conception Conteneur (Container Pattern), commun avec STL (pensez à std::vector) et qui a apparu sous plusieurs formes dont (dans cette séance) celle du IConnectionPointContainer;
- le schéma de conception Itérateur (Iterator Pattern), dont je fais usage sans arrêt (c'est de la poésie);
- le schéma de conception Singleton (Singleton Pattern);
- le schéma de conception Fabrique (Factory Pattern);
- le schéma de conception Intermédiaire (Proxy Pattern); et
- le schéma de conception Observateur (Observer Pattern).
dans la catégorie des schémas de conception, nous avons aussi utilisé l'idiome RAII avec, entre autres choses, le ChargeurCOM et la classe Autoverrou.
enfin, nous avons brièvement abordé la question du TP03 et de l'activité synthèse du cours.

À la séance T14, 22 mai 2006, nous avons parlé:

des SCS avec interfaces asynchrones.

Relatif aux travaux pratiques

Parce que je vous aime, vous trouverez ici des documents ayant trait aux travaux pratiques du cours.

	Vous trouverez ici l'énoncé du travail pratique 01, qui consistera en l'écriture d'un client multiprogrammé à trois (3) threads utilisant les services de deux serveurs mis à votre disposition par votre chic prof pour prendre du code C++ en entrée et en produire une version HTML coloriée en sortie.
	Vous trouverez ici des outils pour vous aider à réaliser le travail pratique 01 (la DLL contenant les serveurs; la spécification IDL des interfaces de ces serveurs; un client de démonstration fonctionnel – la version binaire seulement, bien entendu; etc.)
	Vous trouverez ici l'énoncé du travail pratique 02, qui consistera en l'écriture d'un serveur et de certaines de ses interfaces pour un SCS permettant de choisir un langage de programmation puis de prendre en entrée du code rédigé dans ce langage et en produire une version HTML coloriée en sortie. Ce travail est une extension du TP01 (plus haut).
	Vous trouverez un petit document pour vous aider à vous orienter dans le volet intégration d'un serveur d'accès à une BD sous .NET et écrit en C# du travail pratique 02. Vous trouverez entre autres plus bas un exemple de client C++ accédant à une DLL écrite en C# et un exemple de programme C# accédant à une base de données, ce qui ne peut pas nuire.
	Inséré le 10 mai 2006 à 15:25.Vous trouverez ici l'énoncé du travail pratique 03.
	Inséré le 10 mai 2006 à 15:25.Vous trouverez ici la grille de correction du travail pratique 03.

Au sujet de l'activité synthèse...

Cliquez sur cette cible pour voir la liste des activités synthèse possibles à la session H-2006. Celle qui vous sera attribuée dépendra d'un tirage aléatoire, mais si vous voulez savoir ce qui vous attend...

Démonstrateurs

Vous trouverez ci-dessous des archives ZIP pour un petit SCS de démonstration.

	Vous trouverez ici l'exécutable SCS--Demo--Client3D.exe. Le professeur vous dira comment vous en servir.
	Vous trouverez ici l'exécutable ServeurDirecteur.exe. Le professeur vous dira comment vous en servir.

Sources des programmes apparaissant dans les notes de cours

Vous trouverez ci-dessous des archives ZIP pour tous les programmes apparaissant dans les notes de cours. Ce ne sont pas des solutionnaires pour les exercices.

Ces archives contiennent pour la plupart des solutions construites avec Visual Studio .NET 2003. Si vous désirez les adapter à un autre environnement, il faudra les retoucher un peu.

Sources pour les projets sur les threads

Vous trouverez ici les sources du projet TempsQuiPasse.

Sources pour les projets par sockets

	Vous trouverez ici les sources du projet ClientTresSimple.
	Vous trouverez ici les sources du projet ServeurTresSimple.
	Vous trouverez ici les sources du projet ClientTresSimple, version OO.
	Vous trouverez ici les sources du projet ServeurTresSimple, version OO.
	Vous trouverez ici les sources du projet ClientClavardage.
	Vous trouverez ici les sources du projet ServeurClavardage.

Sources pour les projets avec COM

	Vous trouverez ici les sources du SCS à contexte interne pour le serveur COMSomme, version 0.
	Vous trouverez ici les sources du SCS à contexte interne pour le serveur COMSomme, version 1.
	Vous trouverez ici les sources du SCS à contexte interne pour le serveur COMSomme, version 2.
	Vous trouverez ici les sources du SCS à contexte interne pour le serveur COMSomme, version 3.
	Vous trouverez ici les sources du SCS à contexte interne pour le serveur COMSomme, version 3 (singleton).
	Vous trouverez ici les sources du SCS à contexte interne pour le serveur COMSomme, version 4.
	Vous trouverez ici les sources du SCS à contexte externe pour le serveur COMSomme.
	Vous trouverez ici les sources pour la version bibliothèque des outils standards proposés dans les notes de cours. Avertissement: j'ai apporté quelques modifications à la bibliothèque le 14 novembre 2005 (entre autres au singleton servant à la génération de nombres aléatoires, qui retourne maintenant une référence plutôt qu'un pointeur), alors il est possible que vous deviez apporter quelques modifications mineures aux sources qui y ont recours.

Sources pour les projets mixtes

	Vous trouverez ici les sources d'un projet capable d'inscrire une TLB au registre (ajouté le 19 février 2004).
	Vous trouverez ici les sources d'un SCS dont le client est rédigé en langage VB6 et le serveur est rédigé en langage C++.
	Vous trouverez ici les sources d'un SCS dont le client est rédigé en langage VB6 et le serveur est rédigé en langage VB6.
	Vous trouverez ici les sources d'un SCS dont le client est rédigé en langage C++ et le serveur est rédigé en langage VB6. Note importante: le serveur VB6 n'est pas inclus--prenez celui utilisé pour le SCS fait d'un client VB6 et d'un serveur VB6, ci-dessus.
	Vous trouverez ici les sources d'un SCS dont le client est rédigé en langage C++ selon les standards COM et pour lequel on trouve deux serveurs rédigés respectivement en langage C# et en langage VB.NET, tous deux selon les standards .NET.
	Vous trouverez ici les sources d'un SCS pour lequel on trouve deux clients rédigés respectivement en langage C# et en langage VB.NET, tous deux selon les standards .NET, et un serveur VB6 rédigé selon les standards COM.
	Vous trouverez ici les sources de deux clients rédigés respectivement en langage C# et en langage VB.NET, tous deux selon les standards .NET, pour les serveurs .NET proposés plus haut (les mêmes que pour le client COM).

Sources pour les projets plus complexes

	Vous trouverez ici les sources du SCS à contexte externe et distant pour le serveur COMSomme.
	Vous trouverez ici les sources du SCS à contexte externe et distant pour le serveur COMSomme (version amincie).
	Vous trouverez ici les sources du SCS à contexte externe et distant servant à suivre le passage du temps.
	Vous trouverez ici les sources du SCS à contexte externe et distant montrant une manière d'utiliser ADO dans une approche CS avec COM.
	Vous trouverez ici les sources du SCS à contexte externe et distant montrant comment un serveur peut être client d'un autre serveur.
	Vous trouverez ici les sources du SCS asynchrone à contexte interne identifiant des nombres premiers.
	Vous trouverez ici les sources du SCS asynchrone à contexte externe identifiant des nombres premiers.
	Vous trouverez ici les sources du programme montrant deux manières de procéder à une transaction asynchrone en C# dans le modèle .NET.
	Vous trouverez ici la paire de projets démontrant comment on peut faire simplement un client C++ qui interroge un serveur résidant dans une DLL C#. Si vous voulez en savoir plus sur le marshalling des tableaux entre .NET et le code indigène, vous pouvez examiner cet article.
	Vous trouverez ici un projet C# qui fait une requête OleDb à une BD Access toute simple et affiche le contenu d'un champ dans une table précise..
	Vous trouverez ici un petit document expliquant comment déverminer un contexte externe COM (un exécutable dans lequel résident des composants COM).
	Ajouté le mardi 23 mai 2006 vers 12:25. Vous trouverez ici une archive contenant un petit SCS asynchrone assez simple montrant qu'il est possible de passer des tableaux en entrée et en sortie à une méthode d'une interface asynchrone même si la capacité des deux tableaux est un intrant strict (donc indiqué seulement dans la méthode Begin_...).

Pour les intéressé(e)s, voici:

quelques liens portant sur les systèmes client/ serveur.
des liens pertinents de programmation orientée objet.