420KEJ – Systèmes client/ serveur (SCS)

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

Vous y trouverez les sections suivantes :

• les documents sous forme électronique (p. ex. : le plan de cours);
• le contenu des séances théoriques, séance par séance;
• les consignes de travaux pratiques;
• les possibilités d'activités synthèses pour la session H2009;
• 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 – H2009

Ce qui suit détaille le contenu des séances du cours 420KEJ, tel que donné à la session H2009.

à la séance T00, 28 janvier 2009, et dans le laboratoire L00, nous avons parlé :

• de polymorphisme;
• de méthodes abstraites;
• de classes abstraites et d'interfaces (comme par exemple IGenId);
• d'énumérations;
• de l'exposition de types publics (souvenez-vous du type id_type dans les générateurs de nombres);
• de la possibilité de livrer plusieurs implémentations d'un même concept (les classes GenSeq, GenAlea et GenRecyc);
• de stratégies de fabrication et de libération de ressources (implémentation simpliste);
• de singletons statiques; et
• d'interfaces en tant que contrat, sujet que nous n'avons que commencé à effleurer.

à la séance T01, 4 février 2009, nous avons parlé :

• d'héritage privé;
• de l'idiome de programmation Incopiable;
• de la gestion des chaînes de caractères brutes, et des diverses sortes de caractères;
• du conteneur générique basic_string<C> et de ses spécialisations;
• du constructeur de séquence;
• de la saine gestion de la mémoire allouée dynamiquement;
• de la surcharge de certaines opérations sur des flux; et
• des conversions généralisées à travers des flux.

à la séance T02, 11 février 2009, nous avons parlé :

• de foncteurs;
• d'itérateurs, de conteneurs et d'algorithmes génériques.

à la séance T03, 18 février 2009, nous avons parlé :

• du TP01, partie 0;
• de bases de multiprogrammation.

à la séance T04, 25 février 2009, nous avons parlé :

• du TP01, partie 1;
• de bases de multiprogrammation (suite).

à la séance T05, 11 mars 2009, nous avons :

• intégré rapidement un petit serveur C# et un petit client C++ à l'aide des mécanismes préconisés par les plateformes .NET et COM;
• entre autres, nous avons utilisé les utilitaires à la ligne de commande que sont tlbexp, regasm et gacutil.

à la séance T06, 18 mars 2009, nous avons :

• discuté de ce que sont les composants, ces serveurs qui ont le comportement d'objets;
• remis le TP01, partie 1;
• commencé le TP02, partie 0.

à la séance T07, 25 mars 2009, gros cours. Nous avons :

• ouvert une petite parenthèse sur la métaprogrammation;
• réalisé un SCS complet sous COM, avec interface IDL.

à la séance T08, 1^er avril 2009, nous avons :

• remis le TP02, partie 0;
• décrit le TP02, partie 1.

à la séance T09, 8 avril 2009, nous avons discuté :

• de mutex portables;
• de schémas de conception; et
• d'idiomes de programmation.

à la séance T10, 15 avril 2009, nous avons discuté :

• d'objets volatiles.

à la séance T11, 22 avril 2009, nous avons travaillé sur le TP02, partie 1.

à la séance T12, 29 avril 2009, nous avons exposé le TPFinal et discuté des modalités de l'activité synthèse (à venir).

