Annal AIHM

Luz y yo hemos considerado absolutamente necesario que vierais el enunciado de nuestro examen (aqui lo llaman ANNAL, es por algo...) de aihm (is2, pero que no tienen nada que ver)

el link directo es el siguiente: https://www-licence.ufr-info-p6.jussieu.fr/lmd/licence/annales/aihm/textes/tx_2009_02_mai_txt.html

esto es solo lo que hay que leerse para poder hacer algo, hacer algo ya es otro tema...
estamos super desesperadas, es todo lo que tenemos que decir.




1. Question de cours (30 minutes, 5 points)

* Cet exercice est indépendant des autres exercices et ne suppose la compréhension d’aucune annexe.

►1a. Pour chacune des lignes L1 à L5 (texte source n° 1), précisez clairement si la ligne est compilable (sans erreur ni avertissement) ou non ; dans les deux cas, précisez clairement pour quelle(s) raison(s).

►1b. Pour chacune des lignes B.1 à B.5 de la classe B du texte source n° 2, précisez clairement si la ligne est compilable (sans erreur ni avertissement) ou non. Si ce n’est pas le cas, précisez clairement pour quelle(s) raison(s) et proposez quel(s) modificateur(s) (parmi new, virtual, override) ajouter ou supprimer à cette ligne pour qu’elle devient compilable.

►1c. Pour chacune des cinq lignes éditées par le programme Exo_Redefinition (texte source n° 3), énoncez la ligne éditée et justifiez votre réponse avec clarté et précision.

2. Le modèle du catalogue des dictionnaires, classe WebDicoData (45 minutes, 7 points)

* Cet exercice suppose la compréhension des annexes 1 et 2.

* Prenez connaissance des contraintes et des indications d’implémentation de l’annexe 2C.

►2a. Énoncez la déclaration et l’initialisation des champs qui vous paraissent nécessaires pour implémenter les deux modèles.

►2b. Proposez une implémentation des méthodes de service qui vous paraissent utiles pour implémenter les méthodes et propriétés des questions qui suivent.

►2c. Proposez une implémentation des méthodes Add, Replace et AddOrReplace.

►2d. Proposez une implémentation de la propriété AsArray.

►2e. Proposez une implémentation des propriétés CurrentInfos et CurrentTitle.

3. Le cluster d’ihm, classe WebDicoCluster (45 minutes, 8 points)

* Cet exercice suppose la compréhension des annexes 1, 2 et 3.

* Prenez connaissance des indications d’implémentation figurant à l’annexe 3.

►3a. Énoncez les champs qui sont nécessaires pour l’implémentation du cluster. Ne mentionnez pas les champs associés aux composants qui sont pris en charge par le concepteur.

►3b. Proposez un énoncé pour le constructeur du cluster. Ne mentionnez pas l’initialisation des composants pris en charge par le concepteur.

►3c. Énoncez, s’il y a lieu, la méthode à abonner à l’événement ApplicationOpen du composant events.

►3d. Énoncez, s’il y a lieu, les méthodes qu’il vous semble nécessaire d’abonner à des événements de notification de changement exposés par les modèles mvc (du plugin WebDiconaryPlugin ou des autres plugins).

►3e. Énoncez la méthode qui gère la validation des actions (à abonner à l’événement ApplicationIdle du composant events).

►3f. Proposez un énoncé pour la méthode à associer à l’événement Execute de l’action acDicoFind.

►3g. Énoncez la méthode qui archive l’état du cluster et du catalogue des dictionnaires (à abonner à l’événement Archive du composant events).

Texte source n° 1 (question 1a)

class A {
private A( int x ) { }
protected A( string s ) { }
public A( A a ) { }
}

class B : A {
public B( int x ) : base( x ) { } // L1
protected B( string s ) : base( s ) { } // L2
private B( B b ) : base( b ) { } // L3
}

class X : A { } // L4

class Y : A {
public Y( string s ) { } // L5
}

Texte source n° 2 (question 1b)

