Au cours du développement de Claymore, pour la partie ASP.NET plus précisément, j'ai eu besoin de trouver un hook me donnant la possibilité d'interagir avec les pages avant les events que l'on trouve sur l'objet Page.

J'ai tout d'abord pensé tripatouiller dans le fichier Global.asax... sans finalement avoir trouvé ce que je souhaitais. Par contre, en fouillant un peu du côté des HttpModule je suis arrivé à la solution suivante :

using System;
using System.Reflection;
using System.Web;
using System.Web.UI;

namespace Claymore.Web
{
    /// <summary>
    /// 
    /// </summary>
    public class ClaymoreHttpModule : IHttpModule
    {
        #region Fields

        private HttpApplication _application;

        #endregion

        /// <summary>
        /// Initializes a module and prepares it to handle requests.
        /// </summary>
        /// <param name="context"> </param>An <see cref="T:System.Web.HttpApplication"/> that provides access to the methods, properties, and events common to all application objects within an ASP.NET application
        public void Init(HttpApplication context)
        {
            if(context == null)
                throw  new ArgumentNullException("context");

            _application = context;

            context.PostMapRequestHandler += onPostMapRequestHandler;
        }


        /// <summary>
        /// Disposes of the resources (other than memory) used by the module that implements <see cref="T:System.Web.IHttpModule"/>.
        /// </summary>
        public void Dispose(){}

        /// <summary>
        /// Handle PostMapRequest event.
        /// </summary>
        /// <param name="sender"> </param>The sender.
        /// <param name="e"> </param>The <see cref="System.EventArgs"/> instance containing the event data.
        private void onPostMapRequestHandler(object sender, EventArgs e)
        {
            Page pageHandler;
            if ((pageHandler = _application.Context.Handler as Page) != null)
                pageHandler.PreInit += HandlePreInit;
        }

        /// <summary>
        /// Handles the pre init event.
        /// </summary>
        /// <param name="sender"> </param>The sender.
        /// <param name="e"> </param>The <see cref="System.EventArgs"/> instance containing the event data.
        protected virtual void HandlePreInit(object sender, EventArgs e)
        {
            Page page = sender as Page;
            if (page != null){
                // Et voila, on a un pointeur sur une page, et l'on peut interagir avec elle avant l'événement Init.
                // Ajouter du code ici.
            }
        }
    }
}

L'un d'entre vous connaîtrait-il une solution équivalente à base de HttpHandler ou autre?

Suite à la demande d'un utilisateur sur Codeplex de pouvoir utiliser Claymore avec le Compact Framework, j'ai ajouté cette feature dans la librairie; Plus précisément, il existe désormais une assembly qui vise spécifiquement cette version du Framework.

Les classes du Namespace Configuration n'existant pas dans le Compact Framework, j'ai donc du ajouter une API permettant de configurer par code, le fonctionnement de la librairie, tout comme il est possible de le faire en passant par une configuration dans le fichier app.config ou web.config.

J'en ai profité pour designer l'API de configuration en suivant les conventions des Fluent interfaces; Ce type d'écriture semblant être de plus en plus apprécié des développeurs que nous sommes.

Bon téléchargement, et n'hésitez pas à me dire ce que vous en pensez.

Non non non, vous ne rêvez pas... non non je ne suis pas mort! Ça faisait bien longtemps que je n'avais pas eu et pas pris le temps de mettre à jour ce blog... Qui as dit que les enfants n'était pas chronophages? :)

Depuis près de deux ans, les missions sur lesquelles j'interviens sont très souvent liées au développement Winform et malheureusement à chaque fois c'est le même constat; les forms et/ou usercontrol sont un joli mélange de code métier et de gestion d'interface graphique, sans parler des cas ou l'on retrouve même le code d'accès aux données fourré au beau milieu de ce jolie petit monde.

Pourtant, cela fait bien longtemps que l'on connait les patterns MVC, MVP et depuis quelques temps le MVVM qui prend son essor avec Silverlight.

En demandant aux architectes ou Lead techniques de ces projets, ce qui avait justifié de ne pas appliquer un des ces patterns, la réponse est presque toujours la même : L'implémentation de ces modèles dans les applications rallonge (parfois beaucoup) les temps de développement, demande des compétences un peu plus high level de la part des développeurs, et la montée en compétence sur les frameworks existants est parfois très lente.

Entre nous, avant de pouvoir appréhender et amortir le temps d'apprentissage d'un framework comme Smart Client - Composite UI Application Block de Microsoft, le projet à intérêt à s'étaler sur un an au minimum.

Afin de rester impartial, je ne m'étendrais pas sur les autres framework MVP qui peuvent se trouver sur la toile.

Bref, il me semblait qu'il serait intéressant d'avoir un framework MVP simple d'utilisation dans mon escarcelle pour les prochains projets. J'ai donc commencé à écrire ça dans mon coin; Aujourd'hui Claymore me semble assez mûre pour le mettre à disposition des autres, et je l'ai donc publié sur codeplex. Évidemment, Claymore fonctionne avec les projets Winform mais je n'ai pu m'empêcher d'ajouter aussi le support des projets ASP.NET.

J'espère que ce framework saura vous aider à découpler les couches métiers des couches UI...