Relatif aux travaux pratiques

	Cliquez sur cette cible pour une version de REGISTRY.ZIP qui sera compatible avec Visual Studio 2005.
	Cliquez sur cette cible pour le TP00 sous forme électronique.
	Cliquez sur cette cible pour un client de test possible pour le TP00. Il ne testera pas tout mais il pourra vous aider à repérer des trucs que vous auriez négligé.
	Cliquez sur cette cible pour le TP01 (partie 0) sous forme électronique.
	Cliquez sur cette cible pour les sources déjà offertes dans l'énoncé du TP01 (partie 0).
	Cliquez sur cette cible pour le TP01 (partie 1) sous forme électronique. Notez que les deux programmes ci-dessous doivent compiler sans peine et s'exécuter parfaitement avec le fruit de votre travail réalisé dans le cadre de ce travail pratique.
	#include "mots.h" #include <iostream> using std::basic_ostream; using std::endl; #include <string> using std::basic_string; #include <fstream> using std::basic_ifstream; template <class C> void bouffer_itt(const basic_string<C> &nom, basic_ostream<C> &sortie) { basic_ifstream<C> flux (nom.c_str ()); mots<C> source (flux); for (mots<C>::iterator itt = source.begin(); itt != source.end(); ++itt) sortie << *itt << endl; } using std::wstring; #include <fstream> using std::basic_ofstream; int main() { const wstring SOURCE = L"source.xml"; basic_ofstream<wchar_t> dump(L"log.txt"); bouffer_itt (SOURCE, dump); }	#include "mots.h" #include <iostream> using std::basic_ostream; using std::endl; template <class C> class afficher { basic_ostream<C> &os_; public: afficher (basic_ostream<C> &os) noexcept : os_(os) { } void operator() (const mot<C> &m) { os_ << m << endl; } }; #include <string> using std::basic_string; #include <algorithm> using std::for_each; #include <fstream> using std::basic_ifstream; template <class C> void bouffer_std(const basic_string<C> &nom, basic_ostream<C> &sortie) { basic_ifstream<C> flux (nom.c_str ()); mots<C> source (flux); for_each (source.begin(), source.end(), afficher<C>(sortie)); } using std::wstring; using std::basic_ofstream; int main() { const wstring SOURCE = L"source.xml"; basic_ofstream<wchar_t> dump(L"log.txt"); bouffer_std (SOURCE, dump); }
	Cliquez sur cette cible pour le TP02 (partie 0) sous forme électronique.
	Cliquez sur cette cible pour le TP02 (partie 1) sous forme électronique.
	Cliquez sur cette cible pour le TPFinal sous forme électronique. Les sources du moteur Avatar et une carte de base sont aussi jointes à l'archive; ne vous reste plus qu'à créer un projet et à vous amuser!

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

Cette cible vous mènera vers la liste des activités synthèses possibles à la session H2009. Celle qui vous sera attribuée dépendra d'un tirage aléatoire. La liste est à jour en date du 18 mai 2009.

Contenu des séances – H2008

Ce qui suit détaille le contenu des séances du cours 420KEJ, tel que donné à la session H2008.

à la séance T00, 30 janvier 2008, nous avons parlé :

• de polymorphisme;
• de méthodes abstraites;
• de classes abstraites et d'interfaces (comme par exemple IGenerateurNombres);
• d'énumérations;
• de l'exposition de types publics (souvenez-vous du type nombre_t dans les générateurs de nombres);
• de la possibilité de livrer plusieurs implémentations d'un même concept (les classes GenerateurSequentiel, GenerateurAleatoire et GenerateurRecycleur);
• de stratégies de fabrication et de libération de ressources (implémentation simpliste); et
• d'interfaces en tant que contrat, sujet que nous n'avons que commencé à effleurer.

à la séance T01, 6 février 2008, nous avons parlé :

• de singletons statiques;
• d'héritage privé;
• de l'idiome de programmation Incopiable.

à la séance T02, 13 février 2008, nous avons parlé :

• d'itérateurs;
• de foncteurs; et
• nous avons fait un premier petit système multiprogrammé.

à la séance T03, 20 février 2008, nous avons parlé :

• de synchronisation, en particulier de mutex et d'autoverrous.

à la séance T04, 27 février 2008, nous avons parlé :

• de l'écriture de classes portables, prenant pour exemple la classe Mutex.

à la séance T05, 12 mars 2008, nous avons parlé :

• de l'approche CS par composants.

à la séance T06, 19 mars 2008, nous avons parlé :

• du découpage d'un projet complexe tel que le serveur de démonstration vu en classe :
  • un singleton pour gérer la vie du contexte;
  • assemblage par implémentations partielles;
  • héritage multiple;
  • implémentation générique du code typique d'une fabrique.

à la séance T07, 26 mars 2008, nous avons parlé :

• du marshalling des séquences de valeurs (tableaux, chaînes ASCIIZ, en entrée et en sortie);
• des macros (beurk);
• des syntaxiquement sympathiques pointeurs de fonctions.

à la séance T08, 2 avril 2008, nous avons parlé :

• des objets volatiles.

