Arguments obligatoires et groupes surchargés

Les activités peuvent être configurées afin que certains arguments soient liés pour que l’activité soit valide pour l’exécution. L’attribut RequiredArgument est utilisé pour indiquer que certains arguments d’une activité sont requis et que l’attribut OverloadGroup est utilisé pour regrouper les catégories d’arguments requis. En utilisant les attributs, les auteurs d’activités peuvent fournir des configurations de validation d’activité simples ou complexes.

Utiliser les arguments requis

Pour utiliser l’attribut RequiredArgument dans une activité, indiquez les arguments souhaités à l’aide RequiredArgumentAttributede . Dans cet exemple, une Add activité est définie avec deux arguments requis.

public sealed class Add : CodeActivity<int>
{
    [RequiredArgument]
    public InArgument<int> Operand1 { get; set; }

    [RequiredArgument]
    public InArgument<int> Operand2 { get; set; }

    protected override int Execute(CodeActivityContext context)
    {
        return Operand1.Get(context) + Operand2.Get(context);
    }
}

En XAML, les arguments requis sont également indiqués à l’aide de RequiredArgumentAttribute. Dans cet exemple, l’activité Add est définie à l’aide de trois arguments et utilise une Assign<T> activité pour effectuer l’opération d’ajout.

<Activity x:Class="ValidationDemo.Add" ...>
  <x:Members>
    <x:Property Name="Operand1" Type="InArgument(x:Int32)">
      <x:Property.Attributes>
        <RequiredArgumentAttribute />
      </x:Property.Attributes>
    </x:Property>
    <x:Property Name="Operand2" Type="InArgument(x:Int32)">
      <x:Property.Attributes>
        <RequiredArgumentAttribute />
      </x:Property.Attributes>
    </x:Property>
    <x:Property Name="Result" Type="OutArgument(x:Int32)" />
  </x:Members>
  <Assign>
    <Assign.To>
      <OutArgument x:TypeArguments="x:Int32">[Result]</OutArgument>
    </Assign.To>
    <Assign.Value>
      <InArgument x:TypeArguments="x:Int32">[Operand1 + Operand2]</InArgument>
    </Assign.Value>
  </Assign>
</Activity>

Si l’activité est utilisée et que l’un des arguments requis n’est pas lié, l’erreur de validation suivante est retournée.

La valeur d’un argument d’activité obligatoire « Operand1 » n’a pas été fournie.

Remarque

Pour plus d’informations sur la vérification et la gestion des erreurs de validation et des avertissements, consultez Appel de validation d’activité.

Utiliser des groupes de surcharge

Les groupes de surcharge fournissent une méthode pour indiquer quelles combinaisons d’arguments sont valides dans une activité. Les arguments sont regroupés à l’aide de OverloadGroupAttribute. Chaque groupe reçoit un nom spécifié par le OverloadGroupAttribute. L’activité est valide quand un seul ensemble d’arguments d’un groupe de surcharge est lié. Dans l’exemple suivant, une CreateLocation classe est définie.

class CreateLocation: Activity
{
    [RequiredArgument]
    public InArgument<string> Name { get; set; }

    public InArgument<string> Description { get; set; }

    [RequiredArgument]
    [OverloadGroup("G1")]
    public InArgument<int> Latitude { get; set; }

    [RequiredArgument]
    [OverloadGroup("G1")]
    public InArgument<int> Longitude { get; set; }

    [RequiredArgument]
    [OverloadGroup("G2")]
    [OverloadGroup("G3")]
    public InArgument<string> Street { get; set; }

    [RequiredArgument]
    [OverloadGroup("G2")]
    public InArgument<string> City { get; set; }

    [RequiredArgument]
    [OverloadGroup("G2")]
    public InArgument<string> State { get; set; }

    [RequiredArgument]
    [OverloadGroup("G3")]
    public InArgument<int> Zip { get; set; }
}

L’objectif de cette activité est de spécifier un emplacement aux États-Unis. Pour ce faire, l’utilisateur de l’activité peut spécifier l’emplacement à l’aide d’un des trois groupes d’arguments. Pour spécifier les combinaisons valides d’arguments, trois groupes de surcharge sont définis. G1 contient les arguments Latitude et Longitude. G2 contient Street, Cityet State. G3 contient Street et Zip. Name est également un argument requis, mais il ne fait pas partie d’un groupe de surcharge. Pour que cette activité soit valide, Name doit être liée avec tous les arguments d’un unique groupe de surcharge.

Dans l’exemple suivant, extrait de l’exemple Activités d’accès à la base de données , il existe deux groupes de surcharge : ConnectionString et ConfigFileSectionName. Pour que cette activité soit valide, soit les arguments ProviderName et ConnectionString doivent être liés, soit l’argument ConfigName, mais pas les deux.

public class DbUpdate: AsyncCodeActivity
{
    [RequiredArgument]
    [OverloadGroup("ConnectionString")]
    [DefaultValue(null)]
    public InArgument<string> ProviderName { get; set; }

    [RequiredArgument]
    [OverloadGroup("ConnectionString")]
    [DependsOn("ProviderName")]
    [DefaultValue(null)]
    public InArgument<string> ConnectionString { get; set; }

    [RequiredArgument]
    [OverloadGroup("ConfigFileSectionName")]
    [DefaultValue(null)]
    public InArgument<string> ConfigName { get; set; }

    [DefaultValue(null)]
    public CommandType CommandType { get; set; }

    [RequiredArgument]
    public InArgument<string> Sql { get; set; }

    [DependsOn("Sql")]
    [DefaultValue(null)]
    public IDictionary<string, Argument> Parameters { get; }

    [DependsOn("Parameters")]
    public OutArgument<int> AffectedRecords { get; set; }
}

Lors de la définition d’un groupe de surcharge :

• Un groupe de surcharge ne peut pas être un sous-ensemble ou un ensemble équivalent d’un autre groupe de surcharge.

  Remarque

  Il existe une exception à cette règle. Si un groupe de surcharge est un sous-ensemble d’un autre groupe de surcharge et que le sous-ensemble contient uniquement des arguments où RequiredArgumentfalsese trouve, le groupe de surcharge est valide.

• Les groupes de surcharge peuvent se chevaucher, mais il s’agit d’une erreur si l’intersection des groupes contient tous les arguments requis d’un ou des deux groupes de surcharge. Dans l’exemple précédent, les groupes de surcharge G2 et G3 se chevauchaient, mais comme l'intersection ne contenait pas tous les arguments de l'un ou l'autre des groupes, ceci était valide.

Lors de la liaison des arguments dans un groupe surchargé :

• Un groupe de surcharge est considéré comme lié si tous les RequiredArgument arguments du groupe sont liés.
• Si un groupe a zéro RequiredArgument argument et au moins un argument lié, le groupe est considéré comme lié.
• Il s’agit d’une erreur de validation si aucun groupe de surcharge n’est lié, sauf si un groupe de surcharge n’a pas RequiredArgument d’arguments dans celui-ci.
• Il s’agit d’une erreur d’avoir plusieurs groupes de surcharge liés, c’est-à-dire que tous les arguments requis d’un groupe de surcharge sont liés et tout argument d’un autre groupe de surcharge est également lié.