class A {
private void Change( ) { } // A.1
protected virtual void Change( int i ) { } // A.2
protected static string Change( byte b ) { return ""; } // A.3
protected virtual string Change( bool b ) { return ""; } // A.4
}

class B : A {
private virtual void Change( float f ) { } // B.1
protected string Change( byte b ) { return ""; } // B.2
protected override string Change( double d ) { return ""; } // B.3
private static new bool Change( int i ) { return false; } // B.4
public override new string Change( bool b ) { return ""; } // B.5
}

Texte source n° 3 (question 1c)

public class A {
public string name = "A" ;
public virtual string Name { get { return name ; } }
private string M1 { get { return name + ".M1" ; } }
protected string M2 { get { return name + ".M2" ; } }
public string M3 { get { return name + ".M3" ; } }
}

public class B : A {
private new string name = "B" ;
public override string Name { get { return name ; } }
public string M1 { get { return ((A) this).name ; } }
public new string M2 { get { return ((A) this).Name ; } }
public new string M3 { get { return base .Name ; } }
}

public class Exo_Redefinition {
static void CW( string s ) { System.Console.WriteLine( s ) ; }
static void Main() {
B refB = new B() ;
CW( "cas 1 : " + ((A) refB).Name ) ;
CW( "cas 2 : " + ((B) refB).name ) ;
CW( "cas 3 : " + refB .M1 ) ;
CW( "cas 4 : " + refB .M2 ) ;
CW( "cas 5 : " + refB .M3 ) ;
}
}

Annexe 1 : spécifications générales

Il existe de nombreux dictionnaires accessibles en ligne. Ainsi, par exemple, le Centre national de ressources textuelles et lexicales (cnrtl), qui dépend [encore] du cnrs, propose le Trésor de la langue française informatisé (tlfi), dictionnaire élaboré entre 1960 et 1994, initialement édité en 16 volumes ; il propose également plusieurs éditions du Dictionnaire de l’Académie française ainsi que l’Encyclopédie de Diderot et d’Alembert (éditées en collaboration avec l’Université de Chicago). La fondation Wikipedia propose des dictionnaires dans de nombreuses langues. Bref, il y a matière à élaborer un plugin « WebDictionaryPlugin » pour l’Explorateur qui fournisse les fonctionnalités permettant d’afficher aisément la définition d’un mot.

L’interface d’utilisation

Comme la tendance est à la sobriété pour les ihm, l’interface d’utilisation de ce plugin est réduite à l’extrême et se présente sous la forme d’une barre d’outils comportant deux boutons et une combo box, sachant qu’un sous-menu « Dictionnaires » a été ajouté au menu principal (photo de gauche ci-dessous) :



Le plugin tient à jour un catalogue de dictionnaires, et l’un de ces dictionnaires fait office de dictionnaire courant. La boîte combo permet de saisir un mot qui se comprend comme le mot courant. Rechercher la définition du mot courant dans le dictionnaire courant revient à composer l’url de la page qui, au sein de ce dictionnaire, correspond à la définition de ce mot.

Un menu contextuel (photo de droite), qui s’ouvre lorsqu’on clique avec le bouton droit de la souris sur l’un quelconque des deux boutons, donne accès aux principales fonctionnalités du plugin (quelques autres fonctionnalités mineures sont accessibles via le menu « Dictionnaires » de la barre d’outils principale) :

acDicoFind (liée aussi au bouton de droite) : provoque l’affichage de la définition du mot courant selon le dictionnaire courant ;

acDicoChoose (liée aussi au bouton de gauche) : ouvre une fenêtre (photo du milieu ci-dessous) qui permet de choisir le dictionnaire courant dans le catalogue des dictionnaires ; l’icône de cette action est la favicon du dictionnaire courant (s’il en a une), ou une image par défaut sinon ;

acDicoEdit : ouvre le dialogue modal (photo de droite ci-dessous) permettant de saisir les informations spécifiant un dictionnaire en vue d’ajouter ou de modifier ces informations dans le catalogue ;

acDicoRemove : supprime le dictionnaire courant du catalogue des dictionnaires ;