à la séance T09, 9 avril 2008, nous avons parlé :

• des bibliothèques de types; et
• de la communication entre threads, incluant les très douloureusement nommées fonctions CoMarshalInterThreadInterfaceInStream() et CoGetInterfaceAndReleaseStream() qui permettent le partage de pointeurs d'interfaces entre deux threads dans le monde COM (pour celles et ceux parmi vous dont la pensée est tordue).

à la séance T10, 16 avril 2008, nous avons parlé :

• des bibliothèques de types; et
• de la communication et du partage de données entre threads. Il y avait encore des choses à dire, et ça dérive souvent vers le design OO, alors mieux vaut le faire correctement.

à la séance T11, 23 avril 2008, nous avons parlé :

• de serveurs à contexte externe.

à la séance T12, 30 avril 2008, nous avons parlé :

• de diverses approches CS :
  • par sockets bruts;
  • selon une approche RPC;
  • par composants (ou par objets répartis);
  • par services;
  • selon une approche SOA; puis
• des règles d'identité des composants (ou : comment assurer une intégrité manifeste des serveurs aux yeux des clients quand les clients ne savent que peu de choses sur les serveurs).

à la séance T13, 7 mai 2008, nous avons parlé :

• de techniques OO pour gérer des difficultés structurelles dans des cas où une partie d'un objet résultant d'un assemblage complexe éprouverait un besoin alors qu'une autre partie, a priori structurellement déconnectée, pourrait combler ce besoin;
• de la technique cousine des mixins, qui repose sur une interface, une classe anonyme et la combinaison d'interfaces standards et d'implémentations opaques développées séparément;
• de complexité algorithmique et de choix de structures de données (différence entre une recherche linéaire sur une séquence triée ou non, une recherche dichotomique sur une séquence triée, une table de hashage, etc.); et
• de techniques pour structurer un programme de manière à gérer des ressources coûteuses telles que des connexions à des abses de données dans un programme pour lequel on trouverait un large éventail de demandeurs..

Sources des programmes dans les notes de cours

La plupart des sources qui suivent sont soit 100% portables (quand cela s'avère possible), soit dans leur version Win32 testée avec le plus récent compilateur à ma disposition (présentement, celui livré avec Visual Studio 2005). N'hésitez pas à me signaler tout problème!

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 ClientTresSimpleOO.
	Vous trouverez ici les sources du projet ServeurTresSimpleOO.
	Vous trouverez ici les sources du projet SocketsFluxLib.
	Vous trouverez ici les sources du projet SocketsFluxClient.
	Vous trouverez ici les sources du projet SocketsFluxServeur.

Sources pour les projets par composants

	Vous trouverez ici les sources des projets Commun, ClientSomme et ServeurSomme pour la version à contexte interne, avant tout raffinement et toute refactorisation.
	Vous trouverez ici les sources des projets Commun, ClientSomme et ServeurSomme pour la version à contexte interne, après refactorisation, divers raffinements et plusieurs automatisations. Cette version est plus complexe que la précédente sur le plan structurel mais est une nettement meilleure base à moyen terme.
	Vous trouverez ici les sources des projets Commun, ClientSomme, ServeurSomme et SommeProxyStub pour la version à contexte externe.
	Vous trouverez ici 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.

Éléments du site pour la session H2007

Ce qui suit a été utilisé à la session H2007 mais n'a pas été adapté aux besoins de la session H2008.

Contenu des séances – H2007

Ce qui suit détaille le contenu des séances du cours 420KEJ, tel que donné à la session H2007.

à la séance T00, 29 janvier 2007, nous avons parlé :

• du concept d'objet;
• de polymorphisme;
• de méthodes abstraites;
• de classes abstraites (je n'ai pas utilisé le mot interface mais j'étais proche);
• de l'exposition de types publics (souvenez-vous du type jeton_t dans les générateurs de nombres séquentiels);
• du type standard STL pour une pile (std::stack<T> pour un type T donné; souvenez-vous qu'il faut inclure <stack>);
• de certaines méthodes de std::stack (push(), pop(), empty() et top());
• de la possibilité de livrer plusieurs implémentations d'un même concept (les classes GenerateurSequentiel et GenerateurRecycleur);
• de stratégies de fabrication et de libération de ressources (implémentation simpliste); et
• d'interfaces en tant que contrat (IGenerateur), sujet que nous n'avons que commencé à effleurer.

à la séance T01, 5 février 2007, nous avons parlé :

• des singletons;
• des classes incopiables;
• d'héritage privé;
• nous avons commencé à parler du concept très important d'itérateur;
• nous avons effleuré l'idée d'algorithme standard tel que std::find() et std::remove() de la bibliothèque <algorithm>); et
• nous avons vu qu'il est possible de lever une exception qui soit une instance d'une classe vide – un pur concept.

à la séance T02, 12 février 2007, nous avons parlé :

• de multiprogrammation à l'aide de fils d'exécution concurrents (de threads);
• d'outils de synchronisation (de mutex).

à la séance T03, 19 février 2007, nous avons parlé :

• 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);
• de foncteurs et d'algorithmes standards tels que std::find(), std::find_if() et std::binary_search().

