420KEJ – Systèmes client/ serveur

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 :

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.

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, 28 janvier 2009, et dans le laboratoire L00, nous avons parlé :

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

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

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

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

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

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

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

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

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

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

à 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.

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 2008, nous avons parlé :

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

Index des séances théoriques (voir ici pour celles de l'hiver 2006)
T00 T01 T02 T03 T04 T05 T06 T07 T08 T09 T10 T11 T12 T13 T14

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

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

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

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

à 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é :

à 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é :


à 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

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é :

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


Valid XHTML 1.0 Transitional

CSS Valide !