acDicoClear : supprime tous les dictionnaires du catalogue des dictionnaires ;

acDicoCreateTab : action en style case à cocher qui indique (propriété Checked) si l’affichage des définitions doit se faire à chaque fois dans un nouvel onglet ;

acDicoShowTools : action en style case à cocher qui indique (propriété Checked) si la barre d’outils du plugin est visible ou non (cette action est accessible via le menu « Affichage »).



– la combo box, qui permet de saisir le mot courant, est associée à une la liste déroulante (photo de gauche) qui affiche un historique mru (most recently used) des mots dont la définition a été recherchée :

· chaque mot ne figure qu’une seule fois dans l’historique ;

· dès que la définition d’un mot a été recherchée (action acDicoFind), le mot est introduit au début de la liste s’il n’y figure pas, ou déplacé au début de la liste s’il y figurait déjà ;

– la photo du milieu montre l’affichage du catalogue des dictionnaires lié à l’action acDicoChoose ;

– la photo de droite montre le dialogue qui permet d’ajouter ou de modifier les informations spécifiant un dictionnaire Ces informations sont : un titre, une url de base pour former les url à soumettre au dictionnaire, et une clé de favicon optionnelle (relative au plugin des icônes WebFaviconPlugin).

Classes et interfaces exposées (espace de noms Psl.Explorer.Exposed)

On suppose que la librairie standard Psl.Explorer.dll contient les classes et interfaces suivantes :

– classe WebDicoInfos : classe associée aux informations relatives à un dictionnaire ;

– classe WebDicoKeys : classe exposant les clés des fonctionnalités exposées dans le registre d’application ;

– interface IWebDicoData : interface du modèle mvc du catalogue des dictionnaires.

Classes de l’implémentation du plugin (espace de noms Psl.Explorer.Dictionaries)

Le plugin des dictionnaires WebDictionaryPlugin est un plugin à chargement dynamique. Toutes les classes qui composent l’implémentation de ce plugin sont générées dans une librairie chargeable de manière dynamique nommée WebDictionaryPlugin.dll :

– WebDicoData : double modèle mvc implémentant l’interface IWebDicoData ;

– WebDicoCluster : cluster d’ihm comportant la barre d’outils et les menus du plugin ;

– WebDicoChooseDialog : fenêtre d’affichage du catalogue pour choisir le dictionnaire courant ;

– WebDicoEditDialog : fenêtre de dialogue modale pour la saisie des informations d’un dictionnaire ;

– WebDicoTools : boîte à outils fournie (méthodes de classe pour faciliter l’implémentation).

Annexe 2 : classes et interfaces exposées

Annexe 2a : la classe WebDicoInfos

La classe WebDicoInfos (espace Psl.Explorer.Exposed), complètement énoncée ci-dessous, regroupe de manière très simple les informations relatives à un dictionnaire :

public class WebDicoInfos {
public const string DefaultTitle = "Dictionnaire indéterminé";
public const string DefaultBaseUrl = "about:blank";
public const string DefaultFavicon = "dictionary://default.*";

/// Référence unique sur la description par défaut d'un dictionnaire
public static readonly WebDicoInfos Default =
new WebDicoInfos( DefaultTitle, DefaultBaseUrl, DefaultFavicon);

// Champs d'instance publics en lecture seule
public readonly string Title;
public readonly string BaseUrl;
public readonly string Favicon;

/// Constructeur
public WebDicoInfos( string title, string baseUrl, string favicon ) {
Title = string.IsNullOrEmpty(title) ? DefaultTitle : title;
BaseUrl = string.IsNullOrEmpty( baseUrl) ? DefaultBaseUrl : baseUrl;
Favicon = string.IsNullOrEmpty(favicon) ? DefaultFavicon : favicon;
}

/// Redéfinition de ToString() retournant le titre du dictionnaire
public override string ToString() { return Title; }
}

* En C#, un champ (de classe ou d’instance) déclaré readonly est un champ qui ne peut être affecté qu’une seule fois, exclusivement dans une clause d’initialisation ou dans un constructeur.

