locked
[WF4] Ajouter des contraintes à une activité (1/2) RRS feed

  • Discussion générale

  • De WF3 à WF4 pas mal de choses on été changées pour faciliter la vie des développeurs, mais certain points peuvent sembler obscures… comme les contraintes.

    Pour vous guider, je me lance dans une série de deux articles. Ils présenterons deux approches possibles pour mettre en place des contraintes sur une activité.

    Petit rappela avant de se lancer :

    L’objectif des contraintes est de forcer l’utilisateur de vos activités à saisir leurs propriétés. En gros il s’agit d’une validation de l’utilisation de votre activité.

     

    Ce premier article est dédié à la présentation de la collection Constraints. L’utilisation classique de celle-ci étant décrite par le fameux “A Developer's Introduction to Windows Workflow Foundation (WF4) in .NET 4 Beta 2” de Matt Milner. Plutôt que de faire une reprise maladroite, je m’attaque ici à un cas un peu plus complexe : Ajouter plusieurs contraintes. Cela peut sembler idiot, mais comprendre le code de l’article base et le transposer pour ce cas n’est pas forcement des plus simple pour un nouveau venu dans WF.

    Pour commencer plusieurs questions doivent trouver réponse :

    Où se place la validation?

    -> Dans le constructeur de l’activité. La classe de base contient une collection de contraintes : base.Constraints.

    Comment avoir une validation par activité?

    -> en instanciant un objet Constraint<T> avec un DelegateInArgument<T> (avec T étant le type de votre activité) pour chaque propriété à valider

    Comment lui indiquer nos propriété à valider? La logique de validation? Le message d’erreur?

    -> Votre Constraint<T> a un Handler qui va contenir le nom de la propriété, le message d’erreur à afficher et la logique

    Voici donc un petit exemple d’activité qui répond à ces quelques questions.

    Note : Cette action permet de lancer un program en lui fournissant des arguments.

    001./// <summary>
    002./// Activité qui permet d'executer un program
    003./// </summary>
    004.public class ExecuterUnProgram : CodeActivity
    005.{
    006.    #region "Déclarations"
    007.  
    008.    private InArgument<String> m_Program;
    009.    private InArgument<String> m_Arguments;
    010.  
    011.    #endregion
    012.  
    013.    #region "Constructeur / destructeur"
    014.  
    015.    public ExecuterUnProgram()
    016.    {
    017.        // Context pour la validation
    018.        DelegateInArgument<ValidationContext> validationContext = new DelegateInArgument<ValidationContext>();
    019.  
    020.        // ------------------------------------------------------------------
    021.        // Activité de validation du program
    022.        DelegateInArgument<ExecuterUnProgram> activityProgram = new DelegateInArgument<ExecuterUnProgram> { Name = "argumentP" };
    023.        // Contrainte
    024.        Constraint<ExecuterUnProgram> consProgram = new Constraint<ExecuterUnProgram>
    025.        {
    026.            Body = new ActivityAction<ExecuterUnProgram, ValidationContext>
    027.            {
    028.                Argument1 = activityProgram,
    029.                Argument2 = validationContext,
    030.                Handler = new AssertValidation
    031.                {
    032.                    // Message affiché dans le designer de WorkFlow
    033.                    Message = "La propriété [Program] ne dois pas être vide.",
    034.                    // Propériété à mettre en évidence dans le designer
    035.                    PropertyName = "Program",
    036.                    Assertion = new InArgument<Boolean>(
    037.                        (e) => activityProgram.Get(e).m_Program != null)
    038.                }
    039.            }
    040.        };
    041.        // Ajout de la contrainte
    042.        base.Constraints.Add(consProgram);
    043.  
    044.        // ------------------------------------------------------------------
    045.        // Activité de validation des arguments
    046.        DelegateInArgument<ExecuterUnProgram> activityArgument = new DelegateInArgument<ExecuterUnProgram> { Name = "argumentA" };
    047.        // Contrainte
    048.        Constraint<ExecuterUnProgram> consArguments = new Constraint<ExecuterUnProgram>
    049.        {
    050.            Body = new ActivityAction<ExecuterUnProgram, ValidationContext>
    051.            {
    052.                Argument1 = activityArgument,
    053.                Argument2 = validationContext,
    054.                Handler = new AssertValidation
    055.                {
    056.                    // Message affiché dans le designer de WorkFlow
    057.                    Message = "La propriété [Arguments] ne dois pas être vide.",
    058.                    // Propériété à mettre en évidence dans le designer
    059.                    PropertyName = "Arguments",
    060.                    Assertion = new InArgument<Boolean>(
    061.                        (e) => activityArgument.Get(e).m_Arguments != null)
    062.                }
    063.            }
    064.        };
    065.        // Ajout de la contrainte
    066.        base.Constraints.Add(consArguments);
    067.    }
    068.  
    069.    #endregion
    070.  
    071.    #region "Propriétés"
    072.  
    073.    /// <summary>
    074.    /// Program à executer
    075.    /// </summary>
    076.    public InArgument<String> Program
    077.    {
    078.        get { return this.m_Program; }
    079.        set { this.m_Program = value; }
    080.    }        
    081.  
    082.    /// <summary>
    083.    /// Arguments du Program à executer
    084.    /// </summary>
    085.    public InArgument<String> Arguments
    086.    {
    087.        get { return m_Arguments; }
    088.        set { m_Arguments = value; }
    089.    }
    090.  
    091.    #endregion
    092.  
    093.    #region "Méthodes"
    094.  
    095.    /// <summary>
    096.    /// Action  executée par l'acitivité
    097.    /// </summary>
    098.    /// <param name="context"></param>
    099.    protected override void Execute(CodeActivityContext context)
    100.    {
    101.        Process.Start(this.m_Program.Get(context), this.m_Arguments.Get(context));
    102.    }
    103.  
    104.    #endregion
    105.  
    106.}
     
     
     
     

    par Jérémy Jeanson.

     

    Article entier : [WF4] Ajouter des contraintes à une activité (1/2)

     

     

    Pour plusieurs informations, visitez la page WF – Articles et Didacticiels

    vendredi 28 mai 2010 12:08