à la séance T04, 26 février 2007, nous avons abordé la question des SCS par composants en faisant un survol des principaux éléments techniques et conceptuels de cette démarche.

à la séance T05, 12 mars 2007, nous sommes revenus sur les SCS par composants de maniètre plus concrète (fabriques, composants, marshalling, interfaces, cocréation, identification unique au monde, intermédiaires de type proxy et de type stub, etc.).

à la séance T06, 19 mars 2007, nous avons examiné comment découper le code d'un contexte serveur pour en arriver à un système un peu plus propre que la version simplette en un seul fichier réalisée lors du laboratoire précédent (implémentations partielles, héritage multiple d'interfaces, création générique, gestionnaire de verrou, etc.)

à la séance T07, 2 avril 2007, je ne me souviens plus de ce dont nous avons discuté!

à la séance T08, 9 avril 2007, le prof fut absent pour cause de maladie.

à la séance T09, 16 avril 2007, nous avons discuté de quelques secrets de multiprogrammation.

à la séance T10, 23 avril 2007, nous avons discuté de contextes externes et de marshalling.

à la séance T11, 30 avril 2007, nous avons discuté :

• de l'interfaçage entre .NET et COM à l'aide d'une TLB;
• de technique d'optimisation par savoir discret (sans la nommer) et du remplacement de constantes par des types;
• 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 T12, 7 mai 2007, le prof fut absent pour cause de maladie. Deux fois la même session, c'est pas fort...

à la séance T13, 14 mai 2007, nous avons parlé :

• de l'importance de valider et de tester les programmes, incluant la maxime suprême des systèmes répartis : faut pas planter;
• de la possibilité de prendre l'habitude de se déboguer mutuellement, de manière rotative, pour développer des aptitudes à comprendre rapidement le code des autres, aptitudes des plus utiles en milieu de travail;
• de ce qui caractérise une approche CS;
• des stratégies CS de type biunivoque (approche par rappel, approche événementielle), 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. Un exemple est disponible ici;
• 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 de l'activité synthèse du cours.

à titre de référence

Ce qui suit détaille le contenu des séances du cours 420KE6, ancêtre direct de 420KEJ, tel qu'il a été donné à la session H2006. Ça vous donnera une idée de ce dont le cours de cette année pourra avoir l'air.

Contenu des séances – H2006

à 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éboguer 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.
	Vous trouverez ici l'énoncé du travail pratique 03.
	Vous trouverez ici la grille de correction du travail pratique 03.

Au sujet de l'activité synthèse (celle de l'hiver 2006, ne vous méprenez pas!)...

Cliquez sur cette cible pour voir la liste des activités synthèse possibles à la session H2006. 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 de l'archive Registry.zip mentionnée dans vos notes de cours. Note : cette archive a été retouchée le 20 février 2007 pour fonctionner avec Visual Studio 2005.
	Vous trouverez ici les sources pour la version bibliothèque des outils standards proposés dans les notes de cours.

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éboguer un contexte externe COM (un exécutable dans lequel résident des composants COM).
	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

• Quelques liens portant sur les systèmes client/ serveur.
• Quelques liens portant sur les applications Internet.
• Des liens pertinents de programmation orientée objet.
• Des liens de support en ligne spécifiques à C++.