* Remarquer que cette classe est immutable : une fois créée, une instance ne peut être modifiée.

– Constructeur : normalise les champs pour qu’ils n’aient jamais une valeur null ou chaîne vide.

– Default : champ de classe (static) déclaré readonly donnant donc accès à une unique instance de WebDicoInfos faisant office de descripteur par défaut (équivaut à la propriété Empty de la classe String).

– BaseUrl : url de base pour les requêtes auprès des dictionnaires.

– Favicon : clé de favicon relative au cache des icônes du plugin WebFaviconPlugin [364].

– ToString() : redéfinit la méthode de object de manière à retourner le Titre du dictionnaire.

Annexe 2b : l’interface IWebDicoData

La classe WebDicoKeys énonce la clé d’enregistrement du catalogue des dictionnaires. L’interface IWebDicoData spécifie deux modèles mvc, liés l’un à l’autre :

public class WebDicoKeys {
public const string KeyWebDicoData = "Psl.Explorer.WebDico.data"; // IWebDicoData
}

public interface IWebDicoData {

// Le modèle MVC lié au catalogue des dictionnaires
int Count { get; }
WebDicoInfos TryGetInfos( string title );
WebDicoInfos this[ int index ] { get; }
bool Contains( string title );
int IndexOf( string title );
void Add( WebDicoInfos value );
void Replace( WebDicoInfos value );
void AddOrReplace( WebDicoInfos value );
void Remove( string title );
void Clear();
WebDicoInfos[] AsArray { get; set; }
event EventHandler CatalogChanged;

// Le modèle MVC lié à désignation du dictionnaire courant
string CurrentTitle { get; set; }
WebDicoInfos CurrentInfos { get; }
event EventHandler CurrentChanged;
}

Le premier modèle mvc : le catalogue des dictionnaires

C’est une liste d’associations clé/valeur où les clés sont les titres des dictionnaires (type string) et où les valeurs sont des objets de type WebDicoInfos. Ce modèle est contraint comme suit :

– aucune clé du catalogue ne peut être null, chaîne vide, ou la valeur WebDicoInfos.DefaultTitle ;

– il n’y pas de duplication des clés, et les clés sont triées dans l’ordre alphabétique ;

– toutes les méthodes (sauf le setter de AsArray) qui modifient l’état de la liste sont optimisées pour ne déclencher une notification de changement OnCatalogChanged que si la liste a réellement changé ;

– une méthode ou un setter déclenche au plus une notification de changement OnCatalogChanged ;

– les méthodes ou setters qui suppriment ou remplacent des éléments du catalogue doivent veiller à tenir à jour le dictionnaire courant et à déclencher s’il y a lieu au plus une notification OnCurrentChanged ;

– lorsqu’un dictionnaire supprimé du catalogue (via Remove, Clear, etc.) est aussi le dictionnaire courant, le dictionnaire courant devient le dictionnaire par défaut WebDicoInfos.Default ;

– lorsqu’un dictionnaire est remplacé (via Replace, AddOrReplace ou le setter de AsArray) et que ce dictionnaire est aussi le dictionnaire courant, le nouveau dictionnaire (le dictionnaire remplaçant) devient le nouveau dictionnaire courant.

Les méthodes et les setters de propriétés effectuent systématiquement une normalisation de la valeur des paramètres qui leur sont soumis. Selon le type :

– type string (en rôle de titre de dictionnaire) : toute valeur null ou chaîne vide est considérée comme étant la valeur WebDicoInfos.DefaultTitle ;

– type WebDicoInfos : toute valeur null est considérée comme étant la valeur WebDicoInfos.Default.

Les contraintes liées au catalogue conduisent les méthodes et propriétés à effectuer certains contrôles et à déclencher éventuellement certaines exceptions. Pour abréger les spécifications, ces exceptions sont désignées par un sigle ; à chaque sigle correspond un type d’exception :

– sigle knfe : type KeyNotFoundException : le titre est introuvable dans le catalogue ;

– sigle kdup : type ArgumentException : un dictionnaire de même titre figure déjà dans le catalogue ;

– signe kdft : type ArgumentException : le titre par défaut n’est pas un titre valide de dictionnaire ;

– sigle aoore : type ArgumentOutOfRangeException : l’index est hors bornes ;

Les contraintes générales précédemment énoncées s’appliquent à toutes les méthodes et propriétés (sauf mention explicite contraire) :

– TryGetInfos : retourne les informations du dictionnaire dont le titre est fourni en argument, retourne null si le dictionnaire est introuvable ; aucune exception ;

– this[int] : retourne les informations du dictionnaire à la position index ; exception : aoore ;

– this[string] : retourne les informations du dictionnaire ayant un titre donné ; exception : knfe ;

– Contains, IndexOf, Remove : sémantique habituelle ; aucune exception ;

– Add : sémantique habituelle, exceptions kdft, kdup ;

– Replace : sémantique habituelle, exceptions kdft, knfe ;

– AddOrReplace : ajoute un dictionnaire ou remplace le dictionnaire de même titre ; exception : kdft ;

– AsArray : propriété en lecture/écriture :

· en lecture, retourne un tableau des éléments figurant dans le catalogue ; ne retourne jamais null ;

· en écriture, commence par vider le catalogue puis peuple le catalogue avec les informations de dictionnaire figurant dans le tableau ; ne déclenche jamais d’exception (ne fait rien si la référence de tableau est null, ignore les références null, les informations de dictionnaire non valides, et effectue un remplacement en cas de titres dupliqués ; déclenche toujours exactement une notification de changement OnCatalogChanged.

Le second modèle mvc : le dictionnaire courant

Ce modèle, qui tient à jour le dictionnaire courant, est piloté via le setter de la propriété CurrentTitle ou par les méthodes qui modifient le catalogue des dictionnaires. Il est régi par les contraintes suivantes :

– CurrentTitle ne retourne jamais null ou chaîne vide ;

– CurrentInfos ne retourne jamais null ;

– lorsqu’il n’y a pas de dictionnaire courant, CurrentTitle retourne WebDicoInfos.DefaultTitle et CurrenInfos retourne WebDicoInfos.Default ;

– une notification de changement (CurrentChanged) doit être déclenchée lorsque la référence CurrentInfos change, même si la [nouvelle] propriété CurrentTitle est la même chaîne de caractères [que l’ancienne] (par exemple, parce que les informations relatives à un dictionnaire ont été remplacées alors que le dictionnaire a conservé le même titre) ; rappel : la classe WebDicoInfos est immutable.

La sémantique des deux propriétés est à peu près évidente :

– CurrentInfos : retourne les informations du dictionnaire courant ;

– CurrentTitle : obtient ou détermine le dictionnaire courant ; en écriture, le setter ne déclenche jamais d’exception : (1) il applique la même normalisation du titre que l’autre modèle (les titres null ou chaîne vide sont considérées comme étant la valeur WebDicoInfos.DefaultTitle), (2) affecter la valeur par défaut WebDicosInfos.DefaultTitle est licite, et signifie qu’il n’y a plus de dictionnaire courant, (3) affecter un titre qui ne correspond à aucun dictionnaire figurant dans le catalogue équivaut à affecter la valeur par défaut WebDicosInfos.DefaultTitle.

Annexe 2C : Contraintes et indications pour l’implémentation

Contraintes d’implémentation

* évitez au mieux la duplication de code, donc dégagez des méthodes de service ;

* diminuez au maximum le nombre de recherches à effectuer sur les clés du catalogue

Indications d’implémentation

* La classe non générique SortedList [253].

· Vous pouvez choisir la liste de votre choix. Il est cependant recommandé d’utiliser la classe SortedList, éventuellement en version générique plus facile à programmer.

· Utilisez au mieux des déclarations proposées dans l’extrait de la classe WebDicoData ci-dessous.

Extrait de l’implémentation de la classe WebDicoData

La classe WebDicoData (espace Psl.Explorer.Dictionaries) implémente l’interface IWebDicoData. L’extrait ci-dessous énonce les déclarations dont vous pourrez faire usage dans votre implémentation :

public class WebDicoData : IWebDicoData {

// Messages d'exceptions
private const string TitleNotFound = "Dictionnaire introuvable dans le catalogue";
private const string TitleDuplicated = "Titre de dictionnaire dupliqué";
private const string TitleInvalid = "Le titre par défaut n'est pas un titre valide";

// Evénements
public event EventHandler CatalogChanged;
public event EventHandler CurrentChanged;

// Déclenchement centralisé des événements

protected virtual void OnCatalogChanged() {
if ( CatalogChanged != null ) CatalogChanged( this, EventArgs.Empty );
}

protected virtual void OnCurrentChanged() {
if ( CurrentChanged != null ) CurrentChanged( this, EventArgs.Empty );
}
}

Annexe 3 : Le cluster d’ihm

La photographie du concepteur montre la barre d’outils (nommée tools) munie de ses deux boutons et de la combo box (nommée combo). Le concepteur comporte en outre une barre de menu principale (nommée menu) correctement composée et paramétrée pour être immergée dans la barre de menu de l’application, une liste d’actions (nommée actions) regroupant les actions spécifiées à l’annexe 1 (acDicoFind, acDicoEdit, acDicoChoose, acDicoEdit, acDicoRemove, acDicoClear, acDicoCreateTab, acDicoShowTools), un composant de type ApplicationEvents (nommé events) pour l’accès aux événements généraux de l’application, et un menu contextuel (nommé contextMenu) associé aux deux boutons (voir l’annexe 1).

Indications pour l’implémentation

* Le composant ComboBox [278].

* Les actions [307], le composant ApplicationEvents [333].

· vous supposerez que les tous les plugins requis par le cluster ne sont peut-être pas installés ;

· vous laisserez de côté le lien au plugin des favicons, et vous utiliserez la méthode GetDicoInfosImage (classe WebDicoTools ci-dessous) pour obtenir les images associées aux dictionnaires ;

· vous utiliserez les deux méthodes Archive de la classe WebDicoTools pour l’archivage du cluster ;

· vous utiliserez la méthode MakeDicoUrl de WebDicoTools pour composer les url à soumettre aux dictionnaires.

La classe WebDicoTools

public class WebDicoTools {
public static void Archive( IArchiver sender, string key, IWebDicoData catalog ) {…}
public static void Archive( IArchiver sender, string key, ComboBox.ObjectCollection items ) {
public static string MakeDicoUrl( string baseUrl, string word ) {…}
public static Image GetDicoInfosImage( WebDicoInfos infos ) {…}
}

* Considérez que la classe WebDicoTools (espace Psl.Explorer.Dictionaries) vous est fournie : vous n’avez pas à énoncer l’implémentation des méthodes de cette classe.

Elle propose quelques méthodes de services :

– Archive (première méthode) : archive en lecture et en écriture, dans la section courante :

· le catalogue des dictionnaires (via la propriété AsArray de IWebDicoData) ;

· le dictionnaire courant (via la propriété CurrentTitle) ;

– Archive (seconde méthode) : archive en lecture et en écriture, dans la section courante, la collection des items d’une combo box (propriété Items de la combo box) ;

– MakeDicoUrl : prépare une requête à partir de l’url de base d’un dictionnaire et du mot dont on cherche la définition ; la chaîne retournée est une url prête à être soumise à un navigateur.

Note : les requêtes de certains dictionnaires sont en fait très simples à former : il suffit d’ajouter (en s’assurant de la présence d’un « / ») le mot à rechercher à l’url de base du dictionnaire.

– GetDicoInfosImage : retourne l’image associée au dictionnaire dont les informations sont fournies en argument ; cette méthode ne retourne jamais null ;

Note : l’image est obtenue auprès du plugin des favicons s’il est installé et si la clé de favicon figurant dans les informations du dictionnaire correspond à une image ; sinon, cette méthode retourne une image par défaut.